@wireio/stake 1.1.0 → 2.0.0

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';
@@ -48,6 +48,7 @@ export class EthereumStakingClient implements IStakingClient {
             this.contractService = new EthereumContractService({
                 provider: this.provider,
                 signer: this.signer,
+                chainId: config.network.chainId as EvmChainID,
             });
 
             this.convertClient = new ConvertClient(this.contractService);
@@ -98,6 +99,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 tokenId  The ID of the withdrawal request NFT
+     * @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 +239,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: {
@@ -342,24 +365,14 @@ export class EthereumStakingClient implements IStakingClient {
      * 
      * SUPPORTS READ-ONLY ACcESS
      */
-    async getTrancheSnapshot(options?: {
-        chainID?: ChainID;
-        windowBefore?: number;
-        windowAfter?: number;
-    }): Promise<TrancheSnapshot> {
-        const {
-            chainID = EvmChainID.Ethereum,
-            windowBefore,
-            windowAfter,
-        } = options ?? {};
+    async getTrancheSnapshot(chainID: ChainID): Promise<TrancheSnapshot> {
 
+        console.log('getTrancheSnapshot', chainID);
 
         try {
-
             const blockNumber = await this.provider.getBlockNumber();
             const blockTag = { blockTag: blockNumber };
 
-
             // Fetch all required contract data
             const [totalSharesBn, indexBn, trancheNumberBn, trancheSupplyBn, tranchePriceUsdBn, totalSupplyBn, supplyGrowthBps, priceGrowthCents, minPriceUsd, maxPriceUsd] = await Promise.all([
                 this.contract.Depositor.totalShares(blockTag),
@@ -377,7 +390,6 @@ export class EthereumStakingClient implements IStakingClient {
             const totalTrancheSupply = BigInt(totalSupplyBn.toString()) / BigInt(1e10);
             const currentTrancheSupply = BigInt(trancheSupplyBn.toString()) / BigInt(1e10);
 
-
             // fetch price and timestamp from aggregator
             // const [roundId, answer, startedAt, updatedAt, answeredInRound] = await this.contract.MockAggregator.latestRoundData();
             //originally fetched ethPrice from aggregator - pulling from EthUsdPriceConsumer instead - this is where the actual price gets pulled from when purchasing pretokens.
@@ -403,11 +415,7 @@ export class EthereumStakingClient implements IStakingClient {
                 priceGrowthCents,
                 minPriceUsd,
                 maxPriceUsd,
-
                 ethPriceUsd,
-                // nativePriceTimestamp,
-                ladderWindowBefore: windowBefore,
-                ladderWindowAfter: windowAfter,
             });
         }
         catch (err: any) {

package/src/networks/ethereum/types.ts

@@ -11,7 +11,7 @@ export const CONTRACT_NAMES = [
     "DepositManager",
     "WithdrawalVault",
     "StakingModule",
-    "YieldOracle",
+    // "YieldOracle",
 
     //Outpost contracts
     "OutpostManagerAuthority",
@@ -29,7 +29,7 @@ export const CONTRACT_NAMES = [
     "Pretoken",
     "OPPInbound",
     "Depositor",
-    // "MockAggregator",
+    "MockAggregator",
 ] as const;
 
 export type ContractName = typeof CONTRACT_NAMES[number];
@@ -110,4 +110,19 @@ export interface preLaunchReceipt {
         shares: BalanceView,
         timestamp: string,
     }
+}
+
+export interface ClaimedEvent {
+    user: string;
+    amount: 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,52 +8,41 @@ 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';
+import type { LiqsolCore } from '../../../assets/solana/devnet/types/liqsol_core';
 
-import {
-    PROGRAM_IDS,
-    deriveDepositAuthorityPda,
-    deriveLiqsolMintPda,
-    deriveLiqsolMintAuthorityPda,
-    deriveReservePoolPda,
-    deriveVaultPda,
-    deriveStakeControllerStatePda,
-    derivePayoutStatePda,
-    deriveBucketAuthorityPda,
-    derivePayRateHistoryPda,
-    deriveDistributionStatePda,
-    deriveUserRecordPda,
-    deriveEphemeralStakeAddress,
-    deriveWithdrawGlobalPda,
-    deriveStakeAllocationStatePda,
-    deriveStakeMetricsPda,
-    deriveMaintenanceLedgerPda,
-    deriveWithdrawMintAuthorityPda,
-    deriveWithdrawMintMetadataPda,
-    deriveWithdrawNftMintPda,
-    deriveLiqReceiptDataPda,
-    deriveGlobalConfigPda,
-} from '../constants';
 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;
     }
 
-    constructor(private provider: AnchorProvider) {
-        const svc = new SolanaProgramService(provider);
-        this.program = svc.getProgram('liqsolCore');
+    constructor(
+        private readonly provider: AnchorProvider,
+        private readonly pgs: SolanaProgramService
+    ) {
+        this.program = pgs.getProgram('liqsolCore');
     }
 
     /**
@@ -63,7 +52,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',
@@ -78,16 +67,16 @@ export class DepositClient {
         // -------------------------------------------------------------
         // 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();
+        const depositAuthority = this.pgs.deriveDepositAuthorityPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const liqsolMintAuthority = this.pgs.deriveLiqsolMintAuthorityPda();
+        const reservePool = this.pgs.deriveReservePoolPda();
+        const vault = this.pgs.deriveVaultPda();
+        const controllerState = this.pgs.deriveStakeControllerStatePda();
+        const payoutState = this.pgs.derivePayoutStatePda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
+        const payRateHistory = this.pgs.derivePayRateHistoryPda();
+        const globalConfig = this.pgs.deriveGlobalConfigPda();
 
         // -------------------------------------------------------------
         // Token-2022 ATAs
@@ -95,15 +84,15 @@ export class DepositClient {
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
         // -------------------------------------------------------------
         // Distribution state + user_record (KEYED BY TOKEN ACCOUNT)
         // -------------------------------------------------------------
-        const distributionState = deriveDistributionStatePda();
-        const userRecord = deriveUserRecordPda(userAta);
+        const distributionState = this.pgs.deriveDistributionStatePda();
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
 
         const bucketTokenAccount = getAssociatedTokenAddressSync(
             liqsolMint,
@@ -116,12 +105,12 @@ export class DepositClient {
         // Ephemeral stake
         // -------------------------------------------------------------
         const seed = Math.floor(Math.random() * 2 ** 32);
-        const ephemeralStake = await deriveEphemeralStakeAddress(user, seed);
+        const ephemeralStake = await this.pgs.deriveEphemeralStakeAddress(user, seed);
 
         // -------------------------------------------------------------
         // 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,
@@ -129,7 +118,7 @@ export class DepositClient {
                 systemProgram: SystemProgram.programId,
                 tokenProgram: TOKEN_2022_PROGRAM_ID,
                 associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
-                liqsolProgram: PROGRAM_IDS.LIQSOL_TOKEN,
+                liqsolProgram: this.pgs.PROGRAM_IDS.LIQSOL_TOKEN,
                 stakeProgram: StakeProgram.programId,
                 liqsolMint,
                 userAta,
@@ -151,10 +140,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.
@@ -182,33 +291,33 @@ export class DepositClient {
         // -------------------------------------------------------------
         // Core program + liqSOL mint / user ATA
         // -------------------------------------------------------------
-        const liqsolMint = deriveLiqsolMintPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
 
         const userAta = getAssociatedTokenAddressSync(
             liqsolMint,
             user,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
         // Distribution / balance-tracking
         // user_record is keyed by the user’s liqSOL ATA (same convention
         // as deposit/purchase).
-        const userRecord = deriveUserRecordPda(userAta);
-        const distributionState = deriveDistributionStatePda();
+        const userRecord = this.pgs.deriveUserRecordPda(userAta);
+        const distributionState = this.pgs.deriveDistributionStatePda();
 
         // Reserve + stake controller PDAs
-        const global = deriveWithdrawGlobalPda();          // withdraw operator state
-        const reservePool = deriveReservePoolPda();
-        const stakeAllocationState = deriveStakeAllocationStatePda();
-        const stakeMetrics = deriveStakeMetricsPda();
-        const maintenanceLedger = deriveMaintenanceLedgerPda();
-        const globalConfig = deriveGlobalConfigPda();      // liqSOL config / roles
+        const global = this.pgs.deriveWithdrawGlobalPda();          // withdraw operator state
+        const reservePool = this.pgs.deriveReservePoolPda();
+        const stakeAllocationState = this.pgs.deriveStakeAllocationStatePda();
+        const stakeMetrics = this.pgs.deriveStakeMetricsPda();
+        const maintenanceLedger = this.pgs.deriveMaintenanceLedgerPda();
+        const globalConfig = this.pgs.deriveGlobalConfigPda();      // liqSOL config / roles
 
         // -------------------------------------------------------------
         // 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;
@@ -231,22 +340,22 @@ export class DepositClient {
         // -------------------------------------------------------------
         // NFT receipt PDAs (mint, metadata, data, ATA)
         // -------------------------------------------------------------
-        const mintAuthority = deriveWithdrawMintAuthorityPda();
-        const metadata = deriveWithdrawMintMetadataPda();
+        const mintAuthority = this.pgs.deriveWithdrawMintAuthorityPda();
+        const metadata = this.pgs.deriveWithdrawMintMetadataPda();
 
-        const nftMint = deriveWithdrawNftMintPda(receiptId);
-        const receiptData = deriveLiqReceiptDataPda(nftMint);
+        const nftMint = this.pgs.deriveWithdrawNftMintPda(receiptId);
+        const receiptData = this.pgs.deriveLiqReceiptDataPda(nftMint);
 
         const owner = user;
         const nftAta = getAssociatedTokenAddressSync(
             nftMint,
             owner,
-            false,
+            true,
             TOKEN_2022_PROGRAM_ID,
         );
 
         // Bucket token account (same bucket used by deposit/distribution)
-        const bucketAuthority = deriveBucketAuthorityPda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
         const bucketTokenAccount = getAssociatedTokenAddressSync(
             liqsolMint,
             bucketAuthority,
@@ -289,4 +398,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 this.pgs.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 = this.pgs.deriveDepositAuthorityPda();
+        const liqsolMint = this.pgs.deriveLiqsolMintPda();
+        const liqsolMintAuthority = this.pgs.deriveLiqsolMintAuthorityPda();
+        const reservePool = this.pgs.deriveReservePoolPda();
+        const vault = this.pgs.deriveVaultPda();
+        const controllerState = this.pgs.deriveStakeControllerStatePda();
+        const payoutState = this.pgs.derivePayoutStatePda();
+        const bucketAuthority = this.pgs.deriveBucketAuthorityPda();
+        const payRateHistory = this.pgs.derivePayRateHistoryPda();
+        const globalConfig = this.pgs.deriveGlobalConfigPda();
+
+        // -------------------------------------------------------------
+        // Token-2022 ATAs
+        // -------------------------------------------------------------
+        const userAta = getAssociatedTokenAddressSync(
+            liqsolMint,
+            user,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+        );
+
+        // -------------------------------------------------------------
+        // Distribution state + user_record (KEYED BY TOKEN ACCOUNT)
+        // -------------------------------------------------------------
+        const distributionState = this.pgs.deriveDistributionStatePda();
+        const userRecord = this.pgs.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 this.pgs.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: this.pgs.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";
+}