feat: add BlsPublicKeyRegistration transaction

.github/workflows/functional.yml

@@ -511,6 +511,61 @@ jobs:
                   name: ${{ github.job }}-coverage
                   path: .coverage/functional/${{ github.job }}/lcov.info
 
+    bls-public-key-registration-resignation:
+        runs-on: ubuntu-latest
+
+        services:
+            postgres:
+                image: postgres:12
+                env:
+                    POSTGRES_USER: ark
+                    POSTGRES_PASSWORD: password
+                    POSTGRES_DB: ark_unitnet
+                ports:
+                    - 5432:5432
+                options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+        strategy:
+            matrix:
+                node-version: [16.x]
+
+        steps:
+            - uses: actions/checkout@v4
+            - name: Cache node modules
+              uses: actions/cache@v4
+              with:
+                  path: node_modules
+                  key: ${{ runner.os }}-node-${{ hashFiles('**/yarn.lock') }}
+                  restore-keys: ${{ runner.os }}-node-
+            - name: Use Node.js ${{ matrix.node-version }}
+              uses: actions/setup-node@v1
+              with:
+                  node-version: ${{ matrix.node-version }}
+
+            - name: Update system
+              run: sudo apt-get update -y
+
+            - name: Install xsel & postgresql-client
+              run: sudo apt-get install -q xsel postgresql-client
+
+            - name: Install and build packages
+              run: yarn setup
+
+            - name: Create .core/database directory
+              run: mkdir -p $HOME/.core/database
+
+            - name: Functional tests
+              run: yarn test __tests__/functional/transaction-forging/bls-public-key-registration.test.ts --coverage --coverageDirectory .coverage/functional/${{ github.job }}
+              env:
+                  CORE_DB_DATABASE: ark_unitnet
+                  CORE_DB_USERNAME: ark
+
+            - name: Archive code coverage
+              uses: actions/upload-artifact@v4
+              with:
+                  name: ${{ github.job }}-coverage
+                  path: .coverage/functional/${{ github.job }}/lcov.info
+
     htlc-claim:
         runs-on: ubuntu-latest
 

__tests__/functional/transaction-forging/__support__/index.ts

@@ -58,11 +58,13 @@ export const setUp = async (): Promise<Contracts.Kernel.Application> => {
 
         Managers.configManager.getMilestone().aip11 = false;
         Managers.configManager.getMilestone().htlcEnabled = false;
+        Managers.configManager.getMilestone().blsPublicKeyRegistrationEnabled = false;
 
         await app.boot();
 
         Managers.configManager.getMilestone().aip11 = true;
         Managers.configManager.getMilestone().htlcEnabled = true;
+        Managers.configManager.getMilestone().blsPublicKeyRegistrationEnabled = true;
     });
 
     return sandbox.app;

__tests__/functional/transaction-forging/bls-public-key-registration.test.ts

