@zcomb/programs-sdk 1.5.1 → 1.7.0

package/dist/svault/instructions.js

@@ -0,0 +1,172 @@
+"use strict";
+/*
+ * Low-level instruction builders for the SVault program.
+ * These are thin wrappers around the program methods - use SVaultClient for higher-level operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEE_AUTHORITY = void 0;
+exports.initializeStakingVault = initializeStakingVault;
+exports.stake = stake;
+exports.initiateUnstake = initiateUnstake;
+exports.withdraw = withdraw;
+exports.postRewards = postRewards;
+exports.claimRewards = claimRewards;
+exports.setConfig = setConfig;
+exports.slash = slash;
+exports.addDelegate = addDelegate;
+exports.removeDelegate = removeDelegate;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const utils_1 = require("./utils");
+/* Fee Authority (same as AMM program) */
+exports.FEE_AUTHORITY = new web3_js_1.PublicKey("FEEnkcCNE2623LYCPtLf63LFzXpCFigBLTu4qZovRGZC");
+function initializeStakingVault(program, admin, tokenMint, unstakingPeriod, volumeWindow, nonce) {
+    const unstakingPeriodBN = typeof unstakingPeriod === "number" ? new anchor_1.BN(unstakingPeriod) : unstakingPeriod;
+    const volumeWindowBN = typeof volumeWindow === "number" ? new anchor_1.BN(volumeWindow) : volumeWindow;
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [stakeVault] = (0, utils_1.deriveStakeVaultPDA)(configPda, program.programId);
+    const [rewardVault] = (0, utils_1.deriveRewardVaultPDA)(configPda, program.programId);
+    return program.methods
+        .initializeStakingVault(unstakingPeriodBN, volumeWindowBN, nonce)
+        .accountsPartial({
+        admin,
+        tokenMint,
+        config: configPda,
+        stakeVault,
+        rewardVault,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    });
+}
+function stake(program, user, tokenMint, nonce, amount) {
+    const amountBN = typeof amount === "number" ? new anchor_1.BN(amount) : amount;
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [userStakePda] = (0, utils_1.deriveUserStakePDA)(configPda, user, program.programId);
+    const [stakeVault] = (0, utils_1.deriveStakeVaultPDA)(configPda, program.programId);
+    const userTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, user);
+    return program.methods.stake(amountBN).accountsPartial({
+        user,
+        tokenMint,
+        config: configPda,
+        userStake: userStakePda,
+        stakeVault,
+        userTokenAccount,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    });
+}
+function initiateUnstake(program, user, tokenMint, nonce, amount) {
+    const amountBN = typeof amount === "number" ? new anchor_1.BN(amount) : amount;
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [userStakePda] = (0, utils_1.deriveUserStakePDA)(configPda, user, program.programId);
+    return program.methods.initiateUnstake(amountBN).accountsPartial({
+        user,
+        tokenMint,
+        config: configPda,
+        userStake: userStakePda,
+    });
+}
+function withdraw(program, user, tokenMint, nonce) {
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [userStakePda] = (0, utils_1.deriveUserStakePDA)(configPda, user, program.programId);
+    const [stakeVault] = (0, utils_1.deriveStakeVaultPDA)(configPda, program.programId);
+    const userTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, user);
+    return program.methods.withdraw().accountsPartial({
+        user,
+        tokenMint,
+        config: configPda,
+        userStake: userStakePda,
+        stakeVault,
+        userTokenAccount,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    });
+}
+function postRewards(program, admin, tokenMint, nonce, merkleRoot, totalAmount) {
+    const merkleRootArray = merkleRoot;
+    const totalAmountBN = typeof totalAmount === "number" ? new anchor_1.BN(totalAmount) : totalAmount;
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [rewardVault] = (0, utils_1.deriveRewardVaultPDA)(configPda, program.programId);
+    const adminTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, admin);
+    return program.methods
+        .postRewards(merkleRootArray, totalAmountBN)
+        .accountsPartial({
+        admin,
+        tokenMint,
+        config: configPda,
+        rewardVault,
+        adminTokenAccount,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    });
+}
+function claimRewards(program, user, tokenMint, nonce, cumulativeAmount, proof) {
+    const cumulativeAmountBN = typeof cumulativeAmount === "number" ? new anchor_1.BN(cumulativeAmount) : cumulativeAmount;
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [userStakePda] = (0, utils_1.deriveUserStakePDA)(configPda, user, program.programId);
+    const [rewardVault] = (0, utils_1.deriveRewardVaultPDA)(configPda, program.programId);
+    const userTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, user);
+    return program.methods
+        .claimRewards(cumulativeAmountBN, proof)
+        .accountsPartial({
+        user,
+        tokenMint,
+        config: configPda,
+        userStake: userStakePda,
+        rewardVault,
+        userTokenAccount,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    });
+}
+function setConfig(program, admin, tokenMint, nonce, unstakingPeriod, volumeWindow) {
+    const unstakingPeriodArg = unstakingPeriod === null
+        ? null
+        : typeof unstakingPeriod === "number"
+            ? new anchor_1.BN(unstakingPeriod)
+            : unstakingPeriod;
+    const volumeWindowArg = volumeWindow === null
+        ? null
+        : typeof volumeWindow === "number"
+            ? new anchor_1.BN(volumeWindow)
+            : volumeWindow;
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    return program.methods
+        .setConfig(unstakingPeriodArg, volumeWindowArg)
+        .accountsPartial({
+        admin,
+        config: configPda,
+    });
+}
+function slash(program, admin, tokenMint, nonce, userStakePda, basisPoints) {
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [stakeVault] = (0, utils_1.deriveStakeVaultPDA)(configPda, program.programId);
+    const feeVault = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, exports.FEE_AUTHORITY);
+    return program.methods.slash(basisPoints).accountsPartial({
+        admin,
+        tokenMint,
+        config: configPda,
+        userStake: userStakePda,
+        stakeVault,
+        feeVault,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    });
+}
+function addDelegate(program, staker, delegateWallet, tokenMint, nonce) {
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [userStakePda] = (0, utils_1.deriveUserStakePDA)(configPda, staker, program.programId);
+    const [delegatePda] = (0, utils_1.deriveDelegatePDA)(configPda, delegateWallet, program.programId);
+    return program.methods.addDelegate().accountsPartial({
+        staker,
+        delegateWallet,
+        config: configPda,
+        userStake: userStakePda,
+        delegate: delegatePda,
+    });
+}
+function removeDelegate(program, staker, delegateWallet, tokenMint, nonce) {
+    const [configPda] = (0, utils_1.deriveStakingConfigPDA)(tokenMint, nonce, program.programId);
+    const [delegatePda] = (0, utils_1.deriveDelegatePDA)(configPda, delegateWallet, program.programId);
+    return program.methods.removeDelegate().accountsPartial({
+        staker,
+        config: configPda,
+        delegate: delegatePda,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../src/svault/instructions.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAiBH,wDAyBC;AAED,sBAuBC;AAED,0CAkBC;AAED,4BAoBC;AAED,kCAyBC;AAED,oCA0BC;AAED,8BA4BC;AAED,sBAqBC;AAED,kCAkBC;AAED,wCAeC;AA5PD,8CAAgD;AAChD,6CAA4C;AAC5C,iDAAoF;AAEpF,mCAMiB;AAEjB,yCAAyC;AAC5B,QAAA,aAAa,GAAG,IAAI,mBAAS,CAAC,8CAA8C,CAAC,CAAC;AAE3F,SAAgB,sBAAsB,CACpC,OAAwB,EACxB,KAAgB,EAChB,SAAoB,EACpB,eAA4B,EAC5B,YAAyB,EACzB,KAAa;IAEb,MAAM,iBAAiB,GAAG,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAE,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC;IAC1G,MAAM,cAAc,GAAG,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;IAE9F,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,UAAU,CAAC,GAAG,IAAA,2BAAmB,EAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACvE,MAAM,CAAC,WAAW,CAAC,GAAG,IAAA,4BAAoB,EAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAEzE,OAAO,OAAO,CAAC,OAAO;SACnB,sBAAsB,CAAC,iBAAiB,EAAE,cAAc,EAAE,KAAK,CAAC;SAChE,eAAe,CAAC;QACf,KAAK;QACL,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,UAAU;QACV,WAAW;QACX,YAAY,EAAE,4BAAgB;KAC/B,CAAC,CAAC;AACP,CAAC;AAED,SAAgB,KAAK,CACnB,OAAwB,EACxB,IAAe,EACf,SAAoB,EACpB,KAAa,EACb,MAAmB;IAEnB,MAAM,QAAQ,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAEtE,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,YAAY,CAAC,GAAG,IAAA,0BAAkB,EAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC9E,MAAM,CAAC,UAAU,CAAC,GAAG,IAAA,2BAAmB,EAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACvE,MAAM,gBAAgB,GAAG,IAAA,yCAA6B,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAExE,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC;QACrD,IAAI;QACJ,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE,YAAY;QACvB,UAAU;QACV,gBAAgB;QAChB,YAAY,EAAE,4BAAgB;KAC/B,CAAC,CAAC;AACL,CAAC;AAED,SAAgB,eAAe,CAC7B,OAAwB,EACxB,IAAe,EACf,SAAoB,EACpB,KAAa,EACb,MAAmB;IAEnB,MAAM,QAAQ,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAEtE,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,YAAY,CAAC,GAAG,IAAA,0BAAkB,EAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAE9E,OAAO,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC;QAC/D,IAAI;QACJ,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE,YAAY;KACxB,CAAC,CAAC;AACL,CAAC;AAED,SAAgB,QAAQ,CACtB,OAAwB,EACxB,IAAe,EACf,SAAoB,EACpB,KAAa;IAEb,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,YAAY,CAAC,GAAG,IAAA,0BAAkB,EAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC9E,MAAM,CAAC,UAAU,CAAC,GAAG,IAAA,2BAAmB,EAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACvE,MAAM,gBAAgB,GAAG,IAAA,yCAA6B,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAExE,OAAO,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,eAAe,CAAC;QAChD,IAAI;QACJ,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE,YAAY;QACvB,UAAU;QACV,gBAAgB;QAChB,YAAY,EAAE,4BAAgB;KAC/B,CAAC,CAAC;AACL,CAAC;AAED,SAAgB,WAAW,CACzB,OAAwB,EACxB,KAAgB,EAChB,SAAoB,EACpB,KAAa,EACb,UAAoB,EACpB,WAAwB;IAExB,MAAM,eAAe,GAAG,UAAsB,CAAC;IAC/C,MAAM,aAAa,GAAG,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;IAE1F,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,WAAW,CAAC,GAAG,IAAA,4BAAoB,EAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACzE,MAAM,iBAAiB,GAAG,IAAA,yCAA6B,EAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAE1E,OAAO,OAAO,CAAC,OAAO;SACnB,WAAW,CAAC,eAAe,EAAE,aAAa,CAAC;SAC3C,eAAe,CAAC;QACf,KAAK;QACL,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,WAAW;QACX,iBAAiB;QACjB,YAAY,EAAE,4BAAgB;KAC/B,CAAC,CAAC;AACP,CAAC;AAED,SAAgB,YAAY,CAC1B,OAAwB,EACxB,IAAe,EACf,SAAoB,EACpB,KAAa,EACb,gBAA6B,EAC7B,KAAiB;IAEjB,MAAM,kBAAkB,GAAG,OAAO,gBAAgB,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC;IAE9G,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,YAAY,CAAC,GAAG,IAAA,0BAAkB,EAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAC9E,MAAM,CAAC,WAAW,CAAC,GAAG,IAAA,4BAAoB,EAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACzE,MAAM,gBAAgB,GAAG,IAAA,yCAA6B,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAExE,OAAO,OAAO,CAAC,OAAO;SACnB,YAAY,CAAC,kBAAkB,EAAE,KAAK,CAAC;SACvC,eAAe,CAAC;QACf,IAAI;QACJ,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE,YAAY;QACvB,WAAW;QACX,gBAAgB;QAChB,YAAY,EAAE,4BAAgB;KAC/B,CAAC,CAAC;AACP,CAAC;AAED,SAAgB,SAAS,CACvB,OAAwB,EACxB,KAAgB,EAChB,SAAoB,EACpB,KAAa,EACb,eAAmC,EACnC,YAAgC;IAEhC,MAAM,kBAAkB,GAAG,eAAe,KAAK,IAAI;QACjD,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,OAAO,eAAe,KAAK,QAAQ;YACnC,CAAC,CAAC,IAAI,WAAE,CAAC,eAAe,CAAC;YACzB,CAAC,CAAC,eAAe,CAAC;IAEtB,MAAM,eAAe,GAAG,YAAY,KAAK,IAAI;QAC3C,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,OAAO,YAAY,KAAK,QAAQ;YAChC,CAAC,CAAC,IAAI,WAAE,CAAC,YAAY,CAAC;YACtB,CAAC,CAAC,YAAY,CAAC;IAEnB,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAEhF,OAAO,OAAO,CAAC,OAAO;SACnB,SAAS,CAAC,kBAAkB,EAAE,eAAe,CAAC;SAC9C,eAAe,CAAC;QACf,KAAK;QACL,MAAM,EAAE,SAAS;KAClB,CAAC,CAAC;AACP,CAAC;AAED,SAAgB,KAAK,CACnB,OAAwB,EACxB,KAAgB,EAChB,SAAoB,EACpB,KAAa,EACb,YAAuB,EACvB,WAAmB;IAEnB,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,UAAU,CAAC,GAAG,IAAA,2BAAmB,EAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACvE,MAAM,QAAQ,GAAG,IAAA,yCAA6B,EAAC,SAAS,EAAE,qBAAa,CAAC,CAAC;IAEzE,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,eAAe,CAAC;QACxD,KAAK;QACL,SAAS;QACT,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE,YAAY;QACvB,UAAU;QACV,QAAQ;QACR,YAAY,EAAE,4BAAgB;KAC/B,CAAC,CAAC;AACL,CAAC;AAED,SAAgB,WAAW,CACzB,OAAwB,EACxB,MAAiB,EACjB,cAAyB,EACzB,SAAoB,EACpB,KAAa;IAEb,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,YAAY,CAAC,GAAG,IAAA,0BAAkB,EAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,WAAW,CAAC,GAAG,IAAA,yBAAiB,EAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAEtF,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,eAAe,CAAC;QACnD,MAAM;QACN,cAAc;QACd,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE,YAAY;QACvB,QAAQ,EAAE,WAAW;KACtB,CAAC,CAAC;AACL,CAAC;AAED,SAAgB,cAAc,CAC5B,OAAwB,EACxB,MAAiB,EACjB,cAAyB,EACzB,SAAoB,EACpB,KAAa;IAEb,MAAM,CAAC,SAAS,CAAC,GAAG,IAAA,8BAAsB,EAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAChF,MAAM,CAAC,WAAW,CAAC,GAAG,IAAA,yBAAiB,EAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAEtF,OAAO,OAAO,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,eAAe,CAAC;QACtD,MAAM;QACN,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,WAAW;KACtB,CAAC,CAAC;AACL,CAAC","sourcesContent":["/*\n * Low-level instruction builders for the SVault program.\n * These are thin wrappers around the program methods - use SVaultClient for higher-level operations.\n */\n\nimport { Program, BN } from \"@coral-xyz/anchor\";\nimport { PublicKey } from \"@solana/web3.js\";\nimport { getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from \"@solana/spl-token\";\nimport { Svault } from \"./types\";\nimport {\n  deriveStakingConfigPDA,\n  deriveUserStakePDA,\n  deriveStakeVaultPDA,\n  deriveRewardVaultPDA,\n  deriveDelegatePDA,\n} from \"./utils\";\n\n/* Fee Authority (same as AMM program) */\nexport const FEE_AUTHORITY = new PublicKey(\"FEEnkcCNE2623LYCPtLf63LFzXpCFigBLTu4qZovRGZC\");\n\nexport function initializeStakingVault(\n  program: Program<Svault>,\n  admin: PublicKey,\n  tokenMint: PublicKey,\n  unstakingPeriod: BN | number,\n  volumeWindow: BN | number,\n  nonce: number\n) {\n  const unstakingPeriodBN = typeof unstakingPeriod === \"number\" ? new BN(unstakingPeriod) : unstakingPeriod;\n  const volumeWindowBN = typeof volumeWindow === \"number\" ? new BN(volumeWindow) : volumeWindow;\n\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);\n  const [rewardVault] = deriveRewardVaultPDA(configPda, program.programId);\n\n  return program.methods\n    .initializeStakingVault(unstakingPeriodBN, volumeWindowBN, nonce)\n    .accountsPartial({\n      admin,\n      tokenMint,\n      config: configPda,\n      stakeVault,\n      rewardVault,\n      tokenProgram: TOKEN_PROGRAM_ID,\n    });\n}\n\nexport function stake(\n  program: Program<Svault>,\n  user: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number,\n  amount: BN | number\n) {\n  const amountBN = typeof amount === \"number\" ? new BN(amount) : amount;\n\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);\n  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);\n  const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);\n\n  return program.methods.stake(amountBN).accountsPartial({\n    user,\n    tokenMint,\n    config: configPda,\n    userStake: userStakePda,\n    stakeVault,\n    userTokenAccount,\n    tokenProgram: TOKEN_PROGRAM_ID,\n  });\n}\n\nexport function initiateUnstake(\n  program: Program<Svault>,\n  user: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number,\n  amount: BN | number\n) {\n  const amountBN = typeof amount === \"number\" ? new BN(amount) : amount;\n\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);\n\n  return program.methods.initiateUnstake(amountBN).accountsPartial({\n    user,\n    tokenMint,\n    config: configPda,\n    userStake: userStakePda,\n  });\n}\n\nexport function withdraw(\n  program: Program<Svault>,\n  user: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number\n) {\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);\n  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);\n  const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);\n\n  return program.methods.withdraw().accountsPartial({\n    user,\n    tokenMint,\n    config: configPda,\n    userStake: userStakePda,\n    stakeVault,\n    userTokenAccount,\n    tokenProgram: TOKEN_PROGRAM_ID,\n  });\n}\n\nexport function postRewards(\n  program: Program<Svault>,\n  admin: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number,\n  merkleRoot: number[],\n  totalAmount: BN | number\n) {\n  const merkleRootArray = merkleRoot as number[];\n  const totalAmountBN = typeof totalAmount === \"number\" ? new BN(totalAmount) : totalAmount;\n\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [rewardVault] = deriveRewardVaultPDA(configPda, program.programId);\n  const adminTokenAccount = getAssociatedTokenAddressSync(tokenMint, admin);\n\n  return program.methods\n    .postRewards(merkleRootArray, totalAmountBN)\n    .accountsPartial({\n      admin,\n      tokenMint,\n      config: configPda,\n      rewardVault,\n      adminTokenAccount,\n      tokenProgram: TOKEN_PROGRAM_ID,\n    });\n}\n\nexport function claimRewards(\n  program: Program<Svault>,\n  user: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number,\n  cumulativeAmount: BN | number,\n  proof: number[][]\n) {\n  const cumulativeAmountBN = typeof cumulativeAmount === \"number\" ? new BN(cumulativeAmount) : cumulativeAmount;\n\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [userStakePda] = deriveUserStakePDA(configPda, user, program.programId);\n  const [rewardVault] = deriveRewardVaultPDA(configPda, program.programId);\n  const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, user);\n\n  return program.methods\n    .claimRewards(cumulativeAmountBN, proof)\n    .accountsPartial({\n      user,\n      tokenMint,\n      config: configPda,\n      userStake: userStakePda,\n      rewardVault,\n      userTokenAccount,\n      tokenProgram: TOKEN_PROGRAM_ID,\n    });\n}\n\nexport function setConfig(\n  program: Program<Svault>,\n  admin: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number,\n  unstakingPeriod: BN | number | null,\n  volumeWindow: BN | number | null\n) {\n  const unstakingPeriodArg = unstakingPeriod === null\n    ? null\n    : typeof unstakingPeriod === \"number\"\n      ? new BN(unstakingPeriod)\n      : unstakingPeriod;\n\n  const volumeWindowArg = volumeWindow === null\n    ? null\n    : typeof volumeWindow === \"number\"\n      ? new BN(volumeWindow)\n      : volumeWindow;\n\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n\n  return program.methods\n    .setConfig(unstakingPeriodArg, volumeWindowArg)\n    .accountsPartial({\n      admin,\n      config: configPda,\n    });\n}\n\nexport function slash(\n  program: Program<Svault>,\n  admin: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number,\n  userStakePda: PublicKey,\n  basisPoints: number\n) {\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [stakeVault] = deriveStakeVaultPDA(configPda, program.programId);\n  const feeVault = getAssociatedTokenAddressSync(tokenMint, FEE_AUTHORITY);\n\n  return program.methods.slash(basisPoints).accountsPartial({\n    admin,\n    tokenMint,\n    config: configPda,\n    userStake: userStakePda,\n    stakeVault,\n    feeVault,\n    tokenProgram: TOKEN_PROGRAM_ID,\n  });\n}\n\nexport function addDelegate(\n  program: Program<Svault>,\n  staker: PublicKey,\n  delegateWallet: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number\n) {\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [userStakePda] = deriveUserStakePDA(configPda, staker, program.programId);\n  const [delegatePda] = deriveDelegatePDA(configPda, delegateWallet, program.programId);\n\n  return program.methods.addDelegate().accountsPartial({\n    staker,\n    delegateWallet,\n    config: configPda,\n    userStake: userStakePda,\n    delegate: delegatePda,\n  });\n}\n\nexport function removeDelegate(\n  program: Program<Svault>,\n  staker: PublicKey,\n  delegateWallet: PublicKey,\n  tokenMint: PublicKey,\n  nonce: number\n) {\n  const [configPda] = deriveStakingConfigPDA(tokenMint, nonce, program.programId);\n  const [delegatePda] = deriveDelegatePDA(configPda, delegateWallet, program.programId);\n\n  return program.methods.removeDelegate().accountsPartial({\n    staker,\n    config: configPda,\n    delegate: delegatePda,\n  });\n}\n"]}

package/dist/svault/types.d.ts

@@ -0,0 +1,46 @@
+import { IdlAccounts, IdlEvents } from "@coral-xyz/anchor";
+import { TxOptions } from "../utils";
+export { Svault } from "../generated/types";
+import type { Svault } from "../generated/types";
+export type StakingConfigAccount = IdlAccounts<Svault>["stakingConfig"];
+export type UserStakeAccount = IdlAccounts<Svault>["userStake"];
+export type DelegateAccount = IdlAccounts<Svault>["delegate"];
+export type StakingVaultInitializedEvent = IdlEvents<Svault>["stakingVaultInitialized"];
+export type StakedEvent = IdlEvents<Svault>["staked"];
+export type UnstakeInitiatedEvent = IdlEvents<Svault>["unstakeInitiated"];
+export type WithdrawnEvent = IdlEvents<Svault>["withdrawn"];
+export type RewardsPostedEvent = IdlEvents<Svault>["rewardsPosted"];
+export type RewardsClaimedEvent = IdlEvents<Svault>["rewardsClaimed"];
+export type SlashedEvent = IdlEvents<Svault>["slashed"];
+export type DelegateAddedEvent = IdlEvents<Svault>["delegateAdded"];
+export type DelegateRemovedEvent = IdlEvents<Svault>["delegateRemoved"];
+export type SVaultEvent = {
+    name: "StakingVaultInitialized";
+    data: StakingVaultInitializedEvent;
+} | {
+    name: "Staked";
+    data: StakedEvent;
+} | {
+    name: "UnstakeInitiated";
+    data: UnstakeInitiatedEvent;
+} | {
+    name: "Withdrawn";
+    data: WithdrawnEvent;
+} | {
+    name: "RewardsPosted";
+    data: RewardsPostedEvent;
+} | {
+    name: "RewardsClaimed";
+    data: RewardsClaimedEvent;
+} | {
+    name: "Slashed";
+    data: SlashedEvent;
+} | {
+    name: "DelegateAdded";
+    data: DelegateAddedEvent;
+} | {
+    name: "DelegateRemoved";
+    data: DelegateRemovedEvent;
+};
+export interface SVaultTxOptions extends TxOptions {
+}

package/dist/svault/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Type definitions for the SVault program.
+ * Exports IDL-derived types and SDK-friendly enums.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/svault/utils.d.ts

@@ -0,0 +1,32 @@
+import { Program } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { Svault, StakingConfigAccount, UserStakeAccount, DelegateAccount } from "./types";
+export declare function deriveStakingConfigPDA(tokenMint: PublicKey, nonce: number, programId?: PublicKey): [PublicKey, number];
+export declare function deriveUserStakePDA(stakingConfig: PublicKey, user: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function deriveDelegatePDA(stakingConfig: PublicKey, delegate: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function deriveStakeVaultPDA(stakingConfig: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function deriveRewardVaultPDA(stakingConfig: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function fetchStakingConfigAccount(program: Program<Svault>, pda: PublicKey): Promise<StakingConfigAccount>;
+export declare function fetchUserStakeAccount(program: Program<Svault>, pda: PublicKey): Promise<UserStakeAccount>;
+export declare function fetchDelegateAccount(program: Program<Svault>, pda: PublicKey): Promise<DelegateAccount>;
+/**
+ * Compute when withdrawal will be available based on unstake initiation time.
+ * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
+ * @param unstakingPeriodDays Number of days in unstaking period
+ * @returns Date when withdrawal becomes available
+ */
+export declare function computeWithdrawAvailableAt(unstakeInitiatedAt: number, unstakingPeriodDays: number): Date;
+/**
+ * Check if withdrawal is currently available.
+ * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
+ * @param unstakingPeriodDays Number of days in unstaking period
+ * @returns true if unstaking period has elapsed
+ */
+export declare function isWithdrawAvailable(unstakeInitiatedAt: number, unstakingPeriodDays: number): boolean;
+/**
+ * Compute the time remaining until withdrawal is available.
+ * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
+ * @param unstakingPeriodDays Number of days in unstaking period
+ * @returns Seconds remaining, or 0 if already available
+ */
+export declare function getTimeUntilWithdraw(unstakeInitiatedAt: number, unstakingPeriodDays: number): number;

package/dist/svault/utils.js

@@ -0,0 +1,86 @@
+"use strict";
+/*
+ * Utility functions for the SVault program.
+ * PDA derivation, state parsing, and account fetching.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveStakingConfigPDA = deriveStakingConfigPDA;
+exports.deriveUserStakePDA = deriveUserStakePDA;
+exports.deriveDelegatePDA = deriveDelegatePDA;
+exports.deriveStakeVaultPDA = deriveStakeVaultPDA;
+exports.deriveRewardVaultPDA = deriveRewardVaultPDA;
+exports.fetchStakingConfigAccount = fetchStakingConfigAccount;
+exports.fetchUserStakeAccount = fetchUserStakeAccount;
+exports.fetchDelegateAccount = fetchDelegateAccount;
+exports.computeWithdrawAvailableAt = computeWithdrawAvailableAt;
+exports.isWithdrawAvailable = isWithdrawAvailable;
+exports.getTimeUntilWithdraw = getTimeUntilWithdraw;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+/* PDA Derivation */
+function deriveStakingConfigPDA(tokenMint, nonce, programId = constants_1.PROGRAM_ID) {
+    const nonceBuffer = Buffer.alloc(2);
+    nonceBuffer.writeUInt16LE(nonce);
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.STAKING_CONFIG_SEED, tokenMint.toBuffer(), nonceBuffer], programId);
+}
+function deriveUserStakePDA(stakingConfig, user, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.USER_STAKE_SEED, stakingConfig.toBuffer(), user.toBuffer()], programId);
+}
+function deriveDelegatePDA(stakingConfig, delegate, programId = constants_1.PROGRAM_ID) {
+    // Uses USER_STAKE_SEED to prevent delegate from also being a staker
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.USER_STAKE_SEED, stakingConfig.toBuffer(), delegate.toBuffer()], programId);
+}
+function deriveStakeVaultPDA(stakingConfig, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.STAKE_VAULT_SEED, stakingConfig.toBuffer()], programId);
+}
+function deriveRewardVaultPDA(stakingConfig, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.REWARD_VAULT_SEED, stakingConfig.toBuffer()], programId);
+}
+/* Fetchers */
+async function fetchStakingConfigAccount(program, pda) {
+    return program.account.stakingConfig.fetch(pda);
+}
+async function fetchUserStakeAccount(program, pda) {
+    return program.account.userStake.fetch(pda);
+}
+async function fetchDelegateAccount(program, pda) {
+    return program.account.delegate.fetch(pda);
+}
+/* Helpers */
+/**
+ * Compute when withdrawal will be available based on unstake initiation time.
+ * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
+ * @param unstakingPeriodDays Number of days in unstaking period
+ * @returns Date when withdrawal becomes available
+ */
+function computeWithdrawAvailableAt(unstakeInitiatedAt, unstakingPeriodDays) {
+    const availableAtSeconds = unstakeInitiatedAt + unstakingPeriodDays * constants_1.SECONDS_PER_DAY;
+    return new Date(availableAtSeconds * 1000);
+}
+/**
+ * Check if withdrawal is currently available.
+ * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
+ * @param unstakingPeriodDays Number of days in unstaking period
+ * @returns true if unstaking period has elapsed
+ */
+function isWithdrawAvailable(unstakeInitiatedAt, unstakingPeriodDays) {
+    if (unstakeInitiatedAt === 0)
+        return false;
+    const now = Math.floor(Date.now() / 1000);
+    const availableAt = unstakeInitiatedAt + unstakingPeriodDays * constants_1.SECONDS_PER_DAY;
+    return now >= availableAt;
+}
+/**
+ * Compute the time remaining until withdrawal is available.
+ * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)
+ * @param unstakingPeriodDays Number of days in unstaking period
+ * @returns Seconds remaining, or 0 if already available
+ */
+function getTimeUntilWithdraw(unstakeInitiatedAt, unstakingPeriodDays) {
+    if (unstakeInitiatedAt === 0)
+        return 0;
+    const now = Math.floor(Date.now() / 1000);
+    const availableAt = unstakeInitiatedAt + unstakingPeriodDays * constants_1.SECONDS_PER_DAY;
+    return Math.max(0, availableAt - now);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/svault/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Utility functions for the SVault program.\n * PDA derivation, state parsing, and account fetching.\n */\n\nimport { Program } from \"@coral-xyz/anchor\";\nimport { PublicKey } from \"@solana/web3.js\";\nimport {\n  STAKING_CONFIG_SEED,\n  USER_STAKE_SEED,\n  STAKE_VAULT_SEED,\n  REWARD_VAULT_SEED,\n  PROGRAM_ID,\n  SECONDS_PER_DAY,\n} from \"./constants\";\nimport { Svault, StakingConfigAccount, UserStakeAccount, DelegateAccount } from \"./types\";\n\n/* PDA Derivation */\n\nexport function deriveStakingConfigPDA(\n  tokenMint: PublicKey,\n  nonce: number,\n  programId: PublicKey = PROGRAM_ID\n): [PublicKey, number] {\n  const nonceBuffer = Buffer.alloc(2);\n  nonceBuffer.writeUInt16LE(nonce);\n  return PublicKey.findProgramAddressSync(\n    [STAKING_CONFIG_SEED, tokenMint.toBuffer(), nonceBuffer],\n    programId\n  );\n}\n\nexport function deriveUserStakePDA(\n  stakingConfig: PublicKey,\n  user: PublicKey,\n  programId: PublicKey = PROGRAM_ID\n): [PublicKey, number] {\n  return PublicKey.findProgramAddressSync(\n    [USER_STAKE_SEED, stakingConfig.toBuffer(), user.toBuffer()],\n    programId\n  );\n}\n\nexport function deriveDelegatePDA(\n  stakingConfig: PublicKey,\n  delegate: PublicKey,\n  programId: PublicKey = PROGRAM_ID\n): [PublicKey, number] {\n  // Uses USER_STAKE_SEED to prevent delegate from also being a staker\n  return PublicKey.findProgramAddressSync(\n    [USER_STAKE_SEED, stakingConfig.toBuffer(), delegate.toBuffer()],\n    programId\n  );\n}\n\nexport function deriveStakeVaultPDA(\n  stakingConfig: PublicKey,\n  programId: PublicKey = PROGRAM_ID\n): [PublicKey, number] {\n  return PublicKey.findProgramAddressSync(\n    [STAKE_VAULT_SEED, stakingConfig.toBuffer()],\n    programId\n  );\n}\n\nexport function deriveRewardVaultPDA(\n  stakingConfig: PublicKey,\n  programId: PublicKey = PROGRAM_ID\n): [PublicKey, number] {\n  return PublicKey.findProgramAddressSync(\n    [REWARD_VAULT_SEED, stakingConfig.toBuffer()],\n    programId\n  );\n}\n\n/* Fetchers */\n\nexport async function fetchStakingConfigAccount(\n  program: Program<Svault>,\n  pda: PublicKey\n): Promise<StakingConfigAccount> {\n  return program.account.stakingConfig.fetch(pda);\n}\n\nexport async function fetchUserStakeAccount(\n  program: Program<Svault>,\n  pda: PublicKey\n): Promise<UserStakeAccount> {\n  return program.account.userStake.fetch(pda);\n}\n\nexport async function fetchDelegateAccount(\n  program: Program<Svault>,\n  pda: PublicKey\n): Promise<DelegateAccount> {\n  return program.account.delegate.fetch(pda);\n}\n\n/* Helpers */\n\n/**\n * Compute when withdrawal will be available based on unstake initiation time.\n * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)\n * @param unstakingPeriodDays Number of days in unstaking period\n * @returns Date when withdrawal becomes available\n */\nexport function computeWithdrawAvailableAt(\n  unstakeInitiatedAt: number,\n  unstakingPeriodDays: number\n): Date {\n  const availableAtSeconds = unstakeInitiatedAt + unstakingPeriodDays * SECONDS_PER_DAY;\n  return new Date(availableAtSeconds * 1000);\n}\n\n/**\n * Check if withdrawal is currently available.\n * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)\n * @param unstakingPeriodDays Number of days in unstaking period\n * @returns true if unstaking period has elapsed\n */\nexport function isWithdrawAvailable(\n  unstakeInitiatedAt: number,\n  unstakingPeriodDays: number\n): boolean {\n  if (unstakeInitiatedAt === 0) return false;\n  const now = Math.floor(Date.now() / 1000);\n  const availableAt = unstakeInitiatedAt + unstakingPeriodDays * SECONDS_PER_DAY;\n  return now >= availableAt;\n}\n\n/**\n * Compute the time remaining until withdrawal is available.\n * @param unstakeInitiatedAt Unix timestamp when unstake was initiated (seconds)\n * @param unstakingPeriodDays Number of days in unstaking period\n * @returns Seconds remaining, or 0 if already available\n */\nexport function getTimeUntilWithdraw(\n  unstakeInitiatedAt: number,\n  unstakingPeriodDays: number\n): number {\n  if (unstakeInitiatedAt === 0) return 0;\n  const now = Math.floor(Date.now() / 1000);\n  const availableAt = unstakeInitiatedAt + unstakingPeriodDays * SECONDS_PER_DAY;\n  return Math.max(0, availableAt - now);\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomb/programs-sdk",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "description": "SDK for ZCombinator Programs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/futarchy/client.ts

@@ -606,13 +606,19 @@ export class FutarchyClient {
 
     // Create ALT
     const createTx = new Transaction().add(createIx);
-    createTx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+    const { blockhash: createBlockhash, lastValidBlockHeight: createLastValidBlockHeight } =
+      await provider.connection.getLatestBlockhash('confirmed');
+    createTx.recentBlockhash = createBlockhash;
     createTx.feePayer = creator;
     const signedTx = await provider.wallet.signTransaction(createTx);
     const sig = await provider.connection.sendRawTransaction(signedTx.serialize(), {
       skipPreflight: true,
     });
-    await provider.connection.confirmTransaction(sig, "confirmed");
+    await provider.connection.confirmTransaction({
+      signature: sig,
+      blockhash: createBlockhash,
+      lastValidBlockHeight: createLastValidBlockHeight,
+    }, "confirmed");
 
     // Extend ALT with addresses
     // Use skipPreflight to avoid race condition where simulation sees stale state
@@ -627,13 +633,19 @@ export class FutarchyClient {
         addresses: chunk,
       });
       const extendTx = new Transaction().add(extendIx);
-      extendTx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+      const { blockhash: extendBlockhash, lastValidBlockHeight: extendLastValidBlockHeight } =
+        await provider.connection.getLatestBlockhash('confirmed');
+      extendTx.recentBlockhash = extendBlockhash;
       extendTx.feePayer = creator;
       const signedExtendTx = await provider.wallet.signTransaction(extendTx);
       const extendSig = await provider.connection.sendRawTransaction(signedExtendTx.serialize(), {
         skipPreflight: true,
       });
-      await provider.connection.confirmTransaction(extendSig, "confirmed");
+      await provider.connection.confirmTransaction({
+        signature: extendSig,
+        blockhash: extendBlockhash,
+        lastValidBlockHeight: extendLastValidBlockHeight,
+      }, "confirmed");
     }
 
     return { altAddress };
