@wireio/stake 1.1.0 → 1.2.69

package/src/index.ts

@@ -6,6 +6,7 @@ export * from './types';
 export * from './networks/ethereum/ethereum';
 export * from './networks/ethereum/contract';
 export * as ETH from './networks/ethereum/types';
+export * from './networks/ethereum/clients/instaswap.client';
 
 export * from './networks/solana/solana';
 export * from './networks/solana/constants';
@@ -13,8 +14,9 @@ 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/instaswap.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";
 
@@ -51,6 +51,11 @@ export class ConvertClient {
             );
         }
 
+        // test the transaction with callStatic to get any revert reasons before sending an actual transaction
+        await this.contract.DepositManager.callStatic.deposit({
+            value: amountWei,
+        });
+
         let tx, receipt;
         try {
             tx = await this.contract.DepositManager.deposit({ value: amountWei });
@@ -114,6 +119,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

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

@@ -0,0 +1,432 @@
+import { BigNumber, ethers } from 'ethers';
+
+import { EthereumContractService } from '../contract';
+import { sendOPPFinalize } from '../utils';
+import HoodiLiqEthBridgeArtifact from '../../../assets/ethereum/hoodi/outpost/LiqEthBridge.sol/LiqEthBridge.json';
+
+export type EthereumInstaswapSubmitParams = {
+    amountWei: ethers.BigNumberish;
+    destinationChain: number | string | bigint;
+    destinationAddress: Uint8Array;
+    minOutWei: ethers.BigNumberish;
+};
+
+export type EthereumInstaswapSubmitHooks = {
+    onSubmitted?: (txHash: string) => void | Promise<void>;
+};
+
+export type EthereumEnsureLiqEthBalanceParams = {
+    targetAmountWei: ethers.BigNumberish;
+    bufferBps?: number;
+    extraNativeWei?: ethers.BigNumberish;
+    maxAttempts?: number;
+};
+
+export type EthereumDepositToWireParams = {
+    quantityWei: ethers.BigNumberish;
+    recipient: string;
+    topUpBufferBps?: number;
+};
+
+export type EthereumInstaswapOutpostAddresses = {
+    liqEthToken: string;
+    depositManager: string;
+    depositor: string;
+    opp: string;
+};
+
+export type EthereumInstaswapConnectedBalances = {
+    nativeWei: string;
+    liqEthWei: string;
+};
+
+type ParsedContractError = {
+    name: string;
+    signature?: string;
+    args?: unknown[];
+};
+
+type EnsureLiqEthBalanceResult = {
+    balance: BigNumber;
+    lastTxHash: string;
+};
+
+type EthereumBridgeConfig = {
+    oppAddress: string;
+    liqEthBridgeAddress: string;
+};
+
+const DEFAULT_BUFFER_BPS = 100;
+const DEFAULT_MAX_TOP_UP_ATTEMPTS = 3;
+const LOCAL_ETH_BRIDGE_BY_CHAIN: Partial<Record<number, EthereumBridgeConfig>> = {
+    [31337]: {
+        oppAddress: '0x7969c5eD335650692Bc04293B07F5BF2e7A673C0',
+        liqEthBridgeAddress: '0x162A433068F51e18b7d13932F27e66a3f99E6890',
+    },
+};
+
+export class EthereumInstaswapClient {
+    constructor(
+        private readonly contractService: EthereumContractService,
+        private readonly signer?: ethers.Signer,
+        private readonly chainId?: number,
+        private readonly rpcUrl?: string,
+    ) { }
+
+    async submitCrossChain(
+        params: EthereumInstaswapSubmitParams,
+        hooks?: EthereumInstaswapSubmitHooks,
+    ): Promise<string> {
+        const signer = this.requireSigner();
+        const owner = await signer.getAddress();
+        const amountIn = BigNumber.from(params.amountWei);
+        const minOut = BigNumber.from(params.minOutWei);
+        const destinationChain = BigNumber.from(params.destinationChain.toString());
+        const destinationAddress = Uint8Array.from(params.destinationAddress);
+
+        const liqEthRead = this.contractService.getReadOnly('LiqEthToken');
+        const liqEthWrite = this.contractService.getWrite('LiqEthToken');
+        const depositorWrite = this.contractService.getWrite('Depositor');
+
+        const currentBalance = await liqEthRead['balanceOf'](owner);
+        if (currentBalance.lt(amountIn)) {
+            throw new Error('Insufficient LIQETH balance for the outpost swap.');
+        }
+
+        const depositorAddress = this.contractService.getAddress('Depositor');
+        const allowance = await liqEthRead['allowance'](owner, depositorAddress);
+        if (allowance.lt(amountIn)) {
+            const approvalTx = await liqEthWrite['approve'](depositorAddress, amountIn);
+            const approvalReceipt = await approvalTx.wait();
+            if (!approvalReceipt || approvalReceipt.status === 0) {
+                throw new Error(`Ethereum approval transaction ${approvalTx.hash} reverted.`);
+            }
+        }
+
+        await this.runPreflight(
+            depositorWrite,
+            owner,
+            amountIn,
+            destinationChain,
+            destinationAddress,
+            minOut,
+        );
+
+        const swapTx = await depositorWrite['instaswapCrossChain'](
+            amountIn,
+            destinationChain,
+            destinationAddress,
+            minOut,
+        );
+        await hooks?.onSubmitted?.(swapTx.hash);
+
+        const receipt = await swapTx.wait();
+        if (!receipt || receipt.status === 0) {
+            throw new Error(`Ethereum transaction ${swapTx.hash} reverted.`);
+        }
+
+        return swapTx.hash;
+    }
+
+    async ensureLiqEthBalance(params: EthereumEnsureLiqEthBalanceParams): Promise<EnsureLiqEthBalanceResult> {
+        const signer = this.requireSigner();
+        const owner = await signer.getAddress();
+        const targetAmount = BigNumber.from(params.targetAmountWei);
+        const bufferBps = params.bufferBps ?? 0;
+        const extraNativeWei = params.extraNativeWei == null
+            ? ethers.constants.Zero
+            : BigNumber.from(params.extraNativeWei);
+        const maxAttempts = params.maxAttempts ?? DEFAULT_MAX_TOP_UP_ATTEMPTS;
+        let lastTxHash = '';
+
+        let currentBalance = await this.getLiqEthBalance(owner);
+        for (let attempt = 0; attempt < maxAttempts && currentBalance.lt(targetAmount); attempt += 1) {
+            const shortfall = targetAmount.sub(currentBalance);
+            const buffered = shortfall.mul(10_000 + bufferBps).div(10_000);
+            const topUpValue = buffered.add(extraNativeWei);
+            lastTxHash = await this.depositNativeForLiqEth(topUpValue);
+            currentBalance = await this.getLiqEthBalance(owner);
+        }
+
+        if (currentBalance.lt(targetAmount)) {
+            throw new Error('Insufficient LIQETH balance after topping up from native ETH.');
+        }
+
+        return {
+            balance: currentBalance,
+            lastTxHash,
+        };
+    }
+
+    async depositToWire(
+        params: EthereumDepositToWireParams,
+        hooks?: EthereumInstaswapSubmitHooks,
+    ): Promise<string> {
+        const signer = this.requireSigner();
+        const quantity = BigNumber.from(params.quantityWei);
+        const recipient = params.recipient.trim();
+        if (!recipient) {
+            throw new Error('Wire recipient is required.');
+        }
+
+        await this.ensureLiqEthBalance({
+            targetAmountWei: quantity,
+            bufferBps: params.topUpBufferBps ?? DEFAULT_BUFFER_BPS,
+        });
+
+        const owner = await signer.getAddress();
+        const liqEthRead = this.contractService.getReadOnly('LiqEthToken');
+        const bridge = this.getLiqEthBridgeContract();
+        const bridgeAddress = bridge.address;
+
+        const allowance = await liqEthRead['allowance'](owner, bridgeAddress);
+        if (allowance.lt(quantity)) {
+            const approvalTx = await this.contractService.getWrite('LiqEthToken')['approve'](
+                bridgeAddress,
+                quantity,
+            );
+            const approvalReceipt = await approvalTx.wait();
+            if (!approvalReceipt || approvalReceipt.status === 0) {
+                throw new Error(`Ethereum approval transaction ${approvalTx.hash} reverted.`);
+            }
+        }
+
+        const depositTx = await bridge['depositToWire'](quantity, recipient);
+        await hooks?.onSubmitted?.(depositTx.hash);
+        const depositReceipt = await depositTx.wait();
+        if (!depositReceipt || depositReceipt.status === 0) {
+            throw new Error(`Ethereum transaction ${depositTx.hash} reverted.`);
+        }
+
+        await this.reconcileOppEpochAtAddress(this.requireBridgeConfig().oppAddress);
+        return depositTx.hash;
+    }
+
+    getOutpostAddresses(): EthereumInstaswapOutpostAddresses {
+        return {
+            liqEthToken: this.contractService.getAddress('LiqEthToken'),
+            depositManager: this.contractService.getAddress('DepositManager'),
+            depositor: this.contractService.getAddress('Depositor'),
+            opp: this.contractService.getAddress('OPP'),
+        };
+    }
+
+    async getConnectedBalances(address?: string): Promise<EthereumInstaswapConnectedBalances> {
+        const owner = await this.resolveAddress(address);
+        const provider = this.getLocalRpcProvider();
+        const liqEthRead = new ethers.Contract(
+            this.contractService.getAddress('LiqEthToken'),
+            this.contractService.getInterface('LiqEthToken'),
+            provider,
+        );
+
+        const [nativeBalance, liqEthBalance] = await Promise.all([
+            provider.getBalance(owner),
+            liqEthRead['balanceOf'](owner),
+        ]);
+
+        return {
+            nativeWei: nativeBalance.toString(),
+            liqEthWei: BigNumber.from(liqEthBalance).toString(),
+        };
+    }
+
+    private async runPreflight(
+        depositorWrite: ethers.Contract,
+        owner: string,
+        amountIn: BigNumber,
+        destinationChain: BigNumber,
+        destinationAddress: Uint8Array,
+        minOut: BigNumber,
+    ): Promise<void> {
+        try {
+            await depositorWrite.callStatic['instaswapCrossChain'](
+                amountIn,
+                destinationChain,
+                destinationAddress,
+                minOut,
+                { from: owner },
+            );
+            return;
+        } catch (error) {
+            const decoded = this.decodeContractError(depositorWrite, error);
+            if (!decoded?.name || !this.isRecoverableOppError(decoded.name)) {
+                throw error;
+            }
+        }
+
+        await this.reconcileOppEpochAtAddress(this.contractService.getAddress('OPP'));
+        await depositorWrite.callStatic['instaswapCrossChain'](
+            amountIn,
+            destinationChain,
+            destinationAddress,
+            minOut,
+            { from: owner },
+        );
+    }
+
+    private async reconcileOppEpochAtAddress(oppAddress: string): Promise<void> {
+        const oppRead = new ethers.Contract(
+            oppAddress,
+            this.contractService.getInterface('OPP'),
+            this.getLocalRpcProvider(),
+        );
+        const oppWrite = new ethers.Contract(oppAddress, this.contractService.getInterface('OPP'), this.requireSigner());
+
+        if (this.supportsFunction(oppWrite, 'testAdvanceEpochClock')) {
+            const epochSecs = await oppRead['MESSAGE_EPOCH_SECS']();
+            const advanceTx = await oppWrite['testAdvanceEpochClock'](
+                BigNumber.from(epochSecs).add(1),
+            );
+            const advanceReceipt = await advanceTx.wait();
+            if (!advanceReceipt || advanceReceipt.status === 0) {
+                throw new Error(`Ethereum transaction ${advanceTx.hash} reverted.`);
+            }
+        }
+
+        await sendOPPFinalize(oppWrite);
+    }
+
+    private async depositNativeForLiqEth(amountWei: ethers.BigNumberish): Promise<string> {
+        const tx = await this.contractService.getWrite('DepositManager')['deposit']({
+            value: BigNumber.from(amountWei),
+        });
+        const receipt = await tx.wait();
+        if (!receipt || receipt.status === 0) {
+            throw new Error(`Ethereum transaction ${tx.hash} reverted.`);
+        }
+        return tx.hash;
+    }
+
+    private async getLiqEthBalance(address: string): Promise<BigNumber> {
+        return this.contractService.getReadOnly('LiqEthToken')['balanceOf'](address);
+    }
+
+    private async resolveAddress(address?: string): Promise<string> {
+        if (address?.trim()) {
+            return address.trim();
+        }
+        return this.requireSigner().getAddress();
+    }
+
+    private requireSigner(): ethers.Signer {
+        if (!this.signer) {
+            throw new Error('Connect an Ethereum wallet first.');
+        }
+        return this.signer;
+    }
+
+    private getLocalRpcProvider(): ethers.providers.JsonRpcProvider {
+        if (!this.rpcUrl) {
+            throw new Error('Ethereum RPC URL is not configured.');
+        }
+        return new ethers.providers.JsonRpcProvider(this.rpcUrl);
+    }
+
+    private getLiqEthBridgeContract(): ethers.Contract {
+        const { liqEthBridgeAddress } = this.requireBridgeConfig();
+        return new ethers.Contract(
+            liqEthBridgeAddress,
+            HoodiLiqEthBridgeArtifact.abi,
+            this.requireSigner(),
+        );
+    }
+
+    private requireBridgeConfig(): EthereumBridgeConfig {
+        const chainId = this.chainId ?? 0;
+        const config = LOCAL_ETH_BRIDGE_BY_CHAIN[chainId];
+        if (!config) {
+            throw new Error(`No Ethereum bridge config is registered for chainId=${chainId}.`);
+        }
+        return config;
+    }
+
+    private supportsFunction(contract: ethers.Contract, name: string): boolean {
+        try {
+            contract.interface.getFunction(name);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    private decodeContractError(
+        contract: ethers.Contract,
+        error: unknown,
+    ): ParsedContractError | null {
+        if (error && typeof error === 'object') {
+            const record = error as Record<string, unknown>;
+            const directName = record['errorName'];
+            const directArgs = record['errorArgs'];
+            const directSignature = record['errorSignature'];
+            if (typeof directName === 'string' && directName) {
+                return {
+                    name: directName,
+                    signature: typeof directSignature === 'string' ? directSignature : undefined,
+                    args: Array.isArray(directArgs) ? directArgs : undefined,
+                };
+            }
+        }
+
+        const revertData = this.extractRevertData(error);
+        if (!revertData) {
+            return null;
+        }
+
+        try {
+            const parsed = contract.interface.parseError(revertData);
+            return {
+                name: parsed.name,
+                signature: parsed.signature,
+                args: Array.from(parsed.args ?? []),
+            };
+        } catch {
+            try {
+                const parsed = this.contractService.parseError(revertData);
+                return {
+                    name: parsed.name,
+                    signature: parsed.signature,
+                    args: Array.from(parsed.args ?? []),
+                };
+            } catch {
+                return null;
+            }
+        }
+    }
+
+    private extractRevertData(error: unknown): string | null {
+        if (!error || typeof error !== 'object') {
+            return null;
+        }
+
+        const record = error as Record<string, unknown>;
+        const candidates = [
+            record['data'],
+            (record['error'] as Record<string, unknown> | undefined)?.['data'],
+            (record['error'] as Record<string, unknown> | undefined)?.['error'],
+            (record['receipt'] as Record<string, unknown> | undefined)?.['revertReason'],
+        ];
+
+        for (const candidate of candidates) {
+            if (typeof candidate === 'string' && candidate.startsWith('0x')) {
+                return candidate;
+            }
+            if (candidate && typeof candidate === 'object') {
+                const nested = (candidate as Record<string, unknown>)['data'];
+                if (typeof nested === 'string' && nested.startsWith('0x')) {
+                    return nested;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private isRecoverableOppError(name: string): boolean {
+        return [
+            'OPP_PreviousEpochUnsent',
+            'OPP_PreviousEpochPendingMessages',
+            'OPP_PreviousEpochSent',
+        ].includes(name);
+    }
+}

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,8 +13,7 @@ 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);
     }
@@ -23,9 +22,7 @@ export class ReceiptClient {
         try {
             const receipts = await this.fetchPreLaunchReceipts(address, ReceiptNFTKind.STAKE);
             return receipts;
-        }
-        catch (err) {
-            // console.log('Error fetching stake receipts:', err);
+        } catch (err) {
             return [];
         }
     }
@@ -34,28 +31,20 @@ export class ReceiptClient {
         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(), 
@@ -78,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;
             }
@@ -88,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
         );
@@ -131,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));
+    }
+}