@wireio/stake 0.9.0 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "0.9.0",
+    "version": "0.9.2",
     "description": "LIQ Staking Module for Wire Network",
     "homepage": "https://gitea.gitgo.app/Wire/sdk-stake",
     "license": "FSL-1.1-Apache-2.0",
@@ -33,7 +33,7 @@
         "lint:fix": "eslint 'src/**/*.{js,ts}' --fix"
     },
     "peerDependencies": {
-        "@wireio/core": ">=0.1.0 <0.3.0"
+        "@wireio/core": ">=0.1.0 <0.4.0"
     },
     "dependencies": {
         "@coral-xyz/anchor": "^0.31.1",
@@ -41,6 +41,7 @@
         "@solana/spl-token": "^0.4.13",
         "@solana/wallet-adapter-base": "^0.9.27",
         "@solana/web3.js": "^1.98.2",
+        "@sqds/multisig": "^2.1.4",
         "bs58": "^6.0.0",
         "buffer": "^6.0.3",
         "crypto-browserify": "^3.12.1",
@@ -63,7 +64,7 @@
         "@types/node": "^18.19.0",
         "@typescript-eslint/eslint-plugin": "^5.60.0",
         "@typescript-eslint/parser": "^5.60.0",
-        "@wireio/core": "^0.2.9",
+        "@wireio/core": "^0.3.0",
         "assert": "^2.0.0",
         "chai": "^4.3.6",
         "esbuild": "^0.25.8",

package/src/networks/ethereum/clients/convert.client.ts

@@ -1,5 +1,5 @@
 import { BigNumber, ethers } from "ethers";
-import { DepositEvent, DepositResult, SharesBurnedEvent } from "../types";
+import { ClaimedEvent, DepositEvent, DepositResult, SharesBurnedEvent } from "../types";
 import { EthereumContractService } from "../contract";
 import { formatContractErrors } from "../utils";
 
@@ -114,6 +114,34 @@ export class ConvertClient {
     }
 
 
+    public async claimWithdraw(tokenId: BigNumber): Promise<any> {
+        let tx, receipt;
+        try {
+            tx = await this.contract.DepositManager.claim(tokenId);
+            receipt = await tx.wait(1);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+        // Parse Claimed event if present
+        let event: ClaimedEvent | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'Claimed');
+
+        if (ev && ev.args) {
+            const { sender, ethAmount } = ev.args;
+            event = {
+                sender,
+                ethAmount: BigNumber.from(ethAmount),
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            event,
+        };
+    }
     
     /*
     // OLD - this was replaced with LiqEth.safeBurn() on 1/13/26

package/src/networks/ethereum/clients/receipt.client.ts

@@ -1,5 +1,5 @@
 import { BigNumber } from "ethers";
-import { preLaunchReceipt } from "../types";
+import { preLaunchReceipt, WithdrawReceipt } from "../types";
 import { EthereumContractService } from "../contract";
 import { ReceiptNFTKind } from "../../../types";
 
@@ -45,7 +45,7 @@ export class ReceiptClient {
         const receiptContract = this.contract.ReceiptNFT;
 
         // first figure out which tokenIds this address owns, from events
-        const tokenIds = await this.getOwnedTokenIdsFor(address);
+        const tokenIds = await this.getOwnedReceiptNFTsFor(address);
 
         const results: preLaunchReceipt[] = [];
 
@@ -90,7 +90,7 @@ export class ReceiptClient {
 
 
 
-    private async getOwnedTokenIdsFor(
+    private async getOwnedReceiptNFTsFor(
         owner: string,
         fromBlock = 0,
         toBlock: number | string = "latest"
@@ -132,5 +132,83 @@ export class ReceiptClient {
     }
 
 
+    /**
+     * 
+     * @param address (string) to fetch receipts for
+     * @returns preLaunchReceipt[]
+     */
+    async fetchWithdrawReceipts(address: string): Promise<WithdrawReceipt[]> {
+        // first figure out which tokenIds this address owns, from events
+        const tokenIds = await this.getOwnedWithdrawReceiptsFor(address);
+        const results: WithdrawReceipt[] = [];
+
+        // next fetch on-chain token data just for those ids
+        for (const idBN of tokenIds) {
+            try {
+                const receiptData = await this.contract.WithdrawalQueue.info(idBN);
+
+                results.push({ 
+                    tokenId: idBN.toBigInt(), 
+                    receipt: {
+                        ethAmount: receiptData.ethAmount,
+                        ethBalance: {
+                            amount: receiptData.ethAmount.toBigInt(),
+                            decimals: 18,
+                            symbol: "ETH"
+                        },
+                        readyAt: new Date(Number(receiptData.readyAt.toString()) * 1000).valueOf(),
+                    }
+                });
+            } catch (err) {
+                // in case of any mismatch or race, just skip this id
+                console.warn(`Failed to load receipt for tokenId=${idBN.toString()}`, err);
+                continue;
+            }
+        }
+
+        return results;
+    }
+
+
+
+    private async getOwnedWithdrawReceiptsFor(
+        owner: string,
+        fromBlock = 0,
+        toBlock: number | string = "latest"
+    ): Promise<BigNumber[]> {
+        const contract = this.contract.WithdrawalQueue;
+
+        // Logs where address received tokens
+        const toLogs = await contract.queryFilter(
+            contract.filters.Transfer(null, owner),
+            fromBlock,
+            toBlock
+        );
+
+        // Logs where address sent tokens (including burns from owner → 0)
+        const fromLogs = await contract.queryFilter(
+            contract.filters.Transfer(owner, null),
+            fromBlock,
+            toBlock
+        );
 
+        const owned = new Set<string>();
+
+        // Add all received tokenIds
+        for (const e of toLogs) {
+            const tokenId = e.args?.tokenId;
+            if (!tokenId) continue;
+            owned.add(tokenId.toString());
+        }
+
+        // Remove all sent tokenIds
+        for (const e of fromLogs) {
+            const tokenId = e.args?.tokenId;
+            if (!tokenId) continue;
+            owned.delete(tokenId.toString());
+        }
+
+        // Convert to BigNumbers
+        return Array.from(owned).map((id) => BigNumber.from(id));
+    }
 }

package/src/networks/ethereum/clients/stake.client.ts

@@ -45,6 +45,7 @@ export class StakeClient {
             throw new Error("Error - Depositor is in a paused state");
         }
 
+        if (bal.lt(amountWei)) throw new Error("Insufficient LiqETH balance");
 
         // if allowance is less than the requested stake amount, request permission to spend LiqEth
         if (allowance.lt(amountWei)) {

package/src/networks/ethereum/ethereum.ts

@@ -8,7 +8,7 @@ import {
     TrancheSnapshot
 } from '../../types';
 import { EthereumContractService } from './contract';
-import { preLaunchReceipt } from './types';
+import { preLaunchReceipt, WithdrawReceipt } from './types';
 import { buildEthereumTrancheSnapshot } from './utils';
 import { ConvertClient } from './clients/convert.client';
 import { StakeClient } from './clients/stake.client';
@@ -98,6 +98,31 @@ export class EthereumStakingClient implements IStakingClient {
         return result.txHash;
     }
 
+    /**
+     * Withdraw native ETH from the liqETH protocol via the liqeth safeBurn function, which burns the LiqETH and adds the user to the withdrawal queue.
+     * @param amount  Amount in wei (or something convertible to BigNumber).
+     * @returns transaction hash
+     */
+    async loadPendingWithdraws(): Promise<WithdrawReceipt[]> {
+        this.ensureUser();
+        const address = await this.signer!.getAddress();
+
+        return await this.receiptClient.fetchWithdrawReceipts(address);
+    }
+
+    /**
+     * Withdraw native ETH from the liqETH protocol via the liqeth safeBurn function, which burns the LiqETH and adds the user to the withdrawal queue.
+     * @param amount  Amount in wei (or something convertible to BigNumber).
+     * @returns transaction hash
+     */
+    async claimWithdraw(tokenId: bigint): Promise<string> {
+        this.ensureUser();
+
+        const tokenIdBigNum = BigNumber.from(tokenId)
+        const result = await this.convertClient.claimWithdraw(tokenIdBigNum)
+        return result.txHash;
+    }
+
 
     /**
      * Stake liqETH via DepositManager.
@@ -213,17 +238,14 @@ export class EthereumStakingClient implements IStakingClient {
             // sharesToTokens(userShares, currentIndex) = userShares * currentIndex / indexScale
             let estimatedClaim = BigInt(0);
             let estimatedYield = BigInt(0);
+            
+            if (userShares > BigInt(0) && currentIndex > BigInt(0)) {
+                estimatedClaim = (userShares * currentIndex) / indexScale;
+                if (estimatedClaim > stakeBalanceBN.toBigInt()) {
+                    estimatedYield = estimatedClaim - stakeBalanceBN.toBigInt();
+                }
+            }
 
-            // started work on estimating the user's personal APY - not necessary at the moment
-            // let estimatedAPY: number | null = null;
-            // if (userShares > BigInt(0) && currentIndex > BigInt(0)) {
-            //     estimatedClaim = (userShares * currentIndex) / indexScale;
-            //     if (estimatedClaim > stakeBalanceBN.toBigInt()) {
-            //         estimatedYield = estimatedClaim - stakeBalanceBN.toBigInt();
-            //     }
-
-            //     estimatedAPY = null;
-            // }
 
             const portfolio: Portfolio = {
                 native: {

package/src/networks/ethereum/types.ts

@@ -110,4 +110,19 @@ export interface preLaunchReceipt {
         shares: BalanceView,
         timestamp: string,
     }
+}
+
+export interface ClaimedEvent {
+    sender: string;
+    ethAmount: BigNumber;
+}
+
+
+export interface WithdrawReceipt {
+    tokenId: bigint;
+    receipt: {
+        ethAmount: BigNumber;
+        ethBalance: BalanceView;
+        readyAt: number;
+    }
 }

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);