@glamsystems/glam-cli 0.1.34 → 0.1.35

package/main.js

@@ -275,12 +275,15 @@ 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 = {};
@@ -763,7 +766,7 @@ const blockhash_1 = __webpack_require__(20);
 const glamPDAs_1 = __webpack_require__(21);
 const DEFAULT_PRIORITY_FEE = 10000; // microLamports
 const LOOKUP_TABLES = [
-    new web3_js_1.PublicKey("284iwGtA9X9aLy3KsyV8uT2pXLARhYbiSi5SiM2g47M2"), // kamino
+    new web3_js_1.PublicKey("284iwGtA9X9aLy3KsyV8uT2pXLARhYbiSi5SiM2g47M2"), // kamino lending
     new web3_js_1.PublicKey("D9cnvzswDikQDf53k4HpQ3KJ9y1Fv3HGGDFYMXnK5T6c"), // drift
     new web3_js_1.PublicKey("EiWSskK5HXnBTptiS5DH6gpAJRVNQ3cAhTKBGaiaysAb"), // drift
 ];
@@ -1353,6 +1356,7 @@ exports.BaseClient = BaseClient;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.setsAreEqual = exports.getSimulationResult = exports.parseMeteoraPosition = exports.fetchMeteoraPositions = exports.getStakeAccountsWithStates = exports.findStakeAccounts = void 0;
+exports.getProgramAccountsV2 = getProgramAccountsV2;
 exports.getTokenAccountsByOwner = getTokenAccountsByOwner;
 exports.getSolAndTokenBalances = getSolAndTokenBalances;
 exports.parseProgramLogs = parseProgramLogs;
@@ -1362,6 +1366,78 @@ const dlmm_1 = __webpack_require__(15);
 const anchor_1 = __webpack_require__(4);
 const glamExports_1 = __webpack_require__(3);
 const spl_token_1 = __webpack_require__(8);
+// 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_1.PublicKey(pubkey),
+                account: {
+                    ...account,
+                    owner: new web3_js_1.PublicKey(account.owner),
+                    data: decodedData,
+                },
+            });
+        });
+        paginationKey = data.result.paginationKey;
+    } while (paginationKey);
+    return allAccounts;
+}
 /**
  * Fetches all the token accounts owned by the specified pubkey.
  */
@@ -5823,7 +5899,6 @@ class MintClient {
         });
     }
     async update(mintModel, txOptions = {}) {
-        // @ts-ignore
         const tx = await this.base.program.methods
             .updateMint(0, new models_1.MintIdlModel(mintModel))
             .accounts({
@@ -5856,6 +5931,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)
@@ -6087,6 +6175,7 @@ const borsh = tslib_1.__importStar(__webpack_require__(25));
 const spl_token_1 = __webpack_require__(8);
 const constants_1 = __webpack_require__(10);
 const kaminoLayouts_1 = __webpack_require__(36);
+const helpers_1 = __webpack_require__(14);
 const DEFAULT_OBLIGATION_ARGS = { tag: 0, id: 0 };
 const EVENT_AUTHORITY = new web3_js_1.PublicKey("24tHwQyJJ9akVXxnvkekGfAoeUJXXS7mE6kQNioNySsK");
 class KaminoLendingClient {
@@ -6907,19 +6996,30 @@ class KaminoFarmClient {
         this.farmVaultsAuthority = (farm) => web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("authority"), farm.toBuffer()], constants_1.KAMINO_FARM_PROGRAM)[0];
         this.rewardsTreasuryVault = (globalConfig, mint) => web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("tvault"), globalConfig.toBuffer(), mint.toBuffer()], constants_1.KAMINO_FARM_PROGRAM)[0];
     }
-    async findAndParseFarmStates(owner) {
-        const accounts = await this.base.provider.connection.getProgramAccounts(constants_1.KAMINO_FARM_PROGRAM, {
-            filters: [
-                { dataSize: 920 },
-                { memcmp: { offset: 48, bytes: owner.toBase58() } },
-            ],
-        });
-        return accounts.map((account) => {
-            const data = account.account.data;
-            const farmState = new web3_js_1.PublicKey(data.subarray(16, 48));
+    async findAndParseUserStates(owner) {
+        const accounts = await (0, helpers_1.getProgramAccountsV2)(constants_1.KAMINO_FARM_PROGRAM, 10, [
+            { dataSize: 920 },
+            { memcmp: { offset: 48, bytes: owner.toBase58() } },
+        ]);
+        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_1.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_1.BN(rewardData, "le");
+            });
             return {
-                userFarmState: account.pubkey,
+                userState: pubkey,
                 farmState,
+                unclaimedRewards,
             };
         });
     }
@@ -6974,22 +7074,25 @@ 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_1.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_1.BN(0))) {
+                    continue;
+                }
+                console.log(`userState: ${userState}, farmState: ${farmState}, unclaimedReward: ${unclaimedRewards[index]}, token: ${mint}`);
                 const vaultAta = this.base.getVaultAta(mint, tokenProgram);