@@ -0,0 +1,250 @@
+import "@packages/core-test-framework/src/matchers";
+
+import { Contracts } from "@arkecosystem/core-kernel";
+import { Identities } from "@arkecosystem/crypto";
+import secrets from "@packages/core-test-framework/src/internal/passphrases.json";
+import { snoozeForBlock, TransactionFactory } from "@packages/core-test-framework/src/utils";
+import { generateMnemonic } from "bip39";
+
+import * as support from "./__support__";
+
+const genesisPassphrase: string = secrets[0];
+
+let app: Contracts.Kernel.Application;
+beforeAll(async () => (app = await support.setUp()));
+afterAll(async () => await support.tearDown());
+
+describe("Transaction Forging - Bls Public Key Registration", () => {
+    describe("Signed with 1 Passphase", () => {
+        it("should broadcast, accept and forge it", async () => {
+            // Prepare a fresh wallet for the tests
+            const passphrase = generateMnemonic();
+
+            // Initial Funds
+            const initialFunds = TransactionFactory.initialize(app)
+                .transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
+                .withPassphrase(genesisPassphrase)
+                .createOne();
+
+            await expect(initialFunds).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(initialFunds.id).toBeForged();
+
+            // Register a delegate
+            const transactionsRegister = TransactionFactory.initialize(app)
+                .delegateRegistration()
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegister).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegister.id).toBeForged();
+
+            // Register bls public key
+            const transactionsRegisterFirst = TransactionFactory.initialize(app)
+                .blsPublicKeyRegistration({
+                    newBlsPublicKey: "a".repeat(96),
+                })
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegisterFirst).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegisterFirst.id).toBeForged();
+            await expect(transactionsRegisterFirst).blsPublicKeyRegistered();
+
+            // Overwrite bls public key
+            const transactionsRegisterSecond = TransactionFactory.initialize(app)
+                .blsPublicKeyRegistration({
+                    oldBlsPublicKey: "a".repeat(96),
+                    newBlsPublicKey: "b".repeat(96),
+                })
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegisterSecond).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegisterSecond.id).toBeForged();
+            await expect(transactionsRegisterSecond).blsPublicKeyRegistered();
+        });
+
+        it("should reject if bls key is already registered", async () => {
+            // Prepare a fresh wallet for the tests
+            const passphrase = generateMnemonic();
+
+            // Initial Funds
+            const initialFunds = TransactionFactory.initialize(app)
+                .transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
+                .withPassphrase(genesisPassphrase)
+                .createOne();
+
+            await expect(initialFunds).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(initialFunds.id).toBeForged();
+
+            // Register a delegate
+            const transactionsRegister = TransactionFactory.initialize(app)
+                .delegateRegistration()
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegister).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegister.id).toBeForged();
+
+            // Register bls public key
+            const transactionsRegisterFirst = TransactionFactory.initialize(app)
+                .blsPublicKeyRegistration({
+                    newBlsPublicKey: "b".repeat(96),
+                })
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegisterFirst).toBeRejected();
+            await snoozeForBlock(1);
+            await expect(transactionsRegisterFirst.id).not.toBeForged();
+            await expect(transactionsRegisterFirst).not.blsPublicKeyRegistered();
+        });
+
+        it("should reject if delegate is resiged", async () => {
+            // Prepare a fresh wallet for the tests
+            const passphrase = generateMnemonic();
+
+            // Initial Funds
+            const initialFunds = TransactionFactory.initialize(app)
+                .transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
+                .withPassphrase(genesisPassphrase)
+                .createOne();
+
+            await expect(initialFunds).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(initialFunds.id).toBeForged();
+
+            // Register a delegate
+            const transactionsRegister = TransactionFactory.initialize(app)
+                .delegateRegistration()
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegister).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegister.id).toBeForged();
+
+            // Resign a delegate
+            const transactionsResign = TransactionFactory.initialize(app)
+                .delegateResignation()
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsResign).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsResign.id).toBeForged();
+
+            // Register bls public key
+            const transactionsRegisterFirst = TransactionFactory.initialize(app)
+                .blsPublicKeyRegistration({
+                    newBlsPublicKey: "f".repeat(96),
+                })
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegisterFirst).toBeRejected();
+            await snoozeForBlock(1);
+            await expect(transactionsRegisterFirst.id).not.toBeForged();
+            await expect(transactionsRegisterFirst).not.blsPublicKeyRegistered();
+        });
+
+        it("should reject if not from delegate", async () => {
+            // Prepare a fresh wallet for the tests
+            const passphrase = generateMnemonic();
+
+            // Initial Funds
+            const initialFunds = TransactionFactory.initialize(app)
+                .transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
+                .withPassphrase(genesisPassphrase)
+                .createOne();
+
+            await expect(initialFunds).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(initialFunds.id).toBeForged();
+
+            // Register bls public key
+            const transactionsRegisterFirst = TransactionFactory.initialize(app)
+                .blsPublicKeyRegistration({
+                    newBlsPublicKey: "g".repeat(96),
+                })
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(transactionsRegisterFirst).toBeRejected();
+            await snoozeForBlock(1);
+            await expect(transactionsRegisterFirst.id).not.toBeForged();
+            await expect(transactionsRegisterFirst).not.blsPublicKeyRegistered();
+        });
+    });
+
+    describe("Signed with 2 Passphases", () => {
+        it("should broadcast, accept and forge it", async () => {
+            // Prepare a fresh wallet for the tests
+            const passphrase = generateMnemonic();
+            const secondPassphrase = generateMnemonic();
+
+            // Initial Funds
+            const initialFunds = TransactionFactory.initialize(app)
+                .transfer(Identities.Address.fromPassphrase(passphrase), 100 * 1e8)
+                .withPassphrase(genesisPassphrase)
+                .createOne();
+
+            await expect(initialFunds).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(initialFunds.id).toBeForged();
+
+            // Register a second passphrase
+            const secondSignature = TransactionFactory.initialize(app)
+                .secondSignature(secondPassphrase)
+                .withPassphrase(passphrase)
+                .createOne();
+
+            await expect(secondSignature).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(secondSignature.id).toBeForged();
+
+            // Register a delegate
+            const transactionsRegister = TransactionFactory.initialize(app)
+                .delegateRegistration()
+                .withPassphrasePair({ passphrase, secondPassphrase })
+                .createOne();
+
+            await expect(transactionsRegister).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegister.id).toBeForged();
+
+            // Register bls public key
+            const transactionsRegisterFirst = TransactionFactory.initialize(app)
+                .blsPublicKeyRegistration({
+                    newBlsPublicKey: "c".repeat(96),
+                })
+                .withPassphrasePair({ passphrase, secondPassphrase })
+                .createOne();
+
+            await expect(transactionsRegisterFirst).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegisterFirst.id).toBeForged();
+            await expect(transactionsRegisterFirst).blsPublicKeyRegistered();
+
+            // Register bls public key
+            const transactionsRegisterSecond = TransactionFactory.initialize(app)
+                .blsPublicKeyRegistration({
+                    oldBlsPublicKey: "c".repeat(96),
+                    newBlsPublicKey: "d".repeat(96),
+                })
+                .withPassphrasePair({ passphrase, secondPassphrase })
+                .createOne();
+
+            await expect(transactionsRegisterSecond).toBeAccepted();
+            await snoozeForBlock(1);
+            await expect(transactionsRegisterSecond.id).toBeForged();
+            await expect(transactionsRegisterSecond).blsPublicKeyRegistered();
+        });
+    });
+});

