public ActivationStatusMutation() { Field <NonNullGraphType <BooleanGraphType> >("activateAccount", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "encodedActivationKey", }), resolve: context => { try { string encodedActivationKey = context.GetArgument <string>("encodedActivationKey"); NineChroniclesNodeService service = context.Source; // FIXME: Private key may not exists at this moment. PrivateKey privateKey = service.PrivateKey; ActivationKey activationKey = ActivationKey.Decode(encodedActivationKey); BlockChain <NineChroniclesActionType> blockChain = service.Swarm.BlockChain; IValue state = blockChain.GetState(activationKey.PendingAddress); if (!(state is Bencodex.Types.Dictionary asDict)) { context.Errors.Add(new ExecutionError("The given key was already expired.")); return(false); } var pendingActivationState = new PendingActivationState(asDict); ActivateAccount action = activationKey.CreateActivateAccount( pendingActivationState.Nonce); var actions = new NineChroniclesActionType[] { action }; blockChain.MakeTransaction(privateKey, actions); }
public void CheckPermission() { var nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 }; var pubKey = new PublicKey( ByteUtil.ParseHex("02ed49dbe0f2c34d9dff8335d6dd9097f7a3ef17dfb5f048382eebc7f451a50aa1") ); var pendingActivation = new PendingActivationState(nonce, pubKey); var action = new CreatePendingActivation(pendingActivation); var adminAddress = new Address("399bddF9F7B6d902ea27037B907B2486C9910730"); var adminState = new AdminState(adminAddress, 100); var state = new State(ImmutableDictionary <Address, IValue> .Empty .Add(AdminState.Address, adminState.Serialize()) ); Assert.Throws <PolicyExpiredException>( () => action.Execute(new ActionContext() { BlockIndex = 101, PreviousStates = state, Signer = adminAddress, }) ); Assert.Throws <PermissionDeniedException>( () => action.Execute(new ActionContext() { BlockIndex = 1, PreviousStates = state, Signer = default,
public void Execute() { var nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 }; var pubKey = new PublicKey( ByteUtil.ParseHex("02ed49dbe0f2c34d9dff8335d6dd9097f7a3ef17dfb5f048382eebc7f451a50aa1") ); var pendingActivation = new PendingActivationState(nonce, pubKey); var action = new CreatePendingActivation(pendingActivation); var adminAddress = new Address("399bddF9F7B6d902ea27037B907B2486C9910730"); var adminState = new AdminState(adminAddress, 100); var state = new State(ImmutableDictionary <Address, IValue> .Empty .Add(AdminState.Address, adminState.Serialize()) ); var actionContext = new ActionContext() { BlockIndex = 1, PreviousStates = state, Signer = adminAddress, }; var nextState = action.Execute(actionContext); Assert.Equal( pendingActivation.Serialize(), nextState.GetState(pendingActivation.address) ); }
public InvalidSignatureException( SerializationInfo info, StreamingContext context ) : base(info, context) { byte[] rawPending = (byte[])info.GetValue(nameof(Pending), typeof(byte[])); Pending = new PendingActivationState( (Bencodex.Types.Dictionary) new Codec().Decode(rawPending) ); Signature = (byte[])info.GetValue(nameof(Signature), typeof(byte[])); }
public void CreatePendingActivationsAfterRenewAdminState() { var random = new Random(); var nonce = new byte[40]; random.NextBytes(nonce); var privateKey = new PrivateKey(); var createPendingActivations = new CreatePendingActivations(new[] { new PendingActivationState(nonce, privateKey.PublicKey), }); long blockIndex = _validUntil + 1; Assert.Throws <PolicyExpiredException>(() => createPendingActivations.Execute(new ActionContext { BlockIndex = blockIndex, PreviousStates = _stateDelta, Signer = _adminPrivateKey.ToAddress(), })); var newValidUntil = _validUntil + 1000; var action = new RenewAdminState(newValidUntil); var stateDelta = action.Execute(new ActionContext { BlockIndex = blockIndex, PreviousStates = _stateDelta, Signer = _adminPrivateKey.ToAddress(), }); // After 100 blocks. blockIndex += 100; Assert.True(blockIndex < newValidUntil); stateDelta = createPendingActivations.Execute(new ActionContext { BlockIndex = blockIndex, PreviousStates = stateDelta, Signer = _adminPrivateKey.ToAddress(), }); Address expectedPendingActivationStateAddress = PendingActivationState.DeriveAddress(nonce, privateKey.PublicKey); Assert.NotNull(stateDelta.GetState(expectedPendingActivationStateAddress)); }
public void Serialize() { var nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 }; var pubKey = new PublicKey( ByteUtil.ParseHex("02ed49dbe0f2c34d9dff8335d6dd9097f7a3ef17dfb5f048382eebc7f451a50aa1") ); var state = new PendingActivationState(nonce, pubKey); var serialized = (Dictionary)state.Serialize(); var deserialized = new PendingActivationState(serialized); Assert.Equal( new Address("8d9f76aF8Dc5A812aCeA15d8bf56E2F790F47fd7"), deserialized.address ); Assert.Equal(pubKey, deserialized.PublicKey); Assert.Equal(nonce, deserialized.Nonce); }
public void PlainValue() { byte[] nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 }; PublicKey pubKey = new PrivateKey().PublicKey; Address address = PendingActivationState.DeriveAddress(nonce, pubKey); var pv = new List() .Add(new List(address.Serialize(), (Binary)nonce, pubKey.Serialize())); var action = new CreatePendingActivations(); action.LoadPlainValue(pv); var pvFromAction = Assert.IsType <List>(action.PlainValue); var activationFromAction = Assert.IsType <List>(pvFromAction[0]); Assert.Equal(address, new Address((Binary)activationFromAction[0])); Assert.Equal(nonce, (Binary)activationFromAction[1]); Assert.Equal(pubKey, new PublicKey(((Binary)activationFromAction[2]).ByteArray)); }
public override IAccountStateDelta Execute(IActionContext context) { IAccountStateDelta state = context.PreviousStates; if (context.Rehearsal) { return(state .SetState(ActivatedAccountsState.Address, MarkChanged) .SetState(PendingAddress, MarkChanged)); } CheckObsolete(BlockChain.Policy.BlockPolicySource.V100080ObsoleteIndex, context); if (!state.TryGetState(ActivatedAccountsState.Address, out Dictionary accountsAsDict)) { throw new ActivatedAccountsDoesNotExistsException(); } if (!state.TryGetState(PendingAddress, out Dictionary pendingAsDict)) { throw new PendingActivationDoesNotExistsException(PendingAddress); } var accounts = new ActivatedAccountsState(accountsAsDict); var pending = new PendingActivationState(pendingAsDict); if (pending.Verify(Signature)) { // We left this log message to track activation history. // Please delete it if we have an API for evaluation results on the Libplanet side. Log.Information("{pendingAddress} is activated by {signer} now.", pending.address, context.Signer); return(state.SetState( ActivatedAccountsState.Address, accounts.AddAccount(context.Signer).Serialize() ).SetState( pending.address, new Bencodex.Types.Null() )); } else { throw new InvalidSignatureException(pending, Signature); } }
public static (ActivationKey, PendingActivationState) Create( PrivateKey privateKey, byte[] nonce ) { if (privateKey is null) { throw new ArgumentNullException(nameof(privateKey)); } if (nonce is null) { throw new ArgumentNullException(nameof(nonce)); } var pendingActivation = new PendingActivationState(nonce, privateKey.PublicKey); var activationKey = new ActivationKey(privateKey, pendingActivation.address); return(activationKey, pendingActivation); }
public ActivationStatusMutation(NineChroniclesNodeService service) { Field <NonNullGraphType <BooleanGraphType> >("activateAccount", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "encodedActivationKey", }), resolve: context => { try { string encodedActivationKey = context.GetArgument <string>("encodedActivationKey"); // FIXME: Private key may not exists at this moment. if (!(service.MinerPrivateKey is { } privateKey)) { throw new InvalidOperationException($"{nameof(privateKey)} is null."); } ActivationKey activationKey = ActivationKey.Decode(encodedActivationKey); if (!(service.Swarm?.BlockChain is { } blockChain)) { throw new InvalidOperationException($"{nameof(blockChain)} is null."); } IValue state = blockChain.GetState(activationKey.PendingAddress); if (!(state is Bencodex.Types.Dictionary asDict)) { context.Errors.Add(new ExecutionError("The given key was already expired.")); return(false); } var pendingActivationState = new PendingActivationState(asDict); ActivateAccount action = activationKey.CreateActivateAccount( pendingActivationState.Nonce); var actions = new NCAction[] { action }; blockChain.MakeTransaction(privateKey, actions); }
public void Serialize() { var formatter = new BinaryFormatter(); using var ms = new MemoryStream(); var pending = new PendingActivationState( new byte[] { 0x00 }, new PrivateKey().PublicKey ); var exc = new InvalidSignatureException( pending, new byte[] { 0x01 } ); formatter.Serialize(ms, exc); ms.Seek(0, SeekOrigin.Begin); var deserialized = (InvalidSignatureException)formatter.Deserialize(ms); Assert.Equal(exc.Pending.Serialize(), deserialized.Pending.Serialize()); Assert.Equal(exc.Signature, deserialized.Signature); }
public override IAccountStateDelta Execute(IActionContext context) { IAccountStateDelta state = context.PreviousStates; if (context.Rehearsal) { return(state .SetState(ActivatedAccountsState.Address, MarkChanged) .SetState(PendingAddress, MarkChanged)); } if (!state.TryGetState(ActivatedAccountsState.Address, out Dictionary accountsAsDict)) { throw new ActivatedAccountsDoesNotExistsException(); } if (!state.TryGetState(PendingAddress, out Dictionary pendingAsDict)) { throw new PendingActivationDoesNotExistsException(PendingAddress); } var accounts = new ActivatedAccountsState(accountsAsDict); var pending = new PendingActivationState(pendingAsDict); if (pending.Verify(this)) { return(state.SetState( ActivatedAccountsState.Address, accounts.AddAccount(context.Signer).Serialize() ).SetState( pending.address, new Bencodex.Types.Null() )); } else { throw new InvalidSignatureException(pending, Signature); } }
public void SerializeWithDotNetAPI() { var nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 }; var pubKey = new PublicKey( ByteUtil.ParseHex("02ed49dbe0f2c34d9dff8335d6dd9097f7a3ef17dfb5f048382eebc7f451a50aa1") ); var state = new PendingActivationState(nonce, pubKey); var formatter = new BinaryFormatter(); using var ms = new MemoryStream(); formatter.Serialize(ms, state); ms.Seek(0, SeekOrigin.Begin); var deserialized = (PendingActivationState)formatter.Deserialize(ms); Assert.Equal( new Address("8d9f76aF8Dc5A812aCeA15d8bf56E2F790F47fd7"), deserialized.address ); Assert.Equal(pubKey, deserialized.PublicKey); Assert.Equal(nonce, deserialized.Nonce); }
public override IAccountStateDelta Execute(IActionContext context) { IAccountStateDelta state = context.PreviousStates; Address activatedAddress = context.Signer.Derive(ActivationKey.DeriveKey); if (context.Rehearsal) { return(state .SetState(activatedAddress, MarkChanged) .SetState(PendingAddress, MarkChanged)); } if (!(state.GetState(activatedAddress) is null)) { throw new AlreadyActivatedException($"{context.Signer} already activated."); } if (!state.TryGetState(PendingAddress, out Dictionary pendingAsDict)) { throw new PendingActivationDoesNotExistsException(PendingAddress); } var pending = new PendingActivationState(pendingAsDict); if (pending.Verify(this)) { // We left this log message to track activation history. // Please delete it if we have an API for evaluation results on the Libplanet side. Log.Information("{pendingAddress} is activated by {signer} now.", pending.address, context.Signer); return(state .SetState(activatedAddress, true.Serialize()) .SetState(pending.address, new Bencodex.Types.Null())); } else { throw new InvalidSignatureException(pending, Signature); } }
public InvalidSignatureException(PendingActivationState pending, byte[] signature) { Pending = pending; Signature = signature; }
public CreatePendingActivation(PendingActivationState activationKey) { PendingActivation = activationKey; }
public override void LoadPlainValue(IValue plainValue) { var asDict = ((Bencodex.Types.Dictionary)plainValue); PendingActivation = new PendingActivationState((Dictionary)asDict["pending_activation"]); }