@@ -646,13 +658,19 @@ export class FutarchyClient {
    * @param creator - The user redeeming
    * @param proposalPda - The proposal PDA
    * @param altAddress - Optional ALT address (will be created if not provided for 3+ options)
-   * @returns Unsigned versioned transaction, ALT address, and number of options
+   * @returns Unsigned versioned transaction, ALT address, number of options, and blockhash info for confirmation
    */
   async redeemLiquidityVersioned(
     creator: PublicKey,
     proposalPda: PublicKey,
     altAddress?: PublicKey,
-  ): Promise<{ versionedTx: VersionedTransaction; altAddress: PublicKey; numOptions: number }> {
+  ): Promise<{
+    versionedTx: VersionedTransaction;
+    altAddress: PublicKey;
+    numOptions: number;
+    blockhash: string;
+    lastValidBlockHeight: number;
+  }> {
     const provider = this.program.provider as AnchorProvider;
     const { builder, numOptions } = await this.redeemLiquidity(creator, proposalPda);
 
@@ -710,8 +728,8 @@ export class FutarchyClient {
     const instruction = await builder.instruction();
     const computeBudgetIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 });
 
-    // Get fresh blockhash
-    const { blockhash } = await provider.connection.getLatestBlockhash();
+    // Get fresh blockhash with lastValidBlockHeight for confirmation tracking
+    const { blockhash, lastValidBlockHeight } = await provider.connection.getLatestBlockhash('confirmed');
 
     // Build versioned transaction using the verified ALT (no re-fetch)
     const versionedTx = this.buildVersionedTxWithALT(
@@ -721,23 +739,56 @@ export class FutarchyClient {
       blockhash,
     );
 
-    // Return the versioned transaction for the caller to sign and send
+    // Return the versioned transaction along with blockhash info for proper confirmation
     // This allows the caller to use their own signing mechanism (e.g., keypair.sign)
-    return { versionedTx, altAddress: altPubkey, numOptions };
+    return { versionedTx, altAddress: altPubkey, numOptions, blockhash, lastValidBlockHeight };
   }
 
   /**
-   * Helper to send a signed versioned transaction.
+   * Helper to send a signed versioned transaction with robust confirmation handling.
+   * Uses blockhash-based confirmation to properly detect transaction expiration
+   * instead of relying on a fixed timeout.
+   *
+   * @param signedTx - The signed versioned transaction to send
+   * @param confirmationInfo - Optional blockhash info from when the transaction was built.
+   *                          If not provided, a fresh blockhash will be fetched (less accurate).
    */
   async sendVersionedTransaction(
     signedTx: VersionedTransaction,
+    confirmationInfo?: { blockhash: string; lastValidBlockHeight: number },
   ): Promise<string> {
     const provider = this.program.provider as AnchorProvider;
+
+    // Use provided blockhash info or fetch fresh one
+    // Using the original blockhash is more accurate for detecting expiration
+    let blockhash: string;
+    let lastValidBlockHeight: number;
+
+    if (confirmationInfo) {
+      blockhash = confirmationInfo.blockhash;
+      lastValidBlockHeight = confirmationInfo.lastValidBlockHeight;
+    } else {
+      // Fallback: get fresh blockhash (may wait longer than necessary if tx already expired)
+      const latestBlockhash = await provider.connection.getLatestBlockhash('confirmed');
+      blockhash = latestBlockhash.blockhash;
+      lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+    }
+
     const signature = await provider.connection.sendTransaction(signedTx, {
       skipPreflight: false,
       preflightCommitment: 'confirmed',
     });
-    await provider.connection.confirmTransaction(signature, 'confirmed');
+
+    // Use blockhash-based confirmation which waits until either:
+    // 1. Transaction is confirmed
+    // 2. Blockhash expires (lastValidBlockHeight passed)
+    // This is more robust than a fixed timeout on congested networks
+    await provider.connection.confirmTransaction({
+      signature,
+      blockhash,
+      lastValidBlockHeight,
+    }, 'confirmed');
+
     return signature;
   }
 
@@ -810,13 +861,19 @@ export class FutarchyClient {
 
     // Send create transaction immediately, skip preflight to avoid slot timing issues
     const createTx = new Transaction().add(createIx);
-    createTx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+    const { blockhash: createBlockhash, lastValidBlockHeight: createLastValidBlockHeight } =
+      await provider.connection.getLatestBlockhash('confirmed');
+    createTx.recentBlockhash = createBlockhash;
     createTx.feePayer = creator;
     const signedTx = await provider.wallet.signTransaction(createTx);
     const sig = await provider.connection.sendRawTransaction(signedTx.serialize(), {
       skipPreflight: true,
     });
-    await provider.connection.confirmTransaction(sig, "confirmed");
+    await provider.connection.confirmTransaction({
+      signature: sig,
+      blockhash: createBlockhash,
+      lastValidBlockHeight: createLastValidBlockHeight,
+    }, "confirmed");
 
     // Split addresses into chunks to avoid transaction size limits
     // Each address is 32 bytes, ~20 addresses per extend instruction is safe
@@ -832,13 +889,19 @@ export class FutarchyClient {
         addresses: chunk,
       });
       const extendTx = new Transaction().add(extendIx);
-      extendTx.recentBlockhash = (await provider.connection.getLatestBlockhash()).blockhash;
+      const { blockhash: extendBlockhash, lastValidBlockHeight: extendLastValidBlockHeight } =
+        await provider.connection.getLatestBlockhash('confirmed');
+      extendTx.recentBlockhash = extendBlockhash;
       extendTx.feePayer = creator;
       const signedExtendTx = await provider.wallet.signTransaction(extendTx);
       const extendSig = await provider.connection.sendRawTransaction(signedExtendTx.serialize(), {
         skipPreflight: true,
       });
-      await provider.connection.confirmTransaction(extendSig, "confirmed");
+      await provider.connection.confirmTransaction({
+        signature: extendSig,
+        blockhash: extendBlockhash,
+        lastValidBlockHeight: extendLastValidBlockHeight,
+      }, "confirmed");
     }
 
     return { altAddress };
@@ -856,11 +919,16 @@ export class FutarchyClient {
     payer: PublicKey,
     instructions: TransactionInstruction[],
     altAddress: PublicKey,
-  ): Promise<VersionedTransaction> {
+  ): Promise<{
+    versionedTx: VersionedTransaction;
+    blockhash: string;
+    lastValidBlockHeight: number;
+  }> {
     const provider = this.program.provider as AnchorProvider;
     const alt = await this.fetchALT(altAddress);
-    const { blockhash } = await provider.connection.getLatestBlockhash();
-    return this.buildVersionedTxWithALT(payer, instructions, alt, blockhash);
+    const { blockhash, lastValidBlockHeight } = await provider.connection.getLatestBlockhash('confirmed');
+    const versionedTx = this.buildVersionedTxWithALT(payer, instructions, alt, blockhash);
+    return { versionedTx, blockhash, lastValidBlockHeight };
   }
 
   buildVersionedTxWithALT(

package/src/generated/idls/index.ts

@@ -1,3 +1,4 @@
 export { default as AmmIDL } from "./amm.json";
 export { default as FutarchyIDL } from "./futarchy.json";
 export { default as VaultIDL } from "./vault.json";
+export { default as SvaultIDL } from "./svault.json";