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

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

@@ -0,0 +1,384 @@
+"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 getBuilderFactory_1 = require("../getBuilderFactory");
+const src_1 = require("../../../src");
+const testData = __importStar(require("../../resources/sol"));
+const public_types_1 = require("@bitgo/public-types");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bs58 = __importStar(require("bs58"));
+const constants_1 = require("../../../src/lib/constants");
+describe('Sol Staking Deactivate Builder', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+    const walletKeyPair = new src_1.KeyPair(testData.authAccount);
+    const wallet = walletKeyPair.getKeys();
+    const stakeAccount = new src_1.KeyPair(testData.stakeAccount).getKeys();
+    const splitAccount = new src_1.KeyPair(testData.splitStakeAccount).getKeys();
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const invalidPubKey = testData.pubKeys.invalidPubKeys[0];
+    const performTest = async ({ makeUnsignedBuilder, signBuilder, addSignatures, verifyBuiltTransaction, knownRawTx, }) => {
+        // 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);
+        if (knownRawTx !== undefined) {
+            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);
+        // Verify addSignature
+        if (addSignatures) {
+            const txBuilder2 = makeUnsignedBuilder();
+            addSignatures(txBuilder2, tx.signature);
+            const tx2 = await txBuilder2.build();
+            should_1.default.equal(tx2.type, sdk_core_1.TransactionType.StakingDeactivate);
+            const rawTx2 = tx2.toBroadcastFormat();
+            should_1.default.deepEqual(tx2.toJson().instructionsData, tx.toJson().instructionsData);
+            if (knownRawTx !== undefined) {
+                should_1.default.equal(rawTx2, knownRawTx);
+            }
+        }
+    };
+    const makeUnsignedBuilderNativeGeneric = (doMemo, stakingAddress) => {
+        const txBuilder = factory.getStakingDeactivateBuilder();
+        txBuilder.sender(wallet.pub);
+        if (typeof stakingAddress === 'string') {
+            txBuilder.stakingAddress(stakingAddress);
+        }
+        else {
+            txBuilder.stakingAddresses(stakingAddress);
+        }
+        txBuilder.nonce(recentBlockHash);
+        if (doMemo) {
+            txBuilder.memo('Test deactivate');
+        }
+        return txBuilder;
+    };
+    const signBuilderNative = (txBuilder) => {
+        txBuilder.sign({ key: wallet.prv });
+        return txBuilder;
+    };
+    const addSignaturesNative = (txBuilder, signature) => {
+        txBuilder.addSignature({ pub: wallet.pub }, Buffer.from(bs58.decode(signature[0])));
+        return txBuilder;
+    };
+    const verifyBuiltTransactionNativeGeneric = (tx, doMemo, stakingAddresses) => {
+        const txJson = tx.toJson();
+        txJson.instructionsData.should.deepEqual([
+            ...(doMemo
+                ? [
+                    {
+                        type: 'Memo',
+                        params: {
+                            memo: 'Test deactivate',
+                        },
+                    },
+                ]
+                : []),
+            ...stakingAddresses.map((stakingAddress) => ({
+                type: 'Deactivate',
+                params: {
+                    stakingAddress,
+                    amount: undefined,
+                    fromAddress: wallet.pub,
+                    unstakingAddress: undefined,
+                    stakingType: public_types_1.SolStakingTypeEnum.NATIVE,
+                },
+            })),
+        ]);
+    };
+    describe('Should succeed', () => {
+        describe('Native staking deactivate', () => {
+            const performTestNative = async (doMemo, stakingAddress, doSign, knownRawTx) => {
+                const stakingAddresses = typeof stakingAddress === 'string' ? [stakingAddress] : stakingAddress;
+                await performTest({
+                    makeUnsignedBuilder: () => makeUnsignedBuilderNativeGeneric(doMemo, stakingAddress),
+                    signBuilder: doSign ? signBuilderNative : undefined,
+                    addSignatures: doSign ? addSignaturesNative : undefined,
+                    verifyBuiltTransaction: (tx) => verifyBuiltTransactionNativeGeneric(tx, doMemo, stakingAddresses),
+                    knownRawTx,
+                });
+            };
+            it('building a staking deactivate tx', async () => {
+                await performTestNative(false, stakeAccount.pub, true, testData.STAKING_DEACTIVATE_SIGNED_TX);
+            });
+            it('building a staking multi deactivate tx', async () => {
+                await performTestNative(false, [stakeAccount.pub, splitAccount.pub], true, testData.STAKING_MULTI_DEACTIVATE_SIGNED_TX);
+            });
+            it('should build and sign a multi deactivate single', async function () {
+                await performTestNative(false, [stakeAccount.pub], true, testData.STAKING_MULTI_DEACTIVATE_SIGNED_TX_single);
+            });
+            it('should build and sign a deactivate single', async function () {
+                await performTestNative(false, stakeAccount.pub, true, testData.STAKING_DEACTIVATE_SIGNED_TX_single);
+            });
+            it('building a staking deactivate signed tx with memo', async () => {
+                await performTestNative(true, stakeAccount.pub, true, testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);
+            });
+            it('building a staking deactivate unsigned tx', async () => {
+                await performTestNative(false, stakeAccount.pub, false, testData.STAKING_DEACTIVATE_UNSIGNED_TX);
+            });
+            it('building a staking deactivate unsigned tx with memo', async () => {
+                await performTestNative(true, stakeAccount.pub, false, testData.STAKING_DEACTIVATE_UNSIGNED_TX_WITH_MEMO);
+            });
+            it('building a staking deactivate unsigned tx with memo', async () => {
+                await performTestNative(true, stakeAccount.pub, false, testData.STAKING_DEACTIVATE_UNSIGNED_TX_WITH_MEMO);
+            });
+            it('all combinations', async () => {
+                for (const doMemo of [false, true]) {
+                    for (const stakingAddress of [stakeAccount.pub, [stakeAccount.pub], [stakeAccount.pub, splitAccount.pub]]) {
+                        for (const doSign of [false, true]) {
+                            await performTestNative(doMemo, stakingAddress, doSign, undefined);
+                        }
+                    }
+                }
+            });
+            it('building an encoded signed transaction', async () => {
+                const txBuilder = factory.from(testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);
+                txBuilder.sign({ key: wallet.prv });
+                const tx = await txBuilder.build();
+                should_1.default.equal(tx.toBroadcastFormat(), testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);
+            });
+            it('building an encoded unsigned transaction and signing it', async () => {
+                const txBuilder = factory.from(testData.STAKING_DEACTIVATE_UNSIGNED_TX_WITH_MEMO);
+                txBuilder.sign({ key: wallet.prv });
+                const tx = await txBuilder.build();
+                should_1.default.equal(tx.toBroadcastFormat(), testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);
+            });
+            it('building a partial staking deactivate tx', async () => {
+                const txBuilder = factory
+                    .getStakingDeactivateBuilder()
+                    .sender(wallet.pub)
+                    .stakingAddress(stakeAccount.pub)
+                    .unstakingAddress(testData.splitStakeAccount.pub)
+                    .amount('100000')
+                    .nonce(recentBlockHash);
+                txBuilder.sign({ key: wallet.prv });
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+                txJson.instructionsData.should.deepEqual([
+                    {
+                        type: 'Deactivate',
+                        params: {
+                            fromAddress: wallet.pub,
+                            stakingAddress: stakeAccount.pub,
+                            amount: '100000',
+                            unstakingAddress: testData.splitStakeAccount.pub,
+                            stakingType: public_types_1.SolStakingTypeEnum.NATIVE,
+                        },
+                    },
+                ]);
+                should_1.default.equal(rawTx, testData.STAKING_PARTIAL_DEACTIVATE_SIGNED_TX);
+                const tx2 = await factory.from(testData.STAKING_PARTIAL_DEACTIVATE_SIGNED_TX).build();
+                const txJson2 = tx2.toJson();
+                tx2.toBroadcastFormat();
+                delete tx['_id'];
+                delete tx2['_id'];
+                // should.deepEqual(tx, tx2) // _useTokenAddressTokenName true for tx2
+                should_1.default.deepEqual(txJson2, txJson2);
+            });
+        });
+        describe('Marinade staking deactivate', () => {
+            const marinadeRecipientsObject = [];
+            marinadeRecipientsObject.push({
+                address: 'opNS8ENpEMWdXcJUgJCsJTDp7arTXayoBEeBUg6UezP',
+                amount: '2300000',
+            });
+            const marinadeMemo = `{\\"PrepareForRevoke\\":{\\"user\\":\\"${wallet.pub}}\\",\\"amount\\":\\"500000000000\\"}`;
+            it('Marinade: build and sign a staking deactivate tx', async () => {
+                await performTest({
+                    makeUnsignedBuilder: () => {
+                        const txBuilder = factory.getStakingDeactivateBuilder();
+                        txBuilder
+                            .sender(wallet.pub)
+                            .stakingAddress(stakeAccount.pub)
+                            .nonce(recentBlockHash)
+                            .stakingType(public_types_1.SolStakingTypeEnum.MARINADE)
+                            .memo(marinadeMemo)
+                            .recipients(marinadeRecipientsObject);
+                        return txBuilder;
+                    },
+                    signBuilder: signBuilderNative,
+                    addSignatures: addSignaturesNative,
+                    verifyBuiltTransaction: (tx) => {
+                        const txJson = tx.toJson();
+                        txJson.instructionsData.should.deepEqual([
+                            {
+                                params: {
+                                    memo: marinadeMemo,
+                                },
+                                type: 'Memo',
+                            },
+                            {
+                                type: 'Deactivate',
+                                params: {
+                                    fromAddress: '',
+                                    stakingAddress: '',
+                                    stakingType: public_types_1.SolStakingTypeEnum.MARINADE,
+                                    recipients: marinadeRecipientsObject,
+                                },
+                            },
+                        ]);
+                    },
+                    knownRawTx: testData.MARINADE_STAKING_DEACTIVATE_SIGNED_TX,
+                });
+            });
+        });
+        describe('Jito staking deactivate', () => {
+            it('Jito: build and sign a staking deactivate tx', async () => {
+                const transferAuthority = new src_1.KeyPair(testData.splitStakeAccount).getKeys();
+                await performTest({
+                    makeUnsignedBuilder: () => {
+                        const txBuilder = factory.getStakingDeactivateBuilder();
+                        txBuilder
+                            .sender(wallet.pub)
+                            .stakingAddress(constants_1.JITO_STAKE_POOL_ADDRESS)
+                            .unstakingAddress(stakeAccount.pub)
+                            .stakingType(public_types_1.SolStakingTypeEnum.JITO)
+                            .extraParams({
+                            validatorAddress: testData.JITO_STAKE_POOL_VALIDATOR_ADDRESS,
+                            transferAuthorityAddress: transferAuthority.pub,
+                            stakePoolData: {
+                                managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),
+                                poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),
+                                validatorListAccount: testData.JITO_STAKE_POOL_DATA_PARSED.validatorList.toString(),
+                            },
+                        })
+                            .amount('1000')
+                            .nonce(recentBlockHash);
+                        return txBuilder;
+                    },
+                    signBuilder: (txBuilder) => {
+                        txBuilder.sign({ key: wallet.prv });
+                        txBuilder.sign({ key: stakeAccount.prv });
+                        txBuilder.sign({ key: transferAuthority.prv });
+                        return txBuilder;
+                    },
+                    addSignatures: (txBuilder, signature) => {
+                        txBuilder.addSignature({ pub: wallet.pub }, Buffer.from(bs58.decode(signature[0])));
+                        txBuilder.addSignature({ pub: stakeAccount.pub }, Buffer.from(bs58.decode(signature[1])));
+                        txBuilder.addSignature({ pub: transferAuthority.pub }, Buffer.from(bs58.decode(signature[2])));
+                        return txBuilder;
+                    },
+                    verifyBuiltTransaction: (tx) => {
+                        const txJson = tx.toJson();
+                        txJson.instructionsData.should.deepEqual([
+                            {
+                                type: 'Deactivate',
+                                params: {
+                                    fromAddress: wallet.pub,
+                                    stakingAddress: constants_1.JITO_STAKE_POOL_ADDRESS,
+                                    unstakingAddress: stakeAccount.pub,
+                                    amount: '1000',
+                                    stakingType: public_types_1.SolStakingTypeEnum.JITO,
+                                    extraParams: {
+                                        validatorAddress: testData.JITO_STAKE_POOL_VALIDATOR_ADDRESS,
+                                        transferAuthorityAddress: transferAuthority.pub,
+                                        stakePoolData: {
+                                            managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),
+                                            poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),
+                                            validatorListAccount: testData.JITO_STAKE_POOL_DATA_PARSED.validatorList.toString(),
+                                        },
+                                    },
+                                },
+                            },
+                        ]);
+                        tx.inputs.should.deepEqual([]);
+                        tx.outputs.should.deepEqual([]);
+                    },
+                    knownRawTx: testData.JITO_STAKING_DEACTIVATE_SIGNED_TX,
+                });
+            });
+        });
+    });
+    describe('Should fail', () => {
+        it('building a staking deactivate tx without staking address', async () => {
+            const txBuilder = factory.getStakingDeactivateBuilder();
+            txBuilder.sender(wallet.pub).nonce(recentBlockHash);
+            txBuilder.sign({ key: wallet.prv });
+            await txBuilder.build().should.be.rejectedWith('Staking address must be set before building the transaction');
+        });
+        it('building a staking deactivate tx with a wrong staking address', async () => {
+            const txBuilder = factory.getStakingDeactivateBuilder();
+            txBuilder.sender(wallet.pub).nonce(recentBlockHash);
+            (0, should_1.default)(() => txBuilder.stakingAddress(invalidPubKey)).throwError(`Invalid or missing stakingAddress, got: ${invalidPubKey}`);
+        });
+        it('building a staking deactivate tx with the same address as sender and staking', async () => {
+            const txBuilder = factory.getStakingDeactivateBuilder();
+            txBuilder.sender(wallet.pub).nonce(recentBlockHash);
+            txBuilder.stakingAddress(wallet.pub);
+            await txBuilder.build().should.rejectedWith('Sender address cannot be the same as the Staking address');
+        });
+        it('building a partial staking deactivate tx without an amount', async () => {
+            const txBuilder = factory
+                .getStakingDeactivateBuilder()
+                .sender(wallet.pub)
+                .nonce(recentBlockHash)
+                .stakingAddress(testData.stakeAccount.pub)
+                .unstakingAddress(testData.splitStakeAccount.pub);
+            txBuilder.sign({ key: wallet.prv });
+            await txBuilder
+                .build()
+                .should.be.rejectedWith('If an unstaking address is given then a partial amount to unstake must also be set before building the transaction');
+        });
+        it('building a partial staking deactivate tx without an unstaking address', async () => {
+            const txBuilder = factory
+                .getStakingDeactivateBuilder()
+                .sender(wallet.pub)
+                .nonce(recentBlockHash)
+                .stakingAddress(testData.stakeAccount.pub)
+                .amount('10');
+            txBuilder.sign({ key: wallet.prv });
+            await txBuilder
+                .build()
+                .should.be.rejectedWith('When partially unstaking the unstaking address must be set before building the transaction');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingDeactivateBuilder.js","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/stakingDeactivateBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\n\nimport { getBuilderFactory } from '../getBuilderFactory';\nimport { KeyPair, StakingDeactivateBuilder, Utils } from '../../../src';\nimport * as testData from '../../resources/sol';\nimport { SolStakingTypeEnum } from '@bitgo/public-types';\nimport { BaseTransaction, Recipient, TransactionType } from '@bitgo-beta/sdk-core';\nimport * as bs58 from 'bs58';\nimport { JITO_STAKE_POOL_ADDRESS } from '../../../src/lib/constants';\n\ndescribe('Sol Staking Deactivate Builder', () => {\n  const factory = getBuilderFactory('tsol');\n\n  const walletKeyPair = new KeyPair(testData.authAccount);\n  const wallet = walletKeyPair.getKeys();\n  const stakeAccount = new KeyPair(testData.stakeAccount).getKeys();\n  const splitAccount = new KeyPair(testData.splitStakeAccount).getKeys();\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n  const invalidPubKey = testData.pubKeys.invalidPubKeys[0];\n\n  const performTest = async ({\n    makeUnsignedBuilder,\n    signBuilder,\n    addSignatures,\n    verifyBuiltTransaction,\n    knownRawTx,\n  }: {\n    makeUnsignedBuilder: () => StakingDeactivateBuilder;\n    signBuilder?: undefined | ((x: StakingDeactivateBuilder) => StakingDeactivateBuilder);\n    addSignatures?: undefined | ((x: StakingDeactivateBuilder, signature: string[]) => StakingDeactivateBuilder);\n    verifyBuiltTransaction: (x: BaseTransaction) => void;\n    knownRawTx?: string;\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    if (knownRawTx !== undefined) {\n      should.equal(rawTx, knownRawTx);\n    }\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    // Verify addSignature\n    if (addSignatures) {\n      const txBuilder2 = makeUnsignedBuilder();\n      addSignatures(txBuilder2, tx.signature);\n      const tx2 = await txBuilder2.build();\n      should.equal(tx2.type, TransactionType.StakingDeactivate);\n      const rawTx2 = tx2.toBroadcastFormat();\n      should.deepEqual(tx2.toJson().instructionsData, tx.toJson().instructionsData);\n      if (knownRawTx !== undefined) {\n        should.equal(rawTx2, knownRawTx);\n      }\n    }\n  };\n\n  const makeUnsignedBuilderNativeGeneric = (doMemo: boolean, stakingAddress: string | string[]) => {\n    const txBuilder = factory.getStakingDeactivateBuilder();\n    txBuilder.sender(wallet.pub);\n    if (typeof stakingAddress === 'string') {\n      txBuilder.stakingAddress(stakingAddress);\n    } else {\n      txBuilder.stakingAddresses(stakingAddress);\n    }\n    txBuilder.nonce(recentBlockHash);\n    if (doMemo) {\n      txBuilder.memo('Test deactivate');\n    }\n    return txBuilder;\n  };\n\n  const signBuilderNative = (txBuilder: StakingDeactivateBuilder) => {\n    txBuilder.sign({ key: wallet.prv });\n    return txBuilder;\n  };\n\n  const addSignaturesNative = (txBuilder: StakingDeactivateBuilder, signature: string[]) => {\n    txBuilder.addSignature({ pub: wallet.pub }, Buffer.from(bs58.decode(signature[0])));\n    return txBuilder;\n  };\n\n  const verifyBuiltTransactionNativeGeneric = (tx: BaseTransaction, doMemo: boolean, stakingAddresses: string[]) => {\n    const txJson = tx.toJson();\n    txJson.instructionsData.should.deepEqual([\n      ...(doMemo\n        ? [\n            {\n              type: 'Memo',\n              params: {\n                memo: 'Test deactivate',\n              },\n            },\n          ]\n        : []),\n      ...stakingAddresses.map((stakingAddress) => ({\n        type: 'Deactivate',\n        params: {\n          stakingAddress,\n          amount: undefined,\n          fromAddress: wallet.pub,\n          unstakingAddress: undefined,\n          stakingType: SolStakingTypeEnum.NATIVE,\n        },\n      })),\n    ]);\n  };\n\n  describe('Should succeed', () => {\n    describe('Native staking deactivate', () => {\n      const performTestNative = async (\n        doMemo: boolean,\n        stakingAddress: string | string[],\n        doSign: boolean,\n        knownRawTx: string | undefined\n      ) => {\n        const stakingAddresses = typeof stakingAddress === 'string' ? [stakingAddress] : stakingAddress;\n        await performTest({\n          makeUnsignedBuilder: () => makeUnsignedBuilderNativeGeneric(doMemo, stakingAddress),\n          signBuilder: doSign ? signBuilderNative : undefined,\n          addSignatures: doSign ? addSignaturesNative : undefined,\n          verifyBuiltTransaction: (tx) => verifyBuiltTransactionNativeGeneric(tx, doMemo, stakingAddresses),\n          knownRawTx,\n        });\n      };\n\n      it('building a staking deactivate tx', async () => {\n        await performTestNative(false, stakeAccount.pub, true, testData.STAKING_DEACTIVATE_SIGNED_TX);\n      });\n\n      it('building a staking multi deactivate tx', async () => {\n        await performTestNative(\n          false,\n          [stakeAccount.pub, splitAccount.pub],\n          true,\n          testData.STAKING_MULTI_DEACTIVATE_SIGNED_TX\n        );\n      });\n\n      it('should build and sign a multi deactivate single', async function () {\n        await performTestNative(false, [stakeAccount.pub], true, testData.STAKING_MULTI_DEACTIVATE_SIGNED_TX_single);\n      });\n\n      it('should build and sign a deactivate single', async function () {\n        await performTestNative(false, stakeAccount.pub, true, testData.STAKING_DEACTIVATE_SIGNED_TX_single);\n      });\n\n      it('building a staking deactivate signed tx with memo', async () => {\n        await performTestNative(true, stakeAccount.pub, true, testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);\n      });\n\n      it('building a staking deactivate unsigned tx', async () => {\n        await performTestNative(false, stakeAccount.pub, false, testData.STAKING_DEACTIVATE_UNSIGNED_TX);\n      });\n\n      it('building a staking deactivate unsigned tx with memo', async () => {\n        await performTestNative(true, stakeAccount.pub, false, testData.STAKING_DEACTIVATE_UNSIGNED_TX_WITH_MEMO);\n      });\n\n      it('building a staking deactivate unsigned tx with memo', async () => {\n        await performTestNative(true, stakeAccount.pub, false, testData.STAKING_DEACTIVATE_UNSIGNED_TX_WITH_MEMO);\n      });\n\n      it('all combinations', async () => {\n        for (const doMemo of [false, true]) {\n          for (const stakingAddress of [stakeAccount.pub, [stakeAccount.pub], [stakeAccount.pub, splitAccount.pub]]) {\n            for (const doSign of [false, true]) {\n              await performTestNative(doMemo, stakingAddress, doSign, undefined);\n            }\n          }\n        }\n      });\n\n      it('building an encoded signed transaction', async () => {\n        const txBuilder = factory.from(testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);\n        txBuilder.sign({ key: wallet.prv });\n        const tx = await txBuilder.build();\n        should.equal(tx.toBroadcastFormat(), testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);\n      });\n\n      it('building an encoded unsigned transaction and signing it', async () => {\n        const txBuilder = factory.from(testData.STAKING_DEACTIVATE_UNSIGNED_TX_WITH_MEMO);\n        txBuilder.sign({ key: wallet.prv });\n        const tx = await txBuilder.build();\n        should.equal(tx.toBroadcastFormat(), testData.STAKING_DEACTIVATE_SIGNED_TX_WITH_MEMO);\n      });\n\n      it('building a partial staking deactivate tx', async () => {\n        const txBuilder = factory\n          .getStakingDeactivateBuilder()\n          .sender(wallet.pub)\n          .stakingAddress(stakeAccount.pub)\n          .unstakingAddress(testData.splitStakeAccount.pub)\n          .amount('100000')\n          .nonce(recentBlockHash);\n        txBuilder.sign({ key: wallet.prv });\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n        txJson.instructionsData.should.deepEqual([\n          {\n            type: 'Deactivate',\n            params: {\n              fromAddress: wallet.pub,\n              stakingAddress: stakeAccount.pub,\n              amount: '100000',\n              unstakingAddress: testData.splitStakeAccount.pub,\n              stakingType: SolStakingTypeEnum.NATIVE,\n            },\n          },\n        ]);\n        should.equal(rawTx, testData.STAKING_PARTIAL_DEACTIVATE_SIGNED_TX);\n\n        const tx2 = await factory.from(testData.STAKING_PARTIAL_DEACTIVATE_SIGNED_TX).build();\n        const txJson2 = tx2.toJson();\n        tx2.toBroadcastFormat();\n\n        delete tx['_id'];\n        delete tx2['_id'];\n\n        // should.deepEqual(tx, tx2) // _useTokenAddressTokenName true for tx2\n        should.deepEqual(txJson2, txJson2);\n      });\n    });\n\n    describe('Marinade staking deactivate', () => {\n      const marinadeRecipientsObject: Recipient[] = [];\n      marinadeRecipientsObject.push({\n        address: 'opNS8ENpEMWdXcJUgJCsJTDp7arTXayoBEeBUg6UezP',\n        amount: '2300000',\n      });\n\n      const marinadeMemo = `{\\\\\"PrepareForRevoke\\\\\":{\\\\\"user\\\\\":\\\\\"${wallet.pub}}\\\\\",\\\\\"amount\\\\\":\\\\\"500000000000\\\\\"}`;\n\n      it('Marinade: build and sign a staking deactivate tx', async () => {\n        await performTest({\n          makeUnsignedBuilder: () => {\n            const txBuilder = factory.getStakingDeactivateBuilder();\n            txBuilder\n              .sender(wallet.pub)\n              .stakingAddress(stakeAccount.pub)\n              .nonce(recentBlockHash)\n              .stakingType(SolStakingTypeEnum.MARINADE)\n              .memo(marinadeMemo)\n              .recipients(marinadeRecipientsObject);\n            return txBuilder;\n          },\n          signBuilder: signBuilderNative,\n          addSignatures: addSignaturesNative,\n          verifyBuiltTransaction: (tx: BaseTransaction) => {\n            const txJson = tx.toJson();\n            txJson.instructionsData.should.deepEqual([\n              {\n                params: {\n                  memo: marinadeMemo,\n                },\n                type: 'Memo',\n              },\n              {\n                type: 'Deactivate',\n                params: {\n                  fromAddress: '',\n                  stakingAddress: '',\n                  stakingType: SolStakingTypeEnum.MARINADE,\n                  recipients: marinadeRecipientsObject,\n                },\n              },\n            ]);\n          },\n          knownRawTx: testData.MARINADE_STAKING_DEACTIVATE_SIGNED_TX,\n        });\n      });\n    });\n\n    describe('Jito staking deactivate', () => {\n      it('Jito: build and sign a staking deactivate tx', async () => {\n        const transferAuthority = new KeyPair(testData.splitStakeAccount).getKeys();\n\n        await performTest({\n          makeUnsignedBuilder: () => {\n            const txBuilder = factory.getStakingDeactivateBuilder();\n            txBuilder\n              .sender(wallet.pub)\n              .stakingAddress(JITO_STAKE_POOL_ADDRESS)\n              .unstakingAddress(stakeAccount.pub)\n              .stakingType(SolStakingTypeEnum.JITO)\n              .extraParams({\n                validatorAddress: testData.JITO_STAKE_POOL_VALIDATOR_ADDRESS,\n                transferAuthorityAddress: transferAuthority.pub,\n                stakePoolData: {\n                  managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),\n                  poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),\n                  validatorListAccount: testData.JITO_STAKE_POOL_DATA_PARSED.validatorList.toString(),\n                },\n              })\n              .amount('1000')\n              .nonce(recentBlockHash);\n            return txBuilder;\n          },\n          signBuilder: (txBuilder: StakingDeactivateBuilder) => {\n            txBuilder.sign({ key: wallet.prv });\n            txBuilder.sign({ key: stakeAccount.prv });\n            txBuilder.sign({ key: transferAuthority.prv });\n            return txBuilder;\n          },\n          addSignatures: (txBuilder: StakingDeactivateBuilder, signature: string[]) => {\n            txBuilder.addSignature({ pub: wallet.pub }, Buffer.from(bs58.decode(signature[0])));\n            txBuilder.addSignature({ pub: stakeAccount.pub }, Buffer.from(bs58.decode(signature[1])));\n            txBuilder.addSignature({ pub: transferAuthority.pub }, Buffer.from(bs58.decode(signature[2])));\n            return txBuilder;\n          },\n          verifyBuiltTransaction: (tx: BaseTransaction) => {\n            const txJson = tx.toJson();\n            txJson.instructionsData.should.deepEqual([\n              {\n                type: 'Deactivate',\n                params: {\n                  fromAddress: wallet.pub,\n                  stakingAddress: JITO_STAKE_POOL_ADDRESS,\n                  unstakingAddress: stakeAccount.pub,\n                  amount: '1000',\n                  stakingType: SolStakingTypeEnum.JITO,\n                  extraParams: {\n                    validatorAddress: testData.JITO_STAKE_POOL_VALIDATOR_ADDRESS,\n                    transferAuthorityAddress: transferAuthority.pub,\n                    stakePoolData: {\n                      managerFeeAccount: testData.JITO_STAKE_POOL_DATA_PARSED.managerFeeAccount.toString(),\n                      poolMint: testData.JITO_STAKE_POOL_DATA_PARSED.poolMint.toString(),\n                      validatorListAccount: testData.JITO_STAKE_POOL_DATA_PARSED.validatorList.toString(),\n                    },\n                  },\n                },\n              },\n            ]);\n            tx.inputs.should.deepEqual([]);\n            tx.outputs.should.deepEqual([]);\n          },\n          knownRawTx: testData.JITO_STAKING_DEACTIVATE_SIGNED_TX,\n        });\n      });\n    });\n  });\n\n  describe('Should fail', () => {\n    it('building a staking deactivate tx without staking address', async () => {\n      const txBuilder = factory.getStakingDeactivateBuilder();\n      txBuilder.sender(wallet.pub).nonce(recentBlockHash);\n      txBuilder.sign({ key: wallet.prv });\n      await txBuilder.build().should.be.rejectedWith('Staking address must be set before building the transaction');\n    });\n\n    it('building a staking deactivate tx with a wrong staking address', async () => {\n      const txBuilder = factory.getStakingDeactivateBuilder();\n      txBuilder.sender(wallet.pub).nonce(recentBlockHash);\n      should(() => txBuilder.stakingAddress(invalidPubKey)).throwError(\n        `Invalid or missing stakingAddress, got: ${invalidPubKey}`\n      );\n    });\n\n    it('building a staking deactivate tx with the same address as sender and staking', async () => {\n      const txBuilder = factory.getStakingDeactivateBuilder();\n      txBuilder.sender(wallet.pub).nonce(recentBlockHash);\n      txBuilder.stakingAddress(wallet.pub);\n      await txBuilder.build().should.rejectedWith('Sender address cannot be the same as the Staking address');\n    });\n\n    it('building a partial staking deactivate tx without an amount', async () => {\n      const txBuilder = factory\n        .getStakingDeactivateBuilder()\n        .sender(wallet.pub)\n        .nonce(recentBlockHash)\n        .stakingAddress(testData.stakeAccount.pub)\n        .unstakingAddress(testData.splitStakeAccount.pub);\n      txBuilder.sign({ key: wallet.prv });\n\n      await txBuilder\n        .build()\n        .should.be.rejectedWith(\n          'If an unstaking address is given then a partial amount to unstake must also be set before building the transaction'\n        );\n    });\n\n    it('building a partial staking deactivate tx without an unstaking address', async () => {\n      const txBuilder = factory\n        .getStakingDeactivateBuilder()\n        .sender(wallet.pub)\n        .nonce(recentBlockHash)\n        .stakingAddress(testData.stakeAccount.pub)\n        .amount('10');\n      txBuilder.sign({ key: wallet.prv });\n\n      await txBuilder\n        .build()\n        .should.be.rejectedWith(\n          'When partially unstaking the unstaking address must be set before building the transaction'\n        );\n    });\n  });\n});\n"]}

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

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

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

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