-                const createAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(glamSigner, vaultAta, vault, mint, tokenProgram);
+                const createAtaIx = (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(glamSigner, vaultAta, this.base.vaultPda, mint, tokenProgram);
                 const harvestIx = await this.base.program.methods
                     .kaminoFarmHarvestReward(new anchor_1.BN(index))
                     .accounts({
                     glamState: this.base.statePda,
                     glamSigner,
-                    userState: userFarmState,
+                    userState,
                     farmState,
                     globalConfig,
                     rewardMint: mint,
@@ -7004,6 +7107,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;
     }
@@ -7504,16 +7610,48 @@ class InvestClient {
     constructor(base) {
         this.base = base;
     }
+    /**
+     * 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);
     }
+    /**
+     * 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);
@@ -7563,7 +7701,6 @@ class InvestClient {
             signerPolicy = (0, glamPDAs_1.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({
@@ -7617,6 +7754,67 @@ class InvestClient {
             .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: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .instruction();
+        preInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(signer, signerAta, signer, baseAsset));
+        const claimIx = await this.base.program.methods
+            .claim(0)
+            .accounts({
+            glamState: this.base.statePda,
+            signer,
+            tokenMint: baseAsset,
+            claimTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        })
+            .instruction();
+        const remainingAccounts = [];
+        if (await this.base.isLockupEnabled()) {
+            const extraMetasAccount = this.base.extraMetasPda;
+            const signerPolicy = (0, glamPDAs_1.getAccountPolicyPda)(this.base.getMintAta(signer));
+            const escrow = this.base.escrowPda;
+            const escrowPolicy = (0, glamPDAs_1.getAccountPolicyPda)(this.base.getMintAta(escrow));
+            remainingAccounts.push(...[
+                extraMetasAccount,
+                signerPolicy,
+                escrowPolicy,
+                constants_1.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");
@@ -8521,6 +8719,7 @@ class CliConfig {
             }
             process.env.ANCHOR_PROVIDER_URL = cliConfig.json_rpc_url;
             process.env.ANCHOR_WALLET = cliConfig.keypair_path;
+            process.env.HELIUS_API_KEY = cliConfig.priority_fee?.helius_api_key;
             return cliConfig;
         }
         catch (err) {
@@ -10083,17 +10282,28 @@ function installInvestCommands(tokenized, glamClient, cliConfig, txOptions) {
     });
     tokenized
         .command("redeem <amount>")
+        .option("-i, --instant", "Redeem share tokens instantly", false)
+        .option("-y, --yes", "Skip confirmation prompt", false)
         .description("Request to redeem share tokens")
-        .option("-y, --yes", "Skip confirmation prompt")
-        .action(async (amount, options) => {
+        .action(async (amount, { instant, yes }) => {
         const amountBN = new anchor_1.BN(parseFloat(amount) * web3_js_1.LAMPORTS_PER_SOL);
-        options?.yes ||
-            (await (0, utils_1.confirmOperation)(`Confirm queued redemption of ${amount} shares?`));
+        yes ||
+            (await (0, utils_1.confirmOperation)(`Confirm ${instant ? "instant" : "queued"} redemption of ${amount} shares?`));
         try {
-            const txSig = await glamClient.invest.queuedRedeem(amountBN, 0, {
-                ...txOptions,
-            });
-            console.log(`${glamClient.signer} requested to redeem:`, txSig);
+            let txSig;
+            if (instant) {
+                const preInstructions = await glamClient.price.priceVaultIxs(glam_sdk_1.PriceDenom.SOL);
+                const lookupTables = glamClient.price.lookupTables;
+                txSig = await glamClient.invest.instantRedeem(amountBN, 0, {
+                    ...txOptions,
+                    preInstructions,
+                    lookupTables,
+                });
+            }
+            else {
+                txSig = await glamClient.invest.queuedRedeem(amountBN, 0, txOptions);
+            }
+            console.log(`${glamClient.signer} ${instant ? "instantly" : "queued"} redeemed:`, txSig);
         }
         catch (e) {
             console.error((0, utils_1.parseTxError)(e));
@@ -10132,6 +10342,20 @@ function installInvestCommands(tokenized, glamClient, cliConfig, txOptions) {
             throw e;
         }
     });
+    tokenized
+        .command("set-permissionless-fulfill")
+        .argument("<enabled>", "Enable or disable permissionless fulfillment", (v) => v === "true" || v === "1", false)
+        .description("Enable or disable permissionless fulfillment")
+        .action(async (enabled) => {
+        try {
+            const txSig = await glamClient.mint.setPermissionlessFulfill(enabled);
+            console.log(`Permissionless fulfillment set to ${enabled}:`, txSig);
+        }
+        catch (e) {
+            console.error((0, utils_1.parseTxError)(e));
+            process.exit(1);
+        }
+    });
 }
 
 
@@ -10150,7 +10374,7 @@ function installAltCommands(alt, glamClient, cliConfig, txOptions = {}) {
         .description("Create address lookup table (ALT) for the active GLAM")
         .action(async () => {
         try {
-            const response = await fetch(`https://rest2.glam.systems/v0/lut/vault/create?state=${glamClient.statePda}&payer=${glamClient.getSigner()}`);
+            const response = await fetch(`https://api.glam.systems/v0/lut/vault/create?state=${glamClient.statePda}&payer=${glamClient.getSigner()}`);
             const data = await response.json();
             const table = data.tables[0];
             const b64Txs = data.tx;
@@ -10642,7 +10866,7 @@ program
     .hook("preSubcommand", async (thisCommand, actionCommand) => {
     await (0, idl_1.idlCheck)(glamClient);
 })
-    .version("0.1.34");
+    .version("0.1.35");
 program
     .command("env")
     .description("Display current environment setup")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glamsystems/glam-cli",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "CLI for interacting with the GLAM Protocol",
   "main": "./main.js",
   "bin": {
@@ -21,7 +21,7 @@
     "node": ">=20.18.0"
   },
   "dependencies": {
-    "@glamsystems/glam-sdk": "0.1.34",
+    "@glamsystems/glam-sdk": "0.1.35",
     "commander": "^11.1.0",
     "inquirer": "^8.2.6",
     "@switchboard-xyz/common": "^3.0.0"