Add evict-peer functionality and tests

Author: mikera

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `dissoc-in`, `update` and `update-in` core functions
 - `switch` conditional macro
 - Tagged values in Reader (e.g. `#Index {}`)
+- `evict-peer` core function to remove old / understaked peers
 
 ### Changed
 

convex-core/src/main/java/convex/core/data/PeerStatus.java

@@ -85,6 +85,10 @@ public long getBalance() {
 	public long getDelegatedStake() {
 		return delegatedStake;
 	}
+	
+	public Index<Address,CVMLong> getStakes() {
+		return stakes;
+	}
 
 	/**
 	 * Gets the self-owned stake of this peer

convex-core/src/main/java/convex/core/lang/Context.java

@@ -44,6 +44,7 @@
 import convex.core.lang.impl.CoreFn;
 import convex.core.util.Economics;
 import convex.core.util.Errors;
+import convex.core.util.Utils;
 
 /**
  * Representation of CVM execution context.
@@ -346,7 +347,6 @@ public Context completeTransaction(State initialState, ResultContext rc) {
 		long balance=account.getBalance();
 		boolean juiceFailure=juiceFees>balance;
 
-		
 		boolean memoryFailure=false;
 		long memorySpend=0L; // usually zero
 
@@ -2024,7 +2024,7 @@ public Context setPeerStake(AccountKey peerKey, long newStake) {
 	/**
 	 * Creates a new peer with the specified stake.
 	 * The accountKey must not be in the list of peers.
-	 * The accountKey must be assigend to the current transaction address
+	 * The accountKey must be assigned to the current transaction address
 	 * Stake must be greater than 0.
 	 * Stake must be less than to the account balance.
 	 *
@@ -2053,12 +2053,54 @@ public Context createPeer(AccountKey accountKey, long initialStake) {
 	}
 
 	public Context evictPeer(AccountKey peerKey) {
-		State s=getState();
-		PeerStatus ps=s.getPeer(peerKey);
+		Context ctx=this;
+		PeerStatus ps=ctx.getState().getPeer(peerKey);
 		if (ps==null) {
 			return this;
 		}
-		return withError(ErrorCodes.TODO,"Can't evict peers yet!");
+		Address controller=ps.getController();
+		if (Utils.equals(ctx.getAddress(),ps.getController())) {
+			// OK
+		} else {
+			if (ps.getPeerStake()>=Constants.MINIMUM_EFFECTIVE_STAKE) {
+				return ctx.withError(ErrorCodes.STATE,"Peer has too much stake to be evicted");
+			}
+		}
+		Index<Address, CVMLong> stakes = ps.getStakes();
+		long ns=stakes.count();
+		for (int i=0; i<ns; i++) {
+			// SECURITY: update juice limit while evicting delegated stakes
+			// This is safe because we are only deleting stuff
+			MapEntry<Address,CVMLong> staked=stakes.entryAt(i);
+			ctx=ctx.withJuiceLimit(getJuiceLimit()+Juice.TRANSFER);
+			ctx=ctx.consumeJuice(Juice.TRANSFER);
+			Address stakedAddress=staked.getKey();
+			long stake=staked.getValue().longValue();
+			if (stake<=0) continue; // shouldn't happen? just in case....
+			
+			// Do refund to delegated staker
+			AccountStatus stakingAccount=ctx.getAccountStatus(stakedAddress); // should always exist
+			stakingAccount=stakingAccount.withBalance(stakingAccount.getBalance()+stake);
+			ctx=ctx.withAccountStatus(stakedAddress, stakingAccount);
+		}
+		
+		// Get the controller account for stake refund
+		AccountStatus controlAccount=ctx.getAccountStatus(controller); // should always exist. Use ctx!!!
+		if (controlAccount==null) {
+			// we refund the caller
+			controller=getAddress();
+			controlAccount=getAccountStatus();
+		}
+		
+		long peerStake=ps.getPeerStake();
+		controlAccount=controlAccount.withBalance(controlAccount.getBalance()+peerStake);
+		ctx=ctx.withAccountStatus(controller, controlAccount);
+		
+		// Finally remove peer record from state
+		State s=ctx.getState();
+		ctx=ctx.withState(s.withPeers(s.getPeers().dissoc(peerKey)));
+		
+		return ctx.withResult(CVMLong.create(peerStake));
 	}
 
 	/**

convex-core/src/main/java/convex/core/lang/Core.java

@@ -967,7 +967,6 @@ public  Context invoke(Context context, ACell[] args) {
 			if (amount == null) return context.withCastError(1,args, Types.LONG);
 
 			return context.setDelegatedStake(accountKey, amount.longValue()).consumeJuice(Juice.TRANSFER);
-
 		}
 	});
 
@@ -993,10 +992,17 @@ public  Context invoke(Context context, ACell[] args) {
 		public  Context invoke(Context context, ACell[] args) {
 			if (args.length != 1) return context.withArityError(exactArityMessage(1, args.length));
 
+			
 			AccountKey accountKey = RT.ensureAccountKey(args[0]);
 			if (accountKey == null) return context.withCastError(0,args, Types.BLOB);
+			
+			// Security: Consume juice first, since eviction can potentially use arbitrary juice
+			// We still want juice to be paid in case of any error
+			context=context.consumeJuice(Juice.PEER_UPDATE);
+			if (context.isExceptional()) return context;
 
-			return context.evictPeer(accountKey).consumeJuice(Juice.PEER_UPDATE);
+			// SECURITY: no juice consumption here, we always let this succeed if last op
+			return context.evictPeer(accountKey);
 		}
 	});
 

convex-core/src/test/java/convex/core/lang/CoreTest.java

@@ -31,6 +31,7 @@
 
 import org.junit.jupiter.api.Test;
 
+import convex.core.Coin;
 import convex.core.Constants;
 import convex.core.ErrorCodes;
 import convex.core.cpos.Block;
@@ -3448,7 +3449,54 @@ public void testCreatePeer() {
 	public void testCreatePeerRegression() {
 		assertJuiceError(step("(create-peer 0x42ae93b185bd2ba64fd9b0304fec81a4d4809221a5b68de4da041b48c85bcc2e *balance*)"));
 		assertFundsError(step("(create-peer 0x42ae93b185bd2ba64fd9b0304fec81a4d4809221a5b68de4da041b48c85bcc2e (inc *balance*))"));
+	}
+	
+	@Test 
+	public void testEvictPeer() {
+		{ // create a peer then evict it
+			Context ctx=context();
+			long PEERSTAKE=2*Constants.MINIMUM_EFFECTIVE_STAKE;
+			AccountKey PK=AccountKey.fromHex("42ae93b185bd2ba64fd9b0304fec81a4d4809221a5b68de4da041b48c85bcc2e");
+			ctx=exec(ctx,"(create-peer "+PK+" "+PEERSTAKE+")");
+			assertNotNull(ctx.getState().getPeer(PK));
+			assertEquals(Coin.MAX_SUPPLY,ctx.getState().computeTotalBalance());
+			assertCVMEquals(PEERSTAKE,eval(ctx,"(get-in *state* [:peers "+PK+" :stake])"));
+			ctx=exec(ctx,"(evict-peer "+PK+")");
+			assertCVMEquals(PEERSTAKE,ctx.getResult());
+			assertNull(ctx.getState().getPeer(PK));
+			assertEquals(Coin.MAX_SUPPLY,ctx.getState().computeTotalBalance());
+		}
+		
+		{ // create a peer with delegated stake and evict
+			Context ctx=context();
+			long PEERSTAKE=2*Constants.MINIMUM_EFFECTIVE_STAKE;
+			long USERFUND=10000000;
+			long USERSTAKE=7000000;
+			AccountKey PK=AccountKey.fromHex("42ae93b185bd2ba64fd9b0304fec81a4d4809221a5b68de4da041b48c85bcc2e");
+			ctx=exec(ctx,"(create-peer "+PK+" "+PEERSTAKE+")");
+			ctx=exec(ctx,"(def USER (deploy '(set-controller *caller*) '(defn ^:callable receive-coin [& args] (accept *offer*))))");
+			Address USER=ctx.getResult();
+			ctx=exec(ctx,"(transfer USER "+USERFUND+")");
+			ctx=exec(ctx,"(eval-as USER '(stake "+PK+" "+USERSTAKE+"))");
+			assertCVMEquals(USERSTAKE,ctx.getResult());
+			assertEquals(Coin.MAX_SUPPLY,ctx.getState().computeTotalBalance());
+			assertEquals(PEERSTAKE+USERSTAKE,ctx.getState().getPeer(PK).getTotalStake());
+			assertEquals(USERFUND-USERSTAKE,ctx.getBalance(USER));
+			
+			// USER should't be able to evict
+			assertStateError(step(ctx,"(eval-as USER '(evict-peer "+PK+"))"));
+			
+			// We can evict, user refund should happen
+			ctx=exec(ctx,"(evict-peer "+PK+")");
+			assertEquals(USERFUND,ctx.getBalance(USER));
+			assertEquals(Coin.MAX_SUPPLY,ctx.getState().computeTotalBalance());
+		}
 
+		assertCastError(step("(evict-peer nil)"));
+		assertCastError(step("(evict-peer 0x)"));
+		assertCastError(step("(evict-peer [])"));
+		assertArityError(step("(evict-peer :foo :bar)"));
+		assertArityError(step("(evict-peer)"));
 	}
 
 	@Test