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

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

@@ -0,0 +1 @@
+{"version":3,"file":"jitoStakePoolOperations.d.ts","sourceRoot":"","sources":["../../../src/lib/jitoStakePoolOperations.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/jitoStakePoolOperations.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * @file Implementation of the depositSol instruction. On upgrade of
+ * '@solana/spl-token', this module may no longer be necessary.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WITHDRAW_STAKE_LAYOUT_CODE = exports.DEPOSIT_SOL_LAYOUT_CODE = void 0;
+exports.findWithdrawAuthorityProgramAddressSync = findWithdrawAuthorityProgramAddressSync;
+exports.depositSolInstructions = depositSolInstructions;
+exports.decodeDepositSol = decodeDepositSol;
+exports.withdrawStakeInstructions = withdrawStakeInstructions;
+exports.decodeWithdrawStake = decodeWithdrawStake;
+const spl_stake_pool_1 = require("@solana/spl-stake-pool");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const assert_1 = __importDefault(require("assert"));
+const constants_1 = require("./constants");
+exports.DEPOSIT_SOL_LAYOUT_CODE = 14;
+exports.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}
+ */
+function findWithdrawAuthorityProgramAddressSync(programId, stakePoolAddress) {
+    const [withdrawAuthority] = web3_js_1.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}
+ */
+function depositSolInstructions(params, stakePool, createAssociatedTokenAccount) {
+    const { stakePoolAddress, from, lamports } = params;
+    const poolMint = new web3_js_1.PublicKey(stakePool.poolMint);
+    const reserveStake = new web3_js_1.PublicKey(stakePool.reserveStake);
+    const managerFeeAccount = new web3_js_1.PublicKey(stakePool.managerFeeAccount);
+    // findWithdrawAuthorityProgramAddress
+    const withdrawAuthority = findWithdrawAuthorityProgramAddressSync(spl_stake_pool_1.STAKE_POOL_PROGRAM_ID, stakePoolAddress);
+    const associatedAddress = (0, spl_token_1.getAssociatedTokenAddressSync)(poolMint, from);
+    const instructions = [];
+    if (createAssociatedTokenAccount) {
+        instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(from, associatedAddress, from, poolMint));
+    }
+    instructions.push(spl_stake_pool_1.StakePoolInstruction.depositSol({
+        stakePool: stakePoolAddress,
+        reserveStake,
+        fundingAccount: from,
+        destinationPoolAccount: associatedAddress,
+        managerFeeAccount,
+        referralPoolAccount: associatedAddress,
+        poolMint,
+        lamports: Number(lamports),
+        withdrawAuthority,
+    }));
+    return instructions;
+}
+function parseKey(key, template) {
+    (0, assert_1.default)(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}
+ */
+function decodeDepositSol(instruction) {
+    const { programId, keys, data } = instruction;
+    (0, assert_1.default)(programId.equals(spl_stake_pool_1.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 });
+    (0, assert_1.default)(systemProgramProgramId.equals(web3_js_1.SystemProgram.programId), 'Unexpected pubkey in DepositSol instruction');
+    const tokenProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    (0, assert_1.default)(tokenProgramId.equals(spl_token_1.TOKEN_PROGRAM_ID), 'Unexpected pubkey in DepositSol instruction');
+    const depositAuthority = keys.length > 10 ? parseKey(keys[i++], { isSigner: true, isWritable: false }) : undefined;
+    (0, assert_1.default)(keys.length <= 11, 'Too many keys in DepositSol instruction');
+    const layoutCode = data.readUint8(0);
+    (0, assert_1.default)(layoutCode === exports.DEPOSIT_SOL_LAYOUT_CODE, 'Incorrect layout code in DepositSol data');
+    (0, assert_1.default)(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[]}
+ */
+function withdrawStakeInstructions(params, stakePool) {
+    const { tokenOwner, stakePoolAddress, destinationStakeAccount, validatorAddress, transferAuthority, poolAmount: poolAmountString, } = params;
+    const poolMint = new web3_js_1.PublicKey(stakePool.poolMint);
+    const validatorList = new web3_js_1.PublicKey(stakePool.validatorListAccount);
+    const managerFeeAccount = new web3_js_1.PublicKey(stakePool.managerFeeAccount);
+    const poolTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(poolMint, tokenOwner);
+    const withdrawAuthority = findWithdrawAuthorityProgramAddressSync(spl_stake_pool_1.STAKE_POOL_PROGRAM_ID, stakePoolAddress);
+    const poolAmount = BigInt(poolAmountString);
+    return [
+        (0, spl_token_1.createApproveInstruction)(poolTokenAccount, transferAuthority, tokenOwner, poolAmount),
+        web3_js_1.SystemProgram.createAccount({
+            fromPubkey: tokenOwner,
+            newAccountPubkey: destinationStakeAccount,
+            lamports: constants_1.STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT,
+            space: web3_js_1.StakeProgram.space,
+            programId: web3_js_1.StakeProgram.programId,
+        }),
+        spl_stake_pool_1.StakePoolInstruction.withdrawStake({
+            stakePool: stakePoolAddress,
+            validatorList: validatorList,
+            validatorStake: validatorAddress,
+            destinationStake: destinationStakeAccount,
+            destinationStakeAuthority: tokenOwner,
+            sourceTransferAuthority: transferAuthority,
+            sourcePoolAccount: poolTokenAccount,
+            managerFeeAccount: managerFeeAccount,
+            poolMint: poolMint,
+            poolTokens: Number(poolAmount),
+            withdrawAuthority,
+        }),
+        ...web3_js_1.StakeProgram.deactivate({
+            stakePubkey: destinationStakeAccount,
+            authorizedPubkey: tokenOwner,
+        }).instructions,
+    ];
+}
+/**
+ * Construct Solana withdrawStake stake pool parameters from instruction.
+ *
+ * @param {TransactionInstruction} instruction
+ * @returns {DepositSolParams}
+ */
+function decodeWithdrawStake(instruction) {
+    const { programId, keys, data } = instruction;
+    (0, assert_1.default)(programId.equals(spl_stake_pool_1.STAKE_POOL_PROGRAM_ID), 'Invalid WithdrawStake instruction, program ID must be the Stake Pool Program');
+    const layoutCode = data.readUint8(0);
+    (0, assert_1.default)(layoutCode === exports.WITHDRAW_STAKE_LAYOUT_CODE, 'Incorrect layout code in WithdrawStake data');
+    (0, assert_1.default)(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 });
+    (0, assert_1.default)(sysvarClockPubkey.equals(web3_js_1.SYSVAR_CLOCK_PUBKEY), 'Unexpected pubkey in WithdrawStake instruction');
+    const tokenProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    (0, assert_1.default)(tokenProgramId.equals(spl_token_1.TOKEN_PROGRAM_ID), 'Unexpected pubkey in WithdrawStake instruction');
+    const stakeProgramProgramId = parseKey(keys[i++], { isSigner: false, isWritable: false });
+    (0, assert_1.default)(stakeProgramProgramId.equals(web3_js_1.StakeProgram.programId), 'Unexpected pubkey in WithdrawStake instruction');
+    (0, assert_1.default)(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":";AAAA;;;GAGG;;;;;;AAuFH,0FAMC;AAkBD,wDAmCC;AAgBD,4CAyCC;AAoBD,8DAiDC;AAQD,kDA6CC;AAnUD,2DAKgC;AAChC,iDAK2B;AAC3B,6CAOyB;AACzB,oDAA4B;AAC5B,2CAA+D;AAsDlD,QAAA,uBAAuB,GAAG,EAAE,CAAC;AAC7B,QAAA,0BAA0B,GAAG,EAAE,CAAC;AAE7C;;;;;;GAMG;AACH,SAAgB,uCAAuC,CAAC,SAAoB,EAAE,gBAA2B;IACvG,MAAM,CAAC,iBAAiB,CAAC,GAAG,mBAAS,CAAC,sBAAsB,CAC1D,CAAC,gBAAgB,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,EACtD,SAAS,CACV,CAAC;IACF,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAUD;;;;;;;GAOG;AACH,SAAgB,sBAAsB,CACpC,MAAoC,EACpC,SAAkC,EAClC,4BAAqC;IAErC,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;IACpD,MAAM,QAAQ,GAAG,IAAI,mBAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACnD,MAAM,YAAY,GAAG,IAAI,mBAAS,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;IAC3D,MAAM,iBAAiB,GAAG,IAAI,mBAAS,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAErE,sCAAsC;IACtC,MAAM,iBAAiB,GAAG,uCAAuC,CAAC,sCAAqB,EAAE,gBAAgB,CAAC,CAAC;IAC3G,MAAM,iBAAiB,GAAG,IAAA,yCAA6B,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAExE,MAAM,YAAY,GAA6B,EAAE,CAAC;IAElD,IAAI,4BAA4B,EAAE,CAAC;QACjC,YAAY,CAAC,IAAI,CAAC,IAAA,mDAAuC,EAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IACtG,CAAC;IAED,YAAY,CAAC,IAAI,CACf,qCAAoB,CAAC,UAAU,CAAC;QAC9B,SAAS,EAAE,gBAAgB;QAC3B,YAAY;QACZ,cAAc,EAAE,IAAI;QACpB,sBAAsB,EAAE,iBAAiB;QACzC,iBAAiB;QACjB,mBAAmB,EAAE,iBAAiB;QACtC,QAAQ;QACR,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;QAC1B,iBAAiB;KAClB,CAAC,CACH,CAAC;IAEF,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,SAAS,QAAQ,CAAC,GAAgB,EAAE,QAAoD;IACtF,IAAA,gBAAM,EACJ,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC,QAAQ,IAAI,GAAG,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU,EAC5E,uDAAuD,GAAG,CAAC,QAAQ,iBAAiB,GAAG,CAAC,UAAU,IAAI,CACvG,CAAC;IACF,OAAO,GAAG,CAAC,MAAM,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,WAAmC;IAClE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,WAAW,CAAC;IAE9C,IAAA,gBAAM,EACJ,SAAS,CAAC,MAAM,CAAC,sCAAqB,CAAC,EACvC,2EAA2E,CAC5E,CAAC;IAEF,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7E,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACtF,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAChF,MAAM,cAAc,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IACjF,MAAM,sBAAsB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1F,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IACrF,MAAM,mBAAmB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IACvF,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5E,MAAM,sBAAsB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3F,IAAA,gBAAM,EAAC,sBAAsB,CAAC,MAAM,CAAC,uBAAa,CAAC,SAAS,CAAC,EAAE,6CAA6C,CAAC,CAAC;IAC9G,MAAM,cAAc,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACnF,IAAA,gBAAM,EAAC,cAAc,CAAC,MAAM,CAAC,4BAAgB,CAAC,EAAE,6CAA6C,CAAC,CAAC;IAC/F,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACnH,IAAA,gBAAM,EAAC,IAAI,CAAC,MAAM,IAAI,EAAE,EAAE,yCAAyC,CAAC,CAAC;IAErE,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACrC,IAAA,gBAAM,EAAC,UAAU,KAAK,+BAAuB,EAAE,0CAA0C,CAAC,CAAC;IAC3F,IAAA,gBAAM,EAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,2CAA2C,CAAC,CAAC;IACvE,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAExC,OAAO;QACL,SAAS;QACT,gBAAgB;QAChB,iBAAiB;QACjB,YAAY;QACZ,cAAc;QACd,sBAAsB;QACtB,iBAAiB;QACjB,mBAAmB;QACnB,QAAQ;QACR,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;KAC3B,CAAC;AACJ,CAAC;AAaD;;;;;;GAMG;AACH,SAAgB,yBAAyB,CACvC,MAAuC,EACvC,SAAqC;IAErC,MAAM,EACJ,UAAU,EACV,gBAAgB,EAChB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EAAE,gBAAgB,GAC7B,GAAG,MAAM,CAAC;IAEX,MAAM,QAAQ,GAAG,IAAI,mBAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACnD,MAAM,aAAa,GAAG,IAAI,mBAAS,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;IACpE,MAAM,iBAAiB,GAAG,IAAI,mBAAS,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IAErE,MAAM,gBAAgB,GAAG,IAAA,yCAA6B,EAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IAC7E,MAAM,iBAAiB,GAAG,uCAAuC,CAAC,sCAAqB,EAAE,gBAAgB,CAAC,CAAC;IAE3G,MAAM,UAAU,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;IAE5C,OAAO;QACL,IAAA,oCAAwB,EAAC,gBAAgB,EAAE,iBAAiB,EAAE,UAAU,EAAE,UAAU,CAAC;QACrF,uBAAa,CAAC,aAAa,CAAC;YAC1B,UAAU,EAAE,UAAU;YACtB,gBAAgB,EAAE,uBAAuB;YACzC,QAAQ,EAAE,4CAAgC;YAC1C,KAAK,EAAE,sBAAY,CAAC,KAAK;YACzB,SAAS,EAAE,sBAAY,CAAC,SAAS;SAClC,CAAC;QACF,qCAAoB,CAAC,aAAa,CAAC;YACjC,SAAS,EAAE,gBAAgB;YAC3B,aAAa,EAAE,aAAa;YAC5B,cAAc,EAAE,gBAAgB;YAChC,gBAAgB,EAAE,uBAAuB;YACzC,yBAAyB,EAAE,UAAU;YACrC,uBAAuB,EAAE,iBAAiB;YAC1C,iBAAiB,EAAE,gBAAgB;YACnC,iBAAiB,EAAE,iBAAiB;YACpC,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;YAC9B,iBAAiB;SAClB,CAAC;QACF,GAAG,sBAAY,CAAC,UAAU,CAAC;YACzB,WAAW,EAAE,uBAAuB;YACpC,gBAAgB,EAAE,UAAU;SAC7B,CAAC,CAAC,YAAY;KAChB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,WAAmC;IACrE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,WAAW,CAAC;IAE9C,IAAA,gBAAM,EACJ,SAAS,CAAC,MAAM,CAAC,sCAAqB,CAAC,EACvC,8EAA8E,CAC/E,CAAC;IAEF,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACrC,IAAA,gBAAM,EAAC,UAAU,KAAK,kCAA0B,EAAE,6CAA6C,CAAC,CAAC;IACjG,IAAA,gBAAM,EAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,8CAA8C,CAAC,CAAC;IAC1E,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAE1C,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7E,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IACjF,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACtF,MAAM,cAAc,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAClF,MAAM,gBAAgB,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,yBAAyB,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;IACnD,MAAM,uBAAuB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3F,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IACrF,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IACrF,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5E,MAAM,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACtF,IAAA,gBAAM,EAAC,iBAAiB,CAAC,MAAM,CAAC,6BAAmB,CAAC,EAAE,gDAAgD,CAAC,CAAC;IACxG,MAAM,cAAc,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IACnF,IAAA,gBAAM,EAAC,cAAc,CAAC,MAAM,CAAC,4BAAgB,CAAC,EAAE,gDAAgD,CAAC,CAAC;IAClG,MAAM,qBAAqB,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;IAC1F,IAAA,gBAAM,EAAC,qBAAqB,CAAC,MAAM,CAAC,sBAAY,CAAC,SAAS,CAAC,EAAE,gDAAgD,CAAC,CAAC;IAC/G,IAAA,gBAAM,EAAC,CAAC,KAAK,IAAI,CAAC,MAAM,EAAE,4CAA4C,CAAC,CAAC;IAExE,OAAO;QACL,SAAS;QACT,aAAa;QACb,iBAAiB;QACjB,cAAc;QACd,gBAAgB;QAChB,yBAAyB;QACzB,uBAAuB;QACvB,iBAAiB;QACjB,iBAAiB;QACjB,QAAQ;QACR,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC;KAC/B,CAAC;AACJ,CAAC","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  createAssociatedTokenAccountInstruction,\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(createAssociatedTokenAccountInstruction(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/src/lib/solInstructionFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solInstructionFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/solInstructionFactory.ts"],"names":[],"mappings":"AAOA,OAAO,EAQL,sBAAsB,EAEvB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAGL,iBAAiB,EAYlB,MAAM,SAAS,CAAC;AAGjB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,kBAAkB,EAAE,iBAAiB,GAAG,sBAAsB,EAAE,CA+BrG"}
+{"version":3,"file":"solInstructionFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/solInstructionFactory.ts"],"names":[],"mappings":"AAWA,OAAO,EASL,sBAAsB,EAEvB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAGL,iBAAiB,EAgBlB,MAAM,SAAS,CAAC;AAKjB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,kBAAkB,EAAE,iBAAiB,GAAG,sBAAsB,EAAE,CAuCrG"}