@wireio/stake 2.1.1 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "2.1.1",
+    "version": "2.2.2",
     "description": "LIQ Staking Module for Wire Network",
     "homepage": "https://gitea.gitgo.app/Wire/sdk-stake",
     "license": "FSL-1.1-Apache-2.0",

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

@@ -0,0 +1,61 @@
+import { BigNumber, ethers } from "ethers";
+import { ClaimedEvent, DepositEvent, DepositResult, SharesBurnedEvent, ValidatorDepositedEvent } from "../types";
+import { EthereumContractService } from "../contract";
+import { formatContractErrors } from "../utils";
+
+export class ValidatorClient {
+
+    private readonly contractService: EthereumContractService;
+    
+    get contract() { return this.contractService.contract; }
+
+    constructor(contract: EthereumContractService) {
+        this.contractService = contract;
+    }
+
+
+    /**
+     * 
+     * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
+     * @returns txHash (hash of the transaction), receipt, Staked event
+     */
+    async validatorDepositAndLockBond(): Promise<any> {
+        const amountWei: BigNumber = ethers.utils.parseEther("32");
+
+        // simulate call first
+        try {
+            await this.contract.DepositManager.callStatic.validatorDepositAndLockBond({ value: amountWei });
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+
+        // send the tx to stake liqeth
+        const tx = await this.contract.DepositManager.validatorDepositAndLockBond({ value: amountWei });
+
+        // Wait for 1 confirmation 
+        const receipt = await tx.wait(1);
+
+        // Parse ValidatorDeposited event if present
+        let staked: ValidatorDepositedEvent | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'Staked');
+
+        if (ev && ev.args) {
+            const { sender, amount, shares } = ev.args;
+            staked = {
+                sender,
+                amount: BigNumber.from(amount),
+                shares: BigNumber.from(shares),
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            staked,
+        };
+    }
+
+
+}

package/src/networks/ethereum/ethereum.ts

@@ -15,6 +15,7 @@ import { StakeClient } from './clients/stake.client';
 import { PretokenClient } from './clients/pretoken.client';
 import { OPPClient } from './clients/opp.client';
 import { ReceiptClient } from './clients/receipt.client';
+import { ValidatorClient } from './clients/validator.client';
 
 export const INITIAL_TRANCHE_SUPPLY = 35000;
 
@@ -29,6 +30,7 @@ export class EthereumStakingClient implements IStakingClient {
     private stakeClient: StakeClient;
     private oppClient: OPPClient;
     private receiptClient: ReceiptClient;
+    private validatorClient: ValidatorClient;
 
 
     get contract() { return this.contractService.contract; }
@@ -56,6 +58,7 @@ export class EthereumStakingClient implements IStakingClient {
             this.stakeClient = new StakeClient(this.contractService);
             this.oppClient = new OPPClient(this.contractService);
             this.receiptClient = new ReceiptClient(this.contractService);
+            this.validatorClient = new ValidatorClient(this.contractService)
         }
         catch (error) {
             // console.error('Error initializing EthereumStakingClient:', error);
@@ -178,6 +181,21 @@ export class EthereumStakingClient implements IStakingClient {
     }
 
 
+    /**
+     * Validator functions
+     */
+    async validatorDeposit(): Promise<string> {
+        this.ensureUser();
+
+        let result = await this.validatorClient.validatorDepositAndLockBond();
+        return result && result.txHash ? result.txHash : "Error - no resulting txHash";
+    }
+    
+
+
+
+
+
     /**
      * Resolve the user's ETH + liqETH balances.
      *
@@ -310,6 +328,8 @@ export class EthereumStakingClient implements IStakingClient {
         return await this.oppClient.getMessages(address);
     }
 
+
+
     // Ensure that signer wallet is available for write operations
     private ensureUser() {
         if (!this.signer) {

package/src/networks/ethereum/types.ts

@@ -117,7 +117,6 @@ export interface ClaimedEvent {
     amount: BigNumber;
 }
 
-
 export interface WithdrawReceipt {
     tokenId: bigint;
     receipt: {
@@ -125,4 +124,12 @@ export interface WithdrawReceipt {
         ethBalance: BalanceView;
         readyAt: number;
     }
-}
+}
+
+
+
+export interface ValidatorDepositedEvent {
+    sender: string;
+    amount: BigNumber;
+    shares: BigNumber
+}

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

@@ -141,126 +141,6 @@ export class DepositClient {
             .instruction();
     }
 
-    // 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.
@@ -273,7 +153,7 @@ export class DepositClient {
     async buildWithdrawTx(
         amount: bigint,
         user = this.wallet.publicKey,
-    ): Promise<Transaction> {
+    ): Promise<TransactionInstruction> {
         if (!user) {
             throw new Error(
                 'DepositClient.buildWithdrawTx: wallet not connected',
@@ -363,7 +243,7 @@ export class DepositClient {
         // -------------------------------------------------------------
         // BUILD IX (MUST MATCH requestWithdraw IDL)
         // -------------------------------------------------------------
-        const ix: TransactionInstruction = await this.program.methods
+        return await this.program.methods
             .requestWithdraw(new BN(amount.toString()))
             .accounts({
                 user,
@@ -393,114 +273,7 @@ export class DepositClient {
             })
             .instruction();
 
-        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)

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

@@ -139,19 +139,18 @@ export class OutpostClient {
      */
     async buildStakeIx(
         amountLamports: bigint,
-        user?: PublicKey,
+        user: PublicKey = this.wallet.publicKey,
     ): Promise<TransactionInstruction> {
-        const userPk = user ?? this.wallet.publicKey;
-        if (!userPk) {
+        if (!user) {
             throw new Error('OutpostClient.buildStakeIx: wallet not connected');
         }
 
-        const a = await this.buildAccounts(userPk);
+        const a = await this.buildAccounts(user);
 
         return this.program.methods
             .synd(new BN(amountLamports.toString()))
             .accounts({
-                user: userPk,
+                user,
                 liqsolMint: a.liqsolMint,
                 globalState: a.globalState,
                 distributionState: a.distributionState,

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

@@ -100,6 +100,8 @@ export class TokenClient {
         amountLamports: bigint,
         user = this.wallet.publicKey,
     ): Promise<TransactionInstruction> {
+        console.log('build purchase for', user.toBase58());
+        
         const a = await this.getAccounts(user);
 
         const extraAccountMetaList = this.pgs.deriveExtraAccountMetaListPda(a.liqsolMint);

package/src/networks/solana/constants.ts

@@ -21,6 +21,7 @@ export type SolanaProgramIds = {
     LIQSOL_TOKEN: PublicKey;
     VALIDATOR_LEADERBOARD: PublicKey;
     TRANSFER_HOOK: PublicKey;
+    ALT_LOOKUP_TABLE: PublicKey;
 };
 
 const MAINNET_PROGRAM_IDS: SolanaProgramIds = {
@@ -28,6 +29,7 @@ const MAINNET_PROGRAM_IDS: SolanaProgramIds = {
     LIQSOL_TOKEN: new PublicKey(mainnetLiqSolTokenIDL.address),
     VALIDATOR_LEADERBOARD: new PublicKey(mainnetValidatorLeaderboardIDL.address),
     TRANSFER_HOOK: new PublicKey(mainnetTransferHookIDL.address),
+    ALT_LOOKUP_TABLE: new PublicKey("AQXTHwkdNBEiXeQuVA5uCoxvzgYUmudRxthQY4vWKCPS")
 };
 
 const DEVNET_PROGRAM_IDS: SolanaProgramIds = {
@@ -35,6 +37,7 @@ const DEVNET_PROGRAM_IDS: SolanaProgramIds = {
     LIQSOL_TOKEN: new PublicKey(devnetLiqSolTokenIDL.address),
     VALIDATOR_LEADERBOARD: new PublicKey(devnetValidatorLeaderboardIDL.address),
     TRANSFER_HOOK: new PublicKey(devnetTransferHookIDL.address),
+    ALT_LOOKUP_TABLE: new PublicKey("3MbupRDxUqPtJzoLLmjEYV3dXJdh1jojQrpDEQUqv7xb")
 };
 
 export const PROGRAM_IDS_BY_CHAIN: Record<SupportedSolChainID, SolanaProgramIds> = {