@wireio/stake 0.1.2 → 0.1.69

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

@@ -0,0 +1,165 @@
+import { BigNumber, ethers } from "ethers";
+import { EthereumContractService } from "../contract";
+import { formatContractErrors, sendOPPFinalize } from "../utils";
+
+export class PretokenClient {
+    private readonly contractService: EthereumContractService;
+    
+    get contract() { return this.contractService.contract; }
+
+    constructor(contract: EthereumContractService) {
+        this.contractService = contract;
+    }
+    
+
+
+    /**
+     * Purchase pretokens by transferring liqETH into the pool (ERC-20) and calling Depositor.purchasePretokensWithLiqETH(amountLiq, buyer).
+     * Returns txHash, receipt and parsed PurchasedWithLiqETH event (if present).
+     */
+    async purchasePretokensWithLiqETH(amountLiq: bigint, buyer: string): Promise<any> {
+
+        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");
+        }
+
+        // if current liq balance is less than the requested buy amount, throw an error
+        if (bal.lt(amountLiq)) {
+            throw new Error(`Balance insufficient for pre-token purchase`);
+        }
+
+        //check that the contract has allowance for the token
+        const depositorAddr = this.contract.Depositor.address;
+        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('LiqEthToken');
+
+            console.warn(`allowance insufficient (${allowance.toString()} < ${amountLiq.toString()}); sending approve(${depositorAddr}, ${amountLiq.toString()})`);
+
+            const approveTx = await liqWrite.approve(depositorAddr, amountLiq);
+            await approveTx.wait(1);
+
+            // re-read allowance to ensure approval succeeded
+            const newAllowance = await this.contract.LiqEthToken.allowance(buyer, depositorAddr);
+            if (newAllowance.lt(amountLiq)) {
+                throw new Error('Approval failed or allowance still insufficient after approve');
+            }
+        }
+        
+        // attempt a simulation of the purchase call
+        try {
+            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
+            if(errorObj.name == "OPP_PreviousEpochUnsent") {
+                console.error("OPP Previous Epoch is unsent - trigger OPP finalizeEpoch()")
+                await sendOPPFinalize(this.contract.OPP);
+                throw new Error(errorObj.name+` - triggering OPP finalizeEpoch() please try again`);
+            }
+
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+        // attempt the real purchase call
+        let tx, receipt;
+        try {
+            tx = await this.contract.Depositor.purchasePretokensWithLiqETH(amountLiq, buyer);
+            receipt = await tx.wait(1);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+
+        // Attempt to parse PurchasedWithLiqETH event
+        let purchased: any | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'PurchasedWithLiqETH' || (e.event && e.event.toString().startsWith('PurchasedWithLiqETH')));
+
+        if (ev && ev.args) {
+            // Event shape: PurchasedWithLiqETH(buyer, amountLiq, ethEqWei, shares, tokenId)
+            const args: any = ev.args;
+            // try named fields first, fallback to positional
+            const evtBuyer = args.buyer ?? args[0];
+            const evtAmountLiq = (args.amountLiq ?? args[1]) ? BigNumber.from(args.amountLiq ?? args[1]) : undefined;
+            const evtEthEqWei = (args.ethEqWei ?? args[2]) ? BigNumber.from(args.ethEqWei ?? args[2]) : undefined;
+            const evtShares = (args.shares ?? args[3]) ? BigNumber.from(args.shares ?? args[3]) : undefined;
+            const evtTokenId = (args.tokenId ?? args[4]) ? BigNumber.from(args.tokenId ?? args[4]) : undefined;
+
+            purchased = {
+                buyer: evtBuyer,
+                amountLiq: evtAmountLiq,
+                ethEqWei: evtEthEqWei,
+                shares: evtShares,
+                tokenId: evtTokenId,
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            purchased,
+        };
+    }
+
+
+
+
+    /**
+     * Purchase pretokens by sending ETH to the Depositor.purchasePretokensWithETH(buyer) payable function.
+     * Returns txHash, receipt and parsed PurchasedWithETH event (if present).
+    async purchasePretokensWithETH(amountWei: BigNumber, buyer: string): Promise<any> {
+        // attempt a simulation of the purchase call
+        try {
+            await this.contract.Depositor.callStatic.purchasePretokensWithETH(buyer, { value: amountWei });
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+        // attempt the real purchase call
+        let tx, receipt;
+        try {
+            tx = await this.contract.Depositor.purchasePretokensWithETH(buyer, { value: amountWei });
+            receipt = await tx.wait(1);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+
+        // Attempt to parse PurchasedWithETH event
+        let purchased: any | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'PurchasedWithETH' || e.event === 'PurchasedWithETH(address,uint256,uint256,uint256)');
+
+        if (ev && ev.args) {
+            // event signature: PurchasedWithETH(address indexed user, uint256 ethIn, uint256 shares, uint256 tokenId)
+            const { user, ethIn, shares, tokenId } = ev.args as any;
+
+            purchased = {
+                buyer: user,
+                amount: BigNumber.from(ethIn),
+                shares: BigNumber.from(shares),
+                tokenId: BigNumber.from(tokenId),
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            purchased,
+        };
+    }
+     */
+
+    
+
+}

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

