@bitgo-beta/sdk-coin-sol 7.6.4-beta.71 → 7.6.4-beta.710

package/dist/esm/lib/stakingDeactivateBuilder.js

@@ -0,0 +1,207 @@
+import { SolStakingTypeEnum } from '@bitgo/public-types';
+import assert from 'assert';
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { InstructionBuilderTypes, STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT } from './constants';
+import { TransactionBuilder } from './transactionBuilder';
+import { isValidStakingAmount, validateAddress } from './utils';
+export class StakingDeactivateBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._stakingType = SolStakingTypeEnum.NATIVE;
+    }
+    get transactionType() {
+        return TransactionType.StakingDeactivate;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const stakingAddresses = [];
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.StakingDeactivate) {
+                const deactivateInstruction = instruction;
+                // Since _stakingAddresses needs to be populated, it gets special treatment.
+                stakingAddresses.push(deactivateInstruction.params.stakingAddress);
+                // Marinade staking also cares about sender.
+                if (deactivateInstruction.params.stakingType !== SolStakingTypeEnum.MARINADE) {
+                    this.sender(deactivateInstruction.params.fromAddress);
+                }
+                // The other values can just be copied.
+                if (deactivateInstruction.params.amount !== undefined) {
+                    this.amount(deactivateInstruction.params.amount);
+                }
+                if (deactivateInstruction.params.unstakingAddress !== undefined) {
+                    this.unstakingAddress(deactivateInstruction.params.unstakingAddress);
+                }
+                if (deactivateInstruction.params.recipients !== undefined) {
+                    this.recipients(deactivateInstruction.params.recipients);
+                }
+                if (deactivateInstruction.params.stakingType !== undefined) {
+                    this.stakingType(deactivateInstruction.params.stakingType);
+                }
+                if (deactivateInstruction.params.extraParams !== undefined) {
+                    this.extraParams(deactivateInstruction.params.extraParams);
+                }
+            }
+        }
+        if (stakingAddresses.length > 1) {
+            this.stakingAddresses(stakingAddresses);
+        }
+        else {
+            if (this._stakingType !== SolStakingTypeEnum.MARINADE) {
+                this.stakingAddress(stakingAddresses[0]);
+            }
+        }
+    }
+    /**
+     * The staking address of the staking account.
+     *
+     * @param {string} stakingAddress public address of the staking account
+     * @returns {StakingDeactivateBuilder} This staking deactivate builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddress(stakingAddress) {
+        validateAddress(stakingAddress, 'stakingAddress');
+        this._stakingAddress = stakingAddress;
+        return this;
+    }
+    /**
+     * The staking addresses of the staking account.
+     *
+     * @param {string[]} stakingAddresses public address of the staking accounts
+     * @returns {StakingDeactivateBuilder} This staking deactivate builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddresses(stakingAddresses) {
+        for (const stakingAddress of stakingAddresses) {
+            validateAddress(stakingAddress, 'stakingAddress');
+        }
+        this._stakingAddresses = stakingAddresses;
+        return this;
+    }
+    /**
+     * Optional amount to unstake expressed in Lamports, 1 SOL = 1_000_000_000 lamports, to be used
+     * when partially unstaking. If not given then the entire staked amount will be unstaked.
+     *
+     * @param {string} amount The partial amount to unstake, expressed in Lamports.
+     * @returns {StakingDeactivateBuilder} This staking builder.
+     *
+     * @see https://docs.solana.com/cli/delegate-stake#split-stake
+     */
+    amount(amount) {
+        if (!isValidStakingAmount(amount)) {
+            throw new BuildTransactionError('If given, amount cannot be zero or less');
+        }
+        this._amount = amount;
+        return this;
+    }
+    /**
+     * Setter to set the recipients object
+     *
+     * @param recipients RecipientEntry[] - The recipients object
+     * @returns {StakingDeactivateBuilder} This staking builder.
+     */
+    recipients(recipients) {
+        this._recipients = recipients;
+        return this;
+    }
+    /**
+     * When partially unstaking move the amount to unstake to this account and initiate the
+     * unstake process. The original stake account will continue staking.
+     *
+     * @param {string} unstakingAddress An account used to unstake a partial amount.
+     * @returns {StakingDeactivateBuilder} This staking builder.
+     *
+     * @see https://docs.solana.com/cli/delegate-stake#split-stake
+     */
+    unstakingAddress(unstakingAddress) {
+        validateAddress(unstakingAddress, 'unstakingAddress');
+        this._unstakingAddress = unstakingAddress;
+        return this;
+    }
+    /**
+     * Set staking type.
+     *
+     * @param {SolStakingType} stakingType a staking type.
+     * @returns {StakingDeactivateBuilder} This staking builder.
+     */
+    stakingType(stakingType) {
+        this._stakingType = stakingType;
+        return this;
+    }
+    /**
+     * Set parameters specific to a staking type.
+     *
+     * @param {StakingDeactivateExtraParams} extraParams parameters specific to a staking type.
+     * @returns {StakingDeactivateBuilder} This staking builder.
+     */
+    extraParams(extraParams) {
+        this._extraParams = extraParams;
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._sender, 'Sender must be set before building the transaction');
+        if (this._stakingAddresses && this._stakingAddresses.length > 0) {
+            this._instructionsData = [];
+            for (const stakingAddress of this._stakingAddresses) {
+                const stakingDeactivateData = {
+                    type: InstructionBuilderTypes.StakingDeactivate,
+                    params: {
+                        fromAddress: this._sender,
+                        stakingAddress: stakingAddress,
+                        stakingType: SolStakingTypeEnum.NATIVE,
+                    },
+                };
+                this._instructionsData.push(stakingDeactivateData);
+            }
+        }
+        else {
+            if (this._stakingType === SolStakingTypeEnum.NATIVE) {
+                // we don't need stakingAddress in marinade staking deactivate txn
+                assert(this._stakingAddress, 'Staking address must be set before building the transaction');
+            }
+            if (this._sender === this._stakingAddress) {
+                throw new BuildTransactionError('Sender address cannot be the same as the Staking address');
+            }
+            if (this._stakingType === SolStakingTypeEnum.NATIVE && this._amount) {
+                assert(this._unstakingAddress, 'When partially unstaking the unstaking address must be set before building the transaction');
+            }
+            this._instructionsData = [];
+            if (this._stakingType === SolStakingTypeEnum.NATIVE && this._unstakingAddress) {
+                assert(this._amount, 'If an unstaking address is given then a partial amount to unstake must also be set before building the transaction');
+                const stakingFundUnstakeAddress = {
+                    type: InstructionBuilderTypes.Transfer,
+                    params: {
+                        fromAddress: this._sender,
+                        amount: STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT.toString(),
+                        toAddress: this._unstakingAddress,
+                    },
+                };
+                this._instructionsData.push(stakingFundUnstakeAddress);
+            }
+            const stakingDeactivateData = {
+                type: InstructionBuilderTypes.StakingDeactivate,
+                params: {
+                    fromAddress: this._sender,
+                    stakingAddress: this._stakingAddress,
+                    amount: this._amount,
+                    unstakingAddress: this._unstakingAddress,
+                    recipients: this._recipients,
+                    stakingType: this._stakingType,
+                    extraParams: this._extraParams,
+                },
+            };
+            this._instructionsData.push(stakingDeactivateData);
+        }
+        if (this._priorityFee && this._priorityFee !== Number(0)) {
+            this._instructionsData.unshift({
+                type: InstructionBuilderTypes.SetPriorityFee,
+                params: { fee: this._priorityFee },
+            });
+        }
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingDeactivateBuilder.js","sourceRoot":"","sources":["../../../src/lib/stakingDeactivateBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,qBAAqB,EAAa,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,uBAAuB,EAAE,gCAAgC,EAAE,MAAM,aAAa,CAAC;AAGxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,OAAO,wBAAyB,SAAQ,kBAAkB;IAS9D,YAAY,WAAiC;QAC3C,KAAK,CAAC,WAAW,CAAC,CAAC;QAJX,iBAAY,GAAuB,kBAAkB,CAAC,MAAM,CAAC;IAKvE,CAAC;IAED,IAAc,eAAe;QAC3B,OAAO,eAAe,CAAC,iBAAiB,CAAC;IAC3C,CAAC;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAe;QACzB,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACtB,MAAM,gBAAgB,GAAa,EAAE,CAAC;QACtC,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACjD,IAAI,WAAW,CAAC,IAAI,KAAK,uBAAuB,CAAC,iBAAiB,EAAE,CAAC;gBACnE,MAAM,qBAAqB,GAAsB,WAAW,CAAC;gBAC7D,4EAA4E;gBAC5E,gBAAgB,CAAC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;gBAEnE,4CAA4C;gBAC5C,IAAI,qBAAqB,CAAC,MAAM,CAAC,WAAW,KAAK,kBAAkB,CAAC,QAAQ,EAAE,CAAC;oBAC7E,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBACxD,CAAC;gBAED,uCAAuC;gBACvC,IAAI,qBAAqB,CAAC,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;oBACtD,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACnD,CAAC;gBACD,IAAI,qBAAqB,CAAC,MAAM,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;oBAChE,IAAI,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;gBACvE,CAAC;gBACD,IAAI,qBAAqB,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;oBAC1D,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBAC3D,CAAC;gBACD,IAAI,qBAAqB,CAAC,MAAM,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;oBAC3D,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBAC7D,CAAC;gBACD,IAAI,qBAAqB,CAAC,MAAM,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;oBAC3D,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBAC7D,CAAC;YACH,CAAC;QACH,CAAC;QACD,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChC,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,IAAI,IAAI,CAAC,YAAY,KAAK,kBAAkB,CAAC,QAAQ,EAAE,CAAC;gBACtD,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,cAAsB;QACnC,eAAe,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;QAClD,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACH,gBAAgB,CAAC,gBAA0B;QACzC,KAAK,MAAM,cAAc,IAAI,gBAAgB,EAAE,CAAC;YAC9C,eAAe,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,MAAc;QACnB,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,qBAAqB,CAAC,yCAAyC,CAAC,CAAC;QAC7E,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,UAAuB;QAChC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;OAQG;IACH,gBAAgB,CAAC,gBAAwB;QACvC,eAAe,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;QACtD,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,WAA+B;QACzC,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,WAA0C;QACpD,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IACR,KAAK,CAAC,mBAAmB;QACjC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,oDAAoD,CAAC,CAAC;QAE3E,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChE,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;YAC5B,KAAK,MAAM,cAAc,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACpD,MAAM,qBAAqB,GAAsB;oBAC/C,IAAI,EAAE,uBAAuB,CAAC,iBAAiB;oBAC/C,MAAM,EAAE;wBACN,WAAW,EAAE,IAAI,CAAC,OAAO;wBACzB,cAAc,EAAE,cAAc;wBAC9B,WAAW,EAAE,kBAAkB,CAAC,MAAM;qBACvC;iBACF,CAAC;gBACF,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACrD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,IAAI,CAAC,YAAY,KAAK,kBAAkB,CAAC,MAAM,EAAE,CAAC;gBACpD,kEAAkE;gBAClE,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,6DAA6D,CAAC,CAAC;YAC9F,CAAC;YAED,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,eAAe,EAAE,CAAC;gBAC1C,MAAM,IAAI,qBAAqB,CAAC,0DAA0D,CAAC,CAAC;YAC9F,CAAC;YAED,IAAI,IAAI,CAAC,YAAY,KAAK,kBAAkB,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACpE,MAAM,CACJ,IAAI,CAAC,iBAAiB,EACtB,4FAA4F,CAC7F,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,YAAY,KAAK,kBAAkB,CAAC,MAAM,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC9E,MAAM,CACJ,IAAI,CAAC,OAAO,EACZ,oHAAoH,CACrH,CAAC;gBACF,MAAM,yBAAyB,GAAa;oBAC1C,IAAI,EAAE,uBAAuB,CAAC,QAAQ;oBACtC,MAAM,EAAE;wBACN,WAAW,EAAE,IAAI,CAAC,OAAO;wBACzB,MAAM,EAAE,gCAAgC,CAAC,QAAQ,EAAE;wBACnD,SAAS,EAAE,IAAI,CAAC,iBAAiB;qBAClC;iBACF,CAAC;gBACF,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;YACzD,CAAC;YAED,MAAM,qBAAqB,GAAsB;gBAC/C,IAAI,EAAE,uBAAuB,CAAC,iBAAiB;gBAC/C,MAAM,EAAE;oBACN,WAAW,EAAE,IAAI,CAAC,OAAO;oBACzB,cAAc,EAAE,IAAI,CAAC,eAAe;oBACpC,MAAM,EAAE,IAAI,CAAC,OAAO;oBACpB,gBAAgB,EAAE,IAAI,CAAC,iBAAiB;oBACxC,UAAU,EAAE,IAAI,CAAC,WAAW;oBAC5B,WAAW,EAAE,IAAI,CAAC,YAAY;oBAC9B,WAAW,EAAE,IAAI,CAAC,YAAY;iBAC/B;aACF,CAAC;YACF,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACzD,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC;gBAC7B,IAAI,EAAE,uBAAuB,CAAC,cAAc;gBAC5C,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE;aACnC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,MAAM,KAAK,CAAC,mBAAmB,EAAE,CAAC;IAC3C,CAAC;CACF","sourcesContent":["import { SolStakingTypeEnum } from '@bitgo/public-types';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport assert from 'assert';\n\nimport { BuildTransactionError, Recipient, TransactionType } from '@bitgo-beta/sdk-core';\nimport { InstructionBuilderTypes, STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT } from './constants';\nimport { StakingDeactivate, StakingDeactivateExtraParams, Transfer } from './iface';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { isValidStakingAmount, validateAddress } from './utils';\n\nexport class StakingDeactivateBuilder extends TransactionBuilder {\n  protected _stakingAddress: string;\n  protected _stakingAddresses: string[];\n  protected _amount?: string;\n  protected _unstakingAddress: string;\n  protected _recipients: Recipient[];\n  protected _stakingType: SolStakingTypeEnum = SolStakingTypeEnum.NATIVE;\n  protected _extraParams?: StakingDeactivateExtraParams;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingDeactivate;\n  }\n\n  /** @inheritdoc */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    const stakingAddresses: string[] = [];\n    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.StakingDeactivate) {\n        const deactivateInstruction: StakingDeactivate = instruction;\n        // Since _stakingAddresses needs to be populated, it gets special treatment.\n        stakingAddresses.push(deactivateInstruction.params.stakingAddress);\n\n        // Marinade staking also cares about sender.\n        if (deactivateInstruction.params.stakingType !== SolStakingTypeEnum.MARINADE) {\n          this.sender(deactivateInstruction.params.fromAddress);\n        }\n\n        // The other values can just be copied.\n        if (deactivateInstruction.params.amount !== undefined) {\n          this.amount(deactivateInstruction.params.amount);\n        }\n        if (deactivateInstruction.params.unstakingAddress !== undefined) {\n          this.unstakingAddress(deactivateInstruction.params.unstakingAddress);\n        }\n        if (deactivateInstruction.params.recipients !== undefined) {\n          this.recipients(deactivateInstruction.params.recipients);\n        }\n        if (deactivateInstruction.params.stakingType !== undefined) {\n          this.stakingType(deactivateInstruction.params.stakingType);\n        }\n        if (deactivateInstruction.params.extraParams !== undefined) {\n          this.extraParams(deactivateInstruction.params.extraParams);\n        }\n      }\n    }\n    if (stakingAddresses.length > 1) {\n      this.stakingAddresses(stakingAddresses);\n    } else {\n      if (this._stakingType !== SolStakingTypeEnum.MARINADE) {\n        this.stakingAddress(stakingAddresses[0]);\n      }\n    }\n  }\n\n  /**\n   * The staking address of the staking account.\n   *\n   * @param {string} stakingAddress public address of the staking account\n   * @returns {StakingDeactivateBuilder} This staking deactivate builder.\n   *\n   * @see https://docs.solana.com/staking/stake-accounts#account-address\n   */\n  stakingAddress(stakingAddress: string): this {\n    validateAddress(stakingAddress, 'stakingAddress');\n    this._stakingAddress = stakingAddress;\n    return this;\n  }\n\n  /**\n   * The staking addresses of the staking account.\n   *\n   * @param {string[]} stakingAddresses public address of the staking accounts\n   * @returns {StakingDeactivateBuilder} This staking deactivate builder.\n   *\n   * @see https://docs.solana.com/staking/stake-accounts#account-address\n   */\n  stakingAddresses(stakingAddresses: string[]): this {\n    for (const stakingAddress of stakingAddresses) {\n      validateAddress(stakingAddress, 'stakingAddress');\n    }\n    this._stakingAddresses = stakingAddresses;\n    return this;\n  }\n\n  /**\n   * Optional amount to unstake expressed in Lamports, 1 SOL = 1_000_000_000 lamports, to be used\n   * when partially unstaking. If not given then the entire staked amount will be unstaked.\n   *\n   * @param {string} amount The partial amount to unstake, expressed in Lamports.\n   * @returns {StakingDeactivateBuilder} This staking builder.\n   *\n   * @see https://docs.solana.com/cli/delegate-stake#split-stake\n   */\n  amount(amount: string): this {\n    if (!isValidStakingAmount(amount)) {\n      throw new BuildTransactionError('If given, amount cannot be zero or less');\n    }\n    this._amount = amount;\n    return this;\n  }\n\n  /**\n   * Setter to set the recipients object\n   *\n   * @param recipients RecipientEntry[] - The recipients object\n   * @returns {StakingDeactivateBuilder} This staking builder.\n   */\n  recipients(recipients: Recipient[]): this {\n    this._recipients = recipients;\n    return this;\n  }\n\n  /**\n   * When partially unstaking move the amount to unstake to this account and initiate the\n   * unstake process. The original stake account will continue staking.\n   *\n   * @param {string} unstakingAddress An account used to unstake a partial amount.\n   * @returns {StakingDeactivateBuilder} This staking builder.\n   *\n   * @see https://docs.solana.com/cli/delegate-stake#split-stake\n   */\n  unstakingAddress(unstakingAddress: string): this {\n    validateAddress(unstakingAddress, 'unstakingAddress');\n    this._unstakingAddress = unstakingAddress;\n    return this;\n  }\n\n  /**\n   * Set staking type.\n   *\n   * @param {SolStakingType} stakingType a staking type.\n   * @returns {StakingDeactivateBuilder} This staking builder.\n   */\n  stakingType(stakingType: SolStakingTypeEnum): this {\n    this._stakingType = stakingType;\n    return this;\n  }\n\n  /**\n   * Set parameters specific to a staking type.\n   *\n   * @param {StakingDeactivateExtraParams} extraParams parameters specific to a staking type.\n   * @returns {StakingDeactivateBuilder} This staking builder.\n   */\n  extraParams(extraParams?: StakingDeactivateExtraParams): this {\n    this._extraParams = extraParams;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._sender, 'Sender must be set before building the transaction');\n\n    if (this._stakingAddresses && this._stakingAddresses.length > 0) {\n      this._instructionsData = [];\n      for (const stakingAddress of this._stakingAddresses) {\n        const stakingDeactivateData: StakingDeactivate = {\n          type: InstructionBuilderTypes.StakingDeactivate,\n          params: {\n            fromAddress: this._sender,\n            stakingAddress: stakingAddress,\n            stakingType: SolStakingTypeEnum.NATIVE,\n          },\n        };\n        this._instructionsData.push(stakingDeactivateData);\n      }\n    } else {\n      if (this._stakingType === SolStakingTypeEnum.NATIVE) {\n        // we don't need stakingAddress in marinade staking deactivate txn\n        assert(this._stakingAddress, 'Staking address must be set before building the transaction');\n      }\n\n      if (this._sender === this._stakingAddress) {\n        throw new BuildTransactionError('Sender address cannot be the same as the Staking address');\n      }\n\n      if (this._stakingType === SolStakingTypeEnum.NATIVE && this._amount) {\n        assert(\n          this._unstakingAddress,\n          'When partially unstaking the unstaking address must be set before building the transaction'\n        );\n      }\n\n      this._instructionsData = [];\n      if (this._stakingType === SolStakingTypeEnum.NATIVE && this._unstakingAddress) {\n        assert(\n          this._amount,\n          'If an unstaking address is given then a partial amount to unstake must also be set before building the transaction'\n        );\n        const stakingFundUnstakeAddress: Transfer = {\n          type: InstructionBuilderTypes.Transfer,\n          params: {\n            fromAddress: this._sender,\n            amount: STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT.toString(),\n            toAddress: this._unstakingAddress,\n          },\n        };\n        this._instructionsData.push(stakingFundUnstakeAddress);\n      }\n\n      const stakingDeactivateData: StakingDeactivate = {\n        type: InstructionBuilderTypes.StakingDeactivate,\n        params: {\n          fromAddress: this._sender,\n          stakingAddress: this._stakingAddress,\n          amount: this._amount,\n          unstakingAddress: this._unstakingAddress,\n          recipients: this._recipients,\n          stakingType: this._stakingType,\n          extraParams: this._extraParams,\n        },\n      };\n      this._instructionsData.push(stakingDeactivateData);\n    }\n\n    if (this._priorityFee && this._priorityFee !== Number(0)) {\n      this._instructionsData.unshift({\n        type: InstructionBuilderTypes.SetPriorityFee,\n        params: { fee: this._priorityFee },\n      });\n    }\n\n    return await super.buildImplementation();\n  }\n}\n"]}

package/dist/esm/lib/stakingDelegateBuilder.d.ts

@@ -0,0 +1,42 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class StakingDelegateBuilder extends TransactionBuilder {
+    protected _stakingAddress: string;
+    protected _stakingAddresses: string[];
+    protected _validator: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * The address of the staking account.
+     *
+     * @param {string} stakingAddress public address of the staking account.
+     * @returns {StakingDelegateBuilder} This staking delegate builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddress(stakingAddress: string): this;
+    /**
+     * The staking addresses of the staking account.
+     *
+     * @param {string[]} stakingAddresses public address of the staking accounts
+     * @returns {StakingDelegateBuilder} This staking delegate builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddresses(stakingAddresses: string[]): this;
+    /**
+     * Set validator address to delegate funds to.
+     *
+     * @param {string} validator Validator address to delegate funds to.
+     * @returns {StakingDelegateBuilder} This staking builder.
+     *
+     */
+    validator(validator: string): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=stakingDelegateBuilder.d.ts.map

package/dist/{src → esm}/lib/stakingDelegateBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stakingDelegateBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingDelegateBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO1D,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IACtC,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEjB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAkBlC;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;;OAOG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI;IASlD;;;;;;OAMG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAMlC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAuC5D"}
+{"version":3,"file":"stakingDelegateBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingDelegateBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO1D,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IACtC,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEjB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAkBlC;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;;OAOG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI;IASlD;;;;;;OAMG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAMlC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CA6C5D"}

package/dist/esm/lib/stakingDelegateBuilder.js

@@ -0,0 +1,119 @@
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { InstructionBuilderTypes } from './constants';
+import assert from 'assert';
+import { validateAddress } from './utils';
+export class StakingDelegateBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return TransactionType.StakingDelegate;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        const stakingAddresses = [];
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.StakingDelegate) {
+                const activateInstruction = instruction;
+                this.sender(activateInstruction.params.fromAddress);
+                stakingAddresses.push(activateInstruction.params.stakingAddress);
+                this.validator(activateInstruction.params.validator);
+            }
+        }
+        if (stakingAddresses.length > 1) {
+            this.stakingAddresses(stakingAddresses);
+        }
+        else {
+            this.stakingAddress(stakingAddresses[0]);
+        }
+    }
+    /**
+     * The address of the staking account.
+     *
+     * @param {string} stakingAddress public address of the staking account.
+     * @returns {StakingDelegateBuilder} This staking delegate builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddress(stakingAddress) {
+        validateAddress(stakingAddress, 'stakingAddress');
+        this._stakingAddress = stakingAddress;
+        return this;
+    }
+    /**
+     * The staking addresses of the staking account.
+     *
+     * @param {string[]} stakingAddresses public address of the staking accounts
+     * @returns {StakingDelegateBuilder} This staking delegate builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddresses(stakingAddresses) {
+        assert(stakingAddresses.length > 0, 'stakingAddresses must not be empty');
+        for (const stakingAddress of stakingAddresses) {
+            validateAddress(stakingAddress, 'stakingAddress');
+        }
+        this._stakingAddresses = stakingAddresses;
+        return this;
+    }
+    /**
+     * Set validator address to delegate funds to.
+     *
+     * @param {string} validator Validator address to delegate funds to.
+     * @returns {StakingDelegateBuilder} This staking builder.
+     *
+     */
+    validator(validator) {
+        validateAddress(validator, 'validator');
+        this._validator = validator;
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._sender, 'Sender must be set before building the transaction');
+        assert(this._validator, 'Validator must be set before building the transaction');
+        if (this._stakingAddresses && this._stakingAddresses.length > 0) {
+            this._instructionsData = [];
+            for (const stakingAddress of this._stakingAddresses) {
+                assert(stakingAddress, 'Staking Address must be set before building the transaction');
+                if (this._sender === stakingAddress) {
+                    throw new BuildTransactionError('Sender address cannot be the same as the Staking address');
+                }
+                const stakingAccountData = {
+                    type: InstructionBuilderTypes.StakingDelegate,
+                    params: {
+                        fromAddress: this._sender,
+                        stakingAddress: stakingAddress,
+                        validator: this._validator,
+                    },
+                };
+                this._instructionsData.push(stakingAccountData);
+            }
+        }
+        else {
+            assert(this._stakingAddress, 'Staking Address must be set before building the transaction');
+            if (this._sender === this._stakingAddress) {
+                throw new BuildTransactionError('Sender address cannot be the same as the Staking address');
+            }
+            const stakingAccountData = {
+                type: InstructionBuilderTypes.StakingDelegate,
+                params: {
+                    fromAddress: this._sender,
+                    stakingAddress: this._stakingAddress,
+                    validator: this._validator,
+                },
+            };
+            this._instructionsData = [stakingAccountData];
+        }
+        if (this._priorityFee && this._priorityFee !== Number(0)) {
+            this._instructionsData.unshift({
+                type: InstructionBuilderTypes.SetPriorityFee,
+                params: { fee: this._priorityFee },
+            });
+        }
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingDelegateBuilder.js","sourceRoot":"","sources":["../../../src/lib/stakingDelegateBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { InstructionBuilderTypes } from './constants';\n\nimport assert from 'assert';\nimport { StakingDelegate } from './iface';\nimport { validateAddress } from './utils';\n\nexport class StakingDelegateBuilder extends TransactionBuilder {\n  protected _stakingAddress: string;\n  protected _stakingAddresses: string[];\n  protected _validator: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingDelegate;\n  }\n\n  /** @inheritdoc */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    const stakingAddresses: string[] = [];\n    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.StakingDelegate) {\n        const activateInstruction: StakingDelegate = instruction;\n        this.sender(activateInstruction.params.fromAddress);\n        stakingAddresses.push(activateInstruction.params.stakingAddress);\n        this.validator(activateInstruction.params.validator);\n      }\n    }\n    if (stakingAddresses.length > 1) {\n      this.stakingAddresses(stakingAddresses);\n    } else {\n      this.stakingAddress(stakingAddresses[0]);\n    }\n  }\n\n  /**\n   * The address of the staking account.\n   *\n   * @param {string} stakingAddress public address of the staking account.\n   * @returns {StakingDelegateBuilder} This staking delegate builder.\n   *\n   * @see https://docs.solana.com/staking/stake-accounts#account-address\n   */\n  stakingAddress(stakingAddress: string): this {\n    validateAddress(stakingAddress, 'stakingAddress');\n    this._stakingAddress = stakingAddress;\n    return this;\n  }\n\n  /**\n   * The staking addresses of the staking account.\n   *\n   * @param {string[]} stakingAddresses public address of the staking accounts\n   * @returns {StakingDelegateBuilder} This staking delegate builder.\n   *\n   * @see https://docs.solana.com/staking/stake-accounts#account-address\n   */\n  stakingAddresses(stakingAddresses: string[]): this {\n    assert(stakingAddresses.length > 0, 'stakingAddresses must not be empty');\n    for (const stakingAddress of stakingAddresses) {\n      validateAddress(stakingAddress, 'stakingAddress');\n    }\n    this._stakingAddresses = stakingAddresses;\n    return this;\n  }\n\n  /**\n   * Set validator address to delegate funds to.\n   *\n   * @param {string} validator Validator address to delegate funds to.\n   * @returns {StakingDelegateBuilder} This staking builder.\n   *\n   */\n  validator(validator: string): this {\n    validateAddress(validator, 'validator');\n    this._validator = validator;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._sender, 'Sender must be set before building the transaction');\n    assert(this._validator, 'Validator must be set before building the transaction');\n\n    if (this._stakingAddresses && this._stakingAddresses.length > 0) {\n      this._instructionsData = [];\n      for (const stakingAddress of this._stakingAddresses) {\n        assert(stakingAddress, 'Staking Address must be set before building the transaction');\n        if (this._sender === stakingAddress) {\n          throw new BuildTransactionError('Sender address cannot be the same as the Staking address');\n        }\n        const stakingAccountData: StakingDelegate = {\n          type: InstructionBuilderTypes.StakingDelegate,\n          params: {\n            fromAddress: this._sender,\n            stakingAddress: stakingAddress,\n            validator: this._validator,\n          },\n        };\n        this._instructionsData.push(stakingAccountData);\n      }\n    } else {\n      assert(this._stakingAddress, 'Staking Address must be set before building the transaction');\n      if (this._sender === this._stakingAddress) {\n        throw new BuildTransactionError('Sender address cannot be the same as the Staking address');\n      }\n\n      const stakingAccountData: StakingDelegate = {\n        type: InstructionBuilderTypes.StakingDelegate,\n        params: {\n          fromAddress: this._sender,\n          stakingAddress: this._stakingAddress,\n          validator: this._validator,\n        },\n      };\n      this._instructionsData = [stakingAccountData];\n    }\n    if (this._priorityFee && this._priorityFee !== Number(0)) {\n      this._instructionsData.unshift({\n        type: InstructionBuilderTypes.SetPriorityFee,\n        params: { fee: this._priorityFee },\n      });\n    }\n    return await super.buildImplementation();\n  }\n}\n"]}

