@bitgo-beta/sdk-coin-sol 2.4.3-beta.9 → 2.4.3-beta.900

package/dist/src/lib/stakingActivateBuilder.js

@@ -12,6 +12,7 @@ const utils_1 = require("./utils");
 class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
+        this._isMarinade = false;
     }
     get transactionType() {
         return sdk_core_1.TransactionType.StakingActivate;
@@ -26,6 +27,7 @@ class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
                 this.stakingAddress(activateInstruction.params.stakingAddress);
                 this.amount(activateInstruction.params.amount);
                 this.validator(activateInstruction.params.validator);
+                this.isMarinade(activateInstruction.params.isMarinade ?? false);
             }
         }
     }
@@ -37,7 +39,7 @@ class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
      *
      */
     amount(amount) {
-        if (!utils_1.isValidStakingAmount(amount)) {
+        if (!(0, utils_1.isValidStakingAmount)(amount)) {
             throw new sdk_core_1.BuildTransactionError('Value cannot be zero or less');
         }
         this._amount = amount;
@@ -47,12 +49,12 @@ class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
      * The address of the staking account.
      *
      * @param {string} stakingAddress public address of the staking account.
-     * @returns {StakeBuilder} This staking builder.
+     * @returns {StakingActivateBuilder} This staking builder.
      *
      * @see https://docs.solana.com/staking/stake-accounts#account-address
      */
     stakingAddress(stakingAddress) {
-        utils_1.validateAddress(stakingAddress, 'stakingAddress');
+        (0, utils_1.validateAddress)(stakingAddress, 'stakingAddress');
         this._stakingAddress = stakingAddress;
         return this;
     }
@@ -60,20 +62,30 @@ class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
      * Set validator address to delegate funds to.
      *
      * @param {string} validator Validator address to delegate funds to.
-     * @returns {StakeBuilder} This staking builder.
+     * @returns {StakingActivateBuilder} This staking builder.
      *
      */
     validator(validator) {
-        utils_1.validateAddress(validator, 'validator');
+        (0, utils_1.validateAddress)(validator, 'validator');
         this._validator = validator;
         return this;
     }
+    /**
+     * Set isMarinade flag
+     * @param {boolean} flag - true if the transaction is for Marinade, false by default if not set
+     * @returns {StakingActivateBuilder} This staking builder
+     */
+    isMarinade(flag) {
+        this._isMarinade = flag;
+        return this;
+    }
     /** @inheritdoc */
     async buildImplementation() {
-        assert_1.default(this._sender, 'Sender must be set before building the transaction');
-        assert_1.default(this._stakingAddress, 'Staking Address must be set before building the transaction');
-        assert_1.default(this._validator, 'Validator must be set before building the transaction');
-        assert_1.default(this._amount, 'Amount must be set before building the transaction');
+        (0, assert_1.default)(this._sender, 'Sender must be set before building the transaction');
+        (0, assert_1.default)(this._stakingAddress, 'Staking Address must be set before building the transaction');
+        (0, assert_1.default)(this._validator, 'Validator must be set before building the transaction');
+        (0, assert_1.default)(this._amount, 'Amount must be set before building the transaction');
+        (0, assert_1.default)(this._isMarinade !== undefined, 'isMarinade must be set before building the transaction');
         if (this._sender === this._stakingAddress) {
             throw new sdk_core_1.BuildTransactionError('Sender address cannot be the same as the Staking address');
         }
@@ -84,6 +96,7 @@ class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
                 stakingAddress: this._stakingAddress,
                 amount: this._amount,
                 validator: this._validator,
+                isMarinade: this._isMarinade,
             },
         };
         this._instructionsData = [stakingAccountData];
@@ -91,4 +104,4 @@ class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
     }
 }
 exports.StakingActivateBuilder = StakingActivateBuilder;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingActivateBuilder.js","sourceRoot":"","sources":["../../../src/lib/stakingActivateBuilder.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 { StakingActivate } from './iface';\nimport { isValidStakingAmount, validateAddress } from './utils';\n\nexport class StakingActivateBuilder extends TransactionBuilder {\n  protected _amount: string;\n  protected _stakingAddress: string;\n  protected _validator: string;\n  protected _isMarinade = false;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingActivate;\n  }\n\n  /** @inheritdoc */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.StakingActivate) {\n        const activateInstruction: StakingActivate = instruction;\n        this.sender(activateInstruction.params.fromAddress);\n        this.stakingAddress(activateInstruction.params.stakingAddress);\n        this.amount(activateInstruction.params.amount);\n        this.validator(activateInstruction.params.validator);\n        this.isMarinade(activateInstruction.params.isMarinade ?? false);\n      }\n    }\n  }\n\n  /**\n   * The amount to stake expressed in Lamports, 1 SOL = 1_000_000_000 lamports.\n   *\n   * @param {string} amount expressed in Lamports.\n   * @returns {StakeBuilder} This staking builder.\n   *\n   */\n  amount(amount: string): this {\n    if (!isValidStakingAmount(amount)) {\n      throw new BuildTransactionError('Value cannot be zero or less');\n    }\n    this._amount = amount;\n    return this;\n  }\n\n  /**\n   * The address of the staking account.\n   *\n   * @param {string} stakingAddress public address of the staking account.\n   * @returns {StakingActivateBuilder} This staking 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   * Set validator address to delegate funds to.\n   *\n   * @param {string} validator Validator address to delegate funds to.\n   * @returns {StakingActivateBuilder} This staking builder.\n   *\n   */\n  validator(validator: string): this {\n    validateAddress(validator, 'validator');\n    this._validator = validator;\n    return this;\n  }\n\n  /**\n   * Set isMarinade flag\n   * @param {boolean} flag - true if the transaction is for Marinade, false by default if not set\n   * @returns {StakingActivateBuilder} This staking builder\n   */\n  isMarinade(flag: boolean): this {\n    this._isMarinade = flag;\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._stakingAddress, 'Staking Address must be set before building the transaction');\n    assert(this._validator, 'Validator must be set before building the transaction');\n    assert(this._amount, 'Amount must be set before building the transaction');\n    assert(this._isMarinade !== undefined, 'isMarinade must be set before building the transaction');\n\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: StakingActivate = {\n      type: InstructionBuilderTypes.StakingActivate,\n      params: {\n        fromAddress: this._sender,\n        stakingAddress: this._stakingAddress,\n        amount: this._amount,\n        validator: this._validator,\n        isMarinade: this._isMarinade,\n      },\n    };\n    this._instructionsData = [stakingAccountData];\n\n    return await super.buildImplementation();\n  }\n}\n"]}

