@bitgo/account-lib 2.20.1 → 2.21.0-hotfix.1

package/dist/src/coin/sol/solInstructionFactory.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solInstructionFactory = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const assert_1 = __importDefault(require("assert"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const constants_1 = require("./constants");
+const statics_1 = require("@bitgo/statics");
+const spl_token_1 = require("@solana/spl-token");
+/**
+ * Construct Solana instructions from instructions params
+ *
+ * @param {InstructionParams} instructionToBuild - the data containing the instruction params
+ * @returns {TransactionInstruction[]} An array containing supported Solana instructions
+ */
+function solInstructionFactory(instructionToBuild) {
+    switch (instructionToBuild.type) {
+        case constants_1.InstructionBuilderTypes.NonceAdvance:
+            return advanceNonceInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.Memo:
+            return memoInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.Transfer:
+            return transferInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.TokenTransfer:
+            return tokenTransferInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.CreateNonceAccount:
+            return createNonceAccountInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.StakingActivate:
+            return stakingInitializeInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.StakingDeactivate:
+            return stakingDeactivateInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.StakingWithdraw:
+            return stakingWithdrawInstruction(instructionToBuild);
+        case constants_1.InstructionBuilderTypes.CreateAssociatedTokenAccount:
+            return createATAInstruction(instructionToBuild);
+        default:
+            throw new Error(`Invalid instruction type or not supported`);
+    }
+}
+exports.solInstructionFactory = solInstructionFactory;
+/**
+ * Construct Advance Nonce Solana instructions
+ *
+ * @param {Nonce} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Advance Nonce Solana instruction
+ */
+function advanceNonceInstruction(data) {
+    const { params: { authWalletAddress, walletNonceAddress }, } = data;
+    assert_1.default(authWalletAddress, 'Missing authWalletAddress param');
+    assert_1.default(walletNonceAddress, 'Missing walletNonceAddress param');
+    const nonceInstruction = web3_js_1.SystemProgram.nonceAdvance({
+        noncePubkey: new web3_js_1.PublicKey(walletNonceAddress),
+        authorizedPubkey: new web3_js_1.PublicKey(authWalletAddress),
+    });
+    return [nonceInstruction];
+}
+/**
+ * Construct Memo Solana instructions
+ *
+ * @param {Memo} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Memo Solana instruction
+ */
+function memoInstruction(data) {
+    const { params: { memo }, } = data;
+    assert_1.default(memo, 'Missing memo param');
+    const memoInstruction = new web3_js_1.TransactionInstruction({
+        keys: [],
+        programId: new web3_js_1.PublicKey(constants_1.MEMO_PROGRAM_PK),
+        data: Buffer.from(memo),
+    });
+    return [memoInstruction];
+}
+/**
+ * Construct Transfer Solana instructions
+ *
+ * @param {Transfer} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction
+ */
+function transferInstruction(data) {
+    const { params: { fromAddress, toAddress, amount }, } = data;
+    assert_1.default(fromAddress, 'Missing fromAddress param');
+    assert_1.default(toAddress, 'Missing toAddress param');
+    assert_1.default(amount, 'Missing toAddress param');
+    const transferInstruction = web3_js_1.SystemProgram.transfer({
+        fromPubkey: new web3_js_1.PublicKey(fromAddress),
+        toPubkey: new web3_js_1.PublicKey(toAddress),
+        lamports: new bignumber_js_1.default(amount).toNumber(),
+    });
+    return [transferInstruction];
+}
+/**
+ * Construct Transfer Solana instructions
+ *
+ * @param {Transfer} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction
+ */
+function tokenTransferInstruction(data) {
+    const { params: { fromAddress, toAddress, amount, tokenName, sourceAddress }, } = data;
+    assert_1.default(fromAddress, 'Missing fromAddress (owner) param');
+    assert_1.default(toAddress, 'Missing toAddress param');
+    assert_1.default(amount, 'Missing amount param');
+    assert_1.default(tokenName, 'Missing token name');
+    assert_1.default(sourceAddress, 'Missing ata address');
+    const token = statics_1.coins.get(data.params.tokenName);
+    assert_1.default(token instanceof statics_1.SolCoin);
+    const transferInstruction = spl_token_1.Token.createTransferCheckedInstruction(spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(sourceAddress), new web3_js_1.PublicKey(token.tokenAddress), new web3_js_1.PublicKey(toAddress), new web3_js_1.PublicKey(fromAddress), [], new bignumber_js_1.default(amount).toNumber(), token.decimalPlaces);
+    return [transferInstruction];
+}
+/**
+ * Construct Create and Initialize Nonce Solana instructions
+ *
+ * @param {WalletInit} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction
+ */
+function createNonceAccountInstruction(data) {
+    const { params: { fromAddress, nonceAddress, authAddress, amount }, } = data;
+    assert_1.default(fromAddress, 'Missing fromAddress param');
+    assert_1.default(nonceAddress, 'Missing nonceAddress param');
+    assert_1.default(authAddress, 'Missing authAddress param');
+    assert_1.default(amount, 'Missing amount param');
+    const nonceAccountInstruction = web3_js_1.SystemProgram.createNonceAccount({
+        fromPubkey: new web3_js_1.PublicKey(fromAddress),
+        noncePubkey: new web3_js_1.PublicKey(nonceAddress),
+        authorizedPubkey: new web3_js_1.PublicKey(authAddress),
+        lamports: new bignumber_js_1.default(amount).toNumber(),
+    });
+    return nonceAccountInstruction.instructions;
+}
+/**
+ * Construct Create Staking Account and Delegate Solana instructions
+ *
+ * @param {StakingActivate} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Create Staking Account and Delegate Solana instructions
+ */
+function stakingInitializeInstruction(data) {
+    const { params: { fromAddress, stakingAddress, amount, validator }, } = data;
+    assert_1.default(fromAddress, 'Missing fromAddress param');
+    assert_1.default(stakingAddress, 'Missing stakingAddress param');
+    assert_1.default(amount, 'Missing amount param');
+    assert_1.default(validator, 'Missing validator param');
+    const fromPubkey = new web3_js_1.PublicKey(fromAddress);
+    const stakePubkey = new web3_js_1.PublicKey(stakingAddress);
+    const tx = new web3_js_1.Transaction();
+    const walletInitStaking = web3_js_1.StakeProgram.createAccount({
+        fromPubkey,
+        stakePubkey,
+        authorized: new web3_js_1.Authorized(fromPubkey, fromPubkey),
+        lockup: new web3_js_1.Lockup(0, 0, fromPubkey),
+        lamports: new bignumber_js_1.default(amount).toNumber(),
+    });
+    tx.add(walletInitStaking);
+    const delegateStaking = web3_js_1.StakeProgram.delegate({
+        stakePubkey: new web3_js_1.PublicKey(stakingAddress),
+        authorizedPubkey: new web3_js_1.PublicKey(fromAddress),
+        votePubkey: new web3_js_1.PublicKey(validator),
+    });
+    tx.add(delegateStaking);
+    return tx.instructions;
+}
+/**
+ * Construct staking deactivate Solana instructions
+ *
+ * @param {StakingDeactivate} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing staking deactivate instruction
+ */
+function stakingDeactivateInstruction(data) {
+    const { params: { fromAddress, stakingAddress }, } = data;
+    assert_1.default(fromAddress, 'Missing fromAddress param');
+    assert_1.default(stakingAddress, 'Missing stakingAddress param');
+    const deactivateStaking = web3_js_1.StakeProgram.deactivate({
+        stakePubkey: new web3_js_1.PublicKey(stakingAddress),
+        authorizedPubkey: new web3_js_1.PublicKey(fromAddress),
+    });
+    return deactivateStaking.instructions;
+}
+/**
+ * Construct Staking Withdraw Solana instructions
+ *
+ * @param {StakingWithdraw} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Staking Withdraw  Solana instructions
+ */
+function stakingWithdrawInstruction(data) {
+    const { params: { fromAddress, stakingAddress, amount }, } = data;
+    assert_1.default(fromAddress, 'Missing fromAddress param');
+    assert_1.default(stakingAddress, 'Missing stakingAddress param');
+    assert_1.default(amount, 'Missing amount param');
+    const withdrawStaking = web3_js_1.StakeProgram.withdraw({
+        stakePubkey: new web3_js_1.PublicKey(stakingAddress),
+        authorizedPubkey: new web3_js_1.PublicKey(fromAddress),
+        toPubkey: new web3_js_1.PublicKey(fromAddress),
+        lamports: new bignumber_js_1.default(amount).toNumber(),
+    });
+    return withdrawStaking.instructions;
+}
+/**
+ * Construct Create and Initialize Nonce Solana instructions
+ *
+ * @param {WalletInit} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction
+ */
+function createATAInstruction(data) {
+    const { params: { mintAddress, ataAddress, ownerAddress, payerAddress }, } = data;
+    assert_1.default(mintAddress, 'Missing mintAddress param');
+    assert_1.default(ataAddress, 'Missing ataAddress param');
+    assert_1.default(ownerAddress, 'Missing ownerAddress param');
+    assert_1.default(payerAddress, 'Missing payerAddress param');
+    const associatedTokenAccountInstruction = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(ataAddress), new web3_js_1.PublicKey(ownerAddress), new web3_js_1.PublicKey(payerAddress));
+    return [associatedTokenAccountInstruction];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"solInstructionFactory.js","sourceRoot":"","sources":["../../../../src/coin/sol/solInstructionFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Authorized,\n  Lockup,\n  PublicKey,\n  StakeProgram,\n  SystemProgram,\n  TransactionInstruction,\n  Transaction,\n} from '@solana/web3.js';\nimport assert from 'assert';\nimport BigNumber from 'bignumber.js';\nimport { InstructionBuilderTypes, MEMO_PROGRAM_PK } from './constants';\nimport {\n  AtaInit,\n  InstructionParams,\n  Memo,\n  Nonce,\n  StakingActivate,\n  StakingDeactivate,\n  StakingWithdraw,\n  TokenTransfer,\n  Transfer,\n  WalletInit,\n} from './iface';\nimport { coins, SolCoin } from '@bitgo/statics';\nimport { TOKEN_PROGRAM_ID, Token, ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token';\n\n/**\n * Construct Solana instructions from instructions params\n *\n * @param {InstructionParams} instructionToBuild - the data containing the instruction params\n * @returns {TransactionInstruction[]} An array containing supported Solana instructions\n */\nexport function solInstructionFactory(instructionToBuild: InstructionParams): TransactionInstruction[] {\n  switch (instructionToBuild.type) {\n    case InstructionBuilderTypes.NonceAdvance:\n      return advanceNonceInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Memo:\n      return memoInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Transfer:\n      return transferInstruction(instructionToBuild);\n    case InstructionBuilderTypes.TokenTransfer:\n      return tokenTransferInstruction(instructionToBuild);\n    case InstructionBuilderTypes.CreateNonceAccount:\n      return createNonceAccountInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingActivate:\n      return stakingInitializeInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingDeactivate:\n      return stakingDeactivateInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingWithdraw:\n      return stakingWithdrawInstruction(instructionToBuild);\n    case InstructionBuilderTypes.CreateAssociatedTokenAccount:\n      return createATAInstruction(instructionToBuild);\n    default:\n      throw new Error(`Invalid instruction type or not supported`);\n  }\n}\n\n/**\n * Construct Advance Nonce Solana instructions\n *\n * @param {Nonce} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Advance Nonce Solana instruction\n */\nfunction advanceNonceInstruction(data: Nonce): TransactionInstruction[] {\n  const {\n    params: { authWalletAddress, walletNonceAddress },\n  } = data;\n  assert(authWalletAddress, 'Missing authWalletAddress param');\n  assert(walletNonceAddress, 'Missing walletNonceAddress param');\n  const nonceInstruction = SystemProgram.nonceAdvance({\n    noncePubkey: new PublicKey(walletNonceAddress),\n    authorizedPubkey: new PublicKey(authWalletAddress),\n  });\n  return [nonceInstruction];\n}\n\n/**\n * Construct Memo Solana instructions\n *\n * @param {Memo} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Memo Solana instruction\n */\nfunction memoInstruction(data: Memo): TransactionInstruction[] {\n  const {\n    params: { memo },\n  } = data;\n  assert(memo, 'Missing memo param');\n  const memoInstruction = new TransactionInstruction({\n    keys: [],\n    programId: new PublicKey(MEMO_PROGRAM_PK),\n    data: Buffer.from(memo),\n  });\n  return [memoInstruction];\n}\n\n/**\n * Construct Transfer Solana instructions\n *\n * @param {Transfer} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction\n */\nfunction transferInstruction(data: Transfer): TransactionInstruction[] {\n  const {\n    params: { fromAddress, toAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(toAddress, 'Missing toAddress param');\n  assert(amount, 'Missing toAddress param');\n  const transferInstruction = SystemProgram.transfer({\n    fromPubkey: new PublicKey(fromAddress),\n    toPubkey: new PublicKey(toAddress),\n    lamports: new BigNumber(amount).toNumber(),\n  });\n  return [transferInstruction];\n}\n\n/**\n * Construct Transfer Solana instructions\n *\n * @param {Transfer} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction\n */\nfunction tokenTransferInstruction(data: TokenTransfer): TransactionInstruction[] {\n  const {\n    params: { fromAddress, toAddress, amount, tokenName, sourceAddress },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress (owner) param');\n  assert(toAddress, 'Missing toAddress param');\n  assert(amount, 'Missing amount param');\n  assert(tokenName, 'Missing token name');\n  assert(sourceAddress, 'Missing ata address');\n  const token = coins.get(data.params.tokenName);\n  assert(token instanceof SolCoin);\n  const transferInstruction = Token.createTransferCheckedInstruction(\n    TOKEN_PROGRAM_ID,\n    new PublicKey(sourceAddress),\n    new PublicKey(token.tokenAddress),\n    new PublicKey(toAddress),\n    new PublicKey(fromAddress),\n    [],\n    new BigNumber(amount).toNumber(),\n    token.decimalPlaces,\n  );\n  return [transferInstruction];\n}\n\n/**\n * Construct Create and Initialize Nonce Solana instructions\n *\n * @param {WalletInit} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction\n */\nfunction createNonceAccountInstruction(data: WalletInit): TransactionInstruction[] {\n  const {\n    params: { fromAddress, nonceAddress, authAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(nonceAddress, 'Missing nonceAddress param');\n  assert(authAddress, 'Missing authAddress param');\n  assert(amount, 'Missing amount param');\n  const nonceAccountInstruction = SystemProgram.createNonceAccount({\n    fromPubkey: new PublicKey(fromAddress),\n    noncePubkey: new PublicKey(nonceAddress),\n    authorizedPubkey: new PublicKey(authAddress),\n    lamports: new BigNumber(amount).toNumber(),\n  });\n  return nonceAccountInstruction.instructions;\n}\n\n/**\n * Construct Create Staking Account and Delegate Solana instructions\n *\n * @param {StakingActivate} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Create Staking Account and Delegate Solana instructions\n */\nfunction stakingInitializeInstruction(data: StakingActivate): TransactionInstruction[] {\n  const {\n    params: { fromAddress, stakingAddress, amount, validator },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(stakingAddress, 'Missing stakingAddress param');\n  assert(amount, 'Missing amount param');\n  assert(validator, 'Missing validator param');\n\n  const fromPubkey = new PublicKey(fromAddress);\n  const stakePubkey = new PublicKey(stakingAddress);\n\n  const tx = new Transaction();\n\n  const walletInitStaking = StakeProgram.createAccount({\n    fromPubkey,\n    stakePubkey,\n    authorized: new Authorized(fromPubkey, fromPubkey), // staker and withdrawer\n    lockup: new Lockup(0, 0, fromPubkey), // Lookup sets the minimum epoch to withdraw, by default is 0,0 which means there's no minimum limit\n    lamports: new BigNumber(amount).toNumber(),\n  });\n  tx.add(walletInitStaking);\n\n  const delegateStaking = StakeProgram.delegate({\n    stakePubkey: new PublicKey(stakingAddress),\n    authorizedPubkey: new PublicKey(fromAddress),\n    votePubkey: new PublicKey(validator),\n  });\n  tx.add(delegateStaking);\n\n  return tx.instructions;\n}\n\n/**\n * Construct staking deactivate Solana instructions\n *\n * @param {StakingDeactivate} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing staking deactivate instruction\n */\nfunction stakingDeactivateInstruction(data: StakingDeactivate): TransactionInstruction[] {\n  const {\n    params: { fromAddress, stakingAddress },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(stakingAddress, 'Missing stakingAddress param');\n\n  const deactivateStaking = StakeProgram.deactivate({\n    stakePubkey: new PublicKey(stakingAddress),\n    authorizedPubkey: new PublicKey(fromAddress),\n  });\n\n  return deactivateStaking.instructions;\n}\n\n/**\n * Construct Staking Withdraw Solana instructions\n *\n * @param {StakingWithdraw} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Staking Withdraw  Solana instructions\n */\nfunction stakingWithdrawInstruction(data: StakingWithdraw): TransactionInstruction[] {\n  const {\n    params: { fromAddress, stakingAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(stakingAddress, 'Missing stakingAddress param');\n  assert(amount, 'Missing amount param');\n\n  const withdrawStaking = StakeProgram.withdraw({\n    stakePubkey: new PublicKey(stakingAddress),\n    authorizedPubkey: new PublicKey(fromAddress),\n    toPubkey: new PublicKey(fromAddress),\n    lamports: new BigNumber(amount).toNumber(),\n  });\n\n  return withdrawStaking.instructions;\n}\n\n/**\n * Construct Create and Initialize Nonce Solana instructions\n *\n * @param {WalletInit} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction\n */\nfunction createATAInstruction(data: AtaInit): TransactionInstruction[] {\n  const {\n    params: { mintAddress, ataAddress, ownerAddress, payerAddress },\n  } = data;\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(ataAddress, 'Missing ataAddress param');\n  assert(ownerAddress, 'Missing ownerAddress param');\n  assert(payerAddress, 'Missing payerAddress param');\n\n  const associatedTokenAccountInstruction = Token.createAssociatedTokenAccountInstruction(\n    ASSOCIATED_TOKEN_PROGRAM_ID,\n    TOKEN_PROGRAM_ID,\n    new PublicKey(mintAddress),\n    new PublicKey(ataAddress),\n    new PublicKey(ownerAddress),\n    new PublicKey(payerAddress),\n  );\n  return [associatedTokenAccountInstruction];\n}\n"]}

package/dist/src/coin/sol/stakingActivateBuilder.d.ts

@@ -0,0 +1,41 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransactionType } from '@bitgo/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class StakingActivateBuilder extends TransactionBuilder {
+    protected _amount: string;
+    protected _stakingAddress: string;
+    protected _validator: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * The amount to stake 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;
+    /**
+     * 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;
+    /**
+     * Set validator address to delegate funds to.
+     *
+     * @param {string} validator Validator address to delegate funds to.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    validator(validator: string): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=stakingActivateBuilder.d.ts.map

package/dist/src/coin/sol/stakingActivateBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakingActivateBuilder.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/stakingActivateBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAyB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAO1D,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,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;IAalC;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ5B;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C;;;;;;OAMG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAMlC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAuB5D"}

package/dist/src/coin/sol/stakingActivateBuilder.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingActivateBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const constants_1 = require("./constants");
+const assert_1 = __importDefault(require("assert"));
+const utils_1 = require("./utils");
+class StakingActivateBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingActivate;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === constants_1.InstructionBuilderTypes.StakingActivate) {
+                const activateInstruction = instruction;
+                this.sender(activateInstruction.params.fromAddress);
+                this.stakingAddress(activateInstruction.params.stakingAddress);
+                this.amount(activateInstruction.params.amount);
+                this.validator(activateInstruction.params.validator);
+            }
+        }
+    }
+    /**
+     * The amount to stake expressed in Lamports, 1 SOL = 1_000_000_000 lamports.
+     *
+     * @param {string} amount expressed in Lamports.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    amount(amount) {
+        if (!utils_1.isValidStakingAmount(amount)) {
+            throw new sdk_core_1.BuildTransactionError('Value cannot be zero or less');
+        }
+        this._amount = amount;
+        return this;
+    }
+    /**
+     * 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) {
+        utils_1.validateAddress(stakingAddress, 'stakingAddress');
+        this._stakingAddress = stakingAddress;
+        return this;
+    }
+    /**
+     * Set validator address to delegate funds to.
+     *
+     * @param {string} validator Validator address to delegate funds to.
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    validator(validator) {
+        utils_1.validateAddress(validator, 'validator');
+        this._validator = validator;
+        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');
+        if (this._sender === this._stakingAddress) {
+            throw new sdk_core_1.BuildTransactionError('Sender address cannot be the same as the Staking address');
+        }
+        const stakingAccountData = {
+            type: constants_1.InstructionBuilderTypes.StakingActivate,
+            params: {
+                fromAddress: this._sender,
+                stakingAddress: this._stakingAddress,
+                amount: this._amount,
+                validator: this._validator,
+            },
+        };
+        this._instructionsData = [stakingAccountData];
+        return await super.buildImplementation();
+    }
+}
+exports.StakingActivateBuilder = StakingActivateBuilder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Rha2luZ0FjdGl2YXRlQnVpbGRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb2luL3NvbC9zdGFraW5nQWN0aXZhdGVCdWlsZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUNBLDhDQUF5RTtBQUV6RSw2REFBMEQ7QUFDMUQsMkNBQXNEO0FBRXRELG9EQUE0QjtBQUU1QixtQ0FBZ0U7QUFFaEUsTUFBYSxzQkFBdUIsU0FBUSx1Q0FBa0I7SUFLNUQsWUFBWSxXQUFpQztRQUMzQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVELElBQWMsZUFBZTtRQUMzQixPQUFPLDBCQUFlLENBQUMsZUFBZSxDQUFDO0lBQ3pDLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsV0FBVyxDQUFDLEVBQWU7UUFDekIsS0FBSyxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUN0QixLQUFLLE1BQU0sV0FBVyxJQUFJLElBQUksQ0FBQyxpQkFBaUIsRUFBRTtZQUNoRCxJQUFJLFdBQVcsQ0FBQyxJQUFJLEtBQUssbUNBQXVCLENBQUMsZUFBZSxFQUFFO2dCQUNoRSxNQUFNLG1CQUFtQixHQUFvQixXQUFXLENBQUM7Z0JBQ3pELElBQUksQ0FBQyxNQUFNLENBQUMsbUJBQW1CLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDO2dCQUNwRCxJQUFJLENBQUMsY0FBYyxDQUFDLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsQ0FBQztnQkFDL0QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7Z0JBQy9DLElBQUksQ0FBQyxTQUFTLENBQUMsbUJBQW1CLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO2FBQ3REO1NBQ0Y7SUFDSCxDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsTUFBTSxDQUFDLE1BQWM7UUFDbkIsSUFBSSxDQUFDLDRCQUFvQixDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQ2pDLE1BQU0sSUFBSSxnQ0FBcUIsQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO1NBQ2pFO1FBQ0QsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7UUFDdEIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILGNBQWMsQ0FBQyxjQUFzQjtRQUNuQyx1QkFBZSxDQUFDLGNBQWMsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ2xELElBQUksQ0FBQyxlQUFlLEdBQUcsY0FBYyxDQUFDO1FBQ3RDLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNILFNBQVMsQ0FBQyxTQUFpQjtRQUN6Qix1QkFBZSxDQUFDLFNBQVMsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUN4QyxJQUFJLENBQUMsVUFBVSxHQUFHLFNBQVMsQ0FBQztRQUM1QixPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCxrQkFBa0I7SUFDUixLQUFLLENBQUMsbUJBQW1CO1FBQ2pDLGdCQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxvREFBb0QsQ0FBQyxDQUFDO1FBQzNFLGdCQUFNLENBQUMsSUFBSSxDQUFDLGVBQWUsRUFBRSw2REFBNkQsQ0FBQyxDQUFDO1FBQzVGLGdCQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSx1REFBdUQsQ0FBQyxDQUFDO1FBQ2pGLGdCQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxvREFBb0QsQ0FBQyxDQUFDO1FBRTNFLElBQUksSUFBSSxDQUFDLE9BQU8sS0FBSyxJQUFJLENBQUMsZUFBZSxFQUFFO1lBQ3pDLE1BQU0sSUFBSSxnQ0FBcUIsQ0FBQywwREFBMEQsQ0FBQyxDQUFDO1NBQzdGO1FBRUQsTUFBTSxrQkFBa0IsR0FBb0I7WUFDMUMsSUFBSSxFQUFFLG1DQUF1QixDQUFDLGVBQWU7WUFDN0MsTUFBTSxFQUFFO2dCQUNOLFdBQVcsRUFBRSxJQUFJLENBQUMsT0FBTztnQkFDekIsY0FBYyxFQUFFLElBQUksQ0FBQyxlQUFlO2dCQUNwQyxNQUFNLEVBQUUsSUFBSSxDQUFDLE9BQU87Z0JBQ3BCLFNBQVMsRUFBRSxJQUFJLENBQUMsVUFBVTthQUMzQjtTQUNGLENBQUM7UUFDRixJQUFJLENBQUMsaUJBQWlCLEdBQUcsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO1FBRTlDLE9BQU8sTUFBTSxLQUFLLENBQUMsbUJBQW1CLEVBQUUsQ0FBQztJQUMzQyxDQUFDO0NBQ0Y7QUE3RkQsd0RBNkZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUNvaW4gYXMgQ29pbkNvbmZpZyB9IGZyb20gJ0BiaXRnby9zdGF0aWNzJztcbmltcG9ydCB7IEJ1aWxkVHJhbnNhY3Rpb25FcnJvciwgVHJhbnNhY3Rpb25UeXBlIH0gZnJvbSAnQGJpdGdvL3Nkay1jb3JlJztcbmltcG9ydCB7IFRyYW5zYWN0aW9uIH0gZnJvbSAnLi90cmFuc2FjdGlvbic7XG5pbXBvcnQgeyBUcmFuc2FjdGlvbkJ1aWxkZXIgfSBmcm9tICcuL3RyYW5zYWN0aW9uQnVpbGRlcic7XG5pbXBvcnQgeyBJbnN0cnVjdGlvbkJ1aWxkZXJUeXBlcyB9IGZyb20gJy4vY29uc3RhbnRzJztcblxuaW1wb3J0IGFzc2VydCBmcm9tICdhc3NlcnQnO1xuaW1wb3J0IHsgU3Rha2luZ0FjdGl2YXRlIH0gZnJvbSAnLi9pZmFjZSc7XG5pbXBvcnQgeyBpc1ZhbGlkU3Rha2luZ0Ftb3VudCwgdmFsaWRhdGVBZGRyZXNzIH0gZnJvbSAnLi91dGlscyc7XG5cbmV4cG9ydCBjbGFzcyBTdGFraW5nQWN0aXZhdGVCdWlsZGVyIGV4dGVuZHMgVHJhbnNhY3Rpb25CdWlsZGVyIHtcbiAgcHJvdGVjdGVkIF9hbW91bnQ6IHN0cmluZztcbiAgcHJvdGVjdGVkIF9zdGFraW5nQWRkcmVzczogc3RyaW5nO1xuICBwcm90ZWN0ZWQgX3ZhbGlkYXRvcjogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKF9jb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKF9jb2luQ29uZmlnKTtcbiAgfVxuXG4gIHByb3RlY3RlZCBnZXQgdHJhbnNhY3Rpb25UeXBlKCk6IFRyYW5zYWN0aW9uVHlwZSB7XG4gICAgcmV0dXJuIFRyYW5zYWN0aW9uVHlwZS5TdGFraW5nQWN0aXZhdGU7XG4gIH1cblxuICAvKiogQGluaGVyaXRkb2MgKi9cbiAgaW5pdEJ1aWxkZXIodHg6IFRyYW5zYWN0aW9uKTogdm9pZCB7XG4gICAgc3VwZXIuaW5pdEJ1aWxkZXIodHgpO1xuICAgIGZvciAoY29uc3QgaW5zdHJ1Y3Rpb24gb2YgdGhpcy5faW5zdHJ1Y3Rpb25zRGF0YSkge1xuICAgICAgaWYgKGluc3RydWN0aW9uLnR5cGUgPT09IEluc3RydWN0aW9uQnVpbGRlclR5cGVzLlN0YWtpbmdBY3RpdmF0ZSkge1xuICAgICAgICBjb25zdCBhY3RpdmF0ZUluc3RydWN0aW9uOiBTdGFraW5nQWN0aXZhdGUgPSBpbnN0cnVjdGlvbjtcbiAgICAgICAgdGhpcy5zZW5kZXIoYWN0aXZhdGVJbnN0cnVjdGlvbi5wYXJhbXMuZnJvbUFkZHJlc3MpO1xuICAgICAgICB0aGlzLnN0YWtpbmdBZGRyZXNzKGFjdGl2YXRlSW5zdHJ1Y3Rpb24ucGFyYW1zLnN0YWtpbmdBZGRyZXNzKTtcbiAgICAgICAgdGhpcy5hbW91bnQoYWN0aXZhdGVJbnN0cnVjdGlvbi5wYXJhbXMuYW1vdW50KTtcbiAgICAgICAgdGhpcy52YWxpZGF0b3IoYWN0aXZhdGVJbnN0cnVjdGlvbi5wYXJhbXMudmFsaWRhdG9yKTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogVGhlIGFtb3VudCB0byBzdGFrZSBleHByZXNzZWQgaW4gTGFtcG9ydHMsIDEgU09MID0gMV8wMDBfMDAwXzAwMCBsYW1wb3J0cy5cbiAgICpcbiAgICogQHBhcmFtIHtzdHJpbmd9IGFtb3VudCBleHByZXNzZWQgaW4gTGFtcG9ydHMuXG4gICAqIEByZXR1cm5zIHtTdGFrZUJ1aWxkZXJ9IFRoaXMgc3Rha2luZyBidWlsZGVyLlxuICAgKlxuICAgKi9cbiAgYW1vdW50KGFtb3VudDogc3RyaW5nKTogdGhpcyB7XG4gICAgaWYgKCFpc1ZhbGlkU3Rha2luZ0Ftb3VudChhbW91bnQpKSB7XG4gICAgICB0aHJvdyBuZXcgQnVpbGRUcmFuc2FjdGlvbkVycm9yKCdWYWx1ZSBjYW5ub3QgYmUgemVybyBvciBsZXNzJyk7XG4gICAgfVxuICAgIHRoaXMuX2Ftb3VudCA9IGFtb3VudDtcbiAgICByZXR1cm4gdGhpcztcbiAgfVxuXG4gIC8qKlxuICAgKiBUaGUgYWRkcmVzcyBvZiB0aGUgc3Rha2luZyBhY2NvdW50LlxuICAgKlxuICAgKiBAcGFyYW0ge3N0cmluZ30gc3Rha2luZ0FkZHJlc3MgcHVibGljIGFkZHJlc3Mgb2YgdGhlIHN0YWtpbmcgYWNjb3VudC5cbiAgICogQHJldHVybnMge1N0YWtlQnVpbGRlcn0gVGhpcyBzdGFraW5nIGJ1aWxkZXIuXG4gICAqXG4gICAqIEBzZWUgaHR0cHM6Ly9kb2NzLnNvbGFuYS5jb20vc3Rha2luZy9zdGFrZS1hY2NvdW50cyNhY2NvdW50LWFkZHJlc3NcbiAgICovXG4gIHN0YWtpbmdBZGRyZXNzKHN0YWtpbmdBZGRyZXNzOiBzdHJpbmcpOiB0aGlzIHtcbiAgICB2YWxpZGF0ZUFkZHJlc3Moc3Rha2luZ0FkZHJlc3MsICdzdGFraW5nQWRkcmVzcycpO1xuICAgIHRoaXMuX3N0YWtpbmdBZGRyZXNzID0gc3Rha2luZ0FkZHJlc3M7XG4gICAgcmV0dXJuIHRoaXM7XG4gIH1cblxuICAvKipcbiAgICogU2V0IHZhbGlkYXRvciBhZGRyZXNzIHRvIGRlbGVnYXRlIGZ1bmRzIHRvLlxuICAgKlxuICAgKiBAcGFyYW0ge3N0cmluZ30gdmFsaWRhdG9yIFZhbGlkYXRvciBhZGRyZXNzIHRvIGRlbGVnYXRlIGZ1bmRzIHRvLlxuICAgKiBAcmV0dXJucyB7U3Rha2VCdWlsZGVyfSBUaGlzIHN0YWtpbmcgYnVpbGRlci5cbiAgICpcbiAgICovXG4gIHZhbGlkYXRvcih2YWxpZGF0b3I6IHN0cmluZyk6IHRoaXMge1xuICAgIHZhbGlkYXRlQWRkcmVzcyh2YWxpZGF0b3IsICd2YWxpZGF0b3InKTtcbiAgICB0aGlzLl92YWxpZGF0b3IgPSB2YWxpZGF0b3I7XG4gICAgcmV0dXJuIHRoaXM7XG4gIH1cblxuICAvKiogQGluaGVyaXRkb2MgKi9cbiAgcHJvdGVjdGVkIGFzeW5jIGJ1aWxkSW1wbGVtZW50YXRpb24oKTogUHJvbWlzZTxUcmFuc2FjdGlvbj4ge1xuICAgIGFzc2VydCh0aGlzLl9zZW5kZXIsICdTZW5kZXIgbXVzdCBiZSBzZXQgYmVmb3JlIGJ1aWxkaW5nIHRoZSB0cmFuc2FjdGlvbicpO1xuICAgIGFzc2VydCh0aGlzLl9zdGFraW5nQWRkcmVzcywgJ1N0YWtpbmcgQWRkcmVzcyBtdXN0IGJlIHNldCBiZWZvcmUgYnVpbGRpbmcgdGhlIHRyYW5zYWN0aW9uJyk7XG4gICAgYXNzZXJ0KHRoaXMuX3ZhbGlkYXRvciwgJ1ZhbGlkYXRvciBtdXN0IGJlIHNldCBiZWZvcmUgYnVpbGRpbmcgdGhlIHRyYW5zYWN0aW9uJyk7XG4gICAgYXNzZXJ0KHRoaXMuX2Ftb3VudCwgJ0Ftb3VudCBtdXN0IGJlIHNldCBiZWZvcmUgYnVpbGRpbmcgdGhlIHRyYW5zYWN0aW9uJyk7XG5cbiAgICBpZiAodGhpcy5fc2VuZGVyID09PSB0aGlzLl9zdGFraW5nQWRkcmVzcykge1xuICAgICAgdGhyb3cgbmV3IEJ1aWxkVHJhbnNhY3Rpb25FcnJvcignU2VuZGVyIGFkZHJlc3MgY2Fubm90IGJlIHRoZSBzYW1lIGFzIHRoZSBTdGFraW5nIGFkZHJlc3MnKTtcbiAgICB9XG5cbiAgICBjb25zdCBzdGFraW5nQWNjb3VudERhdGE6IFN0YWtpbmdBY3RpdmF0ZSA9IHtcbiAgICAgIHR5cGU6IEluc3RydWN0aW9uQnVpbGRlclR5cGVzLlN0YWtpbmdBY3RpdmF0ZSxcbiAgICAgIHBhcmFtczoge1xuICAgICAgICBmcm9tQWRkcmVzczogdGhpcy5fc2VuZGVyLFxuICAgICAgICBzdGFraW5nQWRkcmVzczogdGhpcy5fc3Rha2luZ0FkZHJlc3MsXG4gICAgICAgIGFtb3VudDogdGhpcy5fYW1vdW50LFxuICAgICAgICB2YWxpZGF0b3I6IHRoaXMuX3ZhbGlkYXRvcixcbiAgICAgIH0sXG4gICAgfTtcbiAgICB0aGlzLl9pbnN0cnVjdGlvbnNEYXRhID0gW3N0YWtpbmdBY2NvdW50RGF0YV07XG5cbiAgICByZXR1cm4gYXdhaXQgc3VwZXIuYnVpbGRJbXBsZW1lbnRhdGlvbigpO1xuICB9XG59XG4iXX0=

package/dist/src/coin/sol/stakingDeactivateBuilder.d.ts

@@ -0,0 +1,23 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransactionType } from '@bitgo/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class StakingDeactivateBuilder extends TransactionBuilder {
+    protected _stakingAddress: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritdoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * 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: string): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=stakingDeactivateBuilder.d.ts.map

package/dist/src/coin/sol/stakingDeactivateBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakingDeactivateBuilder.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/stakingDeactivateBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGxD,OAAO,EAAyB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGzE,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;gBAEtB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAWlC;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAM5C,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAmB5D"}

package/dist/src/coin/sol/stakingDeactivateBuilder.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingDeactivateBuilder = void 0;
+const assert_1 = __importDefault(require("assert"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const constants_1 = require("./constants");
+const transactionBuilder_1 = require("./transactionBuilder");
+const utils_1 = require("./utils");
+class StakingDeactivateBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingDeactivate;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        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);
+            }
+        }
+    }
+    /**
+     * 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) {
+        utils_1.validateAddress(stakingAddress, 'stakingAddress');
+        this._stakingAddress = stakingAddress;
+        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');
+        }
+        const stakingDeactivateData = {
+            type: constants_1.InstructionBuilderTypes.StakingDeactivate,
+            params: {
+                fromAddress: this._sender,
+                stakingAddress: this._stakingAddress,
+            },
+        };
+        this._instructionsData = [stakingDeactivateData];
+        return await super.buildImplementation();
+    }
+}
+exports.StakingDeactivateBuilder = StakingDeactivateBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/coin/sol/stakingWithdrawBuilder.d.ts

@@ -0,0 +1,31 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransactionType } from '@bitgo/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/coin/sol/stakingWithdrawBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakingWithdrawBuilder.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/stakingWithdrawBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAyB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACzE,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"}

package/dist/src/coin/sol/stakingWithdrawBuilder.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingWithdrawBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const constants_1 = require("./constants");
+const assert_1 = __importDefault(require("assert"));
+const utils_1 = require("./utils");
+class StakingWithdrawBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingWithdraw;
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === constants_1.InstructionBuilderTypes.StakingWithdraw) {
+                const withdrawInstruction = instruction;
+                this.sender(withdrawInstruction.params.fromAddress);
+                this.stakingAddress(withdrawInstruction.params.stakingAddress);
+                this.amount(withdrawInstruction.params.amount);
+            }
+        }
+    }
+    /**
+     * The address of the staking account.
+     *
+     * @param {string} stakingAddress public address of the staking account
+     * @returns {StakeBuilder} This staking builder.
+     *
+     */
+    stakingAddress(stakingAddress) {
+        utils_1.validateAddress(stakingAddress, 'stakingAddress');
+        this._stakingAddress = stakingAddress;
+        return 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) {
+        if (!utils_1.isValidStakingAmount(amount)) {
+            throw new sdk_core_1.BuildTransactionError('Value cannot be zero or less');
+        }
+        this._amount = amount;
+        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._amount, 'Amount 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');
+        }
+        const stakingWithdrawData = {
+            type: constants_1.InstructionBuilderTypes.StakingWithdraw,
+            params: {
+                fromAddress: this._sender,
+                stakingAddress: this._stakingAddress,
+                amount: this._amount,
+            },
+        };
+        this._instructionsData = [stakingWithdrawData];
+        return await super.buildImplementation();
+    }
+}
+exports.StakingWithdrawBuilder = StakingWithdrawBuilder;
+//# sourceMappingURL=data:application/json;base64,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