__tests__/unit/core-api/__support__/app.ts

@@ -106,6 +106,7 @@ export const initApp = (): Application => {
     app.bind(Identifiers.TransactionHandler).to(Two.HtlcLockTransactionHandler);
     app.bind(Identifiers.TransactionHandler).to(Two.HtlcClaimTransactionHandler);
     app.bind(Identifiers.TransactionHandler).to(Two.HtlcRefundTransactionHandler);
+    app.bind(Identifiers.TransactionHandler).to(Two.BlsPublicKeyRegistrationTransactionHandler);
 
     app.bind(Identifiers.TransactionHandlerProvider).to(TransactionHandlerProvider).inSingletonScope();
     app.bind(Identifiers.TransactionHandlerRegistry).to(TransactionHandlerRegistry).inSingletonScope();

__tests__/unit/core-api/controllers/transactions.test.ts

@@ -316,7 +316,7 @@ describe("TransactionsController", () => {
         it("should return registered schemas", async () => {
             const response = (await controller.schemas(undefined, undefined)) as ItemResponse;
 
-            const coreTransactionHandlersCount = 11;
+            const coreTransactionHandlersCount = 12;
             expect(Object.keys(response.data["1"]).length).toBe(coreTransactionHandlersCount);
         });
     });

__tests__/unit/core-state/wallets/wallet-repository-copy-on-write.test.ts

@@ -4,6 +4,7 @@ import { Contracts } from "@packages/core-kernel";
 import { Wallet, WalletRepository, WalletRepositoryCopyOnWrite } from "@packages/core-state/src/wallets";
 import {
     addressesIndexer,
+    blsPublicKeysIndexer,
     ipfsIndexer,
     locksIndexer,
     publicKeysIndexer,
@@ -36,14 +37,15 @@ describe("Wallet Repository Copy On Write", () => {
     });
 
     it("should be able to look up indexers", () => {
-        const expected = ["addresses", "publicKeys", "usernames", "resignations", "locks", "ipfs"];
+        const expected = ["addresses", "publicKeys", "usernames", "resignations", "locks", "ipfs", "blsPublicKeys"];
         expect(walletRepoCopyOnWrite.getIndexNames()).toEqual(expected);
         expect(walletRepoCopyOnWrite.getIndex("addresses").indexer).toEqual(addressesIndexer);
         expect(walletRepoCopyOnWrite.getIndex("publicKeys").indexer).toEqual(publicKeysIndexer);
         expect(walletRepoCopyOnWrite.getIndex("usernames").indexer).toEqual(usernamesIndexer);
         expect(walletRepoCopyOnWrite.getIndex("resignations").indexer).toEqual(resignationsIndexer);
         expect(walletRepoCopyOnWrite.getIndex("locks").indexer).toEqual(locksIndexer);
         expect(walletRepoCopyOnWrite.getIndex("ipfs").indexer).toEqual(ipfsIndexer);
+        expect(walletRepoCopyOnWrite.getIndex("blsPublicKeys").indexer).toEqual(blsPublicKeysIndexer);
     });
 
     it("should find wallets by address", () => {

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

@@ -11,6 +11,7 @@ import {
 import { Wallet, WalletRepository } from "@packages/core-state/src/wallets";
 import {
     addressesIndexer,
+    blsPublicKeysIndexer,
     ipfsIndexer,
     locksIndexer,
     publicKeysIndexer,
@@ -75,6 +76,7 @@ describe("Wallet Repository", () => {
             "resignations",
             "locks",
             "ipfs",
+            "blsPublicKeys",
             "businesses",
             "bridgechains",
         ];
@@ -85,6 +87,7 @@ describe("Wallet Repository", () => {
         expect(walletRepo.getIndex("resignations").indexer).toEqual(resignationsIndexer);
         expect(walletRepo.getIndex("locks").indexer).toEqual(locksIndexer);
         expect(walletRepo.getIndex("ipfs").indexer).toEqual(ipfsIndexer);
+        expect(walletRepo.getIndex("blsPublicKeys").indexer).toEqual(blsPublicKeysIndexer);
         expect(() => walletRepo.getIndex("iDontExist")).toThrow();
     });