@wireio/stake 0.7.3 → 0.9.1

package/src/networks/solana/clients/deposit.client.ts

@@ -1,4 +1,4 @@
-import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import { AnchorProvider, BN, Program, Wallet } from '@coral-xyz/anchor';
 import {
     SystemProgram,
     Transaction,
@@ -8,12 +8,19 @@ import {
     SYSVAR_CLOCK_PUBKEY,
     SYSVAR_RENT_PUBKEY,
     SYSVAR_STAKE_HISTORY_PUBKEY,
+    Connection,
+    PublicKey,
+    TransactionMessage,
+    LAMPORTS_PER_SOL,
+    Signer,
 } from '@solana/web3.js';
+
 import {
     TOKEN_2022_PROGRAM_ID,
     ASSOCIATED_TOKEN_PROGRAM_ID,
     getAssociatedTokenAddressSync,
 } from '@solana/spl-token';
+import * as multisig from "@sqds/multisig";
 
 import { SolanaProgramService } from '../program';
 import type { LiqsolCore } from '../../../assets/solana/types/liqsol_core';
@@ -47,6 +54,10 @@ import { GlobalAccount, WalletLike } from '../types';
 export class DepositClient {
     private program: Program<LiqsolCore>;
 
+    get connection() {
+        return this.provider.connection;
+    }
+
     get wallet(): WalletLike {
         return this.provider.wallet;
     }
@@ -63,7 +74,7 @@ export class DepositClient {
     async buildDepositTx(
         amount: bigint,
         user = this.wallet.publicKey,
-    ): Promise<Transaction> {
+    ): Promise<TransactionInstruction> {
         if (!user) {
             throw new Error(
                 'DepositClient.buildDepositTx: wallet not connected',
@@ -95,7 +106,7 @@ export class DepositClient {
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
@@ -121,7 +132,7 @@ export class DepositClient {
         // -------------------------------------------------------------
         // BUILD IX (MUST MATCH IDL)
         // -------------------------------------------------------------
-        const ix: TransactionInstruction = await this.program.methods
+        return await this.program.methods
             .deposit(new BN(amount.toString()), seed)
             .accounts({
                 user,
@@ -151,10 +162,130 @@ export class DepositClient {
                 globalConfig
             })
             .instruction();
+    }
 
-        return new Transaction().add(ix);
+
+
+    async buildSquadsDepositProposalTx(params: {
+        connection: Connection;
+        multisigPda: PublicKey;
+        amountLamports: bigint;
+        wallet: WalletLikeSigner;   // your WalletLikeSigner type
+        vaultIndex?: number;
+    }): Promise<{
+        tx: Transaction;
+        transactionIndex: bigint;
+        vaultPda: PublicKey;
+    }> {
+        const { connection, multisigPda, amountLamports, wallet } = params;
+        const vaultIndex = params.vaultIndex ?? 0;
+
+        if (!wallet?.publicKey) throw new Error("wallet.publicKey missing");
+        if (!amountLamports || amountLamports <= BigInt(0)) throw new Error("amountLamports must be > 0");
+
+        // 1) vault PDA
+        const [vaultPda] = multisig.getVaultPda({ multisigPda, index: vaultIndex });
+
+        // 2) build deposit ix where `user` = vaultPda (off-curve OK)
+        const depositBuilt = await this.buildDepositIxForUser(amountLamports, vaultPda);
+
+        // 3) compute next transactionIndex (best-effort; see note below)
+        const ms = await multisig.accounts.Multisig.fromAccountAddress(connection, multisigPda);
+        const current = BigInt((ms as any).transactionIndex?.toString?.() ?? 0);
+        const transactionIndex = current + BigInt(1);
+
+        // 4) inner message uses vault as payer
+        const { blockhash } = await connection.getLatestBlockhash("confirmed");
+        const message = new TransactionMessage({
+            payerKey: vaultPda,
+            recentBlockhash: blockhash,
+            instructions: [depositBuilt.ix],
+        });
+
+        // 5) squads instructions (no rpc.*)
+        const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+            multisigPda,
+            transactionIndex,
+            creator: wallet.publicKey,
+            vaultIndex,
+            ephemeralSigners: 0,
+            transactionMessage: message,
+        });
+
+        // const createProposalIx = await multisig.instructions.proposalCreate({
+        //     multisigPda,
+        //     transactionIndex,
+        //     creator: wallet.publicKey,
+        // });
+        console.log('createVaultTxIx', createVaultTxIx);
+
+
+        // 6) return a normal Transaction for your pipeline
+        const tx = new Transaction().add(createVaultTxIx);
+
+        return { tx, transactionIndex, vaultPda };
+    }
+
+    async buildSquadsDepositProposalTx2(params: {
+        connection: Connection;
+        multisigPda: PublicKey;
+        amountLamports: bigint;
+        wallet: WalletLikeSigner;   // your WalletLikeSigner type
+        vaultIndex?: number;
+    }): Promise<{
+        tx: Transaction;
+        transactionIndex: bigint;
+        vaultPda: PublicKey;
+    }> {
+        const { connection, multisigPda, amountLamports, wallet } = params;
+        const vaultIndex = params.vaultIndex ?? 0;
+
+        if (!wallet?.publicKey) throw new Error("wallet.publicKey missing");
+        if (!amountLamports || amountLamports <= BigInt(0)) throw new Error("amountLamports must be > 0");
+
+        // 1) vault PDA
+        const [vaultPda] = multisig.getVaultPda({ multisigPda, index: vaultIndex });
+
+        // 2) build deposit ix where `user` = vaultPda (off-curve OK)
+        const depositBuilt = await this.buildDepositIxForUser(amountLamports, vaultPda);
+
+        // 3) compute next transactionIndex (best-effort; see note below)
+        const ms = await multisig.accounts.Multisig.fromAccountAddress(connection, multisigPda);
+        const current = BigInt(ms.transactionIndex?.toString?.() ?? 0);
+        const transactionIndex = current + BigInt(1);
+
+        // 4) inner message uses vault as payer
+        const { blockhash } = await connection.getLatestBlockhash("confirmed");
+        const message = new TransactionMessage({
+            payerKey: vaultPda,
+            recentBlockhash: blockhash,
+            instructions: [depositBuilt.ix],
+        });
+
+        // 5) squads instructions (no rpc.*)
+        // const createVaultTxIx = await multisig.instructions.vaultTransactionCreate({
+        //     multisigPda,
+        //     transactionIndex,
+        //     creator: wallet.publicKey,
+        //     vaultIndex,
+        //     ephemeralSigners: 0,
+        //     transactionMessage: message,
+        // });
+
+        const createProposalIx = await multisig.instructions.proposalCreate({
+            multisigPda,
+            transactionIndex,
+            creator: wallet.publicKey,
+        });
+
+        // 6) return a normal Transaction for your pipeline
+        const tx = new Transaction().add(createProposalIx);
+
+        return { tx, transactionIndex, vaultPda };
     }
 
+
+
     /**
      * Build a withdraw-request transaction:
      *   liqSOL -> SOL via liqsol_core::requestWithdraw.
@@ -187,7 +318,7 @@ export class DepositClient {
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
@@ -208,7 +339,7 @@ export class DepositClient {
         // -------------------------------------------------------------
         // Need nextReceiptId from withdraw global state
         // -------------------------------------------------------------
-        const globalAcct : GlobalAccount = await this.program.account.global.fetch(global);
+        const globalAcct: GlobalAccount = await this.program.account.global.fetch(global);
 
         const rawId = globalAcct.nextReceiptId;
         let receiptId: bigint;
@@ -241,7 +372,7 @@ export class DepositClient {
         const nftAta = getAssociatedTokenAddressSync(
             nftMint,
             owner,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
@@ -289,4 +420,124 @@ export class DepositClient {
 
         return new Transaction().add(ix);
     }
-}
+
+
+
+
+
+    /**
+     * Internal helper: build the liqsol_core::deposit instruction for a specific `user`.
+     * This is the exact same account wiring as buildDepositTx(), but returns the IX
+     * plus useful derived addresses/seed for Squads flows.
+     */
+    private async buildDepositIxForUser(
+        amount: bigint,
+        user: PublicKey,
+    ): Promise<{
+        ix: TransactionInstruction;
+        seed: number;
+        userAta: PublicKey;
+        ephemeralStake: PublicKey;
+    }> {
+        if (!user) {
+            throw new Error("buildDepositIxForUser: user is required");
+        }
+        if (!amount || amount <= BigInt(0)) {
+            throw new Error("buildDepositIxForUser: amount must be > 0");
+        }
+
+        // -------------------------------------------------------------
+        // PDAs
+        // -------------------------------------------------------------
+        const depositAuthority = deriveDepositAuthorityPda();
+        const liqsolMint = deriveLiqsolMintPda();
+        const liqsolMintAuthority = deriveLiqsolMintAuthorityPda();
+        const reservePool = deriveReservePoolPda();
+        const vault = deriveVaultPda();
+        const controllerState = deriveStakeControllerStatePda();
+        const payoutState = derivePayoutStatePda();
+        const bucketAuthority = deriveBucketAuthorityPda();
+        const payRateHistory = derivePayRateHistoryPda();
+        const globalConfig = deriveGlobalConfigPda();
+
+        // -------------------------------------------------------------
+        // Token-2022 ATAs
+        // -------------------------------------------------------------
+        const userAta = getAssociatedTokenAddressSync(
+            liqsolMint,
+            user,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        // -------------------------------------------------------------
+        // Distribution state + user_record (KEYED BY TOKEN ACCOUNT)
+        // -------------------------------------------------------------
+        const distributionState = deriveDistributionStatePda();
+        const userRecord = deriveUserRecordPda(userAta);
+
+        const bucketTokenAccount = getAssociatedTokenAddressSync(
+            liqsolMint,
+            bucketAuthority,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        // -------------------------------------------------------------
+        // Ephemeral stake
+        // -------------------------------------------------------------
+        const seed = Math.floor(Math.random() * 2 ** 32);
+        const ephemeralStake = await deriveEphemeralStakeAddress(user, seed);
+
+        // -------------------------------------------------------------
+        // BUILD IX (MUST MATCH IDL)
+        // -------------------------------------------------------------
+        const ix: TransactionInstruction = await this.program.methods
+            .deposit(new BN(amount.toString()), seed)
+            .accounts({
+                user,
+                depositAuthority,
+                systemProgram: SystemProgram.programId,
+                tokenProgram: TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+                liqsolProgram: PROGRAM_IDS.LIQSOL_TOKEN,
+                stakeProgram: StakeProgram.programId,
+                liqsolMint,
+                userAta,
+                liqsolMintAuthority,
+                reservePool,
+                vault,
+                ephemeralStake,
+                controllerState,
+                payoutState,
+                bucketAuthority,
+                bucketTokenAccount,
+                userRecord,
+                distributionState,
+                payRateHistory,
+                instructionsSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
+                clock: SYSVAR_CLOCK_PUBKEY,
+                stakeHistory: SYSVAR_STAKE_HISTORY_PUBKEY,
+                rent: SYSVAR_RENT_PUBKEY,
+                globalConfig,
+            })
+            .instruction();
+
+        return { ix, seed, userAta, ephemeralStake };
+    }
+
+}
+
+// A “wallet-adapter-like” shape (AnchorProvider.wallet matches this)
+type WalletLikeSigner = {
+    publicKey: PublicKey;
+    signTransaction: (tx: Transaction) => Promise<Transaction>;
+};
+
+function isKeypairSigner(x: any): x is { publicKey: PublicKey; secretKey: Uint8Array } {
+    return !!x && x.publicKey instanceof PublicKey && x.secretKey instanceof Uint8Array;
+}
+
+function isWalletLikeSigner(x: any): x is WalletLikeSigner {
+    return !!x && x.publicKey instanceof PublicKey && typeof x.signTransaction === "function";
+}

package/src/networks/solana/clients/distribution.client.ts

@@ -106,7 +106,7 @@ export class DistributionClient {
             const ata = getAssociatedTokenAddressSync(
                 liqsolMint,
                 ownerOrAta,
-                false,
+                true,
                 TOKEN_2022_PROGRAM_ID,
             );
             const pdaFromWallet = deriveUserRecordPda(ata);

package/src/networks/solana/clients/outpost.client.ts

@@ -277,7 +277,7 @@ export class OutpostClient {
      *   if remainder > 0 → shares + 1
      */
     static tokensToShares(amount: BN, currentIndex: BN): BN {
-        const numerator = amount.mul(INDEX_SCALE);
+        const numerator = amount.mul(new BN(INDEX_SCALE));
         const shares = numerator.div(currentIndex);
         const remainder = numerator.mod(currentIndex);
         return remainder.eqn(0) ? shares : shares.addn(1);

package/src/networks/solana/constants.ts

@@ -355,7 +355,7 @@ export const deriveEphemeralStakeAddress = async (
  * Constant keys (Chainlink)
  */
 export const CHAINLINK_FEED = new PublicKey(
-    '99B2bTijsU6f1GCT73HmdR7HCFFjGMBcPZY6jZ96ynrR',
+    'CH31Xns5z3M1cTAbKW34jcxPPciazARpijcHj9rxtemt',
 );
 export const CHAINLINK_PROGRAM = new PublicKey(
     'HEvSKofvBgfaexv23kMabbYqxasxU3mQ4ibBMEmJWHny',