@bitgo/sdk-coin-algo 2.5.2 → 2.5.3

package/dist/test/unit/lib/transactionBuilder/keyRegistrationBuilder.js

@@ -0,0 +1,473 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const statics_1 = require("@bitgo/statics");
+const algosdk_1 = __importDefault(require("algosdk"));
+const assert_1 = __importDefault(require("assert"));
+const should_1 = __importDefault(require("should"));
+const sinon_1 = __importStar(require("sinon"));
+const keyRegistrationBuilder_1 = require("../../../../src/lib/keyRegistrationBuilder");
+const AlgoResources = __importStar(require("../../../fixtures/resources"));
+class StubTransactionBuilder extends keyRegistrationBuilder_1.KeyRegistrationBuilder {
+    getTransaction() {
+        return this._transaction;
+    }
+}
+describe('Algo KeyRegistration Builder', () => {
+    const { networks: { testnet }, } = AlgoResources;
+    const { genesisHash, genesisID } = testnet;
+    let builder;
+    const sender = AlgoResources.accounts.account1;
+    const { rawTx } = AlgoResources;
+    beforeEach(() => {
+        const config = statics_1.coins.get('algo');
+        builder = new StubTransactionBuilder(config);
+    });
+    describe('setter validation', () => {
+        it('should validate voteKey, is set and is a valid string', () => {
+            should_1.default.doesNotThrow(() => builder.voteKey(sender.voteKey));
+        });
+        it('should validate selection key, is set and is a valid string', () => {
+            should_1.default.doesNotThrow(() => builder.selectionKey(sender.selectionKey));
+        });
+        it('should validate voteFirst is gt than 0', () => {
+            const spy = sinon_1.default.spy(builder, 'validateValue');
+            assert_1.default.throws(() => builder.voteFirst(-1), (e) => e.message === 'Value cannot be less than zero');
+            should_1.default.doesNotThrow(() => builder.voteFirst(15));
+            sinon_1.assert.calledTwice(spy);
+        });
+        it('should validate voteLast is gt than 0', () => {
+            const validateValueSpy = sinon_1.default.spy(builder, 'validateValue');
+            builder.voteFirst(1);
+            assert_1.default.throws(() => builder.voteLast(-1), (e) => e.message === 'Value cannot be less than zero');
+            should_1.default.doesNotThrow(() => builder.voteLast(15));
+            sinon_1.assert.calledThrice(validateValueSpy);
+        });
+        it('should validate vote Key Dilution', () => {
+            const validateValueSpy = sinon_1.default.spy(builder, 'validateValue');
+            builder.voteFirst(5).voteLast(18);
+            should_1.default.doesNotThrow(() => builder.voteKeyDilution(2));
+            sinon_1.assert.calledThrice(validateValueSpy);
+        });
+    });
+    describe('transaction validation', () => {
+        beforeEach(() => {
+            builder.sender({ address: sender.address }).fee({ fee: '1000' }).firstRound(1).lastRound(100).testnet();
+        });
+        it('should validate an online transaction', () => {
+            builder.voteKey(sender.voteKey).selectionKey(sender.selectionKey).voteFirst(1).voteLast(100).voteKeyDilution(9);
+            should_1.default.doesNotThrow(() => builder.validateTransaction(builder.getTransaction()));
+        });
+    });
+    describe('build key registration transaction', () => {
+        const requiredFieldErrorRegEx = /Transaction validation failed: "(voteLast|voteKey|voteFirst|voteKeyDilution|selectionKey)" is required/;
+        it('should build an online key registration transaction without stateProof param', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteKey(sender.voteKey)
+                .selectionKey(sender.selectionKey)
+                .voteFirst(1)
+                .voteLast(100)
+                .voteKeyDilution(9)
+                .testnet()
+                .numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));
+            should_1.default.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));
+            should_1.default.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, 1);
+            should_1.default.deepEqual(txJson.voteLast, 100);
+            should_1.default.deepEqual(txJson.voteKeyDilution, 9);
+            should_1.default.deepEqual(txJson.genesisID, genesisID.toString());
+            should_1.default.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);
+        });
+        it('should build an online key registration transaction with stateProof Param', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteKey(sender.voteKey)
+                .selectionKey(sender.selectionKey)
+                .voteFirst(1)
+                .voteLast(100)
+                .voteKeyDilution(9)
+                .stateProofKey(sender.stateProofKey)
+                .testnet()
+                .numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));
+            should_1.default.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));
+            should_1.default.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, 1);
+            should_1.default.deepEqual(txJson.voteLast, 100);
+            should_1.default.deepEqual(txJson.voteKeyDilution, 9);
+            should_1.default.deepEqual(txJson.genesisID, genesisID.toString());
+            should_1.default.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);
+            should_1.default.deepEqual(txJson.stateProofKey.toString('base64'), sender.stateProofKey);
+        });
+        it('should build an online keyreg transaction with malformated stateProof Param', async () => {
+            const malformatedStateProofKey = '0x' + '0'.repeat(64);
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteKey(sender.voteKey)
+                .selectionKey(sender.selectionKey)
+                .voteFirst(1)
+                .voteLast(100)
+                .voteKeyDilution(9);
+            assert_1.default.throws(() => builder.stateProofKey(malformatedStateProofKey), 'Error: Invalid base64 string');
+        });
+        it('should build an offline key registration transaction', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .testnet()
+                .numberOfSigners(1)
+                .nonParticipation(false);
+            builder.sign({ key: sender.prvKey });
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.deepEqual(txJson.voteKey, undefined);
+            should_1.default.deepEqual(txJson.selectionKey, undefined);
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, undefined);
+            should_1.default.deepEqual(txJson.voteLast, undefined);
+            should_1.default.deepEqual(txJson.voteKeyDilution, undefined);
+            should_1.default.deepEqual(txJson.nonParticipation, undefined);
+            should_1.default.deepEqual(txJson.genesisID, genesisID.toString());
+            should_1.default.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);
+        });
+        it('should build a key registration transaction with non participation', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .testnet()
+                .numberOfSigners(1)
+                .nonParticipation(true);
+            builder.sign({ key: sender.prvKey });
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.deepEqual(txJson.voteKey, undefined);
+            should_1.default.deepEqual(txJson.selectionKey, undefined);
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, undefined);
+            should_1.default.deepEqual(txJson.voteLast, undefined);
+            should_1.default.deepEqual(txJson.voteKeyDilution, undefined);
+            should_1.default.deepEqual(txJson.nonParticipation, true);
+            should_1.default.deepEqual(txJson.genesisID, genesisID.toString());
+            should_1.default.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);
+        });
+        it('build an offline key registration transaction should thrown an error when it hasfee', async () => {
+            builder.sender({ address: sender.address }).firstRound(1).lastRound(100).testnet().numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "fee" is required');
+        });
+        it('build an offline key registration transaction should thrown an error when it has voteLast', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteLast(100)
+                .testnet()
+                .numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);
+        });
+        it('build an offline key registration transaction should thrown an error when it has selectionKey', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .selectionKey(sender.selectionKey)
+                .testnet()
+                .numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);
+        });
+        it('build an offline key registration transaction should thrown an error when it has voteKeyDilution', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteKeyDilution(9)
+                .testnet()
+                .numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);
+        });
+        it('build an offline key registration transaction should thrown an error when it has voteFirst', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteFirst(1)
+                .testnet()
+                .numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);
+        });
+        it('build an offline key registration transaction should thrown an error when it has voteKey', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteKey(sender.voteKey)
+                .testnet()
+                .numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);
+        });
+        it('build an offline key registration transaction without non participation should thrown an error when it has not first round', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .lastRound(100)
+                .testnet()
+                .numberOfSigners(1)
+                .nonParticipation(false);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "firstRound" is required');
+        });
+        it('build an offline key registration transaction without non participation should thrown an error when it has not last round', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .testnet()
+                .numberOfSigners(1)
+                .nonParticipation(false);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "lastRound" is required');
+        });
+        it('build an offline key registration transaction without non participation should thrown an error when it has not testnet set', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .numberOfSigners(1)
+                .nonParticipation(false);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "genesisHash" is required');
+        });
+        it('should build an unsigned offline key registration transaction', async () => {
+            builder.sender({ address: sender.address }).fee({ fee: '1000' }).firstRound(1).lastRound(100).testnet();
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.genesisID, genesisID.toString());
+            should_1.default.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);
+        });
+        it('build a key registration transaction with non participation should thrown an error when it has not fee', async () => {
+            builder
+                .sender({ address: sender.address })
+                .firstRound(1)
+                .lastRound(100)
+                .testnet()
+                .numberOfSigners(1)
+                .nonParticipation(true);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "fee" is required');
+        });
+        it('build a key registration transaction with non participation should thrown an error when it has not first round', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .lastRound(100)
+                .testnet()
+                .numberOfSigners(1)
+                .nonParticipation(true);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "firstRound" is required');
+        });
+        it('build a key registration transaction with non participation should thrown an error when it has not last round', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .testnet()
+                .numberOfSigners(1)
+                .nonParticipation(true);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "lastRound" is required');
+        });
+        it('build a key registration transaction with non participation should thrown an error when it has not testnet set', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .numberOfSigners(1)
+                .nonParticipation(true);
+            builder.sign({ key: sender.prvKey });
+            await builder.build().should.be.rejectedWith('Transaction validation failed: "genesisHash" is required');
+        });
+        it('should build an unsigned key registration transaction', async () => {
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteKey(sender.voteKey)
+                .selectionKey(sender.selectionKey)
+                .voteFirst(1)
+                .voteLast(100)
+                .voteKeyDilution(9)
+                .testnet();
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));
+            should_1.default.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));
+            should_1.default.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, 1);
+            should_1.default.deepEqual(txJson.voteLast, 100);
+            should_1.default.deepEqual(txJson.voteKeyDilution, 9);
+            should_1.default.deepEqual(txJson.genesisID, genesisID.toString());
+            should_1.default.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);
+        });
+        it('should build a trx from an unsigned raw transaction', async () => {
+            builder.from(rawTx.keyReg.unsigned);
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));
+            should_1.default.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));
+            should_1.default.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, 1);
+            should_1.default.deepEqual(txJson.voteLast, 100);
+            should_1.default.deepEqual(txJson.voteKeyDilution, 9);
+        });
+        it('should sign from raw unsigned tx', async () => {
+            builder.from(rawTx.keyReg.unsigned);
+            builder.numberOfSigners(1);
+            builder.sign({ key: sender.prvKey });
+            const tx = await builder.build();
+            should_1.default.deepEqual(Buffer.from(tx.toBroadcastFormat()).toString('hex'), AlgoResources.rawTx.keyReg.signed);
+            const txJson = tx.toJson();
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));
+            should_1.default.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));
+            should_1.default.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);
+            should_1.default.deepEqual(txJson.from, sender.address);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, 1);
+            should_1.default.deepEqual(txJson.voteLast, 100);
+            should_1.default.deepEqual(txJson.voteKeyDilution, 9);
+        });
+    });
+    describe('build multi-sig key registration transaction', () => {
+        it('should build a msig registration transaction', async () => {
+            const msigAddress = algosdk_1.default.multisigAddress({
+                version: 1,
+                threshold: 2,
+                addrs: [AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address],
+            });
+            builder
+                .sender({ address: sender.address })
+                .fee({ fee: '1000' })
+                .firstRound(1)
+                .lastRound(100)
+                .voteKey(sender.voteKey)
+                .selectionKey(sender.selectionKey)
+                .voteFirst(1)
+                .voteLast(100)
+                .voteKeyDilution(9)
+                .testnet()
+                .numberOfSigners(2)
+                .setSigners([AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address])
+                .sign({ key: AlgoResources.accounts.account1.prvKey });
+            builder.sign({ key: AlgoResources.accounts.account3.prvKey });
+            const tx = await builder.build();
+            const txJson = tx.toJson();
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));
+            should_1.default.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);
+            should_1.default.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));
+            should_1.default.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);
+            should_1.default.deepEqual(txJson.from, msigAddress);
+            should_1.default.deepEqual(txJson.firstRound, 1);
+            should_1.default.deepEqual(txJson.lastRound, 100);
+            should_1.default.deepEqual(txJson.voteFirst, 1);
+            should_1.default.deepEqual(txJson.voteLast, 100);
+            should_1.default.deepEqual(txJson.voteKeyDilution, 9);
+            should_1.default.deepEqual(txJson.genesisID, genesisID.toString());
+            should_1.default.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyRegistrationBuilder.js","sourceRoot":"","sources":["../../../../../test/unit/lib/transactionBuilder/keyRegistrationBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { coins } from '@bitgo/statics';\nimport algosdk from 'algosdk';\nimport assert from 'assert';\nimport should from 'should';\nimport sinon, { assert as SinonAssert } from 'sinon';\nimport { Transaction } from '../../../../src/lib';\nimport { KeyRegistrationBuilder } from '../../../../src/lib/keyRegistrationBuilder';\n\nimport * as AlgoResources from '../../../fixtures/resources';\n\nclass StubTransactionBuilder extends KeyRegistrationBuilder {\n  getTransaction(): Transaction {\n    return this._transaction;\n  }\n}\n\ndescribe('Algo KeyRegistration Builder', () => {\n  const {\n    networks: { testnet },\n  } = AlgoResources;\n  const { genesisHash, genesisID } = testnet;\n  let builder: StubTransactionBuilder;\n\n  const sender = AlgoResources.accounts.account1;\n  const { rawTx } = AlgoResources;\n\n  beforeEach(() => {\n    const config = coins.get('algo');\n    builder = new StubTransactionBuilder(config);\n  });\n\n  describe('setter validation', () => {\n    it('should validate voteKey, is set and is a valid string', () => {\n      should.doesNotThrow(() => builder.voteKey(sender.voteKey));\n    });\n\n    it('should validate selection key, is set and is a valid string', () => {\n      should.doesNotThrow(() => builder.selectionKey(sender.selectionKey));\n    });\n\n    it('should validate voteFirst is gt than 0', () => {\n      const spy = sinon.spy(builder, 'validateValue');\n      assert.throws(\n        () => builder.voteFirst(-1),\n        (e: Error) => e.message === 'Value cannot be less than zero'\n      );\n      should.doesNotThrow(() => builder.voteFirst(15));\n      SinonAssert.calledTwice(spy);\n    });\n\n    it('should validate voteLast is gt than 0', () => {\n      const validateValueSpy = sinon.spy(builder, 'validateValue');\n      builder.voteFirst(1);\n      assert.throws(\n        () => builder.voteLast(-1),\n        (e: Error) => e.message === 'Value cannot be less than zero'\n      );\n      should.doesNotThrow(() => builder.voteLast(15));\n      SinonAssert.calledThrice(validateValueSpy);\n    });\n\n    it('should validate vote Key Dilution', () => {\n      const validateValueSpy = sinon.spy(builder, 'validateValue');\n      builder.voteFirst(5).voteLast(18);\n      should.doesNotThrow(() => builder.voteKeyDilution(2));\n      SinonAssert.calledThrice(validateValueSpy);\n    });\n  });\n\n  describe('transaction validation', () => {\n    beforeEach(() => {\n      builder.sender({ address: sender.address }).fee({ fee: '1000' }).firstRound(1).lastRound(100).testnet();\n    });\n    it('should validate an online transaction', () => {\n      builder.voteKey(sender.voteKey).selectionKey(sender.selectionKey).voteFirst(1).voteLast(100).voteKeyDilution(9);\n      should.doesNotThrow(() => builder.validateTransaction(builder.getTransaction()));\n    });\n  });\n\n  describe('build key registration transaction', () => {\n    const requiredFieldErrorRegEx =\n      /Transaction validation failed: \"(voteLast|voteKey|voteFirst|voteKeyDilution|selectionKey)\" is required/;\n\n    it('should build an online key registration transaction without stateProof param', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteKey(sender.voteKey)\n        .selectionKey(sender.selectionKey)\n        .voteFirst(1)\n        .voteLast(100)\n        .voteKeyDilution(9)\n        .testnet()\n        .numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));\n      should.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));\n      should.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, 1);\n      should.deepEqual(txJson.voteLast, 100);\n      should.deepEqual(txJson.voteKeyDilution, 9);\n      should.deepEqual(txJson.genesisID, genesisID.toString());\n      should.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);\n    });\n\n    it('should build an online key registration transaction with stateProof Param', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteKey(sender.voteKey)\n        .selectionKey(sender.selectionKey)\n        .voteFirst(1)\n        .voteLast(100)\n        .voteKeyDilution(9)\n        .stateProofKey(sender.stateProofKey)\n        .testnet()\n        .numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));\n      should.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));\n      should.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, 1);\n      should.deepEqual(txJson.voteLast, 100);\n      should.deepEqual(txJson.voteKeyDilution, 9);\n      should.deepEqual(txJson.genesisID, genesisID.toString());\n      should.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);\n      should.deepEqual(txJson.stateProofKey.toString('base64'), sender.stateProofKey);\n    });\n\n    it('should build an online keyreg transaction with malformated stateProof Param', async () => {\n      const malformatedStateProofKey = '0x' + '0'.repeat(64);\n\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteKey(sender.voteKey)\n        .selectionKey(sender.selectionKey)\n        .voteFirst(1)\n        .voteLast(100)\n        .voteKeyDilution(9);\n      assert.throws(() => builder.stateProofKey(malformatedStateProofKey), 'Error: Invalid base64 string');\n    });\n\n    it('should build an offline key registration transaction', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .testnet()\n        .numberOfSigners(1)\n        .nonParticipation(false);\n      builder.sign({ key: sender.prvKey });\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.voteKey, undefined);\n      should.deepEqual(txJson.selectionKey, undefined);\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, undefined);\n      should.deepEqual(txJson.voteLast, undefined);\n      should.deepEqual(txJson.voteKeyDilution, undefined);\n      should.deepEqual(txJson.nonParticipation, undefined);\n      should.deepEqual(txJson.genesisID, genesisID.toString());\n      should.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);\n    });\n\n    it('should build a key registration transaction with non participation', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .testnet()\n        .numberOfSigners(1)\n        .nonParticipation(true);\n      builder.sign({ key: sender.prvKey });\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.voteKey, undefined);\n      should.deepEqual(txJson.selectionKey, undefined);\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, undefined);\n      should.deepEqual(txJson.voteLast, undefined);\n      should.deepEqual(txJson.voteKeyDilution, undefined);\n      should.deepEqual(txJson.nonParticipation, true);\n      should.deepEqual(txJson.genesisID, genesisID.toString());\n      should.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);\n    });\n\n    it('build an offline key registration transaction should thrown an error when it hasfee', async () => {\n      builder.sender({ address: sender.address }).firstRound(1).lastRound(100).testnet().numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"fee\" is required');\n    });\n\n    it('build an offline key registration transaction should thrown an error when it has voteLast', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteLast(100)\n        .testnet()\n        .numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);\n    });\n\n    it('build an offline key registration transaction should thrown an error when it has selectionKey', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .selectionKey(sender.selectionKey)\n        .testnet()\n        .numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);\n    });\n\n    it('build an offline key registration transaction should thrown an error when it has voteKeyDilution', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteKeyDilution(9)\n        .testnet()\n        .numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);\n    });\n\n    it('build an offline key registration transaction should thrown an error when it has voteFirst', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteFirst(1)\n        .testnet()\n        .numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);\n    });\n\n    it('build an offline key registration transaction should thrown an error when it has voteKey', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteKey(sender.voteKey)\n        .testnet()\n        .numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith(requiredFieldErrorRegEx);\n    });\n\n    it('build an offline key registration transaction without non participation should thrown an error when it has not first round', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .lastRound(100)\n        .testnet()\n        .numberOfSigners(1)\n        .nonParticipation(false);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"firstRound\" is required');\n    });\n\n    it('build an offline key registration transaction without non participation should thrown an error when it has not last round', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .testnet()\n        .numberOfSigners(1)\n        .nonParticipation(false);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"lastRound\" is required');\n    });\n\n    it('build an offline key registration transaction without non participation should thrown an error when it has not testnet set', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .numberOfSigners(1)\n        .nonParticipation(false);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"genesisHash\" is required');\n    });\n\n    it('should build an unsigned offline key registration transaction', async () => {\n      builder.sender({ address: sender.address }).fee({ fee: '1000' }).firstRound(1).lastRound(100).testnet();\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.genesisID, genesisID.toString());\n      should.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);\n    });\n\n    it('build a key registration transaction with non participation should thrown an error when it has not fee', async () => {\n      builder\n        .sender({ address: sender.address })\n        .firstRound(1)\n        .lastRound(100)\n        .testnet()\n        .numberOfSigners(1)\n        .nonParticipation(true);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"fee\" is required');\n    });\n\n    it('build a key registration transaction with non participation should thrown an error when it has not first round', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .lastRound(100)\n        .testnet()\n        .numberOfSigners(1)\n        .nonParticipation(true);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"firstRound\" is required');\n    });\n\n    it('build a key registration transaction with non participation should thrown an error when it has not last round', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .testnet()\n        .numberOfSigners(1)\n        .nonParticipation(true);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"lastRound\" is required');\n    });\n\n    it('build a key registration transaction with non participation should thrown an error when it has not testnet set', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .numberOfSigners(1)\n        .nonParticipation(true);\n      builder.sign({ key: sender.prvKey });\n      await builder.build().should.be.rejectedWith('Transaction validation failed: \"genesisHash\" is required');\n    });\n\n    it('should build an unsigned key registration transaction', async () => {\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteKey(sender.voteKey)\n        .selectionKey(sender.selectionKey)\n        .voteFirst(1)\n        .voteLast(100)\n        .voteKeyDilution(9)\n        .testnet();\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));\n      should.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));\n      should.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, 1);\n      should.deepEqual(txJson.voteLast, 100);\n      should.deepEqual(txJson.voteKeyDilution, 9);\n      should.deepEqual(txJson.genesisID, genesisID.toString());\n      should.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);\n    });\n\n    it('should build a trx from an unsigned raw transaction', async () => {\n      builder.from(rawTx.keyReg.unsigned);\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));\n      should.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));\n      should.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, 1);\n      should.deepEqual(txJson.voteLast, 100);\n      should.deepEqual(txJson.voteKeyDilution, 9);\n    });\n\n    it('should sign from raw unsigned tx', async () => {\n      builder.from(rawTx.keyReg.unsigned);\n      builder.numberOfSigners(1);\n      builder.sign({ key: sender.prvKey });\n      const tx = await builder.build();\n      should.deepEqual(Buffer.from(tx.toBroadcastFormat()).toString('hex'), AlgoResources.rawTx.keyReg.signed);\n      const txJson = tx.toJson();\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));\n      should.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));\n      should.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);\n      should.deepEqual(txJson.from, sender.address);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, 1);\n      should.deepEqual(txJson.voteLast, 100);\n      should.deepEqual(txJson.voteKeyDilution, 9);\n    });\n  });\n\n  describe('build multi-sig key registration transaction', () => {\n    it('should build a msig registration transaction', async () => {\n      const msigAddress = algosdk.multisigAddress({\n        version: 1,\n        threshold: 2,\n        addrs: [AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address],\n      });\n      builder\n        .sender({ address: sender.address })\n        .fee({ fee: '1000' })\n        .firstRound(1)\n        .lastRound(100)\n        .voteKey(sender.voteKey)\n        .selectionKey(sender.selectionKey)\n        .voteFirst(1)\n        .voteLast(100)\n        .voteKeyDilution(9)\n        .testnet()\n        .numberOfSigners(2)\n        .setSigners([AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address])\n        .sign({ key: AlgoResources.accounts.account1.prvKey });\n      builder.sign({ key: AlgoResources.accounts.account3.prvKey });\n      const tx = await builder.build();\n      const txJson = tx.toJson();\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.voteKey }));\n      should.deepEqual(txJson.voteKey.toString('base64'), sender.voteKey);\n      should.doesNotThrow(() => builder.validateKey({ key: txJson.selectionKey }));\n      should.deepEqual(txJson.selectionKey.toString('base64'), sender.selectionKey);\n      should.deepEqual(txJson.from, msigAddress);\n      should.deepEqual(txJson.firstRound, 1);\n      should.deepEqual(txJson.lastRound, 100);\n      should.deepEqual(txJson.voteFirst, 1);\n      should.deepEqual(txJson.voteLast, 100);\n      should.deepEqual(txJson.voteKeyDilution, 9);\n      should.deepEqual(txJson.genesisID, genesisID.toString());\n      should.deepEqual(txJson.genesisHash.toString('base64'), genesisHash);\n    });\n  });\n});\n"]}

package/dist/test/unit/lib/transactionBuilder/transactionBuilderFactory.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

package/dist/test/unit/lib/transactionBuilder/transactionBuilderFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../../../test/unit/lib/transactionBuilder/transactionBuilderFactory.ts"],"names":[],"mappings":""}