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

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

@@ -0,0 +1,113 @@
+/**
+ * @file Implementation of the depositSol instruction. On upgrade of
+ * '@solana/spl-token', this module may no longer be necessary.
+ */
+import { DepositSolParams, WithdrawStakeParams } from '@solana/spl-stake-pool';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+/**
+ * Replicates the fields in @solana/spl-stake-pool Fee.
+ *
+ * @see {Fee}
+ */
+export interface Fee {
+    denominator: string;
+    numerator: string;
+}
+/**
+ * Replicates the fields in @solana/spl-stake-pool StakePoolLayout.
+ *
+ * @see {StakePoolLayout}
+ */
+export interface StakePoolData {
+    accountType: number;
+    manager: string;
+    staker: string;
+    stakeDepositAuthority: string;
+    stakeWithdrawBumpSeed: number;
+    validatorListAccount: string;
+    reserveStake: string;
+    poolMint: string;
+    managerFeeAccount: string;
+    tokenProgramId: string;
+    totalLamports: string;
+    poolTokenSupply: string;
+    lastUpdateEpoch: string;
+    lockup: {
+        unixTimestamp: string;
+        epoch: string;
+        custodian: string;
+    };
+    epochFee: Fee;
+    nextEpochFee?: Fee | undefined;
+    preferredDepositValidatorVoteAddress?: string | undefined;
+    preferredWithdrawValidatorVoteAddress?: string | undefined;
+    stakeDepositFee: Fee;
+    stakeWithdrawalFee: Fee;
+    nextStakeWithdrawalFee?: Fee | undefined;
+    stakeReferralFee: number;
+    solDepositAuthority?: string | undefined;
+    solDepositFee: Fee;
+    solReferralFee: number;
+    solWithdrawAuthority?: string | undefined;
+    solWithdrawalFee: Fee;
+    nextSolWithdrawalFee?: Fee | undefined;
+    lastEpochPoolTokenSupply: string;
+    lastEpochTotalLamports: string;
+}
+export declare const DEPOSIT_SOL_LAYOUT_CODE = 14;
+export declare const WITHDRAW_STAKE_LAYOUT_CODE = 10;
+/**
+ * Generates the withdraw authority program address for the stake pool.
+ * Like findWithdrawAuthorityProgramAddress in @solana/spl-stake-pool,
+ * but synchronous.
+ *
+ * @see {findWithdrawAuthorityProgramAddress}
+ */
+export declare function findWithdrawAuthorityProgramAddressSync(programId: PublicKey, stakePoolAddress: PublicKey): PublicKey;
+export interface DepositSolInstructionsParams {
+    stakePoolAddress: PublicKey;
+    from: PublicKey;
+    lamports: bigint;
+}
+export type DepositSolStakePoolData = Pick<StakePoolData, 'poolMint' | 'reserveStake' | 'managerFeeAccount'>;
+/**
+ * Construct Solana depositSol stake pool instruction from parameters.
+ *
+ * @param {DepositSolInstructionsParams} params - parameters for staking to stake pool
+ * @param {DepositSolStakePoolData} stakePool - data from getStakePoolAccount needed for DepositSol
+ * @param createAssociatedTokenAccount
+ * @returns {TransactionInstruction}
+ */
+export declare function depositSolInstructions(params: DepositSolInstructionsParams, stakePool: DepositSolStakePoolData, createAssociatedTokenAccount: boolean): TransactionInstruction[];
+/**
+ * Construct Solana depositSol stake pool parameters from instruction.
+ *
+ * @param {TransactionInstruction} instruction
+ * @returns {DepositSolParams}
+ */
+export declare function decodeDepositSol(instruction: TransactionInstruction): DepositSolParams;
+export interface WithdrawStakeInstructionsParams {
+    stakePoolAddress: PublicKey;
+    tokenOwner: PublicKey;
+    destinationStakeAccount: PublicKey;
+    validatorAddress: PublicKey;
+    transferAuthority: PublicKey;
+    poolAmount: string;
+}
+export type WithdrawStakeStakePoolData = Pick<StakePoolData, 'poolMint' | 'validatorListAccount' | 'managerFeeAccount'>;
+/**
+ * Construct Solana withdrawStake stake pool instructions from parameters.
+ *
+ * @param {WithdrawStakeInstructionsParams} params - parameters for unstaking from stake pool
+ * @param {WithdrawStakeStakePoolData} stakePool - data from getStakePoolAccount needed for WithdrawStake
+ * @returns {TransactionInstruction[]}
+ */
+export declare function withdrawStakeInstructions(params: WithdrawStakeInstructionsParams, stakePool: WithdrawStakeStakePoolData): TransactionInstruction[];
+/**
+ * Construct Solana withdrawStake stake pool parameters from instruction.
+ *
+ * @param {TransactionInstruction} instruction
+ * @returns {DepositSolParams}
+ */
+export declare function decodeWithdrawStake(instruction: TransactionInstruction): WithdrawStakeParams;
+//# sourceMappingURL=jitoStakePoolOperations.d.ts.map

package/dist/esm/lib/jitoStakePoolOperations.js