package/dist/esm/lib/stakingRawMsgAuthorizeBuilder.d.ts

@@ -0,0 +1,33 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { BaseAddress, BaseKey, BaseTransaction, BaseTransactionBuilder, TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import BigNumber from 'bignumber.js';
+export declare class StakingRawMsgAuthorizeBuilder extends BaseTransactionBuilder {
+    protected _transaction: Transaction;
+    protected _transactionMessage: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * The raw message generated by Solana CLI.
+     *
+     * @param {string} msg msg generated by 'solana stake-authorize-check.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    transactionMessage(msg: string): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    validateTransaction(tx: Transaction): boolean;
+    build(): Promise<Transaction>;
+    protected validateMessage(msg: string): boolean;
+    protected fromImplementation(rawTransaction: string): Transaction;
+    protected signImplementation(key: BaseKey): BaseTransaction;
+    protected get transaction(): Transaction;
+    validateAddress(address: BaseAddress, addressFormat?: string): void;
+    validateKey(key: BaseKey): void;
+    validateRawTransaction(rawTransaction: string): void;
+    validateValue(value: BigNumber): void;
+}
+//# sourceMappingURL=stakingRawMsgAuthorizeBuilder.d.ts.map

package/dist/esm/lib/stakingRawMsgAuthorizeBuilder.js

@@ -0,0 +1,103 @@
+import { BaseTransactionBuilder, NotSupported, TransactionType, } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { Transaction as SOLTransaction, Message as SOLMessage, SystemProgram, SystemInstruction, StakeProgram, } from '@solana/web3.js';
+import assert from 'assert';
+import { nonceAdvanceInstruction, validInstructionData, validInstructionData2 } from './constants';
+export class StakingRawMsgAuthorizeBuilder extends BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new Transaction(_coinConfig);
+    }
+    get transactionType() {
+        return TransactionType.StakingAuthorizeRaw;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        if (this.validateTransaction(tx)) {
+            this.transactionMessage(tx.solTransaction.serializeMessage().toString('base64'));
+        }
+    }
+    /**
+     * The raw message generated by Solana CLI.
+     *
+     * @param {string} msg msg generated by 'solana stake-authorize-check.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    transactionMessage(msg) {
+        this.validateMessage(msg);
+        this._transactionMessage = msg;
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._transactionMessage, 'missing transaction message');
+        this.validateMessage(this._transactionMessage);
+        const solTransaction = SOLTransaction.populate(SOLMessage.from(Buffer.from(this._transactionMessage, 'base64')), []);
+        // this is workaround for solana web3.js generate wrong signing message
+        const serialized = solTransaction.serialize({ requireAllSignatures: false }).toString('base64');
+        this.transaction.fromRawTransaction(serialized);
+        this.transaction.setTransactionType(this.transactionType);
+        assert(this._transactionMessage === this.transaction.signablePayload.toString('base64'), 'wrong signing message');
+        return this.transaction;
+    }
+    validateTransaction(tx) {
+        return this.validateMessage(tx.solTransaction.serializeMessage().toString('base64'));
+    }
+    async build() {
+        return this.buildImplementation();
+    }
+    validateMessage(msg) {
+        const tx = SOLTransaction.populate(SOLMessage.from(Buffer.from(msg, 'base64')), []);
+        const instructions = tx.instructions;
+        if (instructions.length !== 2 && instructions.length !== 3) {
+            throw new Error(`Invalid transaction, expected 2 instruction, got ${instructions.length}`);
+        }
+        for (const instruction of instructions) {
+            switch (instruction.programId.toString()) {
+                case SystemProgram.programId.toString():
+                    const instructionName = SystemInstruction.decodeInstructionType(instruction);
+                    if (instructionName !== nonceAdvanceInstruction) {
+                        throw new Error(`Invalid system instruction : ${instructionName}`);
+                    }
+                    break;
+                case StakeProgram.programId.toString():
+                    const data = instruction.data.toString('hex');
+                    if (data !== validInstructionData && data !== validInstructionData2) {
+                        throw new Error(`Invalid staking instruction data: ${data}`);
+                    }
+                    break;
+                default:
+                    throw new Error(`Invalid transaction, instruction program id not supported: ${instruction.programId.toString()}`);
+            }
+        }
+        return true;
+    }
+    fromImplementation(rawTransaction) {
+        const tx = new Transaction(this._coinConfig);
+        tx.fromRawTransaction(rawTransaction);
+        this.initBuilder(tx);
+        return this.transaction;
+    }
+    signImplementation(key) {
+        throw new NotSupported('Method not supported on this builder');
+    }
+    get transaction() {
+        return this._transaction;
+    }
+    validateAddress(address, addressFormat) {
+        throw new NotSupported('Method not supported on this builder');
+    }
+    validateKey(key) {
+        throw new NotSupported('Method not supported on this builder');
+    }
+    validateRawTransaction(rawTransaction) {
+        const tx = new Transaction(this._coinConfig);
+        tx.fromRawTransaction(rawTransaction);
+        this.validateTransaction(tx);
+    }
+    validateValue(value) {
+        throw new NotSupported('Method not supported on this builder');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingRawMsgAuthorizeBuilder.js","sourceRoot":"","sources":["../../../src/lib/stakingRawMsgAuthorizeBuilder.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,sBAAsB,EACtB,YAAY,EACZ,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EACL,WAAW,IAAI,cAAc,EAC7B,OAAO,IAAI,UAAU,EACrB,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEnG,MAAM,OAAO,6BAA8B,SAAQ,sBAAsB;IAGvE,YAAY,WAAiC;QAC3C,KAAK,CAAC,WAAW,CAAC,CAAC;QACnB,IAAI,CAAC,YAAY,GAAG,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED,IAAc,eAAe;QAC3B,OAAO,eAAe,CAAC,mBAAmB,CAAC;IAC7C,CAAC;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAe;QACzB,IAAI,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,EAAE,CAAC;YACjC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,cAAc,CAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QACnF,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,kBAAkB,CAAC,GAAW;QAC5B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IACR,KAAK,CAAC,mBAAmB;QACjC,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,6BAA6B,CAAC,CAAC;QAEhE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC/C,MAAM,cAAc,GAAG,cAAc,CAAC,QAAQ,CAC5C,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC,EAChE,EAAE,CACH,CAAC;QACF,uEAAuE;QACvE,MAAM,UAAU,GAAG,cAAc,CAAC,SAAS,CAAC,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAChG,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC1D,MAAM,CAAC,IAAI,CAAC,mBAAmB,KAAK,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,uBAAuB,CAAC,CAAC;QAClH,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,mBAAmB,CAAC,EAAe;QACjC,OAAO,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,cAAc,CAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACvF,CAAC;IAED,KAAK,CAAC,KAAK;QACT,OAAO,IAAI,CAAC,mBAAmB,EAAE,CAAC;IACpC,CAAC;IAES,eAAe,CAAC,GAAW;QACnC,MAAM,EAAE,GAAG,cAAc,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACpF,MAAM,YAAY,GAAG,EAAE,CAAC,YAAY,CAAC;QACrC,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3D,MAAM,IAAI,KAAK,CAAC,oDAAoD,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QAC7F,CAAC;QACD,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACvC,QAAQ,WAAW,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC;gBACzC,KAAK,aAAa,CAAC,SAAS,CAAC,QAAQ,EAAE;oBACrC,MAAM,eAAe,GAAG,iBAAiB,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;oBAC7E,IAAI,eAAe,KAAK,uBAAuB,EAAE,CAAC;wBAChD,MAAM,IAAI,KAAK,CAAC,gCAAgC,eAAe,EAAE,CAAC,CAAC;oBACrE,CAAC;oBACD,MAAM;gBACR,KAAK,YAAY,CAAC,SAAS,CAAC,QAAQ,EAAE;oBACpC,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;oBAC9C,IAAI,IAAI,KAAK,oBAAoB,IAAI,IAAI,KAAK,qBAAqB,EAAE,CAAC;wBACpE,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,EAAE,CAAC,CAAC;oBAC/D,CAAC;oBACD,MAAM;gBACR;oBACE,MAAM,IAAI,KAAK,CACb,8DAA8D,WAAW,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,CACjG,CAAC;YACN,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAES,kBAAkB,CAAC,cAAsB;QACjD,MAAM,EAAE,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC7C,EAAE,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC;QACtC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAES,kBAAkB,CAAC,GAAY;QACvC,MAAM,IAAI,YAAY,CAAC,sCAAsC,CAAC,CAAC;IACjE,CAAC;IAED,IAAc,WAAW;QACvB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,eAAe,CAAC,OAAoB,EAAE,aAAsB;QAC1D,MAAM,IAAI,YAAY,CAAC,sCAAsC,CAAC,CAAC;IACjE,CAAC;IAED,WAAW,CAAC,GAAY;QACtB,MAAM,IAAI,YAAY,CAAC,sCAAsC,CAAC,CAAC;IACjE,CAAC;IAED,sBAAsB,CAAC,cAAsB;QAC3C,MAAM,EAAE,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC7C,EAAE,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC;QACtC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED,aAAa,CAAC,KAAgB;QAC5B,MAAM,IAAI,YAAY,CAAC,sCAAsC,CAAC,CAAC;IACjE,CAAC;CACF","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport {\n  BaseAddress,\n  BaseKey,\n  BaseTransaction,\n  BaseTransactionBuilder,\n  NotSupported,\n  TransactionType,\n} from '@bitgo-beta/sdk-core';\nimport { Transaction } from './transaction';\nimport {\n  Transaction as SOLTransaction,\n  Message as SOLMessage,\n  SystemProgram,\n  SystemInstruction,\n  StakeProgram,\n} from '@solana/web3.js';\n\nimport assert from 'assert';\nimport BigNumber from 'bignumber.js';\nimport { nonceAdvanceInstruction, validInstructionData, validInstructionData2 } from './constants';\n\nexport class StakingRawMsgAuthorizeBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  protected _transactionMessage: string;\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingAuthorizeRaw;\n  }\n\n  /** @inheritdoc */\n  initBuilder(tx: Transaction): void {\n    if (this.validateTransaction(tx)) {\n      this.transactionMessage(tx.solTransaction.serializeMessage().toString('base64'));\n    }\n  }\n\n  /**\n   * The raw message generated by Solana CLI.\n   *\n   * @param {string} msg msg generated by 'solana stake-authorize-check.\n   * @returns {StakeBuilder} This staking builder.\n   *\n   */\n  transactionMessage(msg: string): this {\n    this.validateMessage(msg);\n    this._transactionMessage = msg;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._transactionMessage, 'missing transaction message');\n\n    this.validateMessage(this._transactionMessage);\n    const solTransaction = SOLTransaction.populate(\n      SOLMessage.from(Buffer.from(this._transactionMessage, 'base64')),\n      []\n    );\n    // this is workaround for solana web3.js generate wrong signing message\n    const serialized = solTransaction.serialize({ requireAllSignatures: false }).toString('base64');\n    this.transaction.fromRawTransaction(serialized);\n    this.transaction.setTransactionType(this.transactionType);\n    assert(this._transactionMessage === this.transaction.signablePayload.toString('base64'), 'wrong signing message');\n    return this.transaction;\n  }\n\n  validateTransaction(tx: Transaction): boolean {\n    return this.validateMessage(tx.solTransaction.serializeMessage().toString('base64'));\n  }\n\n  async build(): Promise<Transaction> {\n    return this.buildImplementation();\n  }\n\n  protected validateMessage(msg: string): boolean {\n    const tx = SOLTransaction.populate(SOLMessage.from(Buffer.from(msg, 'base64')), []);\n    const instructions = tx.instructions;\n    if (instructions.length !== 2 && instructions.length !== 3) {\n      throw new Error(`Invalid transaction, expected 2 instruction, got ${instructions.length}`);\n    }\n    for (const instruction of instructions) {\n      switch (instruction.programId.toString()) {\n        case SystemProgram.programId.toString():\n          const instructionName = SystemInstruction.decodeInstructionType(instruction);\n          if (instructionName !== nonceAdvanceInstruction) {\n            throw new Error(`Invalid system instruction : ${instructionName}`);\n          }\n          break;\n        case StakeProgram.programId.toString():\n          const data = instruction.data.toString('hex');\n          if (data !== validInstructionData && data !== validInstructionData2) {\n            throw new Error(`Invalid staking instruction data: ${data}`);\n          }\n          break;\n        default:\n          throw new Error(\n            `Invalid transaction, instruction program id not supported: ${instruction.programId.toString()}`\n          );\n      }\n    }\n    return true;\n  }\n\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = new Transaction(this._coinConfig);\n    tx.fromRawTransaction(rawTransaction);\n    this.initBuilder(tx);\n    return this.transaction;\n  }\n\n  protected signImplementation(key: BaseKey): BaseTransaction {\n    throw new NotSupported('Method not supported on this builder');\n  }\n\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  validateAddress(address: BaseAddress, addressFormat?: string): void {\n    throw new NotSupported('Method not supported on this builder');\n  }\n\n  validateKey(key: BaseKey): void {\n    throw new NotSupported('Method not supported on this builder');\n  }\n\n  validateRawTransaction(rawTransaction: string): void {\n    const tx = new Transaction(this._coinConfig);\n    tx.fromRawTransaction(rawTransaction);\n    this.validateTransaction(tx);\n  }\n\n  validateValue(value: BigNumber): void {\n    throw new NotSupported('Method not supported on this builder');\n  }\n}\n"]}

package/dist/esm/lib/stakingWithdrawBuilder.d.ts

@@ -0,0 +1,31 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class StakingWithdrawBuilder extends TransactionBuilder {
+    protected _stakingAddress: string;
+    protected _amount: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * The address of the staking account.
+     *
+     * @param {string} stakingAddress public address of the staking account
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    stakingAddress(stakingAddress: string): this;
+    /**
+     * The amount to withdraw expressed in Lamports, 1 SOL = 1_000_000_000 lamports
+     *
+     * @param {string} amount expressed in Lamports
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    amount(amount: string): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=stakingWithdrawBuilder.d.ts.map

package/dist/{src → esm}/lib/stakingWithdrawBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stakingWithdrawBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingWithdrawBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO1D,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAYlC;;;;;;OAMG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ5B,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAqB5D"}
+{"version":3,"file":"stakingWithdrawBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingWithdrawBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO1D,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAYlC;;;;;;OAMG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ5B,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CA8B5D"}