package/dist/src/lib/stakingAuthorizeBuilder.d.ts

@@ -0,0 +1,43 @@
+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 StakingAuthorizeBuilder extends TransactionBuilder {
+    protected _stakingAddress: string;
+    protected _newAuthorizedAddress: string;
+    protected _oldAuthorizedAddress: 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.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddress(stakingAddress: string): this;
+    /**
+     * The address of the new staking account authorization.
+     *
+     * @param {string} stakingAddress public address of the staking account.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    newAuthorizedAddress(newAuthorizedAddress: string): this;
+    /**
+     * The address of the new staking account authorization.
+     *
+     * @param {string} stakingAddress public address of the staking account.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    oldAuthorizedAddress(oldAuthorizedAddress: string): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=stakingAuthorizeBuilder.d.ts.map

package/dist/src/lib/stakingAuthorizeBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakingAuthorizeBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingAuthorizeBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO1D,qBAAa,uBAAwB,SAAQ,kBAAkB;IAC7D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACxC,SAAS,CAAC,qBAAqB,EAAE,MAAM,CAAC;gBAE5B,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;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;;OAOG;IACH,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI;IAMxD;;;;;;;OAOG;IACH,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI;IAMxD,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAkB5D"}

package/dist/src/lib/stakingAuthorizeBuilder.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingAuthorizeBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const constants_1 = require("./constants");
+const assert_1 = __importDefault(require("assert"));
+const utils_1 = require("./utils");
+class StakingAuthorizeBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingAuthorize;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === constants_1.InstructionBuilderTypes.StakingAuthorize) {
+                const AuthorizeInstruction = instruction;
+                this.stakingAddress(AuthorizeInstruction.params.stakingAddress);
+                this.newAuthorizedAddress(AuthorizeInstruction.params.newAuthorizeAddress);
+                this.oldAuthorizedAddress(AuthorizeInstruction.params.oldAuthorizeAddress);
+            }
+        }
+    }
+    /**
+     * The address of the staking account.
+     *
+     * @param {string} stakingAddress public address of the staking account.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddress(stakingAddress) {
+        (0, utils_1.validateAddress)(stakingAddress, 'stakingAddress');
+        this._stakingAddress = stakingAddress;
+        return this;
+    }
+    /**
+     * The address of the new staking account authorization.
+     *
+     * @param {string} stakingAddress public address of the staking account.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    newAuthorizedAddress(newAuthorizedAddress) {
+        (0, utils_1.validateAddress)(newAuthorizedAddress, 'newAuthorizedAddress');
+        this._newAuthorizedAddress = newAuthorizedAddress;
+        return this;
+    }
+    /**
+     * The address of the new staking account authorization.
+     *
+     * @param {string} stakingAddress public address of the staking account.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    oldAuthorizedAddress(oldAuthorizedAddress) {
+        (0, utils_1.validateAddress)(oldAuthorizedAddress, 'oldAuthorizedAddress');
+        this._oldAuthorizedAddress = oldAuthorizedAddress;
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        (0, assert_1.default)(this._stakingAddress, 'Staking Address must be set before building the transaction');
+        (0, assert_1.default)(this._newAuthorizedAddress, 'new authorized Address must be set before building the transaction');
+        (0, assert_1.default)(this._oldAuthorizedAddress, 'old authorized Address must be set before building the transaction');
+        const stakingAccountData = {
+            type: constants_1.InstructionBuilderTypes.StakingAuthorize,
+            params: {
+                stakingAddress: this._stakingAddress,
+                newWithdrawAddress: this._newAuthorizedAddress,
+                newAuthorizeAddress: this._newAuthorizedAddress,
+                oldAuthorizeAddress: this._oldAuthorizedAddress,
+            },
+        };
+        this._instructionsData = [stakingAccountData];
+        return await super.buildImplementation();
+    }
+}
+exports.StakingAuthorizeBuilder = StakingAuthorizeBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/stakingDeactivateBuilder.d.ts

@@ -1,11 +1,14 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-import { TransactionType } from '@bitgo-beta/sdk-core';
+import { Recipient, TransactionType } from '@bitgo-beta/sdk-core';
 import { Transaction } from './transaction';
 import { TransactionBuilder } from './transactionBuilder';
 export declare class StakingDeactivateBuilder extends TransactionBuilder {
     protected _stakingAddress: string;
+    protected _stakingAddresses: string[];
     protected _amount?: string;
     protected _unstakingAddress: string;
+    protected _isMarinade: boolean;
+    protected _recipients: Recipient[];
     constructor(_coinConfig: Readonly<CoinConfig>);
     protected get transactionType(): TransactionType;
     /** @inheritdoc */
@@ -19,6 +22,15 @@ export declare class StakingDeactivateBuilder extends TransactionBuilder {
      * @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 {StakingDeactivateBuilder} This staking deactivate builder.
+     *
+     * @see https://docs.solana.com/staking/stake-accounts#account-address
+     */
+    stakingAddresses(stakingAddresses: string[]): 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.
@@ -29,6 +41,13 @@ export declare class StakingDeactivateBuilder extends TransactionBuilder {
      * @see https://docs.solana.com/cli/delegate-stake#split-stake
      */
     amount(amount: string): this;
+    /**
+     * Setter to set the recipients object
+     *
+     * @param recipients RecipientEntry[] - The recipients object
+     * @returns {StakingDeactivateBuilder} This staking builder.
+     */
+    recipients(recipients: Recipient[]): this;
     /**
      * When partially unstaking move the amount to unstake to this account and initiate the
      * unstake process. The original stake account will continue staking.
@@ -39,6 +58,12 @@ export declare class StakingDeactivateBuilder extends TransactionBuilder {
      * @see https://docs.solana.com/cli/delegate-stake#split-stake
      */
     unstakingAddress(unstakingAddress: string): this;
+    /**
+     * Set isMarinade flag
+     * @param {boolean} flag - true if the transaction is for Marinade, false by default if not set
+     * @returns {StakingActivateBuilder} This staking builder
+     */
+    isMarinade(flag: boolean): this;
     /** @inheritdoc */
     protected buildImplementation(): Promise<Transaction>;
 }

package/dist/src/lib/stakingDeactivateBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stakingDeactivateBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingDeactivateBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG9E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,wBAAyB,SAAQ,kBAAkB;IAC9D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC;gBAExB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAelC;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;;;OAQG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ5B;;;;;;;;OAQG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAMhD,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAmC5D"}
+{"version":3,"file":"stakingDeactivateBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingDeactivateBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG7D,OAAO,EAAyB,SAAS,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGzF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,wBAAyB,SAAQ,kBAAkB;IAC9D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IACtC,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACpC,SAAS,CAAC,WAAW,UAAS;IAC9B,SAAS,CAAC,WAAW,EAAE,SAAS,EAAE,CAAC;gBAEvB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IA6BlC;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;;OAOG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI;IAQlD;;;;;;;;OAQG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ5B;;;;;OAKG;IACH,UAAU,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI;IAKzC;;;;;;;;OAQG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAMhD;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAK/B,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAgE5D"}

package/dist/src/lib/stakingDeactivateBuilder.js

@@ -12,6 +12,7 @@ const utils_1 = require("./utils");
 class StakingDeactivateBuilder extends transactionBuilder_1.TransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
+        this._isMarinade = false;
     }
     get transactionType() {
         return sdk_core_1.TransactionType.StakingDeactivate;
@@ -19,17 +20,32 @@ class StakingDeactivateBuilder extends transactionBuilder_1.TransactionBuilder {
     /** @inheritdoc */
     initBuilder(tx) {
         super.initBuilder(tx);
+        const stakingAddresses = [];
         for (const instruction of this._instructionsData) {
             if (instruction.type === constants_1.InstructionBuilderTypes.StakingDeactivate) {
                 const deactivateInstruction = instruction;
-                this.sender(deactivateInstruction.params.fromAddress);
-                this.stakingAddress(deactivateInstruction.params.stakingAddress);
+                this.isMarinade(deactivateInstruction.params.isMarinade ?? false);
+                if (!deactivateInstruction.params.isMarinade) {
+                    this.sender(deactivateInstruction.params.fromAddress);
+                }
+                if (deactivateInstruction.params.isMarinade) {
+                    this.recipients(deactivateInstruction.params.recipients ?? []);
+                }
+                stakingAddresses.push(deactivateInstruction.params.stakingAddress);
                 if (deactivateInstruction.params.amount && deactivateInstruction.params.unstakingAddress) {
                     this.amount(deactivateInstruction.params.amount);
                     this.unstakingAddress(deactivateInstruction.params.unstakingAddress);
                 }
             }
         }
+        if (stakingAddresses.length > 1) {
+            this.stakingAddresses(stakingAddresses);
+        }
+        else {
+            if (!this._isMarinade) {
+                this.stakingAddress(stakingAddresses[0]);
+            }
+        }
     }
     /**
      * The staking address of the staking account.
@@ -40,10 +56,25 @@ class StakingDeactivateBuilder extends transactionBuilder_1.TransactionBuilder {
      * @see https://docs.solana.com/staking/stake-accounts#account-address
      */
     stakingAddress(stakingAddress) {
-        utils_1.validateAddress(stakingAddress, 'stakingAddress');
+        (0, utils_1.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) {
+            (0, utils_1.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.
@@ -54,12 +85,22 @@ class StakingDeactivateBuilder extends transactionBuilder_1.TransactionBuilder {
      * @see https://docs.solana.com/cli/delegate-stake#split-stake
      */
     amount(amount) {
-        if (!utils_1.isValidStakingAmount(amount)) {
+        if (!(0, utils_1.isValidStakingAmount)(amount)) {
             throw new sdk_core_1.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.
@@ -70,35 +111,75 @@ class StakingDeactivateBuilder extends transactionBuilder_1.TransactionBuilder {
      * @see https://docs.solana.com/cli/delegate-stake#split-stake
      */
     unstakingAddress(unstakingAddress) {
-        utils_1.validateAddress(unstakingAddress, 'unstakingAddress');
+        (0, utils_1.validateAddress)(unstakingAddress, 'unstakingAddress');
         this._unstakingAddress = unstakingAddress;
         return this;
     }
+    /**
+     * Set isMarinade flag
+     * @param {boolean} flag - true if the transaction is for Marinade, false by default if not set
+     * @returns {StakingActivateBuilder} This staking builder
+     */
+    isMarinade(flag) {
+        this._isMarinade = flag;
+        return this;
+    }
     /** @inheritdoc */
     async buildImplementation() {
-        assert_1.default(this._sender, 'Sender must be set before building the transaction');
-        assert_1.default(this._stakingAddress, 'Staking address must be set before building the transaction');
-        if (this._sender === this._stakingAddress) {
-            throw new sdk_core_1.BuildTransactionError('Sender address cannot be the same as the Staking address');
-        }
-        if (this._amount) {
-            assert_1.default(this._unstakingAddress, 'When partially unstaking the unstaking address must be set before building the transaction');
+        (0, assert_1.default)(this._sender, 'Sender must be set before building the transaction');
+        (0, assert_1.default)(this._isMarinade !== undefined, 'isMarinade 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: constants_1.InstructionBuilderTypes.StakingDeactivate,
+                    params: {
+                        fromAddress: this._sender,
+                        stakingAddress: stakingAddress,
+                    },
+                };
+                this._instructionsData.push(stakingDeactivateData);
+            }
         }
-        if (this._unstakingAddress) {
-            assert_1.default(this._amount, 'If an unstaking address is given then a partial amount to unstake must also be set before building the transaction');
+        else {
+            if (!this._isMarinade) {
+                // we don't need stakingAddress in marinade staking deactivate txn
+                (0, assert_1.default)(this._stakingAddress, 'Staking address must be set before building the transaction');
+            }
+            if (this._sender === this._stakingAddress) {
+                throw new sdk_core_1.BuildTransactionError('Sender address cannot be the same as the Staking address');
+            }
+            if (this._amount && !this._isMarinade) {
+                (0, assert_1.default)(this._unstakingAddress, 'When partially unstaking the unstaking address must be set before building the transaction');
+            }
+            this._instructionsData = [];
+            if (this._unstakingAddress && !this._isMarinade) {
+                (0, assert_1.default)(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: constants_1.InstructionBuilderTypes.Transfer,
+                    params: {
+                        fromAddress: this._sender,
+                        amount: constants_1.STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT.toString(),
+                        toAddress: this._unstakingAddress,
+                    },
+                };
+                this._instructionsData.push(stakingFundUnstakeAddress);
+            }
+            const stakingDeactivateData = {
+                type: constants_1.InstructionBuilderTypes.StakingDeactivate,
+                params: {
+                    fromAddress: this._sender,
+                    stakingAddress: this._stakingAddress,
+                    amount: this._amount,
+                    unstakingAddress: this._unstakingAddress,
+                    isMarinade: this._isMarinade,
+                    recipients: this._recipients,
+                },
+            };
+            this._instructionsData.push(stakingDeactivateData);
         }
-        const stakingDeactivateData = {
-            type: constants_1.InstructionBuilderTypes.StakingDeactivate,
-            params: {
-                fromAddress: this._sender,
-                stakingAddress: this._stakingAddress,
-                amount: this._amount,
-                unstakingAddress: this._unstakingAddress,
-            },
-        };
-        this._instructionsData = [stakingDeactivateData];
         return await super.buildImplementation();
     }
 }
 exports.StakingDeactivateBuilder = StakingDeactivateBuilder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingDeactivateBuilder.js","sourceRoot":"","sources":["../../../src/lib/stakingDeactivateBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport assert from 'assert';\n\nimport { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { InstructionBuilderTypes } from './constants';\nimport { StakingDeactivate } 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 _amount?: string;\n  protected _unstakingAddress: string;\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    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.StakingDeactivate) {\n        const deactivateInstruction: StakingDeactivate = instruction;\n        this.sender(deactivateInstruction.params.fromAddress);\n        this.stakingAddress(deactivateInstruction.params.stakingAddress);\n        if (deactivateInstruction.params.amount && deactivateInstruction.params.unstakingAddress) {\n          this.amount(deactivateInstruction.params.amount);\n          this.unstakingAddress(deactivateInstruction.params.unstakingAddress);\n        }\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   * 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   * 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  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._sender, 'Sender must be set before building the transaction');\n    assert(this._stakingAddress, 'Staking address must be set before building the transaction');\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._amount) {\n      assert(\n        this._unstakingAddress,\n        'When partially unstaking the unstaking address must be set before building the transaction'\n      );\n    }\n\n    if (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    }\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      },\n    };\n    this._instructionsData = [stakingDeactivateData];\n\n    return await super.buildImplementation();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingDeactivateBuilder.js","sourceRoot":"","sources":["../../../src/lib/stakingDeactivateBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { 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, 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 _isMarinade = false;\n  protected _recipients: Recipient[];\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        this.isMarinade(deactivateInstruction.params.isMarinade ?? false);\n        if (!deactivateInstruction.params.isMarinade) {\n          this.sender(deactivateInstruction.params.fromAddress);\n        }\n        if (deactivateInstruction.params.isMarinade) {\n          this.recipients(deactivateInstruction.params.recipients ?? []);\n        }\n        stakingAddresses.push(deactivateInstruction.params.stakingAddress);\n        if (deactivateInstruction.params.amount && deactivateInstruction.params.unstakingAddress) {\n          this.amount(deactivateInstruction.params.amount);\n          this.unstakingAddress(deactivateInstruction.params.unstakingAddress);\n        }\n      }\n    }\n    if (stakingAddresses.length > 1) {\n      this.stakingAddresses(stakingAddresses);\n    } else {\n      if (!this._isMarinade) {\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 isMarinade flag\n   * @param {boolean} flag - true if the transaction is for Marinade, false by default if not set\n   * @returns {StakingActivateBuilder} This staking builder\n   */\n  isMarinade(flag: boolean): this {\n    this._isMarinade = flag;\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._isMarinade !== undefined, 'isMarinade 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          },\n        };\n        this._instructionsData.push(stakingDeactivateData);\n      }\n    } else {\n      if (!this._isMarinade) {\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._amount && !this._isMarinade) {\n        assert(\n          this._unstakingAddress,\n          'When partially unstaking the unstaking address must be set before building the transaction'\n        );\n      }\n      this._instructionsData = [];\n      if (this._unstakingAddress && !this._isMarinade) {\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          isMarinade: this._isMarinade,\n          recipients: this._recipients,\n        },\n      };\n      this._instructionsData.push(stakingDeactivateData);\n    }\n    return await super.buildImplementation();\n  }\n}\n"]}

package/dist/src/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/lib/stakingDelegateBuilder.d.ts.map

@@ -0,0 +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"}