@@ -0,0 +1,189 @@
+/**
+ * @file Implementation of the depositSol instruction. On upgrade of
+ * '@solana/spl-token', this module may no longer be necessary.
+ */
+import { StakePoolInstruction, STAKE_POOL_PROGRAM_ID, } from '@solana/spl-stake-pool';
+import { createApproveInstruction, createAssociatedTokenAccountIdempotentInstruction, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID, } from '@solana/spl-token';
+import { PublicKey, StakeProgram, SystemProgram, SYSVAR_CLOCK_PUBKEY, } from '@solana/web3.js';
+import assert from 'assert';
+import { STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT } from './constants';
+export const DEPOSIT_SOL_LAYOUT_CODE = 14;
+export const WITHDRAW_STAKE_LAYOUT_CODE = 10;
+/**
+ * Generates the withdraw authority program address for the stake pool.
+ * Like findWithdrawAuthorityProgramAddress in @solana/spl-stake-pool,
+ * but synchronous.
+ *
+ * @see {findWithdrawAuthorityProgramAddress}
+ */
+export function findWithdrawAuthorityProgramAddressSync(programId, stakePoolAddress) {
+    const [withdrawAuthority] = PublicKey.findProgramAddressSync([stakePoolAddress.toBuffer(), Buffer.from('withdraw')], programId);
+    return withdrawAuthority;
+}
+/**
+ * Construct Solana depositSol stake pool instruction from parameters.
+ *
+ * @param {DepositSolInstructionsParams} params - parameters for staking to stake pool
+ * @param {DepositSolStakePoolData} stakePool - data from getStakePoolAccount needed for DepositSol
+ * @param createAssociatedTokenAccount
+ * @returns {TransactionInstruction}
+ */
+export function depositSolInstructions(params, stakePool, createAssociatedTokenAccount) {
+    const { stakePoolAddress, from, lamports } = params;
+    const poolMint = new PublicKey(stakePool.poolMint);
+    const reserveStake = new PublicKey(stakePool.reserveStake);
+    const managerFeeAccount = new PublicKey(stakePool.managerFeeAccount);
+    // findWithdrawAuthorityProgramAddress
+    const withdrawAuthority = findWithdrawAuthorityProgramAddressSync(STAKE_POOL_PROGRAM_ID, stakePoolAddress);
+    const associatedAddress = getAssociatedTokenAddressSync(poolMint, from);
+    const instructions = [];
+    if (createAssociatedTokenAccount) {
+        instructions.push(createAssociatedTokenAccountIdempotentInstruction(from, associatedAddress, from, poolMint));
+    }
+    instructions.push(StakePoolInstruction.depositSol({
+        stakePool: stakePoolAddress,
+        reserveStake,
+        fundingAccount: from,
+        destinationPoolAccount: associatedAddress,
+        managerFeeAccount,
+        referralPoolAccount: associatedAddress,
+        poolMint,
+        lamports: Number(lamports),
+        withdrawAuthority,
+    }));
+    return instructions;
+}
+function parseKey(key, template) {
+    assert(key.isSigner === template.isSigner && key.isWritable === template.isWritable, `Unexpected key metadata in instruction: { isSigner: ${key.isSigner}, isWritable: ${key.isWritable} }`);
+    return key.pubkey;
+}
+/**
+ * Construct Solana depositSol stake pool parameters from instruction.
+ *
+ * @param {TransactionInstruction} instruction
+ * @returns {DepositSolParams}
+ */
+export function decodeDepositSol(instruction) {
+    const { programId, keys, data } = instruction;
+    assert(programId.equals(STAKE_POOL_PROGRAM_ID), 'Invalid DepositSol instruction, program ID must be the Stake Pool Program');
+    let i = 0;
+    const stakePool = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const withdrawAuthority = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    const reserveStake = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const fundingAccount = parseKey(keys[i++], { isSigner: true, isWritable: true });
+    const destinationPoolAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const managerFeeAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const referralPoolAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const poolMint = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const systemProgramProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    assert(systemProgramProgramId.equals(SystemProgram.programId), 'Unexpected pubkey in DepositSol instruction');
+    const tokenProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    assert(tokenProgramId.equals(TOKEN_PROGRAM_ID), 'Unexpected pubkey in DepositSol instruction');
+    const depositAuthority = keys.length > 10 ? parseKey(keys[i++], { isSigner: true, isWritable: false }) : undefined;
+    assert(keys.length <= 11, 'Too many keys in DepositSol instruction');
+    const layoutCode = data.readUint8(0);
+    assert(layoutCode === DEPOSIT_SOL_LAYOUT_CODE, 'Incorrect layout code in DepositSol data');
+    assert(data.length === 9, 'Incorrect data size for DepositSol layout');
+    const lamports = data.readBigInt64LE(1);
+    return {
+        stakePool,
+        depositAuthority,
+        withdrawAuthority,
+        reserveStake,
+        fundingAccount,
+        destinationPoolAccount,
+        managerFeeAccount,
+        referralPoolAccount,
+        poolMint,
+        lamports: Number(lamports),
+    };
+}
+/**
+ * Construct Solana withdrawStake stake pool instructions from parameters.
+ *
+ * @param {WithdrawStakeInstructionsParams} params - parameters for unstaking from stake pool
+ * @param {WithdrawStakeStakePoolData} stakePool - data from getStakePoolAccount needed for WithdrawStake
+ * @returns {TransactionInstruction[]}
+ */
+export function withdrawStakeInstructions(params, stakePool) {
+    const { tokenOwner, stakePoolAddress, destinationStakeAccount, validatorAddress, transferAuthority, poolAmount: poolAmountString, } = params;
+    const poolMint = new PublicKey(stakePool.poolMint);
+    const validatorList = new PublicKey(stakePool.validatorListAccount);
+    const managerFeeAccount = new PublicKey(stakePool.managerFeeAccount);
+    const poolTokenAccount = getAssociatedTokenAddressSync(poolMint, tokenOwner);
+    const withdrawAuthority = findWithdrawAuthorityProgramAddressSync(STAKE_POOL_PROGRAM_ID, stakePoolAddress);
+    const poolAmount = BigInt(poolAmountString);
+    return [
+        createApproveInstruction(poolTokenAccount, transferAuthority, tokenOwner, poolAmount),
+        SystemProgram.createAccount({
+            fromPubkey: tokenOwner,
+            newAccountPubkey: destinationStakeAccount,
+            lamports: STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT,
+            space: StakeProgram.space,
+            programId: StakeProgram.programId,
+        }),
+        StakePoolInstruction.withdrawStake({
+            stakePool: stakePoolAddress,
+            validatorList: validatorList,
+            validatorStake: validatorAddress,
+            destinationStake: destinationStakeAccount,
+            destinationStakeAuthority: tokenOwner,
+            sourceTransferAuthority: transferAuthority,
+            sourcePoolAccount: poolTokenAccount,
+            managerFeeAccount: managerFeeAccount,
+            poolMint: poolMint,
+            poolTokens: Number(poolAmount),
+            withdrawAuthority,
+        }),
+        ...StakeProgram.deactivate({
+            stakePubkey: destinationStakeAccount,
+            authorizedPubkey: tokenOwner,
+        }).instructions,
+    ];
+}
+/**
+ * Construct Solana withdrawStake stake pool parameters from instruction.
+ *
+ * @param {TransactionInstruction} instruction
+ * @returns {DepositSolParams}
+ */
+export function decodeWithdrawStake(instruction) {
+    const { programId, keys, data } = instruction;
+    assert(programId.equals(STAKE_POOL_PROGRAM_ID), 'Invalid WithdrawStake instruction, program ID must be the Stake Pool Program');
+    const layoutCode = data.readUint8(0);
+    assert(layoutCode === WITHDRAW_STAKE_LAYOUT_CODE, 'Incorrect layout code in WithdrawStake data');
+    assert(data.length === 9, 'Incorrect data size for WithdrawStake layout');
+    const poolTokens = data.readBigInt64LE(1);
+    let i = 0;
+    const stakePool = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const validatorList = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const withdrawAuthority = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    const validatorStake = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const destinationStake = keys[i++].pubkey;
+    const destinationStakeAuthority = keys[i++].pubkey;
+    const sourceTransferAuthority = parseKey(keys[i++], { isSigner: true, isWritable: false });
+    const sourcePoolAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const managerFeeAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const poolMint = parseKey(keys[i++], { isSigner: false, isWritable: true });
+    const sysvarClockPubkey = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    assert(sysvarClockPubkey.equals(SYSVAR_CLOCK_PUBKEY), 'Unexpected pubkey in WithdrawStake instruction');
+    const tokenProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    assert(tokenProgramId.equals(TOKEN_PROGRAM_ID), 'Unexpected pubkey in WithdrawStake instruction');
+    const stakeProgramProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    assert(stakeProgramProgramId.equals(StakeProgram.programId), 'Unexpected pubkey in WithdrawStake instruction');
+    assert(i === keys.length, 'Too many keys in WithdrawStake instruction');
+    return {
+        stakePool,
+        validatorList,
+        withdrawAuthority,
+        validatorStake,
+        destinationStake,
+        destinationStakeAuthority,
+        sourceTransferAuthority,
+        sourcePoolAccount,
+        managerFeeAccount,
+        poolMint,
+        poolTokens: Number(poolTokens),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jitoStakePoolOperations.js","sourceRoot":"","sources":["../../../src/lib/jitoStakePoolOperations.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @file Implementation of the depositSol instruction. On upgrade of\n * '@solana/spl-token', this module may no longer be necessary.\n */\n\nimport {\n  StakePoolInstruction,\n  STAKE_POOL_PROGRAM_ID,\n  DepositSolParams,\n  WithdrawStakeParams,\n} from '@solana/spl-stake-pool';\nimport {\n  createApproveInstruction,\n  createAssociatedTokenAccountIdempotentInstruction,\n  getAssociatedTokenAddressSync,\n  TOKEN_PROGRAM_ID,\n} from '@solana/spl-token';\nimport {\n  AccountMeta,\n  PublicKey,\n  StakeProgram,\n  SystemProgram,\n  SYSVAR_CLOCK_PUBKEY,\n  TransactionInstruction,\n} from '@solana/web3.js';\nimport assert from 'assert';\nimport { STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT } from './constants';\n\n/**\n * Replicates the fields in @solana/spl-stake-pool Fee.\n *\n * @see {Fee}\n */\nexport interface Fee {\n  denominator: string;\n  numerator: string;\n}\n\n/**\n * Replicates the fields in @solana/spl-stake-pool StakePoolLayout.\n *\n * @see {StakePoolLayout}\n */\nexport interface StakePoolData {\n  accountType: number;\n  manager: string;\n  staker: string;\n  stakeDepositAuthority: string;\n  stakeWithdrawBumpSeed: number;\n  validatorListAccount: string;\n  reserveStake: string;\n  poolMint: string;\n  managerFeeAccount: string;\n  tokenProgramId: string;\n  totalLamports: string;\n  poolTokenSupply: string;\n  lastUpdateEpoch: string;\n  lockup: {\n    unixTimestamp: string;\n    epoch: string;\n    custodian: string;\n  };\n  epochFee: Fee;\n  nextEpochFee?: Fee | undefined;\n  preferredDepositValidatorVoteAddress?: string | undefined;\n  preferredWithdrawValidatorVoteAddress?: string | undefined;\n  stakeDepositFee: Fee;\n  stakeWithdrawalFee: Fee;\n  nextStakeWithdrawalFee?: Fee | undefined;\n  stakeReferralFee: number;\n  solDepositAuthority?: string | undefined;\n  solDepositFee: Fee;\n  solReferralFee: number;\n  solWithdrawAuthority?: string | undefined;\n  solWithdrawalFee: Fee;\n  nextSolWithdrawalFee?: Fee | undefined;\n  lastEpochPoolTokenSupply: string;\n  lastEpochTotalLamports: string;\n}\n\nexport const DEPOSIT_SOL_LAYOUT_CODE = 14;\nexport const WITHDRAW_STAKE_LAYOUT_CODE = 10;\n\n/**\n * Generates the withdraw authority program address for the stake pool.\n * Like findWithdrawAuthorityProgramAddress in @solana/spl-stake-pool,\n * but synchronous.\n *\n * @see {findWithdrawAuthorityProgramAddress}\n */\nexport function findWithdrawAuthorityProgramAddressSync(programId: PublicKey, stakePoolAddress: PublicKey): PublicKey {\n  const [withdrawAuthority] = PublicKey.findProgramAddressSync(\n    [stakePoolAddress.toBuffer(), Buffer.from('withdraw')],\n    programId\n  );\n  return withdrawAuthority;\n}\n\nexport interface DepositSolInstructionsParams {\n  stakePoolAddress: PublicKey;\n  from: PublicKey;\n  lamports: bigint;\n}\n\nexport type DepositSolStakePoolData = Pick<StakePoolData, 'poolMint' | 'reserveStake' | 'managerFeeAccount'>;\n\n/**\n * Construct Solana depositSol stake pool instruction from parameters.\n *\n * @param {DepositSolInstructionsParams} params - parameters for staking to stake pool\n * @param {DepositSolStakePoolData} stakePool - data from getStakePoolAccount needed for DepositSol\n * @param createAssociatedTokenAccount\n * @returns {TransactionInstruction}\n */\nexport function depositSolInstructions(\n  params: DepositSolInstructionsParams,\n  stakePool: DepositSolStakePoolData,\n  createAssociatedTokenAccount: boolean\n): TransactionInstruction[] {\n  const { stakePoolAddress, from, lamports } = params;\n  const poolMint = new PublicKey(stakePool.poolMint);\n  const reserveStake = new PublicKey(stakePool.reserveStake);\n  const managerFeeAccount = new PublicKey(stakePool.managerFeeAccount);\n\n  // findWithdrawAuthorityProgramAddress\n  const withdrawAuthority = findWithdrawAuthorityProgramAddressSync(STAKE_POOL_PROGRAM_ID, stakePoolAddress);\n  const associatedAddress = getAssociatedTokenAddressSync(poolMint, from);\n\n  const instructions: TransactionInstruction[] = [];\n\n  if (createAssociatedTokenAccount) {\n    instructions.push(createAssociatedTokenAccountIdempotentInstruction(from, associatedAddress, from, poolMint));\n  }\n\n  instructions.push(\n    StakePoolInstruction.depositSol({\n      stakePool: stakePoolAddress,\n      reserveStake,\n      fundingAccount: from,\n      destinationPoolAccount: associatedAddress,\n      managerFeeAccount,\n      referralPoolAccount: associatedAddress,\n      poolMint,\n      lamports: Number(lamports),\n      withdrawAuthority,\n    })\n  );\n\n  return instructions;\n}\n\nfunction parseKey(key: AccountMeta, template: { isSigner: boolean; isWritable: boolean }): PublicKey {\n  assert(\n    key.isSigner === template.isSigner && key.isWritable === template.isWritable,\n    `Unexpected key metadata in instruction: { isSigner: ${key.isSigner}, isWritable: ${key.isWritable} }`\n  );\n  return key.pubkey;\n}\n\n/**\n * Construct Solana depositSol stake pool parameters from instruction.\n *\n * @param {TransactionInstruction} instruction\n * @returns {DepositSolParams}\n */\nexport function decodeDepositSol(instruction: TransactionInstruction): DepositSolParams {\n  const { programId, keys, data } = instruction;\n\n  assert(\n    programId.equals(STAKE_POOL_PROGRAM_ID),\n    'Invalid DepositSol instruction, program ID must be the Stake Pool Program'\n  );\n\n  let i = 0;\n  const stakePool = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const withdrawAuthority = parseKey(keys[i++], { isSigner: false, isWritable: false });\n  const reserveStake = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const fundingAccount = parseKey(keys[i++], { isSigner: true, isWritable: true });\n  const destinationPoolAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const managerFeeAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const referralPoolAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const poolMint = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const systemProgramProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });\n  assert(systemProgramProgramId.equals(SystemProgram.programId), 'Unexpected pubkey in DepositSol instruction');\n  const tokenProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });\n  assert(tokenProgramId.equals(TOKEN_PROGRAM_ID), 'Unexpected pubkey in DepositSol instruction');\n  const depositAuthority = keys.length > 10 ? parseKey(keys[i++], { isSigner: true, isWritable: false }) : undefined;\n  assert(keys.length <= 11, 'Too many keys in DepositSol instruction');\n\n  const layoutCode = data.readUint8(0);\n  assert(layoutCode === DEPOSIT_SOL_LAYOUT_CODE, 'Incorrect layout code in DepositSol data');\n  assert(data.length === 9, 'Incorrect data size for DepositSol layout');\n  const lamports = data.readBigInt64LE(1);\n\n  return {\n    stakePool,\n    depositAuthority,\n    withdrawAuthority,\n    reserveStake,\n    fundingAccount,\n    destinationPoolAccount,\n    managerFeeAccount,\n    referralPoolAccount,\n    poolMint,\n    lamports: Number(lamports),\n  };\n}\n\nexport interface WithdrawStakeInstructionsParams {\n  stakePoolAddress: PublicKey;\n  tokenOwner: PublicKey;\n  destinationStakeAccount: PublicKey;\n  validatorAddress: PublicKey;\n  transferAuthority: PublicKey;\n  poolAmount: string;\n}\n\nexport type WithdrawStakeStakePoolData = Pick<StakePoolData, 'poolMint' | 'validatorListAccount' | 'managerFeeAccount'>;\n\n/**\n * Construct Solana withdrawStake stake pool instructions from parameters.\n *\n * @param {WithdrawStakeInstructionsParams} params - parameters for unstaking from stake pool\n * @param {WithdrawStakeStakePoolData} stakePool - data from getStakePoolAccount needed for WithdrawStake\n * @returns {TransactionInstruction[]}\n */\nexport function withdrawStakeInstructions(\n  params: WithdrawStakeInstructionsParams,\n  stakePool: WithdrawStakeStakePoolData\n): TransactionInstruction[] {\n  const {\n    tokenOwner,\n    stakePoolAddress,\n    destinationStakeAccount,\n    validatorAddress,\n    transferAuthority,\n    poolAmount: poolAmountString,\n  } = params;\n\n  const poolMint = new PublicKey(stakePool.poolMint);\n  const validatorList = new PublicKey(stakePool.validatorListAccount);\n  const managerFeeAccount = new PublicKey(stakePool.managerFeeAccount);\n\n  const poolTokenAccount = getAssociatedTokenAddressSync(poolMint, tokenOwner);\n  const withdrawAuthority = findWithdrawAuthorityProgramAddressSync(STAKE_POOL_PROGRAM_ID, stakePoolAddress);\n\n  const poolAmount = BigInt(poolAmountString);\n\n  return [\n    createApproveInstruction(poolTokenAccount, transferAuthority, tokenOwner, poolAmount),\n    SystemProgram.createAccount({\n      fromPubkey: tokenOwner,\n      newAccountPubkey: destinationStakeAccount,\n      lamports: STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT,\n      space: StakeProgram.space,\n      programId: StakeProgram.programId,\n    }),\n    StakePoolInstruction.withdrawStake({\n      stakePool: stakePoolAddress,\n      validatorList: validatorList,\n      validatorStake: validatorAddress,\n      destinationStake: destinationStakeAccount,\n      destinationStakeAuthority: tokenOwner,\n      sourceTransferAuthority: transferAuthority,\n      sourcePoolAccount: poolTokenAccount,\n      managerFeeAccount: managerFeeAccount,\n      poolMint: poolMint,\n      poolTokens: Number(poolAmount),\n      withdrawAuthority,\n    }),\n    ...StakeProgram.deactivate({\n      stakePubkey: destinationStakeAccount,\n      authorizedPubkey: tokenOwner,\n    }).instructions,\n  ];\n}\n\n/**\n * Construct Solana withdrawStake stake pool parameters from instruction.\n *\n * @param {TransactionInstruction} instruction\n * @returns {DepositSolParams}\n */\nexport function decodeWithdrawStake(instruction: TransactionInstruction): WithdrawStakeParams {\n  const { programId, keys, data } = instruction;\n\n  assert(\n    programId.equals(STAKE_POOL_PROGRAM_ID),\n    'Invalid WithdrawStake instruction, program ID must be the Stake Pool Program'\n  );\n\n  const layoutCode = data.readUint8(0);\n  assert(layoutCode === WITHDRAW_STAKE_LAYOUT_CODE, 'Incorrect layout code in WithdrawStake data');\n  assert(data.length === 9, 'Incorrect data size for WithdrawStake layout');\n  const poolTokens = data.readBigInt64LE(1);\n\n  let i = 0;\n  const stakePool = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const validatorList = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const withdrawAuthority = parseKey(keys[i++], { isSigner: false, isWritable: false });\n  const validatorStake = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const destinationStake = keys[i++].pubkey;\n  const destinationStakeAuthority = keys[i++].pubkey;\n  const sourceTransferAuthority = parseKey(keys[i++], { isSigner: true, isWritable: false });\n  const sourcePoolAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const managerFeeAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const poolMint = parseKey(keys[i++], { isSigner: false, isWritable: true });\n  const sysvarClockPubkey = parseKey(keys[i++], { isSigner: false, isWritable: false });\n  assert(sysvarClockPubkey.equals(SYSVAR_CLOCK_PUBKEY), 'Unexpected pubkey in WithdrawStake instruction');\n  const tokenProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });\n  assert(tokenProgramId.equals(TOKEN_PROGRAM_ID), 'Unexpected pubkey in WithdrawStake instruction');\n  const stakeProgramProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });\n  assert(stakeProgramProgramId.equals(StakeProgram.programId), 'Unexpected pubkey in WithdrawStake instruction');\n  assert(i === keys.length, 'Too many keys in WithdrawStake instruction');\n\n  return {\n    stakePool,\n    validatorList,\n    withdrawAuthority,\n    validatorStake,\n    destinationStake,\n    destinationStakeAuthority,\n    sourceTransferAuthority,\n    sourcePoolAccount,\n    managerFeeAccount,\n    poolMint,\n    poolTokens: Number(poolTokens),\n  };\n}\n"]}

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

@@ -0,0 +1,32 @@
+import { DefaultKeys, KeyPairOptions, Ed25519KeyPair } from '@bitgo-beta/sdk-core';
+import { SolanaKeys } from './iface';
+export declare class KeyPair extends Ed25519KeyPair {
+    protected keyPair: DefaultKeys;
+    protected source?: KeyPairOptions;
+    /**
+     * Public constructor. By default, creates a key pair with a random master seed.
+     *
+     * @param { KeyPairOptions } source Either a master seed, a private key, or a public key
+     */
+    constructor(source?: KeyPairOptions);
+    /** @inheritdoc */
+    recordKeysFromPrivateKeyInProtocolFormat(prv: string): DefaultKeys;
+    /** @inheritdoc */
+    recordKeysFromPublicKeyInProtocolFormat(pub: string): DefaultKeys;
+    /**
+     * Solana default keys format public key as a base58 string and secret key as Uint8Array
+     *
+     * @param {boolean} raw defines if the prv key is returned in Uint8Array, default is base58
+     * @returns {SolanaKeys} The keys in the defined format
+     */
+    getKeys(raw?: boolean): SolanaKeys;
+    /** @inheritdoc */
+    getAddress(): string;
+    /**
+     * Signs the message bytes exactly as given: Buffers are signed byte-for-byte and strings
+     * as their UTF-8 encoding. The base Ed25519KeyPair only accepts strings, which corrupts
+     * arbitrary-byte messages.
+     */
+    signMessage(message: string | Buffer): Uint8Array;
+}
+//# sourceMappingURL=keyPair.d.ts.map

package/dist/esm/lib/keyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPair.d.ts","sourceRoot":"","sources":["../../../src/lib/keyPair.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAgB,MAAM,sBAAsB,CAAC;AACjG,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC,qBAAa,OAAQ,SAAQ,cAAc;IACzC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC;IAC/B,SAAS,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IAElC;;;;OAIG;gBACS,MAAM,CAAC,EAAE,cAAc;IAInC,kBAAkB;IAClB,wCAAwC,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAUlE,kBAAkB;IAClB,uCAAuC,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAMjE;;;;;OAKG;IACH,OAAO,CAAC,GAAG,UAAQ,GAAG,UAAU;IAqBhC,kBAAkB;IAClB,UAAU,IAAI,MAAM;IAKpB;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU;CAUlD"}

package/dist/esm/lib/keyPair.js

@@ -0,0 +1,75 @@
+import { Keypair as SolKeypair } from '@solana/web3.js';
+import * as nacl from 'tweetnacl';
+import { Ed25519KeyPair, toUint8Array } from '@bitgo-beta/sdk-core';
+import { base58ToUint8Array, Uint8ArrayTobase58 } from './utils';
+export class KeyPair extends Ed25519KeyPair {
+    /**
+     * Public constructor. By default, creates a key pair with a random master seed.
+     *
+     * @param { KeyPairOptions } source Either a master seed, a private key, or a public key
+     */
+    constructor(source) {
+        super(source);
+    }
+    /** @inheritdoc */
+    recordKeysFromPrivateKeyInProtocolFormat(prv) {
+        const prvKey = base58ToUint8Array(prv);
+        const keyPair = SolKeypair.fromSecretKey(prvKey);
+        return {
+            pub: keyPair.publicKey.toBuffer().toString('hex'),
+            prv: Buffer.from(keyPair.secretKey.slice(0, 32)).toString('hex'),
+        };
+    }
+    /** @inheritdoc */
+    recordKeysFromPublicKeyInProtocolFormat(pub) {
+        return {
+            pub: Buffer.from(base58ToUint8Array(pub)).toString('hex'),
+        };
+    }
+    /**
+     * Solana default keys format public key as a base58 string and secret key as Uint8Array
+     *
+     * @param {boolean} raw defines if the prv key is returned in Uint8Array, default is base58
+     * @returns {SolanaKeys} The keys in the defined format
+     */
+    getKeys(raw = false) {
+        // keys are originally created in hex, but we need base58
+        const publicKeyBuffer = Buffer.from(this.keyPair.pub, 'hex');
+        const base58Pub = Uint8ArrayTobase58(publicKeyBuffer);
+        const result = { pub: base58Pub };
+        if (!!this.keyPair.prv) {
+            const secretKeyBuffer = Buffer.from(this.keyPair.prv, 'hex');
+            const solanaSecretKey = new Uint8Array(64);
+            solanaSecretKey.set(secretKeyBuffer);
+            solanaSecretKey.set(publicKeyBuffer, 32);
+            if (raw) {
+                result.prv = solanaSecretKey;
+            }
+            else {
+                result.prv = Uint8ArrayTobase58(solanaSecretKey);
+            }
+        }
+        return result;
+    }
+    /** @inheritdoc */
+    getAddress() {
+        const keys = this.getKeys();
+        return keys.pub;
+    }
+    /**
+     * Signs the message bytes exactly as given: Buffers are signed byte-for-byte and strings
+     * as their UTF-8 encoding. The base Ed25519KeyPair only accepts strings, which corrupts
+     * arbitrary-byte messages.
+     */
+    signMessage(message) {
+        const messageToSign = Buffer.isBuffer(message)
+            ? new Uint8Array(message)
+            : toUint8Array(Buffer.from(message).toString('hex'));
+        const prv = this.keyPair?.prv;
+        if (!prv) {
+            throw new Error('Missing private key');
+        }
+        return nacl.sign.detached(messageToSign, nacl.sign.keyPair.fromSeed(toUint8Array(prv)).secretKey);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5UGFpci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIva2V5UGFpci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxJQUFJLFVBQVUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3hELE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sRUFBK0IsY0FBYyxFQUFFLFlBQVksRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRWpHLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUVqRSxNQUFNLE9BQU8sT0FBUSxTQUFRLGNBQWM7SUFJekM7Ozs7T0FJRztJQUNILFlBQVksTUFBdUI7UUFDakMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2hCLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsd0NBQXdDLENBQUMsR0FBVztRQUNsRCxNQUFNLE1BQU0sR0FBRyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUN2QyxNQUFNLE9BQU8sR0FBRyxVQUFVLENBQUMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBRWpELE9BQU87WUFDTCxHQUFHLEVBQUUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDO1lBQ2pELEdBQUcsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUM7U0FDakUsQ0FBQztJQUNKLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsdUNBQXVDLENBQUMsR0FBVztRQUNqRCxPQUFPO1lBQ0wsR0FBRyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDO1NBQzFELENBQUM7SUFDSixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxPQUFPLENBQUMsR0FBRyxHQUFHLEtBQUs7UUFDakIseURBQXlEO1FBQ3pELE1BQU0sZUFBZSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDN0QsTUFBTSxTQUFTLEdBQUcsa0JBQWtCLENBQUMsZUFBZSxDQUFDLENBQUM7UUFFdEQsTUFBTSxNQUFNLEdBQWUsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLENBQUM7UUFDOUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUN2QixNQUFNLGVBQWUsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQzdELE1BQU0sZUFBZSxHQUFHLElBQUksVUFBVSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQzNDLGVBQWUsQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLENBQUM7WUFDckMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxlQUFlLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFFekMsSUFBSSxHQUFHLEVBQUUsQ0FBQztnQkFDUixNQUFNLENBQUMsR0FBRyxHQUFHLGVBQWUsQ0FBQztZQUMvQixDQUFDO2lCQUFNLENBQUM7Z0JBQ04sTUFBTSxDQUFDLEdBQUcsR0FBRyxrQkFBa0IsQ0FBQyxlQUFlLENBQUMsQ0FBQztZQUNuRCxDQUFDO1FBQ0gsQ0FBQztRQUNELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsVUFBVTtRQUNSLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUM1QixPQUFPLElBQUksQ0FBQyxHQUFHLENBQUM7SUFDbEIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxXQUFXLENBQUMsT0FBd0I7UUFDbEMsTUFBTSxhQUFhLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUM7WUFDNUMsQ0FBQyxDQUFDLElBQUksVUFBVSxDQUFDLE9BQU8sQ0FBQztZQUN6QixDQUFDLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDdkQsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLE9BQU8sRUFBRSxHQUFHLENBQUM7UUFDOUIsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQ1QsTUFBTSxJQUFJLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1FBQ3pDLENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDcEcsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgS2V5cGFpciBhcyBTb2xLZXlwYWlyIH0gZnJvbSAnQHNvbGFuYS93ZWIzLmpzJztcbmltcG9ydCAqIGFzIG5hY2wgZnJvbSAndHdlZXRuYWNsJztcbmltcG9ydCB7IERlZmF1bHRLZXlzLCBLZXlQYWlyT3B0aW9ucywgRWQyNTUxOUtleVBhaXIsIHRvVWludDhBcnJheSB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcbmltcG9ydCB7IFNvbGFuYUtleXMgfSBmcm9tICcuL2lmYWNlJztcbmltcG9ydCB7IGJhc2U1OFRvVWludDhBcnJheSwgVWludDhBcnJheVRvYmFzZTU4IH0gZnJvbSAnLi91dGlscyc7XG5cbmV4cG9ydCBjbGFzcyBLZXlQYWlyIGV4dGVuZHMgRWQyNTUxOUtleVBhaXIge1xuICBwcm90ZWN0ZWQga2V5UGFpcjogRGVmYXVsdEtleXM7XG4gIHByb3RlY3RlZCBzb3VyY2U/OiBLZXlQYWlyT3B0aW9ucztcblxuICAvKipcbiAgICogUHVibGljIGNvbnN0cnVjdG9yLiBCeSBkZWZhdWx0LCBjcmVhdGVzIGEga2V5IHBhaXIgd2l0aCBhIHJhbmRvbSBtYXN0ZXIgc2VlZC5cbiAgICpcbiAgICogQHBhcmFtIHsgS2V5UGFpck9wdGlvbnMgfSBzb3VyY2UgRWl0aGVyIGEgbWFzdGVyIHNlZWQsIGEgcHJpdmF0ZSBrZXksIG9yIGEgcHVibGljIGtleVxuICAgKi9cbiAgY29uc3RydWN0b3Ioc291cmNlPzogS2V5UGFpck9wdGlvbnMpIHtcbiAgICBzdXBlcihzb3VyY2UpO1xuICB9XG5cbiAgLyoqIEBpbmhlcml0ZG9jICovXG4gIHJlY29yZEtleXNGcm9tUHJpdmF0ZUtleUluUHJvdG9jb2xGb3JtYXQocHJ2OiBzdHJpbmcpOiBEZWZhdWx0S2V5cyB7XG4gICAgY29uc3QgcHJ2S2V5ID0gYmFzZTU4VG9VaW50OEFycmF5KHBydik7XG4gICAgY29uc3Qga2V5UGFpciA9IFNvbEtleXBhaXIuZnJvbVNlY3JldEtleShwcnZLZXkpO1xuXG4gICAgcmV0dXJuIHtcbiAgICAgIHB1Yjoga2V5UGFpci5wdWJsaWNLZXkudG9CdWZmZXIoKS50b1N0cmluZygnaGV4JyksXG4gICAgICBwcnY6IEJ1ZmZlci5mcm9tKGtleVBhaXIuc2VjcmV0S2V5LnNsaWNlKDAsIDMyKSkudG9TdHJpbmcoJ2hleCcpLFxuICAgIH07XG4gIH1cblxuICAvKiogQGluaGVyaXRkb2MgKi9cbiAgcmVjb3JkS2V5c0Zyb21QdWJsaWNLZXlJblByb3RvY29sRm9ybWF0KHB1Yjogc3RyaW5nKTogRGVmYXVsdEtleXMge1xuICAgIHJldHVybiB7XG4gICAgICBwdWI6IEJ1ZmZlci5mcm9tKGJhc2U1OFRvVWludDhBcnJheShwdWIpKS50b1N0cmluZygnaGV4JyksXG4gICAgfTtcbiAgfVxuXG4gIC8qKlxuICAgKiBTb2xhbmEgZGVmYXVsdCBrZXlzIGZvcm1hdCBwdWJsaWMga2V5IGFzIGEgYmFzZTU4IHN0cmluZyBhbmQgc2VjcmV0IGtleSBhcyBVaW50OEFycmF5XG4gICAqXG4gICAqIEBwYXJhbSB7Ym9vbGVhbn0gcmF3IGRlZmluZXMgaWYgdGhlIHBydiBrZXkgaXMgcmV0dXJuZWQgaW4gVWludDhBcnJheSwgZGVmYXVsdCBpcyBiYXNlNThcbiAgICogQHJldHVybnMge1NvbGFuYUtleXN9IFRoZSBrZXlzIGluIHRoZSBkZWZpbmVkIGZvcm1hdFxuICAgKi9cbiAgZ2V0S2V5cyhyYXcgPSBmYWxzZSk6IFNvbGFuYUtleXMge1xuICAgIC8vIGtleXMgYXJlIG9yaWdpbmFsbHkgY3JlYXRlZCBpbiBoZXgsIGJ1dCB3ZSBuZWVkIGJhc2U1OFxuICAgIGNvbnN0IHB1YmxpY0tleUJ1ZmZlciA9IEJ1ZmZlci5mcm9tKHRoaXMua2V5UGFpci5wdWIsICdoZXgnKTtcbiAgICBjb25zdCBiYXNlNThQdWIgPSBVaW50OEFycmF5VG9iYXNlNTgocHVibGljS2V5QnVmZmVyKTtcblxuICAgIGNvbnN0IHJlc3VsdDogU29sYW5hS2V5cyA9IHsgcHViOiBiYXNlNThQdWIgfTtcbiAgICBpZiAoISF0aGlzLmtleVBhaXIucHJ2KSB7XG4gICAgICBjb25zdCBzZWNyZXRLZXlCdWZmZXIgPSBCdWZmZXIuZnJvbSh0aGlzLmtleVBhaXIucHJ2LCAnaGV4Jyk7XG4gICAgICBjb25zdCBzb2xhbmFTZWNyZXRLZXkgPSBuZXcgVWludDhBcnJheSg2NCk7XG4gICAgICBzb2xhbmFTZWNyZXRLZXkuc2V0KHNlY3JldEtleUJ1ZmZlcik7XG4gICAgICBzb2xhbmFTZWNyZXRLZXkuc2V0KHB1YmxpY0tleUJ1ZmZlciwgMzIpO1xuXG4gICAgICBpZiAocmF3KSB7XG4gICAgICAgIHJlc3VsdC5wcnYgPSBzb2xhbmFTZWNyZXRLZXk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICByZXN1bHQucHJ2ID0gVWludDhBcnJheVRvYmFzZTU4KHNvbGFuYVNlY3JldEtleSk7XG4gICAgICB9XG4gICAgfVxuICAgIHJldHVybiByZXN1bHQ7XG4gIH1cblxuICAvKiogQGluaGVyaXRkb2MgKi9cbiAgZ2V0QWRkcmVzcygpOiBzdHJpbmcge1xuICAgIGNvbnN0IGtleXMgPSB0aGlzLmdldEtleXMoKTtcbiAgICByZXR1cm4ga2V5cy5wdWI7XG4gIH1cblxuICAvKipcbiAgICogU2lnbnMgdGhlIG1lc3NhZ2UgYnl0ZXMgZXhhY3RseSBhcyBnaXZlbjogQnVmZmVycyBhcmUgc2lnbmVkIGJ5dGUtZm9yLWJ5dGUgYW5kIHN0cmluZ3NcbiAgICogYXMgdGhlaXIgVVRGLTggZW5jb2RpbmcuIFRoZSBiYXNlIEVkMjU1MTlLZXlQYWlyIG9ubHkgYWNjZXB0cyBzdHJpbmdzLCB3aGljaCBjb3JydXB0c1xuICAgKiBhcmJpdHJhcnktYnl0ZSBtZXNzYWdlcy5cbiAgICovXG4gIHNpZ25NZXNzYWdlKG1lc3NhZ2U6IHN0cmluZyB8IEJ1ZmZlcik6IFVpbnQ4QXJyYXkge1xuICAgIGNvbnN0IG1lc3NhZ2VUb1NpZ24gPSBCdWZmZXIuaXNCdWZmZXIobWVzc2FnZSlcbiAgICAgID8gbmV3IFVpbnQ4QXJyYXkobWVzc2FnZSlcbiAgICAgIDogdG9VaW50OEFycmF5KEJ1ZmZlci5mcm9tKG1lc3NhZ2UpLnRvU3RyaW5nKCdoZXgnKSk7XG4gICAgY29uc3QgcHJ2ID0gdGhpcy5rZXlQYWlyPy5wcnY7XG4gICAgaWYgKCFwcnYpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignTWlzc2luZyBwcml2YXRlIGtleScpO1xuICAgIH1cbiAgICByZXR1cm4gbmFjbC5zaWduLmRldGFjaGVkKG1lc3NhZ2VUb1NpZ24sIG5hY2wuc2lnbi5rZXlQYWlyLmZyb21TZWVkKHRvVWludDhBcnJheShwcnYpKS5zZWNyZXRLZXkpO1xuICB9XG59XG4iXX0=

package/dist/esm/lib/messages/index.d.ts

@@ -0,0 +1,2 @@
+export * from './messageBuilderFactory';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/lib/messages/index.js

@@ -0,0 +1,2 @@
+export * from './messageBuilderFactory';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL21lc3NhZ2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21lc3NhZ2VCdWlsZGVyRmFjdG9yeSc7XG4iXX0=

package/dist/esm/lib/messages/messageBuilderFactory.d.ts

@@ -0,0 +1,7 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { BaseMessageBuilderFactory, IMessageBuilder, MessageStandardType } from '@bitgo-beta/sdk-core';
+export declare class MessageBuilderFactory extends BaseMessageBuilderFactory {
+    constructor(coinConfig: Readonly<CoinConfig>);
+    getMessageBuilder(type: MessageStandardType): IMessageBuilder;
+}
+//# sourceMappingURL=messageBuilderFactory.d.ts.map

package/dist/{src → esm}/lib/messages/messageBuilderFactory.js

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageBuilderFactory = void 0;
-const sdk_core_1 = require("@bitgo-beta/sdk-core");
-class MessageBuilderFactory extends sdk_core_1.BaseMessageBuilderFactory {
+import { BaseMessageBuilderFactory, MessageStandardType, SimpleMessageBuilder } from '@bitgo-beta/sdk-core';
+export class MessageBuilderFactory extends BaseMessageBuilderFactory {
     constructor(coinConfig) {
         super(coinConfig);
     }
     getMessageBuilder(type) {
         switch (type) {
-            case sdk_core_1.MessageStandardType.SIMPLE:
-                return new sdk_core_1.SimpleMessageBuilder(this.coinConfig);
+            case MessageStandardType.SIMPLE:
+                return new SimpleMessageBuilder(this.coinConfig);
             default:
                 throw new Error(`Invalid message standard ${type}`);
         }
     }
 }
-exports.MessageBuilderFactory = MessageBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZUJ1aWxkZXJGYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9tZXNzYWdlcy9tZXNzYWdlQnVpbGRlckZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsbURBQTZIO0FBRTdILE1BQWEscUJBQXNCLFNBQVEsb0NBQXlCO0lBQ2xFLFlBQVksVUFBZ0M7UUFDMUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQ3BCLENBQUM7SUFFTSxpQkFBaUIsQ0FBQyxJQUF5QjtRQUNoRCxRQUFRLElBQUksRUFBRSxDQUFDO1lBQ2IsS0FBSyw4QkFBbUIsQ0FBQyxNQUFNO2dCQUM3QixPQUFPLElBQUksK0JBQW9CLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1lBQ25EO2dCQUNFLE1BQU0sSUFBSSxLQUFLLENBQUMsNEJBQTRCLElBQUksRUFBRSxDQUFDLENBQUM7UUFDeEQsQ0FBQztJQUNILENBQUM7Q0FDRjtBQWJELHNEQWFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUNvaW4gYXMgQ29pbkNvbmZpZyB9IGZyb20gJ0BiaXRnby1iZXRhL3N0YXRpY3MnO1xuaW1wb3J0IHsgQmFzZU1lc3NhZ2VCdWlsZGVyRmFjdG9yeSwgSU1lc3NhZ2VCdWlsZGVyLCBNZXNzYWdlU3RhbmRhcmRUeXBlLCBTaW1wbGVNZXNzYWdlQnVpbGRlciB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcblxuZXhwb3J0IGNsYXNzIE1lc3NhZ2VCdWlsZGVyRmFjdG9yeSBleHRlbmRzIEJhc2VNZXNzYWdlQnVpbGRlckZhY3Rvcnkge1xuICBjb25zdHJ1Y3Rvcihjb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKGNvaW5Db25maWcpO1xuICB9XG5cbiAgcHVibGljIGdldE1lc3NhZ2VCdWlsZGVyKHR5cGU6IE1lc3NhZ2VTdGFuZGFyZFR5cGUpOiBJTWVzc2FnZUJ1aWxkZXIge1xuICAgIHN3aXRjaCAodHlwZSkge1xuICAgICAgY2FzZSBNZXNzYWdlU3RhbmRhcmRUeXBlLlNJTVBMRTpcbiAgICAgICAgcmV0dXJuIG5ldyBTaW1wbGVNZXNzYWdlQnVpbGRlcih0aGlzLmNvaW5Db25maWcpO1xuICAgICAgZGVmYXVsdDpcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBJbnZhbGlkIG1lc3NhZ2Ugc3RhbmRhcmQgJHt0eXBlfWApO1xuICAgIH1cbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZUJ1aWxkZXJGYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9tZXNzYWdlcy9tZXNzYWdlQnVpbGRlckZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLHlCQUF5QixFQUFtQixtQkFBbUIsRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRTdILE1BQU0sT0FBTyxxQkFBc0IsU0FBUSx5QkFBeUI7SUFDbEUsWUFBWSxVQUFnQztRQUMxQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDcEIsQ0FBQztJQUVNLGlCQUFpQixDQUFDLElBQXlCO1FBQ2hELFFBQVEsSUFBSSxFQUFFLENBQUM7WUFDYixLQUFLLG1CQUFtQixDQUFDLE1BQU07Z0JBQzdCLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDbkQ7Z0JBQ0UsTUFBTSxJQUFJLEtBQUssQ0FBQyw0QkFBNEIsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN4RCxDQUFDO0lBQ0gsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUNvaW4gYXMgQ29pbkNvbmZpZyB9IGZyb20gJ0BiaXRnby1iZXRhL3N0YXRpY3MnO1xuaW1wb3J0IHsgQmFzZU1lc3NhZ2VCdWlsZGVyRmFjdG9yeSwgSU1lc3NhZ2VCdWlsZGVyLCBNZXNzYWdlU3RhbmRhcmRUeXBlLCBTaW1wbGVNZXNzYWdlQnVpbGRlciB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcblxuZXhwb3J0IGNsYXNzIE1lc3NhZ2VCdWlsZGVyRmFjdG9yeSBleHRlbmRzIEJhc2VNZXNzYWdlQnVpbGRlckZhY3Rvcnkge1xuICBjb25zdHJ1Y3Rvcihjb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKGNvaW5Db25maWcpO1xuICB9XG5cbiAgcHVibGljIGdldE1lc3NhZ2VCdWlsZGVyKHR5cGU6IE1lc3NhZ2VTdGFuZGFyZFR5cGUpOiBJTWVzc2FnZUJ1aWxkZXIge1xuICAgIHN3aXRjaCAodHlwZSkge1xuICAgICAgY2FzZSBNZXNzYWdlU3RhbmRhcmRUeXBlLlNJTVBMRTpcbiAgICAgICAgcmV0dXJuIG5ldyBTaW1wbGVNZXNzYWdlQnVpbGRlcih0aGlzLmNvaW5Db25maWcpO1xuICAgICAgZGVmYXVsdDpcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBJbnZhbGlkIG1lc3NhZ2Ugc3RhbmRhcmQgJHt0eXBlfWApO1xuICAgIH1cbiAgfVxufVxuIl19

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

@@ -0,0 +1,25 @@
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class RecoverNestedAtaBuilder extends TransactionBuilder {
+    protected _nestedAccountAddress: string;
+    protected _nestedMintAddress: string;
+    protected _destinationAccountAddress: string;
+    protected _ownerAccountAddress: string;
+    protected _ownerMintAddress: string;
+    protected _walletAddress: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    nestedAccountAddress(nestedAccountAddress: string): this;
+    nestedMintAddress(nestedMintAddress: string): this;
+    destinationAccountAddress(destinationAccountAddress: string): this;
+    ownerAccountAddress(ownerAccountAddress: string): this;
+    ownerMintAddress(ownerMintAddress: string): this;
+    walletAddress(walletAddress: string): this;
+    /** @inheritDoc */
+    initBuilder(tx: Transaction): void;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=recoverNestedAtaBuilder.d.ts.map

package/dist/esm/lib/recoverNestedAtaBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recoverNestedAtaBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/recoverNestedAtaBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAI7D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,uBAAwB,SAAQ,kBAAkB;IAC7D,SAAS,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACxC,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,0BAA0B,EAAE,MAAM,CAAC;IAC7C,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACvC,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACpC,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC;gBAErB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI;IAMxD,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI;IAMlD,yBAAyB,CAAC,yBAAyB,EAAE,MAAM,GAAG,IAAI;IAMlE,mBAAmB,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI;IAMtD,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAMhD,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAM1C,kBAAkB;IAClB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAelC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAwB5D"}