@glamsystems/glam-cli 1.0.10 → 1.0.11

package/main.js

@@ -2345,6 +2345,7 @@ async function fetchAddressLookupTableAccounts(connection, pubkeys) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getProtocolNamesFromBitmask = getProtocolNamesFromBitmask;
 exports.getPermissionNamesFromBitmask = getPermissionNamesFromBitmask;
+exports.comparePublicKeyArrays = comparePublicKeyArrays;
 exports.compareIntegrationAcls = compareIntegrationAcls;
 exports.compareDelegateAcls = compareDelegateAcls;
 const bitmask_1 = __webpack_require__(38);
@@ -2366,6 +2367,17 @@ function getPermissionNamesFromBitmask(integrationProgram, protocolBitflag, perm
     const { permissions } = (0, bitmask_1.parseProtocolPermissionsBitmask)(integrationProgram, protocolBitflag, permissionsBitmask);
     return permissions.map((p) => p.name);
 }
+/**
+ * Compare current and staged PublicKey arrays and return added/removed keys
+ */
+function comparePublicKeyArrays(current, staged) {
+    const currentSet = new pkset_1.PkSet(current || []);
+    const stagedSet = new pkset_1.PkSet(staged);
+    return {
+        added: [...stagedSet].filter((pk) => !currentSet.has(pk)),
+        removed: [...currentSet].filter((pk) => !stagedSet.has(pk)),
+    };
+}
 /**
  * Compare current and staged integrationAcls and return the differences
  */
@@ -15151,6 +15163,9 @@ exports.validateInvestorAction = validateInvestorAction;
 exports.validateBooleanInput = validateBooleanInput;
 exports.validateDriftMarketType = validateDriftMarketType;
 exports.executeTxWithErrorHandling = executeTxWithErrorHandling;
+exports.levenshtein = levenshtein;
+exports.resolveProtocolName = resolveProtocolName;
+exports.resolvePermissionNames = resolvePermissionNames;
 const tslib_1 = __webpack_require__(2);
 const anchor_1 = __webpack_require__(4);
 const glam_sdk_1 = __webpack_require__(1);
@@ -15454,6 +15469,127 @@ async function executeTxWithErrorHandling(txFn, confirmOptions, successMessage)
         process.exit(1);
     }
 }
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: n + 1 }, (_, i) => i);
+    for (let i = 1; i <= m; i++) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const tmp = dp[j];
+            dp[j] =
+                a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+/**
+ * Resolve a single protocol name with fuzzy matching:
+ * 1. Exact match
+ * 2. Case-insensitive match
+ * 3. Levenshtein suggestion (distance <= 3)
+ *
+ * Returns the canonical protocol name or exits with an error.
+ */
+function resolveProtocolName(name) {
+    const lookup = (0, glam_sdk_1.getProgramAndBitflagByProtocolName)();
+    const validNames = Object.keys(lookup);
+    // 1. Exact match
+    if (lookup[name]) {
+        return name;
+    }
+    // 2. Case-insensitive match
+    const ciIndex = new Map();
+    for (const valid of validNames) {
+        ciIndex.set(valid.toLowerCase(), valid);
+    }
+    const ciMatch = ciIndex.get(name.toLowerCase());
+    if (ciMatch) {
+        console.log(`Note: using '${ciMatch}' for '${name}'`);
+        return ciMatch;
+    }
+    // 3. Levenshtein suggestion
+    let bestName = "";
+    let bestDist = Infinity;
+    const nameLower = name.toLowerCase();
+    for (const valid of validNames) {
+        const dist = levenshtein(nameLower, valid.toLowerCase());
+        if (dist < bestDist) {
+            bestDist = dist;
+            bestName = valid;
+        }
+    }
+    const suggestion = bestDist <= 3 ? `  Did you mean '${bestName}' instead of '${name}'?` : "";
+    console.error(`Unknown protocol name: ${name}`);
+    if (suggestion)
+        console.error(suggestion);
+    console.error(`Valid protocol names: ${validNames.join(", ")}`);
+    process.exit(1);
+}
+/**
+ * Resolve permission names for a given (already-resolved) protocol with fuzzy matching.
+ * Returns an array of canonical permission names or exits with an error.
+ */
+function resolvePermissionNames(protocolName, inputNames) {
+    const protocolConfig = (0, glam_sdk_1.getProgramAndBitflagByProtocolName)()[protocolName];
+    if (!protocolConfig) {
+        console.error(`Unknown protocol name: ${protocolName}`);
+        process.exit(1);
+    }
+    const [programIdStr, bitflagStr] = protocolConfig;
+    const protocolPermissions = (0, glam_sdk_1.getProtocolsAndPermissions)()[programIdStr]?.[bitflagStr];
+    if (!protocolPermissions) {
+        console.error(`Protocol mapping not found for protocol name ${protocolName}`);
+        process.exit(1);
+    }
+    const validNames = Object.values(protocolPermissions.permissions);
+    const ciIndex = new Map();
+    for (const valid of validNames) {
+        ciIndex.set(valid.toLowerCase(), valid);
+    }
+    const resolved = [];
+    const unknown = [];
+    const suggestions = [];
+    for (const name of inputNames) {
+        // 1. Exact match
+        if (validNames.includes(name)) {
+            resolved.push(name);
+            continue;
+        }
+        // 2. Case-insensitive match
+        const ciMatch = ciIndex.get(name.toLowerCase());
+        if (ciMatch) {
+            console.log(`Note: using '${ciMatch}' for '${name}'`);
+            resolved.push(ciMatch);
+            continue;
+        }
+        // 3. Levenshtein suggestion
+        let bestName = "";
+        let bestDist = Infinity;
+        const nameLower = name.toLowerCase();
+        for (const valid of validNames) {
+            const dist = levenshtein(nameLower, valid.toLowerCase());
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestName = valid;
+            }
+        }
+        if (bestDist <= 3) {
+            suggestions.push(`  Did you mean '${bestName}' instead of '${name}'?`);
+        }
+        unknown.push(name);
+    }
+    if (unknown.length) {
+        console.error(`Unknown permission name(s) for ${protocolName}: ${unknown.join(", ")}`);
+        for (const s of suggestions) {
+            console.error(s);
+        }
+        console.error(`Valid permissions for ${protocolName}: ${validNames.join(", ")}`);
+        process.exit(1);
+    }
+    return resolved;
+}
 
 
 /***/ }),
