feat: Implement Delegate Resignation (AIP11)

__tests__/helpers/transaction-factory.ts

@@ -32,6 +32,10 @@ export class TransactionFactory {
         return new TransactionFactory(Transactions.BuilderFactory.delegateRegistration().usernameAsset(username));
     }
 
+    public static delegateResignation(): TransactionFactory {
+        return new TransactionFactory(Transactions.BuilderFactory.delegateResignation());
+    }
+
     public static vote(publicKey?: string): TransactionFactory {
         return new TransactionFactory(
             Transactions.BuilderFactory.vote().votesAsset([

__tests__/unit/core-jest-matchers/transactions/types/delegate.test.ts

@@ -4,13 +4,17 @@ import { Enums } from "@arkecosystem/crypto";
 const { TransactionTypes } = Enums;
 
 describe(".toBeDelegateType", () => {
-    test("passes when given a valid transaction", () => {
+    test("passes when given a delegate transaction", () => {
         expect({
             type: TransactionTypes.DelegateRegistration,
         }).toBeDelegateType();
+
+        expect({
+            type: TransactionTypes.DelegateResignation,
+        }).toBeDelegateType();
     });
 
-    test("fails when given an invalid transaction", () => {
+    test("fails when given a non-delegate transaction", () => {
         expect(expect({ type: "invalid" }).toBeDelegateType).toThrowError(
             "Expected value to be a valid DELEGATE transaction.",
         );

__tests__/unit/core-state/wallets/wallet.test.ts

@@ -202,6 +202,23 @@ describe("Models - Wallet", () => {
             ]);
         });
 
+        it("should return correct audit data for delegate resignation type", () => {
+            const transaction = TransactionFactory.delegateResignation()
+                .withNetwork("devnet")
+                .withPassphrase("super secret passphrase")
+                .create()[0];
+            const audit = testWallet.auditApply(transaction);
+
+            expect(audit).toEqual([
+                {
+                    "Remaining amount": +walletInit.balance.minus(transaction.amount).minus(transaction.fee),
+                },
+                { "Signature validation": true },
+                { "Current username": undefined },
+                { "New username": undefined },
+            ]);
+        });
+
         it("should return correct audit data for vote type", () => {
             const transaction = TransactionFactory.vote(
                 "02337316a26d8d49ec27059bd0589c49ba474029c3627715380f4df83fb431aece",

packages/core-jest-matchers/src/transactions/types/delegate.ts

@@ -1,6 +1,6 @@
 import { Enums } from "@arkecosystem/crypto";
 
-const { DelegateRegistration } = Enums.TransactionTypes;
+const { TransactionTypes } = Enums;
 
 export {};
 
@@ -17,7 +17,8 @@ expect.extend({
     toBeDelegateType: received => {
         return {
             message: () => "Expected value to be a valid DELEGATE transaction.",
-            pass: received.type === DelegateRegistration,
+            pass: received.type === TransactionTypes.DelegateRegistration ||
+                  received.type === TransactionTypes.DelegateResignation,
         };
     },
 });

packages/core-state/src/wallets/wallet.ts

@@ -162,6 +162,11 @@ export class Wallet implements State.IWallet {
             audit.push({ "New username": username });
         }
 
+        if (transaction.type === Enums.TransactionTypes.DelegateResignation) {
+            audit.push({ "Current username": this.username });
+            audit.push({ "New username": undefined });
+        }
+
         if (transaction.type === Enums.TransactionTypes.Vote) {
             audit.push({ "Current vote": this.vote });
             audit.push({ "New vote": transaction.asset.votes[0] });

packages/core-transaction-pool/src/defaults.ts

@@ -28,7 +28,7 @@ export const defaults = {
             ipfs: 250,
             timelockTransfer: 500,
             multiPayment: 500,
-            delegateResignation: 400000,
+            delegateResignation: 100,
         },
     },
 };

packages/core-transactions/src/handlers/delegate-resignation.ts

@@ -1,5 +1,6 @@
-import { EventEmitter, State } from "@arkecosystem/core-interfaces";
+import { EventEmitter, State, TransactionPool } from "@arkecosystem/core-interfaces";
 import { Interfaces, Transactions } from "@arkecosystem/crypto";
+import { WalletUsernameEmptyError } from "../errors";
 import { TransactionHandler } from "./transaction";
 
 export class DelegateResignationTransactionHandler extends TransactionHandler {
@@ -12,13 +13,51 @@ export class DelegateResignationTransactionHandler extends TransactionHandler {
         wallet: State.IWallet,
         databaseWalletManager: State.IWalletManager,
     ): boolean {
+        if (!wallet.username || !transaction.data.asset.delegate.username) {
+            throw new WalletUsernameEmptyError();
+        }
+
         return super.canBeApplied(transaction, wallet, databaseWalletManager);
     }
 
     public emitEvents(transaction: Interfaces.ITransaction, emitter: EventEmitter.EventEmitter): void {
         emitter.emit("delegate.resigned", transaction.data);
     }
 
+    public canEnterTransactionPool(
+        data: Interfaces.ITransactionData,
+        pool: TransactionPool.IConnection,
+        processor: TransactionPool.IProcessor,
+    ): boolean {
+        if (this.typeFromSenderAlreadyInPool(data, pool, processor)) {
+            processor.pushError(data, "ERR_PENDING",
+                `Delegate resignation for "${data.asset.delegate.username}" already in the pool`);
+            return false;
+        }
+
+        return true;
+    }
+
+    protected applyToSender(transaction: Interfaces.ITransaction, walletManager: State.IWalletManager): void {
+        super.applyToSender(transaction, walletManager);
+
+        const sender: State.IWallet = walletManager.findByPublicKey(transaction.data.senderPublicKey);
+
+        walletManager.forgetByUsername(sender.username);
+
+        sender.username = undefined;
+    }
+
+    protected revertForSender(transaction: Interfaces.ITransaction, walletManager: State.IWalletManager): void {
+        super.revertForSender(transaction, walletManager);
+
+        const sender: State.IWallet = walletManager.findByPublicKey(transaction.data.senderPublicKey);
+
+        sender.username = transaction.data.asset.delegate.username;
+
+        walletManager.reindex(sender);
+    }
+
     protected applyToRecipient(transaction: Interfaces.ITransaction, walletManager: State.IWalletManager): void {
         return;
     }

packages/core/bin/config/devnet/plugins.js

@@ -28,7 +28,7 @@ module.exports = {
                 ipfs: 250,
                 timelockTransfer: 500,
                 multiPayment: 500,
-                delegateResignation: 400000,
+                delegateResignation: 100,
             },
         },
     },

packages/core/bin/config/mainnet/plugins.js

@@ -28,7 +28,7 @@ module.exports = {
                 ipfs: 250,
                 timelockTransfer: 500,
                 multiPayment: 500,
-                delegateResignation: 400000,
+                delegateResignation: 100,
             },
         },
     },

packages/core/bin/config/testnet/plugins.js

@@ -28,7 +28,7 @@ module.exports = {
                 ipfs: 250,
                 timelockTransfer: 500,
                 multiPayment: 500,
-                delegateResignation: 400000,
+                delegateResignation: 100,
             },
         },
     },

packages/crypto/src/transactions/builders/transactions/delegate-resignation.ts

@@ -11,12 +11,20 @@ export class DelegateResignationBuilder extends TransactionBuilder<DelegateResig
         this.data.type = TransactionTypes.DelegateResignation;
         this.data.fee = feeManager.get(TransactionTypes.DelegateResignation);
         this.data.amount = BigNumber.ZERO;
-        this.data.asset = {};
+        this.data.recipientId = undefined;
+        this.data.senderPublicKey = undefined;
+        this.data.asset = { delegate: {} } as ITransactionAsset;
+    }
+
+    public usernameAsset(username: string): DelegateResignationBuilder {
+        this.data.asset.delegate.username = username;
+        return this;
     }
 
     public getStruct(): ITransactionData {
         const struct: ITransactionData = super.getStruct();
         struct.amount = this.data.amount;
+        struct.recipientId = this.data.recipientId;
         struct.asset = this.data.asset;
         return struct;
     }

packages/crypto/src/transactions/serializer.ts

@@ -69,7 +69,8 @@ export class Serializer {
                 break;
             }
 
-            case TransactionTypes.DelegateRegistration: {
+            case TransactionTypes.DelegateRegistration:
+            case TransactionTypes.DelegateResignation: {
                 assetBytes = Buffer.from(transaction.asset.delegate.username, "utf8");
                 assetSize = assetBytes.length;
                 break;

packages/crypto/src/transactions/types/delegate-resignation.ts

@@ -12,10 +12,22 @@ export class DelegateResignationTransaction extends Transaction {
     }
 
     public serialize(options?: ISerializeOptions): ByteBuffer {
-        return new ByteBuffer(0);
+        const delegateBytes: Buffer = Buffer.from(this.data.asset.delegate.username, "utf8");
+        const buffer: ByteBuffer = new ByteBuffer(delegateBytes.length, true);
+
+        buffer.writeByte(delegateBytes.length);
+        buffer.append(delegateBytes, "hex");
+
+        return buffer;
     }
 
     public deserialize(buf: ByteBuffer): void {
-        return;
+        const usernamelength: number = buf.readUint8();
+
+        this.data.asset = {
+            delegate: {
+                username: buf.readString(usernamelength),
+            },
+        };
     }
 }

packages/crypto/src/transactions/types/schemas.ts

@@ -205,9 +205,23 @@ export const multiPayment = extend(transactionBaseSchema, {
 
 export const delegateResignation = extend(transactionBaseSchema, {
     $id: "delegateResignation",
+    required: ["asset"],
     properties: {
         type: { transactionType: TransactionTypes.DelegateResignation },
         amount: { bignumber: { minimum: 0, maximum: 0 } },
+        asset: {
+            type: "object",
+            required: ["delegate"],
+            properties: {
+                delegate: {
+                    type: "object",
+                    required: ["username"],
+                    properties: {
+                        username: { $ref: "delegateUsername" },
+                    },
+                },
+            },
+        },
     },
 });