@glamsystems/glam-sdk 0.1.34 → 0.1.36

package/index.cjs.js

@@ -14783,12 +14783,13 @@ class StateModel extends StateIdlModel {
                 // @ts-ignore
                 const value = Object.values(param.value)[0].val;
                 // Ledger is a mint param but we store it on the state model
-                if (Object.keys(stateAccount.accountType)[0] === "fund") {
-                    if (name === "ledger") {
-                        stateModel["ledger"] = value;
-                    }
+                if (name === "ledger") {
+                    stateModel["ledger"] = value;
+                } else if (name === "redemptionNotifyAndSettle") {
+                    mintIdlModel["notifyAndSettle"] = value;
+                } else {
+                    mintIdlModel[name] = value;
                 }
-                mintIdlModel[name] = value;
             });
             if (openfundsMetadataAccount) {
                 const mintOpenfundsFields = {};
@@ -15028,6 +15029,82 @@ var ClusterNetwork = /*#__PURE__*/ function(ClusterNetwork) {
     return ClusterNetwork;
 }({});
 
+// Example response from Helius:
+// {
+//   "jsonrpc": "2.0",
+//   "id": "1",
+//   "result": {
+//     "accounts": [
+//       {
+//         "pubkey": "CxELquR1gPP8wHe33gZ4QxqGB3sZ9RSwsJ2KshVewkFY",
+//         "account": {
+//           "lamports": 15298080,
+//           "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+//           "data": [
+//             "2R9jLfiAQ9bgdcw6h8s44439",
+//             "base64"
+//           ],
+//           "executable": false,
+//           "rentEpoch": 28,
+//           "space": 165
+//         }
+//       }
+//     ],
+//     "paginationKey": "8WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
+//     "totalResults": 25000
+//   }
+// }
+async function getProgramAccountsV2(programId, limit = 100, filters) {
+    const heliusApiKey = process.env.NEXT_PUBLIC_HELIUS_API_KEY || process.env.HELIUS_API_KEY;
+    let allAccounts = [];
+    let paginationKey = null;
+    let encoding = "base64";
+    do {
+        const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${heliusApiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: "1",
+                method: "getProgramAccountsV2",
+                params: [
+                    programId.toBase58(),
+                    {
+                        encoding,
+                        filters,
+                        limit,
+                        ...paginationKey && {
+                            paginationKey
+                        }
+                    }
+                ]
+            })
+        });
+        const data = await response.json();
+        data.result.accounts.forEach(({ pubkey, account })=>{
+            const [acountData, encoding] = account.data;
+            let decodedData;
+            if (encoding === "base64") {
+                decodedData = Buffer.from(acountData, "base64");
+            }
+            if (!decodedData) {
+                throw new Error("Failed to decode base64 account data");
+            }
+            allAccounts.push({
+                pubkey: new web3_js.PublicKey(pubkey),
+                account: {
+                    ...account,
+                    owner: new web3_js.PublicKey(account.owner),
+                    data: decodedData
+                }
+            });
+        });
+        paginationKey = data.result.paginationKey;
+    }while (paginationKey)
+    return allAccounts;
+}
 /**
  * Fetches all the token accounts owned by the specified pubkey.
  */ async function getTokenAccountsByOwner(connection, owner) {
@@ -19428,7 +19505,8 @@ class StakingClient {
         const { programId: stakePoolProgram, poolMint, withdrawAuthority, feeAccount, tokenProgramId: tokenProgram, validatorList, reserveStake } = await this.getStakePoolAccountData(stakePool);
         const poolTokensFrom = this.base.getVaultAta(poolMint, tokenProgram);
         // The reserve stake account should NOT be used for withdrawals unless we have no other options.
-        const validatorStakeCandidates = (await getStakeAccountsWithStates(this.base.provider.connection, withdrawAuthority)).filter((s)=>!s.address.equals(reserveStake));
+        // And only active validator stake accounts should be used.
+        const validatorStakeCandidates = (await getStakeAccountsWithStates(this.base.provider.connection, withdrawAuthority)).filter((s)=>!s.address.equals(reserveStake) && s.state === "active");
         const validatorStakeAccount = validatorStakeCandidates.length === 0 ? reserveStake : validatorStakeCandidates[0].address;
         const [stakeAccount, createStakeAccountIx] = await this.createStakeAccount(glamSigner);
         const postInstructions = deactivate ? [
@@ -19857,7 +19935,6 @@ class MintClient {
         });
     }
     async update(mintModel, txOptions = {}) {
-        // @ts-ignore
         const tx = await this.base.program.methods.updateMint(0, new MintIdlModel(mintModel)).accounts({
             glamState: this.base.statePda,
             glamMint: this.base.mintPda
@@ -19881,6 +19958,19 @@ class MintClient {
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
+    async setPermissionlessFulfill(enabled, txOptions = {}) {
+        const stateModel = await this.base.fetchStateModel();
+        const notifyAndSettle = stateModel.mints?.[0]?.notifyAndSettle;
+        if (!notifyAndSettle) {
+            throw new Error("Mint does not have notifyAndSettle configured.");
+        }
+        return await this.update({
+            notifyAndSettle: {
+                ...notifyAndSettle,
+                permissionlessFulfillment: enabled
+            }
+        }, txOptions);
+    }
     async closeMintIx() {
         return await this.base.program.methods.closeMint(0).accounts({
             glamState: this.base.statePda,
@@ -21090,26 +21180,39 @@ class KaminoLendingClient {
     }
 }
 class KaminoFarmClient {
-    async findAndParseFarmStates(owner) {
-        const accounts = await this.base.provider.connection.getProgramAccounts(KAMINO_FARM_PROGRAM, {
-            filters: [
-                {
-                    dataSize: 920
-                },
-                {
-                    memcmp: {
-                        offset: 48,
-                        bytes: owner.toBase58()
-                    }
+    async findAndParseUserStates(owner) {
+        const accounts = await getProgramAccountsV2(KAMINO_FARM_PROGRAM, 10, [
+            {
+                dataSize: 920
+            },
+            {
+                memcmp: {
+                    offset: 48,
+                    bytes: owner.toBase58()
                 }
-            ]
-        });
-        return accounts.map((account)=>{
-            const data = account.account.data;
-            const farmState = new web3_js.PublicKey(data.subarray(16, 48));
+            }
+        ]);
+        return accounts.map(({ pubkey, account })=>{
+            // farmState: [16, 48]
+            // owner: [48, 80]
+            // isFarmDelegated + padding: [80, 88]
+            // rewardsTallyScaled: [88, 248]
+            // unclaimedRewards[0..10]: [248, 328]
+            const farmState = new web3_js.PublicKey(account.data.subarray(16, 48));
+            const rewardsOffset = 248;
+            const numRewards = 10;
+            const rewardSize = 8;
+            const rewardsData = account.data.subarray(rewardsOffset, rewardsOffset + numRewards * rewardSize);
+            const unclaimedRewards = Array.from({
+                length: numRewards
+            }, (_, i)=>{
+                const rewardData = rewardsData.subarray(i * rewardSize, (i + 1) * rewardSize);
+                return new anchor.BN(rewardData, "le");
+            });
             return {
-                userFarmState: account.pubkey,
-                farmState
+                userState: pubkey,
+                farmState,
+                unclaimedRewards
             };
         });
     }
@@ -21169,20 +21272,23 @@ class KaminoFarmClient {
     }
     async harvestTx(txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.vaultPda;
-        const farmStates = await this.findAndParseFarmStates(vault);
+        const farmStates = await this.findAndParseUserStates(this.base.vaultPda);
         const parsedFarms = await this.fetchAndParseFarms(farmStates.map((f)=>f.farmState));
         const tx = new web3_js.Transaction();
-        for (const { userFarmState, farmState } of farmStates){
+        console.log("Building transaction to harvest the following rewards:");
+        for (const { userState, farmState, unclaimedRewards } of farmStates){
             const { globalConfig, rewards } = parsedFarms.get(farmState.toBase58());
             for (const { index, mint, tokenProgram, rewardsVault } of rewards){
-                console.log("Reward token:", mint.toBase58());
+                if (unclaimedRewards[index].eq(new anchor.BN(0))) {
+                    continue;
+                }
+                console.log(`userState: ${userState}, farmState: ${farmState}, unclaimedReward: ${unclaimedRewards[index]}, token: ${mint}`);
                 const vaultAta = this.base.getVaultAta(mint, tokenProgram);
-                const createAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultAta, vault, mint, tokenProgram);
+                const createAtaIx = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultAta, this.base.vaultPda, mint, tokenProgram);
                 const harvestIx = await this.base.program.methods.kaminoFarmHarvestReward(new anchor.BN(index)).accounts({
                     glamState: this.base.statePda,
                     glamSigner,
-                    userState: userFarmState,
+                    userState,
                     farmState,
                     globalConfig,
                     rewardMint: mint,
@@ -21196,6 +21302,9 @@ class KaminoFarmClient {
                 tx.add(createAtaIx, harvestIx);
             }
         }
+        if (tx.instructions.length === 0) {
+            throw new Error("No rewards to harvest");
+        }
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
     }
@@ -21605,14 +21714,43 @@ class MeteoraDlmmClient {
 }
 
 class InvestClient {
-    async subscribe(asset, amount, mintId = 0, queued = false, txOptions = {}) {
+    /**
+   * Subscribe to a tokenized vault
+   *
+   * @param asset Deposit asset
+   * @param amount
+   * @param mintId
+   * @param queued by default false, set to true to subscribe in queued mode
+   * @param txOptions
+   * @returns
+   */ async subscribe(asset, amount, mintId = 0, queued = false, txOptions = {}) {
         const tx = await (queued ? this.queuedSubscribeTx(asset, amount, mintId, txOptions) : this.subscribeTx(asset, amount, mintId, txOptions));
         return await this.base.sendAndConfirm(tx);
     }
-    async queuedRedeem(amount, mintId = 0, txOptions = {}) {
+    /**
+   * Request to redeem share tokens of a tokenized vault in queued mode
+   *
+   * @param amount
+   * @param mintId
+   * @param txOptions
+   * @returns
+   */ async queuedRedeem(amount, mintId = 0, txOptions = {}) {
         const tx = await this.queuedRedeemTx(amount, mintId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
+    /**
+   * Redeem share tokens of a tokenized vault instantly. Preconditions:
+   * 1. The vault must allow permissionless fulfillment
+   * 2. The vault must have sufficient liquidity
+   *
+   * @param amount
+   * @param mintId
+   * @param txOptions
+   * @returns
+   */ async instantRedeem(amount, mintId = 0, txOptions = {}) {
+        const tx = await this.instantRedeemTx(amount, mintId, txOptions);
+        return await this.base.sendAndConfirm(tx);
+    }
     async fulfill(mintId = 0, txOptions = {}) {
         const tx = await this.fulfillTx(mintId, txOptions);
         return await this.base.sendAndConfirm(tx);
@@ -21660,7 +21798,6 @@ class InvestClient {
             signerPolicy = getAccountPolicyPda(this.base.getMintAta(signer));
             console.log(`signerPolicy: ${signerPolicy} for signer ${signer} and token account ${mintTo}`);
         }
-        // @ts-ignore
         const tx = await this.base.program.methods.subscribe(0, amount).accounts({
             glamState: this.base.statePda,
             glamMint,
@@ -21702,6 +21839,58 @@ class InvestClient {
         }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
+    async instantRedeemTx(amount, mintId = 0, txOptions = {}) {
+        if (mintId !== 0) {
+            throw new Error("mintId must be 0");
+        }
+        // Instant redemption flow is realized by enqueueing a redemption, fulfilling it, and then claiming the tokens in a single transaction.
+        const preInstructions = txOptions.preInstructions || [];
+        const signer = txOptions.signer || this.base.getSigner();
+        const glamMint = this.base.mintPda;
+        const stateModel = await this.base.fetchStateModel();
+        const baseAsset = stateModel.baseAsset;
+        const signerAta = this.base.getAta(baseAsset, signer);
+        const fulfillIx = await this.base.program.methods.fulfill(mintId).accounts({
+            glamState: this.base.statePda,
+            glamMint,
+            signer,
+            asset: baseAsset,
+            depositTokenProgram: splToken.TOKEN_PROGRAM_ID
+        }).instruction();
+        preInstructions.push(splToken.createAssociatedTokenAccountIdempotentInstruction(signer, signerAta, signer, baseAsset));
+        const claimIx = await this.base.program.methods.claim(0).accounts({
+            glamState: this.base.statePda,
+            signer,
+            tokenMint: baseAsset,
+            claimTokenProgram: splToken.TOKEN_PROGRAM_ID
+        }).instruction();
+        const remainingAccounts = [];
+        if (await this.base.isLockupEnabled()) {
+            const extraMetasAccount = this.base.extraMetasPda;
+            const signerPolicy = getAccountPolicyPda(this.base.getMintAta(signer));
+            const escrow = this.base.escrowPda;
+            const escrowPolicy = getAccountPolicyPda(this.base.getMintAta(escrow));
+            remainingAccounts.push(...[
+                extraMetasAccount,
+                signerPolicy,
+                escrowPolicy,
+                TRANSFER_HOOK_PROGRAM
+            ]);
+        }
+        const tx = await this.base.program.methods.queuedRedeem(0, amount).accounts({
+            glamState: this.base.statePda,
+            glamMint,
+            signer
+        }).remainingAccounts(remainingAccounts.map((pubkey)=>({
+                pubkey,
+                isSigner: false,
+                isWritable: false
+            }))).preInstructions(preInstructions).postInstructions([
+            fulfillIx,
+            claimIx
+        ]).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
     async queuedRedeemTx(amount, mintId = 0, txOptions = {}) {
         if (mintId !== 0) {
             throw new Error("mintId must be 0");
@@ -22649,6 +22838,7 @@ exports.getMintPda = getMintPda;
 exports.getOpenfundsPda = getOpenfundsPda;
 exports.getOrderParams = getOrderParams;
 exports.getPriorityFeeEstimate = getPriorityFeeEstimate;
+exports.getProgramAccountsV2 = getProgramAccountsV2;
 exports.getSimulationResult = getSimulationResult;
 exports.getSolAndTokenBalances = getSolAndTokenBalances;
 exports.getStakeAccountsWithStates = getStakeAccountsWithStates;

package/index.esm.js

@@ -14763,12 +14763,13 @@ class StateModel extends StateIdlModel {
                 // @ts-ignore
                 const value = Object.values(param.value)[0].val;
                 // Ledger is a mint param but we store it on the state model
-                if (Object.keys(stateAccount.accountType)[0] === "fund") {
-                    if (name === "ledger") {
-                        stateModel["ledger"] = value;
-                    }
+                if (name === "ledger") {
+                    stateModel["ledger"] = value;
+                } else if (name === "redemptionNotifyAndSettle") {
+                    mintIdlModel["notifyAndSettle"] = value;
+                } else {
+                    mintIdlModel[name] = value;
                 }
-                mintIdlModel[name] = value;
             });
             if (openfundsMetadataAccount) {
                 const mintOpenfundsFields = {};
@@ -15008,6 +15009,82 @@ var ClusterNetwork = /*#__PURE__*/ function(ClusterNetwork) {
     return ClusterNetwork;
 }({});
 
+// Example response from Helius:
+// {
+//   "jsonrpc": "2.0",
+//   "id": "1",
+//   "result": {
+//     "accounts": [
+//       {
+//         "pubkey": "CxELquR1gPP8wHe33gZ4QxqGB3sZ9RSwsJ2KshVewkFY",
+//         "account": {
+//           "lamports": 15298080,
+//           "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+//           "data": [
+//             "2R9jLfiAQ9bgdcw6h8s44439",
+//             "base64"
+//           ],
+//           "executable": false,
+//           "rentEpoch": 28,
+//           "space": 165
+//         }
+//       }
+//     ],
+//     "paginationKey": "8WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
+//     "totalResults": 25000
+//   }
+// }
+async function getProgramAccountsV2(programId, limit = 100, filters) {
+    const heliusApiKey = process.env.NEXT_PUBLIC_HELIUS_API_KEY || process.env.HELIUS_API_KEY;
+    let allAccounts = [];
+    let paginationKey = null;
+    let encoding = "base64";
+    do {
+        const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${heliusApiKey}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: "1",
+                method: "getProgramAccountsV2",
+                params: [
+                    programId.toBase58(),
+                    {
+                        encoding,
+                        filters,
+                        limit,
+                        ...paginationKey && {
+                            paginationKey
+                        }
+                    }
+                ]
+            })
+        });
+        const data = await response.json();
+        data.result.accounts.forEach(({ pubkey, account })=>{
+            const [acountData, encoding] = account.data;
+            let decodedData;
+            if (encoding === "base64") {
+                decodedData = Buffer.from(acountData, "base64");
+            }
+            if (!decodedData) {
+                throw new Error("Failed to decode base64 account data");
+            }
+            allAccounts.push({
+                pubkey: new PublicKey(pubkey),
+                account: {
+                    ...account,
+                    owner: new PublicKey(account.owner),
+                    data: decodedData
+                }
+            });
+        });
+        paginationKey = data.result.paginationKey;
+    }while (paginationKey)
+    return allAccounts;
+}
 /**
  * Fetches all the token accounts owned by the specified pubkey.
  */ async function getTokenAccountsByOwner(connection, owner) {
@@ -19408,7 +19485,8 @@ class StakingClient {
         const { programId: stakePoolProgram, poolMint, withdrawAuthority, feeAccount, tokenProgramId: tokenProgram, validatorList, reserveStake } = await this.getStakePoolAccountData(stakePool);
         const poolTokensFrom = this.base.getVaultAta(poolMint, tokenProgram);
         // The reserve stake account should NOT be used for withdrawals unless we have no other options.
-        const validatorStakeCandidates = (await getStakeAccountsWithStates(this.base.provider.connection, withdrawAuthority)).filter((s)=>!s.address.equals(reserveStake));
+        // And only active validator stake accounts should be used.
+        const validatorStakeCandidates = (await getStakeAccountsWithStates(this.base.provider.connection, withdrawAuthority)).filter((s)=>!s.address.equals(reserveStake) && s.state === "active");
         const validatorStakeAccount = validatorStakeCandidates.length === 0 ? reserveStake : validatorStakeCandidates[0].address;
         const [stakeAccount, createStakeAccountIx] = await this.createStakeAccount(glamSigner);
         const postInstructions = deactivate ? [
@@ -19837,7 +19915,6 @@ class MintClient {
         });
     }
     async update(mintModel, txOptions = {}) {
-        // @ts-ignore
         const tx = await this.base.program.methods.updateMint(0, new MintIdlModel(mintModel)).accounts({
             glamState: this.base.statePda,
             glamMint: this.base.mintPda
@@ -19861,6 +19938,19 @@ class MintClient {
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
+    async setPermissionlessFulfill(enabled, txOptions = {}) {
+        const stateModel = await this.base.fetchStateModel();
+        const notifyAndSettle = stateModel.mints?.[0]?.notifyAndSettle;
+        if (!notifyAndSettle) {
+            throw new Error("Mint does not have notifyAndSettle configured.");
+        }
+        return await this.update({
+            notifyAndSettle: {
+                ...notifyAndSettle,
+                permissionlessFulfillment: enabled
+            }
+        }, txOptions);
+    }
     async closeMintIx() {
         return await this.base.program.methods.closeMint(0).accounts({
             glamState: this.base.statePda,
@@ -21070,26 +21160,39 @@ class KaminoLendingClient {
     }
 }
 class KaminoFarmClient {
-    async findAndParseFarmStates(owner) {
-        const accounts = await this.base.provider.connection.getProgramAccounts(KAMINO_FARM_PROGRAM, {
-            filters: [
-                {
-                    dataSize: 920
-                },
-                {
-                    memcmp: {
-                        offset: 48,
-                        bytes: owner.toBase58()
-                    }
+    async findAndParseUserStates(owner) {
+        const accounts = await getProgramAccountsV2(KAMINO_FARM_PROGRAM, 10, [
+            {
+                dataSize: 920
+            },
+            {
+                memcmp: {
+                    offset: 48,
+                    bytes: owner.toBase58()
                 }
-            ]
-        });
-        return accounts.map((account)=>{
-            const data = account.account.data;
-            const farmState = new PublicKey(data.subarray(16, 48));
+            }
+        ]);
+        return accounts.map(({ pubkey, account })=>{
+            // farmState: [16, 48]
+            // owner: [48, 80]
+            // isFarmDelegated + padding: [80, 88]
+            // rewardsTallyScaled: [88, 248]
+            // unclaimedRewards[0..10]: [248, 328]
+            const farmState = new PublicKey(account.data.subarray(16, 48));
+            const rewardsOffset = 248;
+            const numRewards = 10;
+            const rewardSize = 8;
+            const rewardsData = account.data.subarray(rewardsOffset, rewardsOffset + numRewards * rewardSize);
+            const unclaimedRewards = Array.from({
+                length: numRewards
+            }, (_, i)=>{
+                const rewardData = rewardsData.subarray(i * rewardSize, (i + 1) * rewardSize);
+                return new BN(rewardData, "le");
+            });
             return {
-                userFarmState: account.pubkey,
-                farmState
+                userState: pubkey,
+                farmState,
+                unclaimedRewards
             };
         });
     }
@@ -21149,20 +21252,23 @@ class KaminoFarmClient {
     }
     async harvestTx(txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
-        const vault = this.base.vaultPda;
-        const farmStates = await this.findAndParseFarmStates(vault);
+        const farmStates = await this.findAndParseUserStates(this.base.vaultPda);
         const parsedFarms = await this.fetchAndParseFarms(farmStates.map((f)=>f.farmState));
         const tx = new Transaction();
-        for (const { userFarmState, farmState } of farmStates){
+        console.log("Building transaction to harvest the following rewards:");
+        for (const { userState, farmState, unclaimedRewards } of farmStates){
             const { globalConfig, rewards } = parsedFarms.get(farmState.toBase58());
             for (const { index, mint, tokenProgram, rewardsVault } of rewards){
-                console.log("Reward token:", mint.toBase58());
+                if (unclaimedRewards[index].eq(new BN(0))) {
+                    continue;
+                }
+                console.log(`userState: ${userState}, farmState: ${farmState}, unclaimedReward: ${unclaimedRewards[index]}, token: ${mint}`);
                 const vaultAta = this.base.getVaultAta(mint, tokenProgram);
-                const createAtaIx = createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultAta, vault, mint, tokenProgram);
+                const createAtaIx = createAssociatedTokenAccountIdempotentInstruction(glamSigner, vaultAta, this.base.vaultPda, mint, tokenProgram);
                 const harvestIx = await this.base.program.methods.kaminoFarmHarvestReward(new BN(index)).accounts({
                     glamState: this.base.statePda,
                     glamSigner,
-                    userState: userFarmState,
+                    userState,
                     farmState,
                     globalConfig,
                     rewardMint: mint,
@@ -21176,6 +21282,9 @@ class KaminoFarmClient {
                 tx.add(createAtaIx, harvestIx);
             }
         }
+        if (tx.instructions.length === 0) {
+            throw new Error("No rewards to harvest");
+        }
         const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
         return vTx;
     }
@@ -21585,14 +21694,43 @@ class MeteoraDlmmClient {
 }
 
 class InvestClient {
-    async subscribe(asset, amount, mintId = 0, queued = false, txOptions = {}) {
+    /**
+   * Subscribe to a tokenized vault
+   *
+   * @param asset Deposit asset
+   * @param amount
+   * @param mintId
+   * @param queued by default false, set to true to subscribe in queued mode
+   * @param txOptions
+   * @returns
+   */ async subscribe(asset, amount, mintId = 0, queued = false, txOptions = {}) {
         const tx = await (queued ? this.queuedSubscribeTx(asset, amount, mintId, txOptions) : this.subscribeTx(asset, amount, mintId, txOptions));
         return await this.base.sendAndConfirm(tx);
     }
-    async queuedRedeem(amount, mintId = 0, txOptions = {}) {
+    /**
+   * Request to redeem share tokens of a tokenized vault in queued mode
+   *
+   * @param amount
+   * @param mintId
+   * @param txOptions
+   * @returns
+   */ async queuedRedeem(amount, mintId = 0, txOptions = {}) {
         const tx = await this.queuedRedeemTx(amount, mintId, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
+    /**
+   * Redeem share tokens of a tokenized vault instantly. Preconditions:
+   * 1. The vault must allow permissionless fulfillment
+   * 2. The vault must have sufficient liquidity
+   *
+   * @param amount
+   * @param mintId
+   * @param txOptions
+   * @returns
+   */ async instantRedeem(amount, mintId = 0, txOptions = {}) {
+        const tx = await this.instantRedeemTx(amount, mintId, txOptions);
+        return await this.base.sendAndConfirm(tx);
+    }
     async fulfill(mintId = 0, txOptions = {}) {
         const tx = await this.fulfillTx(mintId, txOptions);
         return await this.base.sendAndConfirm(tx);
@@ -21640,7 +21778,6 @@ class InvestClient {
             signerPolicy = getAccountPolicyPda(this.base.getMintAta(signer));
             console.log(`signerPolicy: ${signerPolicy} for signer ${signer} and token account ${mintTo}`);
         }
-        // @ts-ignore
         const tx = await this.base.program.methods.subscribe(0, amount).accounts({
             glamState: this.base.statePda,
             glamMint,
@@ -21682,6 +21819,58 @@ class InvestClient {
         }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
+    async instantRedeemTx(amount, mintId = 0, txOptions = {}) {
+        if (mintId !== 0) {
+            throw new Error("mintId must be 0");
+        }
+        // Instant redemption flow is realized by enqueueing a redemption, fulfilling it, and then claiming the tokens in a single transaction.
+        const preInstructions = txOptions.preInstructions || [];
+        const signer = txOptions.signer || this.base.getSigner();
+        const glamMint = this.base.mintPda;
+        const stateModel = await this.base.fetchStateModel();
+        const baseAsset = stateModel.baseAsset;
+        const signerAta = this.base.getAta(baseAsset, signer);
+        const fulfillIx = await this.base.program.methods.fulfill(mintId).accounts({
+            glamState: this.base.statePda,
+            glamMint,
+            signer,
+            asset: baseAsset,
+            depositTokenProgram: TOKEN_PROGRAM_ID
+        }).instruction();
+        preInstructions.push(createAssociatedTokenAccountIdempotentInstruction(signer, signerAta, signer, baseAsset));
+        const claimIx = await this.base.program.methods.claim(0).accounts({
+            glamState: this.base.statePda,
+            signer,
+            tokenMint: baseAsset,
+            claimTokenProgram: TOKEN_PROGRAM_ID
+        }).instruction();
+        const remainingAccounts = [];
+        if (await this.base.isLockupEnabled()) {
+            const extraMetasAccount = this.base.extraMetasPda;
+            const signerPolicy = getAccountPolicyPda(this.base.getMintAta(signer));
+            const escrow = this.base.escrowPda;
+            const escrowPolicy = getAccountPolicyPda(this.base.getMintAta(escrow));
+            remainingAccounts.push(...[
+                extraMetasAccount,
+                signerPolicy,
+                escrowPolicy,
+                TRANSFER_HOOK_PROGRAM
+            ]);
+        }
+        const tx = await this.base.program.methods.queuedRedeem(0, amount).accounts({
+            glamState: this.base.statePda,
+            glamMint,
+            signer
+        }).remainingAccounts(remainingAccounts.map((pubkey)=>({
+                pubkey,
+                isSigner: false,
+                isWritable: false
+            }))).preInstructions(preInstructions).postInstructions([
+            fulfillIx,
+            claimIx
+        ]).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
     async queuedRedeemTx(amount, mintId = 0, txOptions = {}) {
         if (mintId !== 0) {
             throw new Error("mintId must be 0");
@@ -22505,4 +22694,4 @@ function getMarketOrderParams(params) {
     return Object.assign({}, DefaultOrderParams, optionalOrderParams, overridingParams);
 }
 
-export { ALT_PROGRAM_ID, ASSETS_MAINNET, ASSETS_TESTS, AssetTier, BaseClient, ClusterNetwork, CompanyModel, ContractTier, ContractType, CreatedModel, DRIFT_PROGRAM_ID, DRIFT_VAULTS_PROGRAM_ID, DRIFT_VAULT_DEPOSITOR_SIZE, DefaultOrderParams, DelegateAcl, DepositDirection, DepositExplanation, DriftClient, DriftVaultsClient, ExchangeStatus, FuelOverflowStatus, FundOpenfundsModel, GLAM_REFERRER, GOVERNANCE_PROGRAM_ID, GlamClient, GlamError, GlamIdl, GlamIntegrations, GlamPermissions, GlamProtocolIdlJson, InsuranceFundOperation, JITO_STAKE_POOL, JITO_TIP_DEFAULT, JUP, JUPITER_API_DEFAULT, JUPITER_PROGRAM_ID, JUPSOL_STAKE_POOL, JUP_VOTE_PROGRAM, JupiterSwapClient, JupiterVoteClient, KAMINO_FARM_PROGRAM, KAMINO_LENDING_PROGRAM, KAMINO_OBTRIGATION_SIZE, KAMINO_SCOPE_PRICES, KAMINO_VAULTS_PROGRAM, LPAction, LiquidationType, MARINADE_NATIVE_STAKE_AUTHORITY, MARINADE_PROGRAM_ID, MEMO_PROGRAM, MERKLE_DISTRIBUTOR_PROGRAM, METEORA_DLMM_PROGRAM, METEORA_POSITION_SIZE, MSOL, ManagerModel, MarginMode, MarketStatus, MarketType, Metadata, MintIdlModel, MintModel, MintOpenfundsModel, ModifyOrderPolicy, OracleSource, OracleSourceNum, OrderAction, OrderActionExplanation, OrderStatus, OrderTriggerCondition, OrderType, PerpOperation, PlaceAndTakeOrderSuccessCondition, PositionDirection, PostOnlyParams, PriceDenom, ReferrerStatus, SANCTUM_STAKE_POOL_PROGRAM_ID, SEED_ESCROW, SEED_METADATA, SEED_MINT, SEED_STATE, SEED_VAULT, SOL_ORACLE, STAKE_ACCOUNT_SIZE, STAKE_POOLS, STAKE_POOLS_MAP, SettlePnlExplanation, SettlePnlMode, SpotBalanceType, SpotFulfillmentConfigStatus, SpotFulfillmentStatus, SpotFulfillmentType, SpotOperation, StakeAction, StateIdlModel, StateModel, SwapDirection, SwapReduceOnly, TRANSFER_HOOK_PROGRAM, TimeUnit, TradeSide, USDC, USDC_ORACLE, UserStatus, VoteAuthorize, WSOL, ZERO, decodeUser, fetchMeteoraPositions, fetchProgramLabels, fetchTokenPrices, fetchTokensList, findStakeAccounts, getAccountPolicyPda, getEscrowPda, getExtraMetasPda, getGlamProgram, getGlamProgramId, getLimitOrderParams, getMarketOrderParams, getMintPda, getOpenfundsPda, getOrderParams, getPriorityFeeEstimate, getSimulationResult, getSolAndTokenBalances, getStakeAccountsWithStates, getStatePda, getTokenAccountsByOwner, getTriggerLimitOrderParams, getTriggerMarketOrderParams, getVariant, getVaultPda, isBrowser, isOneOfVariant, isVariant, parseMeteoraPosition, parseProgramLogs, setsAreEqual };
+export { ALT_PROGRAM_ID, ASSETS_MAINNET, ASSETS_TESTS, AssetTier, BaseClient, ClusterNetwork, CompanyModel, ContractTier, ContractType, CreatedModel, DRIFT_PROGRAM_ID, DRIFT_VAULTS_PROGRAM_ID, DRIFT_VAULT_DEPOSITOR_SIZE, DefaultOrderParams, DelegateAcl, DepositDirection, DepositExplanation, DriftClient, DriftVaultsClient, ExchangeStatus, FuelOverflowStatus, FundOpenfundsModel, GLAM_REFERRER, GOVERNANCE_PROGRAM_ID, GlamClient, GlamError, GlamIdl, GlamIntegrations, GlamPermissions, GlamProtocolIdlJson, InsuranceFundOperation, JITO_STAKE_POOL, JITO_TIP_DEFAULT, JUP, JUPITER_API_DEFAULT, JUPITER_PROGRAM_ID, JUPSOL_STAKE_POOL, JUP_VOTE_PROGRAM, JupiterSwapClient, JupiterVoteClient, KAMINO_FARM_PROGRAM, KAMINO_LENDING_PROGRAM, KAMINO_OBTRIGATION_SIZE, KAMINO_SCOPE_PRICES, KAMINO_VAULTS_PROGRAM, LPAction, LiquidationType, MARINADE_NATIVE_STAKE_AUTHORITY, MARINADE_PROGRAM_ID, MEMO_PROGRAM, MERKLE_DISTRIBUTOR_PROGRAM, METEORA_DLMM_PROGRAM, METEORA_POSITION_SIZE, MSOL, ManagerModel, MarginMode, MarketStatus, MarketType, Metadata, MintIdlModel, MintModel, MintOpenfundsModel, ModifyOrderPolicy, OracleSource, OracleSourceNum, OrderAction, OrderActionExplanation, OrderStatus, OrderTriggerCondition, OrderType, PerpOperation, PlaceAndTakeOrderSuccessCondition, PositionDirection, PostOnlyParams, PriceDenom, ReferrerStatus, SANCTUM_STAKE_POOL_PROGRAM_ID, SEED_ESCROW, SEED_METADATA, SEED_MINT, SEED_STATE, SEED_VAULT, SOL_ORACLE, STAKE_ACCOUNT_SIZE, STAKE_POOLS, STAKE_POOLS_MAP, SettlePnlExplanation, SettlePnlMode, SpotBalanceType, SpotFulfillmentConfigStatus, SpotFulfillmentStatus, SpotFulfillmentType, SpotOperation, StakeAction, StateIdlModel, StateModel, SwapDirection, SwapReduceOnly, TRANSFER_HOOK_PROGRAM, TimeUnit, TradeSide, USDC, USDC_ORACLE, UserStatus, VoteAuthorize, WSOL, ZERO, decodeUser, fetchMeteoraPositions, fetchProgramLabels, fetchTokenPrices, fetchTokensList, findStakeAccounts, getAccountPolicyPda, getEscrowPda, getExtraMetasPda, getGlamProgram, getGlamProgramId, getLimitOrderParams, getMarketOrderParams, getMintPda, getOpenfundsPda, getOrderParams, getPriorityFeeEstimate, getProgramAccountsV2, getSimulationResult, getSolAndTokenBalances, getStakeAccountsWithStates, getStatePda, getTokenAccountsByOwner, getTriggerLimitOrderParams, getTriggerMarketOrderParams, getVariant, getVaultPda, isBrowser, isOneOfVariant, isVariant, parseMeteoraPosition, parseProgramLogs, setsAreEqual };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",

package/src/client/invest.d.ts

@@ -4,12 +4,42 @@ import { BaseClient, TxOptions } from "./base";
 export declare class InvestClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
+    /**
+     * Subscribe to a tokenized vault
+     *
+     * @param asset Deposit asset
+     * @param amount
+     * @param mintId
+     * @param queued by default false, set to true to subscribe in queued mode
+     * @param txOptions
+     * @returns
+     */
     subscribe(asset: PublicKey, amount: BN, mintId?: number, queued?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Request to redeem share tokens of a tokenized vault in queued mode
+     *
+     * @param amount
+     * @param mintId
+     * @param txOptions
+     * @returns
+     */
     queuedRedeem(amount: BN, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Redeem share tokens of a tokenized vault instantly. Preconditions:
+     * 1. The vault must allow permissionless fulfillment
+     * 2. The vault must have sufficient liquidity
+     *
+     * @param amount
+     * @param mintId
+     * @param txOptions
+     * @returns
+     */
+    instantRedeem(amount: BN, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     fulfill(mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     claim(asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     subscribeTx(asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
     queuedSubscribeTx(asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    instantRedeemTx(amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
     queuedRedeemTx(amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
     fulfillTx(mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
     claimAssetTx(asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;

package/src/client/kamino.d.ts

@@ -149,9 +149,10 @@ export declare class KaminoLendingClient {
 export declare class KaminoFarmClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    findAndParseFarmStates(owner: PublicKey): Promise<{
-        userFarmState: PublicKey;
+    findAndParseUserStates(owner: PublicKey): Promise<{
+        userState: any;
         farmState: PublicKey;
+        unclaimedRewards: BN[];
     }[]>;
     parseFarm(data: Buffer): Promise<{
         globalConfig: PublicKey;

package/src/client/mint.d.ts

@@ -10,6 +10,7 @@ export declare class MintClient {
     update(mintModel: Partial<MintModel>, txOptions?: TxOptions): Promise<string>;
     updateApplyTimelock(txOptions?: TxOptions): Promise<string>;
     emergencyUpdate(mintModel: Partial<MintModel>, txOptions?: TxOptions): Promise<string>;
+    setPermissionlessFulfill(enabled: boolean, txOptions?: TxOptions): Promise<string>;
     closeMintIx(): Promise<anchor.web3.TransactionInstruction>;
     closeMint(txOptions?: TxOptions): Promise<string>;
     /**

package/src/utils/helpers.d.ts

@@ -6,6 +6,7 @@ export type StakeAccountInfo = {
     state: string;
     voter?: PublicKey;
 };
+export declare function getProgramAccountsV2(programId: PublicKey, limit?: number, filters?: any[]): Promise<any[]>;
 /**
  * Fetches all the token accounts owned by the specified pubkey.
  */