@@ -48054,6 +48190,21 @@ const validateIntegrationProgram = (input) => {
     }
     return pubkey;
 };
+function resolveProtocolNames(names) {
+    const lookup = (0, glam_sdk_1.getProgramAndBitflagByProtocolName)();
+    const groups = {};
+    for (const name of names) {
+        const resolved = (0, utils_1.resolveProtocolName)(name);
+        const [programIdStr, bitflagStr] = lookup[resolved];
+        if (programIdStr === (0, glam_sdk_1.getGlamMintProgramId)().toBase58()) {
+            console.error("Mint integration is not allowed");
+            process.exit(1);
+        }
+        const bitflag = parseInt(bitflagStr, 2);
+        groups[programIdStr] = (groups[programIdStr] || 0) | bitflag;
+    }
+    return groups;
+}
 function installIntegrationCommands(integration, context) {
     integration
         .command("list")
@@ -48073,27 +48224,7 @@ function installIntegrationCommands(integration, context) {
         .argument("<protocols...>", "Protocol names (e.g., SplToken, JupiterSwap, DriftProtocol)")
         .option("-y, --yes", "Skip confirmation")
         .action(async (protocols, { yes }) => {
-        const groups = {}; // Program ID -> Protocols Bitmask
-        const unknown = [];
-        const PROGRAM_AND_BITFLAG_BY_PROTOCOL_NAME = (0, glam_sdk_1.getProgramAndBitflagByProtocolName)();
-        for (const name of protocols) {
-            const entry = PROGRAM_AND_BITFLAG_BY_PROTOCOL_NAME[name];
-            if (!entry) {
-                unknown.push(name);
-                continue;
-            }
-            const [programIdStr, bitflagStr] = entry;
-            if (programIdStr === (0, glam_sdk_1.getGlamMintProgramId)().toBase58()) {
-                console.error("Mint integration is not allowed");
-                process.exit(1);
-            }
-            const bitflag = parseInt(bitflagStr, 2);
-            groups[programIdStr] = (groups[programIdStr] || 0) | bitflag;
-        }
-        if (unknown.length) {
-            console.error(`Unknown protocol name(s): ${unknown.join(", ")}`);
-            process.exit(1);
-        }
+        const groups = resolveProtocolNames(protocols);
         const details = Object.entries(groups).map(([pid, mask]) => {
             const { protocols } = (0, glam_sdk_1.parseProtocolsBitmask)(new web3_js_1.PublicKey(pid), mask);
             const names = protocols.map((p) => p.name).join(", ");
@@ -48117,27 +48248,7 @@ function installIntegrationCommands(integration, context) {
         .argument("<protocols...>", "Protocol names (e.g., SplToken, JupiterSwap, DriftProtocol)")
         .option("-y, --yes", "Skip confirmation")
         .action(async (protocols, { yes }) => {
-        const groups = {};
-        const unknown = [];
-        const PROGRAM_AND_BITFLAG_BY_PROTOCOL_NAME = (0, glam_sdk_1.getProgramAndBitflagByProtocolName)();
-        for (const name of protocols) {
-            const entry = PROGRAM_AND_BITFLAG_BY_PROTOCOL_NAME[name];
-            if (!entry) {
-                unknown.push(name);
-                continue;
-            }
-            const [programIdStr, bitflagStr] = entry;
-            if (programIdStr === (0, glam_sdk_1.getGlamMintProgramId)().toBase58()) {
-                console.error("Mint integration is not allowed");
-                process.exit(1);
-            }
-            const mask = parseInt(bitflagStr, 2);
-            groups[programIdStr] = (groups[programIdStr] || 0) | mask;
-        }
-        if (unknown.length) {
-            console.error(`Unknown protocol name(s): ${unknown.join(", ")}`);
-            process.exit(1);
-        }
+        const groups = resolveProtocolNames(protocols);
         const details = Object.entries(groups).map(([pid, mask]) => {
             const { protocols } = (0, glam_sdk_1.parseProtocolsBitmask)(new web3_js_1.PublicKey(pid), mask);
             const names = protocols.map((p) => p.name).join(", ");
@@ -48218,17 +48329,13 @@ function installDelegateCommands(delegate, context) {
         .option("-y, --yes", "Skip confirmation prompt")
         .description("Grant delegate permissions for a single protocol")
         .action(async (delegate, permissions, { protocol, yes }) => {
-        try {
-            const { integrationProgram, protocolBitflag, permissionsBitmask } = (0, glam_sdk_1.parsePermissionNames)({
-                protocolName: protocol,
-                permissionNames: permissions,
-            });
-            await handleDelegatePermissions("grant", delegate, integrationProgram, protocolBitflag, protocol, permissionsBitmask, permissions, context, yes);
-        }
-        catch (e) {
-            console.error(e);
-            process.exit(1);
-        }
+        const resolvedProtocol = (0, utils_1.resolveProtocolName)(protocol);
+        const resolvedPermissions = (0, utils_1.resolvePermissionNames)(resolvedProtocol, permissions);
+        const { integrationProgram, protocolBitflag, permissionsBitmask } = (0, glam_sdk_1.parsePermissionNames)({
+            protocolName: resolvedProtocol,
+            permissionNames: resolvedPermissions,
+        });
+        await handleDelegatePermissions("grant", delegate, integrationProgram, protocolBitflag, resolvedProtocol, permissionsBitmask, resolvedPermissions, context, yes);
     });
     delegate
         .command("revoke")
@@ -48238,17 +48345,13 @@ function installDelegateCommands(delegate, context) {
         .option("-y, --yes", "Skip confirmation prompt")
         .description("Revoke delegate permissions for a single protocol by name")
         .action(async (delegate, permissions, { protocol, yes }) => {
-        try {
-            const { integrationProgram, protocolBitflag, permissionsBitmask } = (0, glam_sdk_1.parsePermissionNames)({
-                protocolName: protocol,
-                permissionNames: permissions,
-            });
-            await handleDelegatePermissions("revoke", delegate, integrationProgram, protocolBitflag, protocol, permissionsBitmask, permissions, context, yes);
-        }
-        catch (e) {
-            console.error(e);
-            process.exit(1);
-        }
+        const resolvedProtocol = (0, utils_1.resolveProtocolName)(protocol);
+        const resolvedPermissions = (0, utils_1.resolvePermissionNames)(resolvedProtocol, permissions);
+        const { integrationProgram, protocolBitflag, permissionsBitmask } = (0, glam_sdk_1.parsePermissionNames)({
+            protocolName: resolvedProtocol,
+            permissionNames: resolvedPermissions,
+        });
+        await handleDelegatePermissions("revoke", delegate, integrationProgram, protocolBitflag, resolvedProtocol, permissionsBitmask, resolvedPermissions, context, yes);
     });
     delegate
         .command("revoke-all")
@@ -48788,18 +48891,33 @@ function installVaultCommands(program, context) {
             message,
         }, (txSig) => `Vault ownership transferred: ${txSig}`);
     });
-    program
-        .command("set-enabled")
-        .argument("<enabled>", "New vault state", utils_1.validateBooleanInput)
-        .description("Enable or disable a GLAM vault")
-        .option("-y, --yes", "Skip confirmation prompt", false)
-        .action(async (enabled, options) => {
+    const setEnabled = async (enabled, options) => {
         const stateAccount = await context.glamClient.fetchStateAccount();
         const name = (0, glam_sdk_1.charsToString)(stateAccount.name);
         await (0, utils_1.executeTxWithErrorHandling)(() => context.glamClient.access.emergencyAccessUpdate({ stateEnabled: enabled }, context.txOptions), {
             skip: options?.yes,
             message: `Confirm ${enabled ? "enabling" : "disabling"} vault: ${name}`,
         }, (txSig) => `GLAM vault ${name} ${enabled ? "enabled" : "disabled"}: ${txSig}`);
+    };
+    program
+        .command("enable")
+        .description("Enable a GLAM vault")
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .action(async (options) => setEnabled(true, options));
+    program
+        .command("disable")
+        .description("Disable a GLAM vault")
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .action(async (options) => setEnabled(false, options));
+    // Deprecated: use 'enable' or 'disable' instead
+    program
+        .command("set-enabled")
+        .argument("<enabled>", "New vault state", utils_1.validateBooleanInput)
+        .description("[deprecated] Use 'enable' or 'disable' instead")
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .action(async (enabled, options) => {
+        console.warn("Warning: 'set-enabled' is deprecated, use 'enable' or 'disable' instead.");
+        await setEnabled(enabled, options);
     });
     program
         .command("view")
@@ -48922,11 +49040,42 @@ function installVaultCommands(program, context) {
         }, (txSig) => `wSOL unwrapped: ${txSig}`);
     });
     program
-        .command("balances")
-        .description("Get balances")
-        .option("-a, --all", "Show all assets including token accounts with 0 balance")
-        .action(async (options) => {
-        const { all } = options;
+        .command("close-token-accounts")
+        .argument("[mints...]", "Mint address(es) of token accounts to close")
+        .option("--empty", "Close all empty (zero-balance) token accounts", false)
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .description("Close vault token accounts")
+        .action(async (mints, options) => {
+        let tokenAccountPubkeys = [];
+        if (options.empty) {
+            const vault = context.glamClient.vaultPda;
+            const { tokenAccounts } = await context.glamClient.getSolAndTokenBalances(vault);
+            const emptyAccounts = tokenAccounts.filter((ta) => ta.uiAmount === 0);
+            if (emptyAccounts.length === 0) {
+                console.log("No empty token accounts to close.");
+                return;
+            }
+            const emptyMints = emptyAccounts.map((ta) => ta.mint);
+            const mintInfos = await (0, glam_sdk_1.fetchMintsAndTokenPrograms)(context.glamClient.connection, emptyMints);
+            tokenAccountPubkeys = mintInfos.map(({ mint: { address }, tokenProgram }) => context.glamClient.getVaultAta(address, tokenProgram));
+        }
+        else if (mints.length > 0) {
+            const mintPubkeys = mints.map((m) => (0, utils_1.validatePublicKey)(m));
+            const mintInfos = await (0, glam_sdk_1.fetchMintsAndTokenPrograms)(context.glamClient.connection, mintPubkeys);
+            tokenAccountPubkeys = mintInfos.map(({ mint: { address }, tokenProgram }) => context.glamClient.getVaultAta(address, tokenProgram));
+        }
+        else {
+            console.error("Provide mint address(es) or use --empty to close all empty token accounts.");
+            process.exit(1);
+        }
+        const count = tokenAccountPubkeys.length;
+        await (0, utils_1.executeTxWithErrorHandling)(() => context.glamClient.vault.closeTokenAccounts(tokenAccountPubkeys, context.txOptions), {
+            skip: options?.yes,
+            message: `Confirm closing ${count} token account(s)`,
+        }, (txSig) => `Closed ${count} token account(s): ${txSig}`);
+    });
+    const tokenBalances = async (options) => {
+        const { all, json } = options;
         const vault = context.glamClient.vaultPda;
         const { uiAmount: solUiAmount, tokenAccounts } = await context.glamClient.getSolAndTokenBalances(vault);
         const mints = tokenAccounts.map((ta) => ta.mint.toBase58());
@@ -48935,33 +49084,59 @@ function installVaultCommands(program, context) {
         }
         const jupApi = context.glamClient.jupiterSwap.jupApi;
         const tokenList = await jupApi.fetchTokensList();
-        // Define column widths
+        const solPrice = tokenList.getByMint(glam_sdk_1.WSOL)?.usdPrice || 0;
+        const rows = [
+            {
+                token: "SOL",
+                mint: "N/A",
+                amount: solUiAmount,
+                value: solPrice * solUiAmount,
+            },
+            ...tokenAccounts
+                .filter((ta) => all || ta.uiAmount > 0)
+                .map((ta) => {
+                const mintStr = ta.mint.toBase58();
+                const token = tokenList.getByMint(mintStr);
+                const tokenSymbol = token?.symbol === "SOL" ? "wSOL" : token?.symbol || "Unknown";
+                const value = (token?.usdPrice || 0) * ta.uiAmount;
+                return {
+                    token: tokenSymbol,
+                    mint: mintStr,
+                    amount: ta.uiAmount,
+                    value,
+                };
+            }),
+        ];
+        if (json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
         const colWidths = [12, 45, 15, 20];
         const printRow = (items) => {
             console.log(items[0].padEnd(colWidths[0]), items[1].padEnd(colWidths[1]), items[2].padEnd(colWidths[2]), items[3].padEnd(colWidths[3]));
         };
-        printRow(["Token", "Mint", "Amount", "Value (USD)"]); // header row
-        printRow([
-            "SOL",
-            "N/A",
-            solUiAmount.toFixed(9).toString(),
-            ((tokenList.getByMint(glam_sdk_1.WSOL)?.usdPrice || 0) * solUiAmount).toFixed(6),
-        ]);
-        tokenAccounts.forEach((ta) => {
-            const { uiAmount, mint } = ta;
-            const mintStr = mint.toBase58();
-            if (all || uiAmount > 0) {
-                const token = tokenList.getByMint(mintStr);
-                const tokenSymbol = token?.symbol === "SOL" ? "wSOL" : token?.symbol || "Unknown";
-                const value = (token?.usdPrice || 0) * uiAmount;
-                printRow([
-                    tokenSymbol,
-                    mintStr,
-                    uiAmount.toString(),
-                    value ? value.toFixed(6) : "NaN",
-                ]);
-            }
-        });
+        printRow(["Token", "Mint", "Amount", "Value (USD)"]);
+        rows.forEach((r) => printRow([
+            r.token,
+            r.mint,
+            r.token === "SOL" ? r.amount.toFixed(9) : r.amount.toString(),
+            r.value ? r.value.toFixed(6) : "NaN",
+        ]));
+    };
+    program
+        .command("token-balances")
+        .description("Get token balances")
+        .option("-a, --all", "Show all assets including token accounts with 0 balance")
+        .option("-j, --json", "Output in JSON format", false)
+        .action(tokenBalances);
+    // Deprecated: use 'token-balances' instead
+    program
+        .command("balances")
+        .description("[deprecated] Use 'token-balances' instead")
+        .option("-a, --all", "Show all assets including token accounts with 0 balance")
+        .action(async (options) => {
+        console.warn("Warning: 'balances' is deprecated, use 'token-balances' instead.");
+        await tokenBalances(options);
     });
     program
         .command("list-assets")
@@ -49104,12 +49279,46 @@ module.exports = require("zlib");
 
 /***/ }),
 /* 642 */
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.installManageCommands = installManageCommands;
+const anchor_1 = __webpack_require__(4);
 const utils_1 = __webpack_require__(102);
 const web3_js_1 = __webpack_require__(5);
 const glam_sdk_1 = __webpack_require__(1);
@@ -49204,6 +49413,62 @@ function installManageCommands(manage, context) {
             message: `Confirm unpausing ${action}`,
         }, (txSig) => `Unpaused ${action}: ${txSig}`);
     });
+    manage
+        .command("list-requests")
+        .description("List pending user requests in the queue")
+        .action(async () => {
+        const queue = await context.glamClient.fetchRequestQueue();
+        const requests = queue?.data || [];
+        if (requests.length === 0) {
+            console.log("No pending requests in the queue.");
+            return;
+        }
+        const { baseAssetDecimals } = await context.glamClient.fetchStateModel();
+        const { mint } = await (await Promise.resolve().then(() => __importStar(__webpack_require__(1)))).fetchMintAndTokenProgram(context.glamClient.connection, context.glamClient.mintPda);
+        const shareDecimals = mint.decimals;
+        console.log(`Found ${requests.length} request(s):\n`);
+        for (const r of requests) {
+            const type = Object.keys(r.requestType)[0];
+            const isSub = glam_sdk_1.RequestType.equals(r.requestType, glam_sdk_1.RequestType.SUBSCRIPTION);
+            const incoming = (0, glam_sdk_1.toUiAmount)(new anchor_1.BN(r.incoming.toString()), isSub ? baseAssetDecimals : shareDecimals);
+            const outgoing = (0, glam_sdk_1.toUiAmount)(new anchor_1.BN(r.outgoing.toString()), isSub ? shareDecimals : baseAssetDecimals);
+            const createdAt = new anchor_1.BN(r.createdAt.toString()).toNumber();
+            const fulfilledAt = new anchor_1.BN(r.fulfilledAt.toString()).toNumber();
+            const createdDate = createdAt
+                ? new Date(createdAt * 1000).toISOString()
+                : "N/A";
+            const status = fulfilledAt ? "fulfilled (claimable)" : "pending";
+            console.log(`  User:      ${r.user.toBase58()}`);
+            console.log(`  Type:      ${type}`);
+            console.log(`  Incoming:  ${incoming}`);
+            console.log(`  Outgoing:  ${outgoing}`);
+            console.log(`  Status:    ${status}`);
+            console.log(`  Created:   ${createdDate}`);
+            console.log();
+        }
+    });
+    manage
+        .command("cancel-for-user")
+        .argument("<pubkey>", "Public key of the user", utils_1.validatePublicKey)
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .description("Cancel a queued request on behalf of a user")
+        .action(async (pubkey, options) => {
+        await (0, utils_1.executeTxWithErrorHandling)(() => context.glamClient.invest.cancelForUser(pubkey, context.txOptions), {
+            skip: options?.yes,
+            message: `Confirm canceling queued request for user ${pubkey.toBase58()}?`,
+        }, (txSig) => `Cancelled request for ${pubkey.toBase58()}: ${txSig}`);
+    });
+    manage
+        .command("claim-for-user")
+        .argument("<pubkey>", "Public key of the user", utils_1.validatePublicKey)
+        .option("-y, --yes", "Skip confirmation prompt", false)
+        .description("Claim a fulfilled request on behalf of a user")
+        .action(async (pubkey, options) => {
+        await (0, utils_1.executeTxWithErrorHandling)(() => context.glamClient.invest.claimForUser(pubkey, context.txOptions), {
+            skip: options?.yes,
+            message: `Confirm claiming for user ${pubkey.toBase58()}?`,
+        }, (txSig) => `Claimed for ${pubkey.toBase58()}: ${txSig}`);
+    });
 }
 
 
@@ -49584,6 +49849,21 @@ function installTimelockCommands(program, context) {
                         });
                     }
                 }
+                else if (name === "assets" || name === "borrowable") {
+                    const { added, removed } = (0, glam_sdk_1.comparePublicKeyArrays)(stateModel[name] || [], value);
+                    if (added.length === 0 && removed.length === 0) {
+                        console.log(`  ${name}: No changes`);
+                    }
+                    else {
+                        console.log(`  ${name}:`);
+                        added.forEach((pk) => {
+                            console.log(`    [+] ${pk.toBase58()}`);
+                        });
+                        removed.forEach((pk) => {
+                            console.log(`    [-] ${pk.toBase58()}`);
+                        });
+                    }
+                }
                 else if (name === "timelockDuration") {
                     console.log(`  ${name}: ${stateModel.timelockDuration}s → ${value}s`);
                 }
@@ -49765,7 +50045,7 @@ program
     initialize(config, skipSimulation);
     await (0, idl_1.idlCheck)(context.glamClient);
 })
-    .version("1.0.10");
+    .version("1.0.11");
 program
     .command("env")
     .description("Display current environment setup")

package/package.json

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