@bitgo-beta/sdk-coin-sol 2.4.3-beta.998 → 7.6.3

package/dist/test/unit/transactionBuilder/stakingActivateBuilder.js

@@ -0,0 +1,430 @@
+"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 should_1 = __importDefault(require("should"));
+const testData = __importStar(require("../../resources/sol"));
+const getBuilderFactory_1 = require("../getBuilderFactory");
+const src_1 = require("../../../src");
+const constants_1 = require("../../../src/lib/constants");
+const public_types_1 = require("@bitgo/public-types");
+describe('Sol Staking Activate Builder', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+    const stakingBuilder = () => {
+        const txBuilder = factory.getStakingActivateBuilder();
+        txBuilder.nonce(recentBlockHash);
+        txBuilder.sender(wallet.pub);
+        return txBuilder;
+    };
+    // not valid data
+    const invalidPubKey = testData.pubKeys.invalidPubKeys[0];
+    const wrongAccount = new src_1.KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();
+    // valid data
+    const wallet = new src_1.KeyPair(testData.authAccount).getKeys();
+    const stakeAccount = new src_1.KeyPair(testData.stakeAccount).getKeys();
+    const validator = testData.validator;
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const amount = '300000';
+    const performTest = async ({ signBuilder, knownRawTx, makeUnsignedBuilder, verifyBuiltTransaction, }) => {
+        // Build transaction
+        const txBuilder = makeUnsignedBuilder();
+        const unsignedTx = await txBuilder.build();
+        const tx = signBuilder ? await signBuilder(txBuilder).build() : unsignedTx;
+        // Verify built transaction
+        verifyBuiltTransaction(tx);
+        // Verify raw transaction
+        const rawTx = tx.toBroadcastFormat();
+        should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+        should_1.default.equal(rawTx, knownRawTx);
+        // Rebuild transaction and verify
+        const builderFromRawTx = factory.from(rawTx);
+        const rebuiltTx = await builderFromRawTx.build();
+        should_1.default.equal(rebuiltTx.toBroadcastFormat(), unsignedTx.toBroadcastFormat());
+        should_1.default.equal(rebuiltTx.signablePayload.toString('hex'), unsignedTx.signablePayload.toString('hex'));
+        should_1.default.deepEqual(rebuiltTx.toJson().instructionsData, tx.toJson().instructionsData);
+    };
+    const makeUnsignedBuilderNative = (doMemo) => {
+        const txBuilder = factory.getStakingActivateBuilder();
+        txBuilder
+            .amount(amount)
+            .sender(wallet.pub)
+            .stakingAddress(stakeAccount.pub)
+            .validator(validator.pub)
+            .nonce(recentBlockHash);
+        if (doMemo) {
+            txBuilder.memo('test memo');
+        }
+        return txBuilder;
+    };
+    const verifyBuiltTransactionNativeOrMarinade = (tx, doMemo, stakingType) => {
+        const txJson = tx.toJson();
+        txJson.instructionsData.should.deepEqual([
+            ...(doMemo
+                ? [
+                    {
+                        type: 'Memo',
+                        params: {
+                            memo: 'test memo',
+                        },
+                    },
+                ]
+                : []),
+            {
+                type: 'Activate',
+                params: {
+                    fromAddress: wallet.pub,
+                    stakingAddress: stakeAccount.pub,
+                    amount: amount,
+                    validator: validator.pub,
+                    stakingType,
+                },
+            },
+        ]);
+        tx.inputs.should.deepEqual([
+            {
+                address: wallet.pub,
+                value: amount,
+                coin: 'tsol',
+            },
+        ]);
+        tx.outputs.should.deepEqual([
+            {
+                address: stakeAccount.pub,
+                value: amount,
+                coin: 'tsol',
+            },
+        ]);
+    };
+    const signBuilderNativeOrMarinade = (txBuilder) => {
+        txBuilder.sign({ key: wallet.prv });
+        txBuilder.sign({ key: stakeAccount.prv });
+        return txBuilder;
+    };
+    const makeUnsignedBuilderMarinade = (doMemo) => {
+        return makeUnsignedBuilderNative(doMemo).stakingType(public_types_1.SolStakingTypeEnum.MARINADE);
+    };
+    const makeUnsignedBuilderJito = (doMemo, doCreateATA) => {
+        const txBuilder = factory.getStakingActivateBuilder();
+        txBuilder
+            .amount(amount)
+            .sender(wallet.pub)
+            .stakingAddress(constants_1.JITO_STAKE_POOL_ADDRESS)
+            .validator(constants_1.JITO_STAKE_POOL_ADDRESS)
+            .stakingType(public_types_1.SolStakingTypeEnum.JITO)
+            .extraParams({
+            stakePoolData: {
+                managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),
+                poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),
+                reserveStake: testData.JITO_STAKE_POOL_DATA_PARSED.reserveStake.toString(),
+            },
+            createAssociatedTokenAccount: doCreateATA,
+        })
+            .nonce(recentBlockHash);
+        if (doMemo) {
+            txBuilder.memo('test memo');
+        }
+        return txBuilder;
+    };
+    const signBuilderJito = (txBuilder) => {
+        txBuilder.sign({ key: wallet.prv });
+        return txBuilder;
+    };
+    const verifyBuiltTransactionJito = (tx, doMemo, doCreateATA) => {
+        const txJson = tx.toJson();
+        const expectedInstructions = [];
+        if (doCreateATA) {
+            expectedInstructions.push({
+                type: constants_1.InstructionBuilderTypes.CreateAssociatedTokenAccount,
+                params: {
+                    ataAddress: '2vJrx2Bn7PifLZDRaSCpphE9WtZsx1k43SRyiQDhE1As',
+                    mintAddress: constants_1.JITOSOL_MINT_ADDRESS,
+                    ownerAddress: wallet.pub,
+                    payerAddress: wallet.pub,
+                    tokenName: 'sol:jitosol',
+                },
+            });
+        }
+        if (doMemo) {
+            expectedInstructions.push({
+                type: constants_1.InstructionBuilderTypes.Memo,
+                params: {
+                    memo: 'test memo',
+                },
+            });
+        }
+        expectedInstructions.push({
+            type: constants_1.InstructionBuilderTypes.StakingActivate,
+            params: {
+                fromAddress: wallet.pub,
+                stakingAddress: constants_1.JITO_STAKE_POOL_ADDRESS,
+                amount: amount,
+                validator: constants_1.JITO_STAKE_POOL_ADDRESS,
+                stakingType: public_types_1.SolStakingTypeEnum.JITO,
+                extraParams: {
+                    stakePoolData: {
+                        managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),
+                        poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),
+                        reserveStake: testData.JITO_STAKE_POOL_DATA_PARSED.reserveStake.toString(),
+                    },
+                    createAssociatedTokenAccount: doCreateATA,
+                },
+            },
+        });
+        txJson.instructionsData.should.deepEqual(expectedInstructions);
+        tx.inputs.should.deepEqual([
+            {
+                address: wallet.pub,
+                value: amount,
+                coin: 'tsol',
+            },
+        ]);
+        tx.outputs.should.deepEqual([]);
+    };
+    describe('Succeed', () => {
+        describe('Native staking tests', () => {
+            const performTestNative = async (doMemo, doSign, knownRawTx) => {
+                await performTest({
+                    signBuilder: doSign ? signBuilderNativeOrMarinade : undefined,
+                    knownRawTx,
+                    makeUnsignedBuilder: () => makeUnsignedBuilderNative(doMemo),
+                    verifyBuiltTransaction: (x) => verifyBuiltTransactionNativeOrMarinade(x, doMemo, public_types_1.SolStakingTypeEnum.NATIVE),
+                });
+            };
+            it('build a create and delegate staking signed tx', async () => performTestNative(false, true, testData.STAKING_ACTIVATE_SIGNED_TX));
+            it('build a create and delegate staking signed tx with memo', async () => performTestNative(true, true, testData.STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO));
+            it('build a create and delegate staking unsigned tx', async () => performTestNative(false, false, testData.STAKING_ACTIVATE_UNSIGNED_TX));
+            it('build a create and delegate staking unsigned tx with memo', async () => performTestNative(true, false, testData.STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO));
+        });
+        describe('Marinade staking tests', () => {
+            const performTestMarinade = async (doMemo, doSign, knownRawTx) => {
+                await performTest({
+                    signBuilder: doSign ? signBuilderNativeOrMarinade : undefined,
+                    knownRawTx,
+                    makeUnsignedBuilder: () => makeUnsignedBuilderMarinade(doMemo),
+                    verifyBuiltTransaction: (x) => verifyBuiltTransactionNativeOrMarinade(x, doMemo, public_types_1.SolStakingTypeEnum.MARINADE),
+                });
+            };
+            it('build a create staking signed tx', async () => performTestMarinade(false, true, testData.MARINADE_STAKING_ACTIVATE_SIGNED_TX));
+            it('build a create signed tx with memo', async () => performTestMarinade(true, true, testData.MARINADE_STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO));
+            it('build a create unsigned tx', async () => performTestMarinade(false, false, testData.MARINADE_STAKING_ACTIVATE_UNSIGNED_TX));
+            it('build a create unsigned tx with memo', async () => performTestMarinade(true, false, testData.MARINADE_STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO));
+        });
+        describe('Jito staking tests', () => {
+            const performTestJito = async (doMemo, doSign, doCreateATA, knownRawTx) => {
+                await performTest({
+                    signBuilder: doSign ? signBuilderJito : undefined,
+                    knownRawTx,
+                    makeUnsignedBuilder: () => makeUnsignedBuilderJito(doMemo, doCreateATA),
+                    verifyBuiltTransaction: (x) => verifyBuiltTransactionJito(x, doMemo, doCreateATA),
+                });
+            };
+            const MEMO = 1;
+            const SIGN = 2;
+            const ATA = 4;
+            const rawTxData = Array.from(new Array(8)).map(() => undefined);
+            rawTxData[0] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX;
+            rawTxData[MEMO] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO;
+            rawTxData[SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX;
+            rawTxData[MEMO + SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO;
+            rawTxData[ATA] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX_WITH_ATA;
+            rawTxData[ATA + MEMO] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO_WITH_ATA;
+            rawTxData[ATA + SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX_WITH_ATA;
+            rawTxData[ATA + MEMO + SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO_WITH_ATA;
+            for (const doMemo of [false, true]) {
+                for (const doSign of [false, true]) {
+                    for (const doCreateATA of [false, true]) {
+                        it(`build a tx with doMemo=${doMemo}, doSign=${doSign}, doCreateATA=${doCreateATA}`, async () => {
+                            const data = rawTxData[(doMemo ? MEMO : 0) + (doSign ? SIGN : 0) + (doCreateATA ? ATA : 0)];
+                            (0, should_1.default)(data).not.be.undefined();
+                            await performTestJito(doMemo, doSign, doCreateATA, data ?? '');
+                        });
+                    }
+                }
+            }
+        });
+    });
+    describe('Fail', () => {
+        it('for invalid sender address', () => {
+            const txBuilder = stakingBuilder();
+            (0, should_1.default)(() => txBuilder.sender(invalidPubKey)).throwError('Invalid or missing sender, got: ' + invalidPubKey);
+        });
+        it('for invalid staking address', () => {
+            const txBuilder = stakingBuilder();
+            (0, should_1.default)(() => txBuilder.stakingAddress(invalidPubKey)).throwError('Invalid or missing stakingAddress, got: ' + invalidPubKey);
+        });
+        it('for invalid validator address', () => {
+            const txBuilder = stakingBuilder();
+            (0, should_1.default)(() => txBuilder.validator(invalidPubKey)).throwError('Invalid or missing validator, got: ' + invalidPubKey);
+        });
+        it('build a staking activate tx when amount is invalid', () => {
+            const txBuilder = stakingBuilder();
+            (0, should_1.default)(() => txBuilder.amount('randomstring')).throwError('Value cannot be zero or less');
+        });
+        it('build a staking activate tx when amount is less than zero', () => {
+            const txBuilder = stakingBuilder();
+            (0, should_1.default)(() => txBuilder.amount('-1')).throwError('Value cannot be zero or less');
+        });
+        it('build a staking activate tx when amount is equal to zero', () => {
+            const txBuilder = stakingBuilder();
+            (0, should_1.default)(() => txBuilder.amount('0')).throwError('Value cannot be zero or less');
+        });
+        it('build a staking activate tx and sign with an incorrect account', async () => {
+            const txBuilder = stakingBuilder();
+            txBuilder.sender(wallet.pub);
+            txBuilder.stakingAddress(stakeAccount.pub);
+            txBuilder.validator(validator.pub);
+            txBuilder.amount(amount);
+            txBuilder.sign({ key: wrongAccount.prv });
+            await txBuilder.build().should.rejectedWith('unknown signer: CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S');
+        });
+        it('build a staking activate tx with the same sender and staking address', async () => {
+            const txBuilder = stakingBuilder();
+            txBuilder.sender(wallet.pub);
+            txBuilder.stakingAddress(wallet.pub);
+            txBuilder.validator(validator.pub);
+            txBuilder.amount(amount);
+            txBuilder.sign({ key: wrongAccount.prv });
+            await txBuilder.build().should.rejectedWith('Sender address cannot be the same as the Staking address');
+        });
+        it('build when nonce is not provided', async () => {
+            const txBuilder = factory.getStakingActivateBuilder();
+            txBuilder.sender(wallet.pub);
+            txBuilder.stakingAddress(stakeAccount.pub);
+            txBuilder.amount(amount);
+            txBuilder.validator(validator.pub);
+            txBuilder.sign({ key: wallet.prv });
+            await txBuilder.build().should.rejectedWith('Invalid transaction: missing nonce blockhash');
+        });
+        it('build when sender is not provided', async () => {
+            const txBuilder = factory.getStakingActivateBuilder();
+            txBuilder.stakingAddress(stakeAccount.pub);
+            txBuilder.amount(amount);
+            txBuilder.validator(validator.pub);
+            txBuilder.nonce(recentBlockHash);
+            txBuilder.sign({ key: wallet.prv });
+            await txBuilder.build().should.rejectedWith('Invalid transaction: missing sender');
+        });
+        it('build when stakingAddress is not provided', async () => {
+            const txBuilder = factory.getStakingActivateBuilder();
+            txBuilder.sender(wallet.pub);
+            txBuilder.amount(amount);
+            txBuilder.validator(validator.pub);
+            txBuilder.nonce(recentBlockHash);
+            txBuilder.sign({ key: wallet.prv });
+            await txBuilder.build().should.rejectedWith('Staking Address must be set before building the transaction');
+        });
+        it('build when validator is not provided', async () => {
+            const txBuilder = factory.getStakingActivateBuilder();
+            txBuilder.stakingAddress(stakeAccount.pub);
+            txBuilder.sender(wallet.pub);
+            txBuilder.amount(amount);
+            txBuilder.nonce(recentBlockHash);
+            txBuilder.sign({ key: wallet.prv });
+            await txBuilder.build().should.rejectedWith('Validator must be set before building the transaction');
+        });
+        it('to sign twice with the same key', () => {
+            const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX);
+            txBuilder.sign({ key: wallet.prv });
+            (0, should_1.default)(() => txBuilder.sign({ key: wallet.prv })).throwError('Duplicated signer: ' + wallet.prv?.toString());
+        });
+    });
+    describe('From and sign', () => {
+        describe('Succeed', () => {
+            it('build from an unsigned staking activate and sign it', async () => {
+                const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX);
+                txBuilder.sign({ key: wallet.prv });
+                txBuilder.sign({ key: stakeAccount.prv });
+                const tx = await txBuilder.build();
+                tx.inputs.length.should.equal(1);
+                tx.inputs[0].should.deepEqual({
+                    address: wallet.pub,
+                    value: amount,
+                    coin: 'tsol',
+                });
+                tx.outputs.length.should.equal(1);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+                should_1.default.equal(rawTx, testData.STAKING_ACTIVATE_SIGNED_TX);
+            });
+            it('Marinade: build from an unsigned staking activate and sign it', async () => {
+                const txBuilder = factory.from(testData.MARINADE_STAKING_ACTIVATE_UNSIGNED_TX);
+                txBuilder.sign({ key: wallet.prv });
+                txBuilder.sign({ key: stakeAccount.prv });
+                const tx = await txBuilder.build();
+                tx.inputs.length.should.equal(1);
+                tx.inputs[0].should.deepEqual({
+                    address: wallet.pub,
+                    value: amount,
+                    coin: 'tsol',
+                });
+                tx.outputs.length.should.equal(1);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+                should_1.default.equal(rawTx, testData.MARINADE_STAKING_ACTIVATE_SIGNED_TX);
+            });
+            it('build from an unsigned staking activate with memo and sign it', async () => {
+                const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO);
+                txBuilder.sign({ key: wallet.prv });
+                txBuilder.sign({ key: stakeAccount.prv });
+                const tx = await txBuilder.build();
+                tx.inputs.length.should.equal(1);
+                tx.inputs[0].should.deepEqual({
+                    address: wallet.pub,
+                    value: amount,
+                    coin: 'tsol',
+                });
+                tx.outputs.length.should.equal(1);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+                should_1.default.equal(rawTx, testData.STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO);
+            });
+        });
+        describe('Fail', () => {
+            it('build from an unsigned staking activate and fail to sign it', async () => {
+                const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX);
+                txBuilder.sign({ key: wrongAccount.prv });
+                await txBuilder.build().should.rejectedWith('unknown signer: CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S');
+            });
+            it('build from a signed staking activate and fail to sign it', async () => {
+                const txBuilder = factory.from(testData.STAKING_ACTIVATE_SIGNED_TX);
+                txBuilder.sign({ key: wrongAccount.prv });
+                await txBuilder.build().should.rejectedWith('unknown signer: CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S');
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingActivateBuilder.js","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/stakingActivateBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\n\nimport * as testData from '../../resources/sol';\nimport { getBuilderFactory } from '../getBuilderFactory';\nimport { KeyPair, Utils, StakingActivateBuilder } from '../../../src';\nimport { InstructionBuilderTypes, JITO_STAKE_POOL_ADDRESS, JITOSOL_MINT_ADDRESS } from '../../../src/lib/constants';\nimport { SolStakingTypeEnum } from '@bitgo/public-types';\nimport { BaseTransaction } from '@bitgo-beta/sdk-core';\nimport { InstructionParams } from '../../../src/lib/iface';\n\ndescribe('Sol Staking Activate Builder', () => {\n  const factory = getBuilderFactory('tsol');\n\n  const stakingBuilder = () => {\n    const txBuilder = factory.getStakingActivateBuilder();\n    txBuilder.nonce(recentBlockHash);\n    txBuilder.sender(wallet.pub);\n    return txBuilder;\n  };\n\n  // not valid data\n  const invalidPubKey = testData.pubKeys.invalidPubKeys[0];\n  const wrongAccount = new KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();\n\n  // valid data\n  const wallet = new KeyPair(testData.authAccount).getKeys();\n  const stakeAccount = new KeyPair(testData.stakeAccount).getKeys();\n  const validator = testData.validator;\n\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n  const amount = '300000';\n\n  const performTest = async ({\n    signBuilder,\n    knownRawTx,\n    makeUnsignedBuilder,\n    verifyBuiltTransaction,\n  }: {\n    signBuilder?: undefined | ((x: StakingActivateBuilder) => StakingActivateBuilder);\n    knownRawTx: string;\n    makeUnsignedBuilder: () => StakingActivateBuilder;\n    verifyBuiltTransaction: (x: BaseTransaction) => void;\n  }) => {\n    // Build transaction\n    const txBuilder = makeUnsignedBuilder();\n    const unsignedTx = await txBuilder.build();\n    const tx = signBuilder ? await signBuilder(txBuilder).build() : unsignedTx;\n\n    // Verify built transaction\n    verifyBuiltTransaction(tx);\n\n    // Verify raw transaction\n    const rawTx = tx.toBroadcastFormat();\n    should.equal(Utils.isValidRawTransaction(rawTx), true);\n    should.equal(rawTx, knownRawTx);\n\n    // Rebuild transaction and verify\n    const builderFromRawTx = factory.from(rawTx);\n    const rebuiltTx = await builderFromRawTx.build();\n\n    should.equal(rebuiltTx.toBroadcastFormat(), unsignedTx.toBroadcastFormat());\n    should.equal(rebuiltTx.signablePayload.toString('hex'), unsignedTx.signablePayload.toString('hex'));\n    should.deepEqual(rebuiltTx.toJson().instructionsData, tx.toJson().instructionsData);\n  };\n\n  const makeUnsignedBuilderNative = (doMemo: boolean) => {\n    const txBuilder = factory.getStakingActivateBuilder();\n    txBuilder\n      .amount(amount)\n      .sender(wallet.pub)\n      .stakingAddress(stakeAccount.pub)\n      .validator(validator.pub)\n      .nonce(recentBlockHash);\n    if (doMemo) {\n      txBuilder.memo('test memo');\n    }\n    return txBuilder;\n  };\n\n  const verifyBuiltTransactionNativeOrMarinade = (\n    tx: BaseTransaction,\n    doMemo: boolean,\n    stakingType: SolStakingTypeEnum.NATIVE | SolStakingTypeEnum.MARINADE\n  ) => {\n    const txJson = tx.toJson();\n    txJson.instructionsData.should.deepEqual([\n      ...(doMemo\n        ? [\n            {\n              type: 'Memo',\n              params: {\n                memo: 'test memo',\n              },\n            },\n          ]\n        : []),\n      {\n        type: 'Activate',\n        params: {\n          fromAddress: wallet.pub,\n          stakingAddress: stakeAccount.pub,\n          amount: amount,\n          validator: validator.pub,\n          stakingType,\n        },\n      },\n    ]);\n    tx.inputs.should.deepEqual([\n      {\n        address: wallet.pub,\n        value: amount,\n        coin: 'tsol',\n      },\n    ]);\n    tx.outputs.should.deepEqual([\n      {\n        address: stakeAccount.pub,\n        value: amount,\n        coin: 'tsol',\n      },\n    ]);\n  };\n\n  const signBuilderNativeOrMarinade = (txBuilder: StakingActivateBuilder) => {\n    txBuilder.sign({ key: wallet.prv });\n    txBuilder.sign({ key: stakeAccount.prv });\n    return txBuilder;\n  };\n\n  const makeUnsignedBuilderMarinade = (doMemo: boolean) => {\n    return makeUnsignedBuilderNative(doMemo).stakingType(SolStakingTypeEnum.MARINADE);\n  };\n\n  const makeUnsignedBuilderJito = (doMemo: boolean, doCreateATA: boolean) => {\n    const txBuilder = factory.getStakingActivateBuilder();\n    txBuilder\n      .amount(amount)\n      .sender(wallet.pub)\n      .stakingAddress(JITO_STAKE_POOL_ADDRESS)\n      .validator(JITO_STAKE_POOL_ADDRESS)\n      .stakingType(SolStakingTypeEnum.JITO)\n      .extraParams({\n        stakePoolData: {\n          managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),\n          poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),\n          reserveStake: testData.JITO_STAKE_POOL_DATA_PARSED.reserveStake.toString(),\n        },\n        createAssociatedTokenAccount: doCreateATA,\n      })\n      .nonce(recentBlockHash);\n    if (doMemo) {\n      txBuilder.memo('test memo');\n    }\n    return txBuilder;\n  };\n\n  const signBuilderJito = (txBuilder: StakingActivateBuilder) => {\n    txBuilder.sign({ key: wallet.prv });\n    return txBuilder;\n  };\n\n  const verifyBuiltTransactionJito = (tx: BaseTransaction, doMemo: boolean, doCreateATA: boolean) => {\n    const txJson = tx.toJson();\n    const expectedInstructions: InstructionParams[] = [];\n\n    if (doCreateATA) {\n      expectedInstructions.push({\n        type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n        params: {\n          ataAddress: '2vJrx2Bn7PifLZDRaSCpphE9WtZsx1k43SRyiQDhE1As',\n          mintAddress: JITOSOL_MINT_ADDRESS,\n          ownerAddress: wallet.pub,\n          payerAddress: wallet.pub,\n          tokenName: 'sol:jitosol',\n        },\n      });\n    }\n\n    if (doMemo) {\n      expectedInstructions.push({\n        type: InstructionBuilderTypes.Memo,\n        params: {\n          memo: 'test memo',\n        },\n      });\n    }\n\n    expectedInstructions.push({\n      type: InstructionBuilderTypes.StakingActivate,\n      params: {\n        fromAddress: wallet.pub,\n        stakingAddress: JITO_STAKE_POOL_ADDRESS,\n        amount: amount,\n        validator: JITO_STAKE_POOL_ADDRESS,\n        stakingType: SolStakingTypeEnum.JITO,\n        extraParams: {\n          stakePoolData: {\n            managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),\n            poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),\n            reserveStake: testData.JITO_STAKE_POOL_DATA_PARSED.reserveStake.toString(),\n          },\n          createAssociatedTokenAccount: doCreateATA,\n        },\n      },\n    });\n\n    txJson.instructionsData.should.deepEqual(expectedInstructions);\n    tx.inputs.should.deepEqual([\n      {\n        address: wallet.pub,\n        value: amount,\n        coin: 'tsol',\n      },\n    ]);\n    tx.outputs.should.deepEqual([]);\n  };\n\n  describe('Succeed', () => {\n    describe('Native staking tests', () => {\n      const performTestNative = async (doMemo: boolean, doSign: boolean, knownRawTx: string) => {\n        await performTest({\n          signBuilder: doSign ? signBuilderNativeOrMarinade : undefined,\n          knownRawTx,\n          makeUnsignedBuilder: () => makeUnsignedBuilderNative(doMemo),\n          verifyBuiltTransaction: (x) => verifyBuiltTransactionNativeOrMarinade(x, doMemo, SolStakingTypeEnum.NATIVE),\n        });\n      };\n\n      it('build a create and delegate staking signed tx', async () =>\n        performTestNative(false, true, testData.STAKING_ACTIVATE_SIGNED_TX));\n\n      it('build a create and delegate staking signed tx with memo', async () =>\n        performTestNative(true, true, testData.STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO));\n\n      it('build a create and delegate staking unsigned tx', async () =>\n        performTestNative(false, false, testData.STAKING_ACTIVATE_UNSIGNED_TX));\n\n      it('build a create and delegate staking unsigned tx with memo', async () =>\n        performTestNative(true, false, testData.STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO));\n    });\n\n    describe('Marinade staking tests', () => {\n      const performTestMarinade = async (doMemo: boolean, doSign: boolean, knownRawTx: string) => {\n        await performTest({\n          signBuilder: doSign ? signBuilderNativeOrMarinade : undefined,\n          knownRawTx,\n          makeUnsignedBuilder: () => makeUnsignedBuilderMarinade(doMemo),\n          verifyBuiltTransaction: (x) => verifyBuiltTransactionNativeOrMarinade(x, doMemo, SolStakingTypeEnum.MARINADE),\n        });\n      };\n\n      it('build a create staking signed tx', async () =>\n        performTestMarinade(false, true, testData.MARINADE_STAKING_ACTIVATE_SIGNED_TX));\n\n      it('build a create signed tx with memo', async () =>\n        performTestMarinade(true, true, testData.MARINADE_STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO));\n\n      it('build a create unsigned tx', async () =>\n        performTestMarinade(false, false, testData.MARINADE_STAKING_ACTIVATE_UNSIGNED_TX));\n\n      it('build a create unsigned tx with memo', async () =>\n        performTestMarinade(true, false, testData.MARINADE_STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO));\n    });\n\n    describe('Jito staking tests', () => {\n      const performTestJito = async (doMemo: boolean, doSign: boolean, doCreateATA: boolean, knownRawTx: string) => {\n        await performTest({\n          signBuilder: doSign ? signBuilderJito : undefined,\n          knownRawTx,\n          makeUnsignedBuilder: () => makeUnsignedBuilderJito(doMemo, doCreateATA),\n          verifyBuiltTransaction: (x) => verifyBuiltTransactionJito(x, doMemo, doCreateATA),\n        });\n      };\n\n      const MEMO = 1;\n      const SIGN = 2;\n      const ATA = 4;\n      const rawTxData: (string | undefined)[] = Array.from(new Array(8)).map(() => undefined);\n      rawTxData[0] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX;\n      rawTxData[MEMO] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO;\n      rawTxData[SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX;\n      rawTxData[MEMO + SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO;\n      rawTxData[ATA] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX_WITH_ATA;\n      rawTxData[ATA + MEMO] = testData.JITO_STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO_WITH_ATA;\n      rawTxData[ATA + SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX_WITH_ATA;\n      rawTxData[ATA + MEMO + SIGN] = testData.JITO_STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO_WITH_ATA;\n\n      for (const doMemo of [false, true]) {\n        for (const doSign of [false, true]) {\n          for (const doCreateATA of [false, true]) {\n            it(`build a tx with doMemo=${doMemo}, doSign=${doSign}, doCreateATA=${doCreateATA}`, async () => {\n              const data = rawTxData[(doMemo ? MEMO : 0) + (doSign ? SIGN : 0) + (doCreateATA ? ATA : 0)];\n              should(data).not.be.undefined();\n              await performTestJito(doMemo, doSign, doCreateATA, data ?? '');\n            });\n          }\n        }\n      }\n    });\n  });\n\n  describe('Fail', () => {\n    it('for invalid sender address', () => {\n      const txBuilder = stakingBuilder();\n      should(() => txBuilder.sender(invalidPubKey)).throwError('Invalid or missing sender, got: ' + invalidPubKey);\n    });\n\n    it('for invalid staking address', () => {\n      const txBuilder = stakingBuilder();\n      should(() => txBuilder.stakingAddress(invalidPubKey)).throwError(\n        'Invalid or missing stakingAddress, got: ' + invalidPubKey\n      );\n    });\n\n    it('for invalid validator address', () => {\n      const txBuilder = stakingBuilder();\n      should(() => txBuilder.validator(invalidPubKey)).throwError(\n        'Invalid or missing validator, got: ' + invalidPubKey\n      );\n    });\n\n    it('build a staking activate tx when amount is invalid', () => {\n      const txBuilder = stakingBuilder();\n      should(() => txBuilder.amount('randomstring')).throwError('Value cannot be zero or less');\n    });\n\n    it('build a staking activate tx when amount is less than zero', () => {\n      const txBuilder = stakingBuilder();\n      should(() => txBuilder.amount('-1')).throwError('Value cannot be zero or less');\n    });\n\n    it('build a staking activate tx when amount is equal to zero', () => {\n      const txBuilder = stakingBuilder();\n      should(() => txBuilder.amount('0')).throwError('Value cannot be zero or less');\n    });\n\n    it('build a staking activate tx and sign with an incorrect account', async () => {\n      const txBuilder = stakingBuilder();\n      txBuilder.sender(wallet.pub);\n      txBuilder.stakingAddress(stakeAccount.pub);\n      txBuilder.validator(validator.pub);\n      txBuilder.amount(amount);\n      txBuilder.sign({ key: wrongAccount.prv });\n      await txBuilder.build().should.rejectedWith('unknown signer: CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S');\n    });\n\n    it('build a staking activate tx with the same sender and staking address', async () => {\n      const txBuilder = stakingBuilder();\n      txBuilder.sender(wallet.pub);\n      txBuilder.stakingAddress(wallet.pub);\n      txBuilder.validator(validator.pub);\n      txBuilder.amount(amount);\n      txBuilder.sign({ key: wrongAccount.prv });\n      await txBuilder.build().should.rejectedWith('Sender address cannot be the same as the Staking address');\n    });\n\n    it('build when nonce is not provided', async () => {\n      const txBuilder = factory.getStakingActivateBuilder();\n      txBuilder.sender(wallet.pub);\n      txBuilder.stakingAddress(stakeAccount.pub);\n      txBuilder.amount(amount);\n      txBuilder.validator(validator.pub);\n      txBuilder.sign({ key: wallet.prv });\n      await txBuilder.build().should.rejectedWith('Invalid transaction: missing nonce blockhash');\n    });\n\n    it('build when sender is not provided', async () => {\n      const txBuilder = factory.getStakingActivateBuilder();\n      txBuilder.stakingAddress(stakeAccount.pub);\n      txBuilder.amount(amount);\n      txBuilder.validator(validator.pub);\n      txBuilder.nonce(recentBlockHash);\n      txBuilder.sign({ key: wallet.prv });\n      await txBuilder.build().should.rejectedWith('Invalid transaction: missing sender');\n    });\n\n    it('build when stakingAddress is not provided', async () => {\n      const txBuilder = factory.getStakingActivateBuilder();\n      txBuilder.sender(wallet.pub);\n      txBuilder.amount(amount);\n      txBuilder.validator(validator.pub);\n      txBuilder.nonce(recentBlockHash);\n      txBuilder.sign({ key: wallet.prv });\n      await txBuilder.build().should.rejectedWith('Staking Address must be set before building the transaction');\n    });\n\n    it('build when validator is not provided', async () => {\n      const txBuilder = factory.getStakingActivateBuilder();\n      txBuilder.stakingAddress(stakeAccount.pub);\n      txBuilder.sender(wallet.pub);\n      txBuilder.amount(amount);\n      txBuilder.nonce(recentBlockHash);\n      txBuilder.sign({ key: wallet.prv });\n      await txBuilder.build().should.rejectedWith('Validator must be set before building the transaction');\n    });\n\n    it('to sign twice with the same key', () => {\n      const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX);\n      txBuilder.sign({ key: wallet.prv });\n      should(() => txBuilder.sign({ key: wallet.prv })).throwError('Duplicated signer: ' + wallet.prv?.toString());\n    });\n  });\n\n  describe('From and sign', () => {\n    describe('Succeed', () => {\n      it('build from an unsigned staking activate and sign it', async () => {\n        const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX);\n\n        txBuilder.sign({ key: wallet.prv });\n        txBuilder.sign({ key: stakeAccount.prv });\n        const tx = await txBuilder.build();\n        tx.inputs.length.should.equal(1);\n        tx.inputs[0].should.deepEqual({\n          address: wallet.pub,\n          value: amount,\n          coin: 'tsol',\n        });\n        tx.outputs.length.should.equal(1);\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n        should.equal(rawTx, testData.STAKING_ACTIVATE_SIGNED_TX);\n      });\n\n      it('Marinade: build from an unsigned staking activate and sign it', async () => {\n        const txBuilder = factory.from(testData.MARINADE_STAKING_ACTIVATE_UNSIGNED_TX);\n\n        txBuilder.sign({ key: wallet.prv });\n        txBuilder.sign({ key: stakeAccount.prv });\n        const tx = await txBuilder.build();\n        tx.inputs.length.should.equal(1);\n        tx.inputs[0].should.deepEqual({\n          address: wallet.pub,\n          value: amount,\n          coin: 'tsol',\n        });\n        tx.outputs.length.should.equal(1);\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n        should.equal(rawTx, testData.MARINADE_STAKING_ACTIVATE_SIGNED_TX);\n      });\n\n      it('build from an unsigned staking activate with memo and sign it', async () => {\n        const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO);\n        txBuilder.sign({ key: wallet.prv });\n        txBuilder.sign({ key: stakeAccount.prv });\n        const tx = await txBuilder.build();\n        tx.inputs.length.should.equal(1);\n        tx.inputs[0].should.deepEqual({\n          address: wallet.pub,\n          value: amount,\n          coin: 'tsol',\n        });\n        tx.outputs.length.should.equal(1);\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n        should.equal(rawTx, testData.STAKING_ACTIVATE_SIGNED_TX_WITH_MEMO);\n      });\n    });\n\n    describe('Fail', () => {\n      it('build from an unsigned staking activate and fail to sign it', async () => {\n        const txBuilder = factory.from(testData.STAKING_ACTIVATE_UNSIGNED_TX);\n        txBuilder.sign({ key: wrongAccount.prv });\n        await txBuilder.build().should.rejectedWith('unknown signer: CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S');\n      });\n      it('build from a signed staking activate and fail to sign it', async () => {\n        const txBuilder = factory.from(testData.STAKING_ACTIVATE_SIGNED_TX);\n        txBuilder.sign({ key: wrongAccount.prv });\n        await txBuilder.build().should.rejectedWith('unknown signer: CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S');\n      });\n    });\n  });\n});\n"]}

package/dist/test/unit/transactionBuilder/stakingAuthorizeBuilder.d.ts

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

package/dist/test/unit/transactionBuilder/stakingAuthorizeBuilder.d.ts.map

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