@@ -0,0 +1,199 @@
+import { BigNumber } from "ethers";
+import { preLaunchReceipt } from "../types";
+import { WithdrawReceipt, ReceiptNFTKind } from "../../../types";
+import { EthereumContractService } from "../contract";
+
+export class ReceiptClient {
+
+    private readonly contractService: EthereumContractService;
+    
+    get contract() { return this.contractService.contract; }
+
+    constructor(contract: EthereumContractService) {
+        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[]> {
+        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);
+    }
+
+    /**
+     * 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;
+
+        const tokenIds = await this.getOwnedReceiptNFTsFor(address);
+        const results: preLaunchReceipt[] = [];
+
+        for (const idBN of tokenIds) {
+            try {
+                const receiptData = await receiptContract.getReceipt(idBN);
+
+                if (type !== undefined && receiptData.kind !== type) continue;
+
+                results.push({ 
+                    tokenId: idBN.toBigInt(), 
+                    receipt: {
+                        account: receiptData.account,
+                        currency: receiptData.currency,
+                        kind: receiptData.kind,
+                        indexAtMint: receiptData.indexAtMint.toBigInt(),
+                        principal: {
+                            amount: receiptData.principal.toBigInt(),
+                            decimals: 18,
+                            symbol: "LiqETH"
+                        },
+                        shares: {
+                            amount: receiptData.shares.toBigInt(),
+                            decimals: 18,
+                            symbol: "LiqETH"
+                        },
+                        timestamp: new Date(Number(receiptData.timestamp.toString()) * 1000).toLocaleString(),
+                    }
+                });
+            } catch (err) {
+                console.warn(`Failed to load receipt for tokenId=${idBN.toString()}`, err);
+                continue;
+            }
+        }
+
+        return results;
+    }
+
+
+    /**
+     * 
+     * @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 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));
+    }
+
+    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

@@ -0,0 +1,203 @@
+import { BigNumber, ethers } from "ethers";
+import {
+    StakedEvent,
+    WithdrawnStakeEvent,
+    WithdrawnStakeResult,
+    DepositAndStakeResult,
+    DepositAndPurchaseResult,
+    UnstakeAndWithdrawResult,
+} from "../types";
+import { EthereumContractService } from "../contract";
+import { formatContractErrors } from "../utils";
+
+export class StakeClient {
+
+    private readonly contractService: EthereumContractService;
+    
+    get contract() { return this.contractService.contract; }
+
+    constructor(contract: EthereumContractService) {
+        this.contractService = contract;
+    }
+    
+
+
+    /**
+     * Simulate a stake via callStatic
+     */
+    async simulateStake(amountWei: BigNumber): Promise<void> {
+        try {
+            await this.contract.Depositor.callStatic.stakeLiqETH(amountWei);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+    }
+
+
+
+    /**
+     * 
+     * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
+     * @returns txHash (hash of the transaction), receipt, Staked event
+     */
+    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');
+            }
+        }
+        
+        
+        await this.simulateStake(amountWei);
+
+
+        // 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,
+        };
+    }
+
+
+
+    /**
+     * 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
+        const receipt = await tx.wait(1);
+
+        // Parse WithdrawnStake event if present
+        let withdrawnstake: WithdrawnStakeEvent | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'WithdrawnStake');
+
+        if (ev && ev.args) {
+            const { user, tokenOut, tokenId } = ev.args;
+            withdrawnstake = {
+                user: user,
+                tokenOut: BigNumber.from(tokenOut),
+                tokenId: BigNumber.from(tokenId)
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            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,
+        };
+    }
+
+
+}