@wireio/stake 0.4.3 → 0.4.69

package/src/index.ts

@@ -13,8 +13,8 @@ export * as SOL from './networks/solana/types';
 export * from './networks/solana/utils';
 
 // CLIENTS
-export * from './networks/solana/clients/deposit.client';
+export * from './networks/solana/clients/convert.client';
 export * from './networks/solana/clients/distribution.client';
 export * from './networks/solana/clients/leaderboard.client';
 export * from './networks/solana/clients/outpost.client';
-export * from './networks/solana/clients/token.client';
+export * from './networks/solana/clients/token.client';

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";
 
@@ -86,7 +86,7 @@ export class ConvertClient {
     public async performWithdraw(signerAddress: string, amountWei: BigNumber): Promise<any> {
         let tx, receipt;
         try {
-            tx = await this.contract.LiqEth.safeBurn(signerAddress, amountWei);
+            tx = await this.contract.LiqEthToken.safeBurn(signerAddress, amountWei);
             receipt = await tx.wait(1);
         } catch (err: any) {
             let errorObj = formatContractErrors(err);
@@ -114,6 +114,35 @@ 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 { user, amount } = ev.args;
+            event = {
+                user,
+                amount: BigNumber.from(amount),
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            event,
+        };
+    }
+    
     
     /*
     // OLD - this was replaced with LiqEth.safeBurn() on 1/13/26
@@ -129,7 +158,7 @@ export class ConvertClient {
             name: await liqEth.name(),
             version: '1',
             chainId,
-            verifyingContract: this.contract.LiqEth.address,
+            verifyingContract: this.contract.LiqEthToken.address,
         } as any;
 
         const types = {

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

@@ -84,34 +84,33 @@ export class OPPClient {
         };
     }
 
-    
-
-
     /**
      * Fetches all OPPMessage events and flattens all assertions into a single OPPAssertion[] array.
      */
     async getMessages(address: string): Promise<OPPAssertion[]> {
-        const oppMessageFilter = this.contract.OPP.filters.OPPMessage();
-        const events = await this.contract.OPP.queryFilter(oppMessageFilter, 0, "latest");
-        const allAssertions: OPPAssertion[] = [];
-        for (const event of events) {
-            const assertions = await this.extractAssertionsFromEvent(event);
-            allAssertions.push(...assertions);
-        }
+        try {
+            const oppMessageFilter = this.contract.OPP.filters.OPPMessage();
+            const events = await this.contract.OPP.queryFilter(oppMessageFilter, 0, "latest");
+            const allAssertions: OPPAssertion[] = [];
+            for (const event of events) {
+                const assertions = await this.extractAssertionsFromEvent(event);
+                allAssertions.push(...assertions);
+            }
 
-        // ! Current implementation is not ideal - no current way to filter OPP Messages by a single user
-        const normalized = address ? address.toLowerCase() : null;
-        const filtered = allAssertions.filter(a =>
-            (a.from && a.from.toLowerCase() === normalized) ||
-            (a.to && a.to.toLowerCase() === normalized)
-        );
-        return filtered.reverse();
+            // ! Current implementation is not ideal - no current way to filter OPP Messages by a single user
+            const normalized = address ? address.toLowerCase() : null;
+            const filtered = allAssertions.filter(a =>
+                (a.from && a.from.toLowerCase() === normalized) ||
+                (a.to && a.to.toLowerCase() === normalized)
+            );
+            return filtered.reverse();
+        }
+        catch (error) {
+            // console.log('Error fetching OPP messages:', error);
+            return [];
+        }
     }
 
-
-
-
-
     /**
      * Extracts all OPPAssertions from a single OPPMessage event, attaching event metadata to each.
      */

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

@@ -19,7 +19,7 @@ export class PretokenClient {
      */
     async purchasePretokensWithLiqETH(amountLiq: bigint, buyer: string): Promise<any> {
 
-        const bal = await this.contract.LiqEth.balanceOf(buyer);
+        const bal = await this.contract.LiqEthToken.balanceOf(buyer);
         const paused = await this.contract.Depositor.paused();
         if(paused) {
             throw new Error("Error - Depositor is in a paused state");
@@ -32,22 +32,19 @@ export class PretokenClient {
 
         //check that the contract has allowance for the token
         const depositorAddr = this.contract.Depositor.address;
-        const allowance = await this.contract.LiqEth.allowance(buyer, depositorAddr);
+        const allowance = await this.contract.LiqEthToken.allowance(buyer, depositorAddr);
 
         // if allowance is less than the requested stake amount, request permission to spend LiqEth
         if (allowance.lt(amountLiq)) {
-            const liqWrite = this.contractService.getWrite('LiqEth');
+            const liqWrite = this.contractService.getWrite('LiqEthToken');
 
-            // currently requested unlimited amount - potentially change to only request up to the current amount?
-            const approveAmount = ethers.constants.MaxUint256;
+            console.warn(`allowance insufficient (${allowance.toString()} < ${amountLiq.toString()}); sending approve(${depositorAddr}, ${amountLiq.toString()})`);
 
-            console.warn(`allowance insufficient (${allowance.toString()} < ${amountLiq.toString()}); sending approve(${depositorAddr}, ${approveAmount.toString()})`);
-
-            const approveTx = await liqWrite.approve(depositorAddr, approveAmount);
+            const approveTx = await liqWrite.approve(depositorAddr, amountLiq);
             await approveTx.wait(1);
 
             // re-read allowance to ensure approval succeeded
-            const newAllowance = await this.contract.LiqEth.allowance(buyer, depositorAddr);
+            const newAllowance = await this.contract.LiqEthToken.allowance(buyer, depositorAddr);
             if (newAllowance.lt(amountLiq)) {
                 throw new Error('Approval failed or allowance still insufficient after approve');
             }
@@ -58,6 +55,8 @@ export class PretokenClient {
             const amountLiqBN = BigNumber.from(amountLiq)
             await this.contract.Depositor.callStatic.purchasePretokensWithLiqETH(amountLiqBN, buyer);
         } catch (err: any) {
+            console.log('err', err);
+            
             let errorObj = formatContractErrors(err);
 
             // ! TEMP for testing

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";
 
@@ -36,7 +43,7 @@ export class StakeClient {
      */
     async performStake(amountWei: BigNumber, signerAddress: string): Promise<any> {
         const depositor = this.contract.Depositor.address;
-        const liqRead = this.contract.LiqEth;
+        const liqRead = this.contract.LiqEthToken;
         const bal = await liqRead.balanceOf(signerAddress);
         const allowance = await liqRead.allowance(signerAddress, depositor);
 
@@ -45,16 +52,14 @@ 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)) {
-            const liqWrite = this.contractService.getWrite('LiqEth');
+            const liqWrite = this.contractService.getWrite('LiqEthToken');
 
-            // currently requested unlimited amount - potentially change to only request up to the current amount?
-            const approveAmount = ethers.constants.MaxUint256;
-
-            console.warn(`allowance insufficient (${allowance.toString()} < ${amountWei.toString()}); sending approve(${depositor}, ${approveAmount.toString()})`);
-            const approveTx = await liqWrite.approve(depositor, approveAmount);
+            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
@@ -98,18 +103,19 @@ 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');
 
@@ -128,4 +134,70 @@ 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 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,
+        };
+    }
+
+
+}