@wireio/stake 1.0.1 → 1.0.69

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

@@ -1,7 +1,7 @@
 import { BigNumber } from "ethers";
 import { preLaunchReceipt } from "../types";
+import { WithdrawReceipt, ReceiptNFTKind } from "../../../types";
 import { EthereumContractService } from "../contract";
-import { ReceiptNFTKind } from "../../../types";
 
 export class ReceiptClient {
 
@@ -13,42 +13,38 @@ export class ReceiptClient {
         this.contractService = contract;
     }
 
-
-
+    // NOTE: Stake/pretoken receipts intentionally ignored for withdraw view.
     async allReceipts(address: string): Promise<preLaunchReceipt[]> {
         return this.fetchPreLaunchReceipts(address);
     }
 
     async stakeReceipts(address: string): Promise<preLaunchReceipt[]> {
-        return this.fetchPreLaunchReceipts(address, ReceiptNFTKind.STAKE);
+        try {
+            const receipts = await this.fetchPreLaunchReceipts(address, ReceiptNFTKind.STAKE);
+            return receipts;
+        } catch (err) {
+            return [];
+        }
     }
     
     async pretokenReceipts(address: string): Promise<preLaunchReceipt[]> {
         return this.fetchPreLaunchReceipts(address, ReceiptNFTKind.PRETOKEN_PURCHASE);
     }
 
-
-
     /**
-     * 
-     * @param address (string) to fetch receipts for
-     * @returns preLaunchReceipt[]
+     * Fetch ReceiptNFT data (stake/pretoken) for an address, optionally filtered by kind.
      */
     async fetchPreLaunchReceipts(address: string, type?: ReceiptNFTKind): Promise<preLaunchReceipt[]> {
         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[] = [];
 
-        // next fetch on-chain receipt data just for those ids
         for (const idBN of tokenIds) {
             try {
                 const receiptData = await receiptContract.getReceipt(idBN);
 
-                //skip any receipt not of the requested type
-                if(type !== undefined && receiptData.kind !== type) continue;
+                if (type !== undefined && receiptData.kind !== type) continue;
 
                 results.push({ 
                     tokenId: idBN.toBigInt(), 
@@ -71,7 +67,6 @@ export class ReceiptClient {
                     }
                 });
             } 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;
             }
@@ -81,25 +76,67 @@ 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);
+
+                // status: ready if readyAt <= now; otherwise queued
+                const readyAtMs = Number(receiptData.readyAt) * 1000;
+                const status = readyAtMs <= Date.now() ? 'ready' : 'queued';
+
+                results.push({
+                    tokenId: idBN.toBigInt(),
+                    receipt: {
+                        amount: {
+                            amount: receiptData.ethAmount.toBigInt(),
+                            decimals: 18,
+                            symbol: "ETH",
+                        },
+                        readyAt: readyAtMs,
+                        chain: 'ETH',
+                        status,
+                    }
+                });
+            } 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 getOwnedTokenIdsFor(
+    private async getOwnedWithdrawReceiptsFor(
         owner: string,
         fromBlock = 0,
         toBlock: number | string = "latest"
     ): Promise<BigNumber[]> {
-        const receiptContract = this.contract.ReceiptNFT;
+        const contract = this.contract.WithdrawalQueue;
 
         // Logs where address received tokens
-        const toLogs = await receiptContract.queryFilter(
-            receiptContract.filters.Transfer(null, owner),
+        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 receiptContract.queryFilter(
-            receiptContract.filters.Transfer(owner, null),
+        const fromLogs = await contract.queryFilter(
+            contract.filters.Transfer(owner, null),
             fromBlock,
             toBlock
         );
@@ -124,6 +161,39 @@ export class ReceiptClient {
         return Array.from(owned).map((id) => BigNumber.from(id));
     }
 
+    private async getOwnedReceiptNFTsFor(
+        owner: string,
+        fromBlock = 0,
+        toBlock: number | string = "latest"
+    ): Promise<BigNumber[]> {
+        const receiptContract = this.contract.ReceiptNFT;
 
+        const toLogs = await receiptContract.queryFilter(
+            receiptContract.filters.Transfer(null, owner),
+            fromBlock,
+            toBlock
+        );
 
-}
+        const fromLogs = await receiptContract.queryFilter(
+            receiptContract.filters.Transfer(owner, null),
+            fromBlock,
+            toBlock
+        );
+
+        const owned = new Set<string>();
+
+        for (const e of toLogs) {
+            const tokenId = e.args?.tokenId;
+            if (!tokenId) continue;
+            owned.add(tokenId.toString());
+        }
+
+        for (const e of fromLogs) {
+            const tokenId = e.args?.tokenId;
+            if (!tokenId) continue;
+            owned.delete(tokenId.toString());
+        }
+
+        return Array.from(owned).map((id) => BigNumber.from(id));
+    }
+}

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

@@ -1,5 +1,12 @@
 import { BigNumber, ethers } from "ethers";
-import { StakedEvent, WithdrawnStakeEvent, WithdrawnStakeResult } from "../types";
+import {
+    StakedEvent,
+    WithdrawnStakeEvent,
+    WithdrawnStakeResult,
+    DepositAndStakeResult,
+    DepositAndPurchaseResult,
+    UnstakeAndWithdrawResult,
+} from "../types";
 import { EthereumContractService } from "../contract";
 import { formatContractErrors } from "../utils";
 
@@ -14,27 +21,82 @@ export class StakeClient {
     }
     
 
-
     /**
-     * Simulate a stake via callStatic
+     * 
+     * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
+     * @returns txHash (hash of the transaction), receipt, Staked event
      */
-    async simulateStake(amountWei: BigNumber): Promise<void> {
+    async performStake(amountWei: BigNumber, signerAddress: string): Promise<any> {
+        const depositor = this.contract.Depositor.address;
+        const liqRead = this.contract.LiqEthToken;
+        const bal = await liqRead.balanceOf(signerAddress);
+        const allowance = await liqRead.allowance(signerAddress, depositor);
+
+        const paused = await this.contract.Depositor.paused();
+        if(paused) {
+            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)) {
+            const liqWrite = this.contractService.getWrite('LiqEthToken');
+
+            console.warn(`allowance insufficient (${allowance.toString()} < ${amountWei.toString()}); sending approve(${depositor}, ${amountWei.toString()})`);
+            const approveTx = await liqWrite.approve(depositor, amountWei);
+            await approveTx.wait(1);
+
+            // re-read allowance to ensure approval succeeded
+            const newAllowance = await liqRead.allowance(signerAddress, depositor);
+            if (newAllowance.lt(amountWei)) {
+                throw new Error('Approval failed or allowance still insufficient after approve');
+            }
+        }
+        
+        // simulate stake via callStatic to catch any errors before sending the transaction and spending gas
         try {
             await this.contract.Depositor.callStatic.stakeLiqETH(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.Depositor.stakeLiqETH(amountWei);
+
+        // Wait for 1 confirmation 
+        const receipt = await tx.wait(1);
+
+        // Parse Staked event if present
+        let staked: StakedEvent | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'Staked');
+
+        if (ev && ev.args) {
+            const { user, amountLiq, shares, tokenId } = ev.args;
+            staked = {
+                user,
+                amountLiq: BigNumber.from(amountLiq),
+                shares: BigNumber.from(shares),
+                tokenId: BigNumber.from(tokenId)
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            staked,
+        };
+    }
 
 
     /**
      * 
      * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
+     * @param wireAccount Wire chain recipient account name. Required.
      * @returns txHash (hash of the transaction), receipt, Staked event
      */
-    async performStake(amountWei: BigNumber, signerAddress: string): Promise<any> {
+    async performStakeToWire(amountWei: BigNumber, signerAddress: string, wireAccount?: string): Promise<any> {
         const depositor = this.contract.Depositor.address;
         const liqRead = this.contract.LiqEthToken;
         const bal = await liqRead.balanceOf(signerAddress);
@@ -42,31 +104,39 @@ export class StakeClient {
 
         const paused = await this.contract.Depositor.paused();
         if(paused) {
-            throw new Error("Error - Depositor is in a paused state");
+            throw new Error("StakeClient.performStakeToWire: Depositor is in a paused state");
+        }
+
+        if (!wireAccount?.trim()) {
+            throw new Error('StakeClient.performStakeToWire: wireAccount is required');
         }
 
+        if (bal.lt(amountWei)) throw new Error("StakeClient.performStakeToWire: Insufficient LiqETH balance");
 
         // if allowance is less than the requested stake amount, request permission to spend LiqEth
         if (allowance.lt(amountWei)) {
             const liqWrite = this.contractService.getWrite('LiqEthToken');
 
-            console.warn(`allowance insufficient (${allowance.toString()} < ${amountWei.toString()}); sending approve(${depositor}, ${amountWei.toString()})`);
             const approveTx = await liqWrite.approve(depositor, amountWei);
             await approveTx.wait(1);
 
             // re-read allowance to ensure approval succeeded
             const newAllowance = await liqRead.allowance(signerAddress, depositor);
             if (newAllowance.lt(amountWei)) {
-                throw new Error('Approval failed or allowance still insufficient after approve');
+                throw new Error('StakeClient.performStakeToWire: Liq allowance approval failed or allowance still insufficient after approve');
             }
         }
         
-        
-        await this.simulateStake(amountWei);
-
+        // simulate stake via callStatic to catch any errors before sending the transaction and spending gas
+        try {
+            await this.contract.Depositor.callStatic.stakeLiqETHToWire(amountWei, wireAccount);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(`StakeClient.performStakeToWire: ${errorObj.name ?? errorObj.raw}`);
+        }
 
         // send the tx to stake liqeth
-        const tx = await this.contract.Depositor.stakeLiqETH(amountWei);
+        const tx = await this.contract.Depositor.stakeLiqETHToWire(amountWei, wireAccount);
 
         // Wait for 1 confirmation 
         const receipt = await tx.wait(1);
@@ -93,20 +163,20 @@ export class StakeClient {
     }
 
 
-
     /**
-     * 
-     * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
-     * @returns txHash (hash of the transaction), receipt, WithdrawnStake event
+     * Burn the STAKE ReceiptNFT and send principal liqETH to `recipient` (Depositor.withdrawStake).
+     * @param tokenId  ReceiptNFT token id for the stake position
+     * @param recipient  Address that receives the liqETH from the pool
+     * @returns txHash, receipt, and parsed WithdrawnStake event if present
      */
     async performWithdrawStake(tokenId: BigNumber, recipient: string): Promise<WithdrawnStakeResult> {
         // Send the payable tx
         const tx = await this.contract.Depositor.withdrawStake(tokenId, recipient);
 
-        // Wait for 1 confirmation 
+        // Wait for 1 confirmation
         const receipt = await tx.wait(1);
 
-        // Parse Staked event if present
+        // Parse WithdrawnStake event if present
         let withdrawnstake: WithdrawnStakeEvent | undefined;
         const ev = receipt.events?.find((e) => e.event === 'WithdrawnStake');
 
@@ -125,4 +195,106 @@ export class StakeClient {
             withdrawnstake,
         };
     }
-}
+
+    /**
+     * Deposit ETH to liqETH, then stake liqETH in a single transaction.
+     * @param amountWei  Amount of ETH in wei to deposit and stake
+     * @returns txHash (hash of the transaction), receipt, Staked event
+     */
+    async performDepositAndStake(amountWei: BigNumber): Promise<DepositAndStakeResult> {
+        try {
+            await this.contract.Depositor.callStatic.depositAndStake({ value: amountWei });
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw);
+        }
+
+        const tx = await this.contract.Depositor.depositAndStake({ value: amountWei });
+        const receipt = await tx.wait(1);
+        let staked: StakedEvent | undefined;
+        const ev = receipt.events?.find((e: any) => e.event === 'Staked');
+        if (ev && ev.args) {
+            const { user, amountLiq, shares, tokenId } = ev.args;
+            staked = {
+                user,
+                amountLiq: BigNumber.from(amountLiq),
+                shares: BigNumber.from(shares),
+                tokenId: BigNumber.from(tokenId),
+            };
+        }
+
+        return { txHash: tx.hash, receipt, staked };
+    }
+
+    /**
+     * Deposit ETH to liqETH, then stake liqETH in a single transaction.
+     * @param amountWei  Amount of ETH in wei to deposit and stake
+     * @param wireAccount Wire chain recipient account name. Required.
+     * @returns txHash (hash of the transaction), receipt, Staked event
+     */
+    // ! CURRENTLY NOT IMPLEMENTED AS OF 4/14/26
+    async performDepositAndStakeToWire(amountWei: BigNumber, wireAccount?: string): Promise<DepositAndStakeResult> {
+        if (!wireAccount?.trim()) {
+            throw new Error('StakeClient.performDepositAndStakeToWire: wireAccount is required');
+        }
+
+        try {
+            await this.contract.Depositor.callStatic.depositAndStake({ value: amountWei });
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw);
+        }
+
+        const tx = await this.contract.Depositor.depositAndStake({ value: amountWei });
+        const receipt = await tx.wait(1);
+        let staked: StakedEvent | undefined;
+        const ev = receipt.events?.find((e: any) => e.event === 'Staked');
+        if (ev && ev.args) {
+            const { user, amountLiq, shares, tokenId } = ev.args;
+            staked = {
+                user,
+                amountLiq: BigNumber.from(amountLiq),
+                shares: BigNumber.from(shares),
+                tokenId: BigNumber.from(tokenId),
+            };
+        }
+
+        return { txHash: tx.hash, receipt, staked };
+    }
+
+    /**
+     * Deposit ETH to liqETH, then purchase pretokens in a single transaction.
+     * @param amountWei  Amount of ETH in wei to deposit and use for pretoken purchase
+     * @returns txHash (hash of the transaction), receipt
+     */
+    async performDepositAndPurchase(amountWei: BigNumber): Promise<DepositAndPurchaseResult> {
+        try {
+            await this.contract.Depositor.callStatic.depositAndPurchase({ value: amountWei });
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw);
+        }
+
+        const tx = await this.contract.Depositor.depositAndPurchase({ value: amountWei });
+        const receipt = await tx.wait(1);
+        return { txHash: tx.hash, receipt };
+    }
+
+    /**
+     * Unstake liqETH, then request a withdrawal in a single transaction.
+     * @param tokenId  The ReceiptNFT token ID for the stake position
+     * @returns txHash (hash of the transaction), receipt
+     */
+    async performUnstakeAndRequestWithdraw(tokenId: BigNumber): Promise<UnstakeAndWithdrawResult> {
+        try {
+            await this.contract.Depositor.callStatic.unstakeAndRequestWithdraw(tokenId);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw);
+        }
+
+        const tx = await this.contract.Depositor.unstakeAndRequestWithdraw(tokenId);
+        const receipt = await tx.wait(1);
+        return { txHash: tx.hash, receipt };
+    }
+}

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,
+        };
+    }
+
+
+}