@wireio/stake 2.7.4 → 3.0.0

package/src/status.ts

@@ -0,0 +1,301 @@
+import { Connection } from '@solana/web3.js';
+import { BigNumber, ethers } from 'ethers';
+
+import { EvmStakingClient } from './networks/evm/evm';
+import { formatContractErrors, resolveContractWriteOverrides } from './networks/evm/utils';
+import { SolanaStakingClient } from './networks/solana/solana';
+
+export type StakingTxChain = 'evm' | 'sol';
+export type StakingTxState = 'pending' | 'confirmed' | 'failed' | 'not_found';
+
+export interface StakingTransactionStatus {
+    chain: StakingTxChain;
+    txId: string;
+    state: StakingTxState;
+    timestampMs: number | null;
+    blockNumber?: number;
+    slot?: number;
+    confirmations?: number | null;
+    errorMessage?: string;
+}
+
+export interface EvmSubmitStepResult {
+    stepId: 'deposit' | 'approve' | 'source';
+    label: string;
+    txId: string;
+    timestampMs: number | null;
+}
+
+export interface EvmStakeSubmission {
+    finalTxId: string;
+    steps: EvmSubmitStepResult[];
+}
+
+type EvmLikeProvider =
+    | ethers.providers.Web3Provider
+    | ethers.providers.JsonRpcProvider;
+
+export async function getEvmTransactionStatus(
+    source: EvmStakingClient | EvmLikeProvider,
+    txId: string,
+): Promise<StakingTransactionStatus> {
+    const provider = isEvmStakingClient(source)
+        ? getEvmProvider(source)
+        : source;
+    const tx = await provider.getTransaction(txId).catch(() => null);
+    const receipt = await provider.getTransactionReceipt(txId).catch(() => null);
+
+    if (!tx && !receipt) {
+        return {
+            chain: 'evm',
+            txId,
+            state: 'not_found',
+            timestampMs: null,
+        };
+    }
+
+    if (!receipt) {
+        return {
+            chain: 'evm',
+            txId,
+            state: 'pending',
+            timestampMs: null,
+            confirmations: tx?.confirmations ?? null,
+        };
+    }
+
+    const block = receipt.blockNumber != null
+        ? await provider.getBlock(receipt.blockNumber).catch(() => null)
+        : null;
+
+    return {
+        chain: 'evm',
+        txId,
+        state: receipt.status === 0 ? 'failed' : 'confirmed',
+        timestampMs: block?.timestamp ? block.timestamp * 1000 : null,
+        blockNumber: receipt.blockNumber,
+        confirmations: tx?.confirmations ?? null,
+    };
+}
+
+export async function getSolanaTransactionStatus(
+    source: SolanaStakingClient | Connection,
+    txId: string,
+): Promise<StakingTransactionStatus> {
+    const connection = isSolanaStakingClient(source)
+        ? source.connection
+        : source;
+
+    const statusResponse = await connection.getSignatureStatuses(
+        [txId],
+        { searchTransactionHistory: true },
+    ).catch(() => ({ value: [null] }));
+    const status = statusResponse.value[0];
+    const transaction = await connection.getTransaction(txId, {
+        commitment: 'confirmed',
+        maxSupportedTransactionVersion: 0,
+    }).catch(() => null);
+
+    if (!status && !transaction) {
+        return {
+            chain: 'sol',
+            txId,
+            state: 'not_found',
+            timestampMs: null,
+        };
+    }
+
+    const errorMessage = status?.err ? JSON.stringify(status.err) : undefined;
+    const isConfirmed = !!transaction || status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized';
+
+    return {
+        chain: 'sol',
+        txId,
+        state: status?.err ? 'failed' : isConfirmed ? 'confirmed' : 'pending',
+        timestampMs: transaction?.blockTime ? transaction.blockTime * 1000 : null,
+        slot: transaction?.slot ?? status?.slot,
+        confirmations: status?.confirmations ?? null,
+        errorMessage,
+    };
+}
+
+export async function getStakingClientTransactionStatus(
+    client: EvmStakingClient | SolanaStakingClient,
+    txId: string,
+): Promise<StakingTransactionStatus> {
+    if (isEvmStakingClient(client)) {
+        return getEvmTransactionStatus(client, txId);
+    }
+    return getSolanaTransactionStatus(client, txId);
+}
+
+export async function submitEvmStakeToWireFlow(
+    client: EvmStakingClient,
+    amount: bigint | string | number | BigNumber,
+    wireAccount: string,
+): Promise<EvmStakeSubmission> {
+    ensureEvmUser(client);
+
+    const amountWei = BigNumber.isBigNumber(amount)
+        ? amount
+        : BigNumber.from(amount);
+    const signerAddress = await client.address;
+    if (!signerAddress) {
+        throw new Error('EVM signer address is unavailable.');
+    }
+
+    const contractService = getEvmContractService(client);
+    const depositor = client.contract.Depositor.address;
+    const liqRead = client.contract.LiqEthToken;
+    const liqWrite = contractService.getWrite('LiqEthToken');
+    const steps: EvmSubmitStepResult[] = [];
+
+    const [balance, allowance, paused] = await Promise.all([
+        liqRead.balanceOf(signerAddress),
+        liqRead.allowance(signerAddress, depositor),
+        client.contract.Depositor.paused(),
+    ]);
+
+    if (paused) {
+        throw new Error('StakeClient.performStakeToWire: Depositor is in a paused state');
+    }
+    if (!wireAccount?.trim()) {
+        throw new Error('StakeClient.performStakeToWire: wireAccount is required');
+    }
+    if (balance.lt(amountWei)) {
+        throw new Error('StakeClient.performStakeToWire: Insufficient LiqETH balance');
+    }
+
+    if (allowance.lt(amountWei)) {
+        const approveTx = await liqWrite.approve(depositor, amountWei);
+        const approveReceipt = await approveTx.wait(1);
+        const updatedAllowance = await liqRead.allowance(signerAddress, depositor);
+        if (updatedAllowance.lt(amountWei)) {
+            throw new Error('StakeClient.performStakeToWire: Liq allowance approval failed or allowance still insufficient after approve');
+        }
+        steps.push({
+            stepId: 'approve',
+            label: 'Approve LIQETH spend',
+            txId: approveTx.hash,
+            timestampMs: approveReceipt?.blockNumber != null
+                ? await getEvmBlockTimestampMs(getEvmProvider(client), approveReceipt.blockNumber)
+                : null,
+        });
+    }
+
+    try {
+        await client.contract.Depositor.callStatic.stakeLiqETHToWire(amountWei, wireAccount);
+    } catch (error: any) {
+        const formatted = formatContractErrors(error);
+        throw new Error(`StakeClient.performStakeToWire: ${formatted.name ?? formatted.raw}`);
+    }
+
+    const txOverrides = await resolveContractWriteOverrides(
+        client.contract.Depositor,
+        'stakeLiqETHToWire',
+        [amountWei, wireAccount],
+    );
+    const stakeTx = await client.contract.Depositor.stakeLiqETHToWire(
+        amountWei,
+        wireAccount,
+        txOverrides,
+    );
+    const stakeReceipt = await stakeTx.wait(1);
+    steps.push({
+        stepId: 'source',
+        label: 'Stake LIQETH to Wire',
+        txId: stakeTx.hash,
+        timestampMs: stakeReceipt?.blockNumber != null
+            ? await getEvmBlockTimestampMs(getEvmProvider(client), stakeReceipt.blockNumber)
+            : null,
+    });
+
+    return {
+        finalTxId: stakeTx.hash,
+        steps,
+    };
+}
+
+export async function submitEvmDepositAndStakeToWireFlow(
+    client: EvmStakingClient,
+    amount: bigint | string | number | BigNumber,
+    wireAccount: string,
+): Promise<EvmStakeSubmission> {
+    ensureEvmUser(client);
+
+    const amountWei = BigNumber.isBigNumber(amount)
+        ? amount
+        : BigNumber.from(amount);
+    if (amountWei.lte(0)) {
+        throw new Error('Amount must be greater than zero.');
+    }
+
+    const convertClient = getEvmConvertClient(client);
+    const depositResult = await convertClient.performDeposit(amountWei);
+    const steps: EvmSubmitStepResult[] = [{
+        stepId: 'deposit',
+        label: 'Deposit native token',
+        txId: depositResult.txHash,
+        timestampMs: depositResult.receipt?.blockNumber != null
+            ? await getEvmBlockTimestampMs(getEvmProvider(client), depositResult.receipt.blockNumber)
+            : null,
+    }];
+
+    const stake = await submitEvmStakeToWireFlow(client, amountWei, wireAccount);
+    return {
+        finalTxId: stake.finalTxId,
+        steps: [...steps, ...stake.steps],
+    };
+}
+
+function isEvmStakingClient(value: unknown): value is EvmStakingClient {
+    return value instanceof EvmStakingClient;
+}
+
+function isSolanaStakingClient(value: unknown): value is SolanaStakingClient {
+    return value instanceof SolanaStakingClient;
+}
+
+function getEvmProvider(client: EvmStakingClient): EvmLikeProvider {
+    const provider = (client as unknown as { provider?: EvmLikeProvider }).provider;
+    if (!provider) {
+        throw new Error('EVM provider is unavailable.');
+    }
+    return provider;
+}
+
+function getEvmContractService(client: EvmStakingClient): {
+    getWrite: (name: string) => any;
+} {
+    const contractService = (client as unknown as { contractService?: { getWrite: (name: string) => any } }).contractService;
+    if (!contractService) {
+        throw new Error('EVM contract service is unavailable.');
+    }
+    return contractService;
+}
+
+function getEvmConvertClient(client: EvmStakingClient): {
+    performDeposit: (amountWei: BigNumber) => Promise<{
+        txHash: string;
+        receipt?: { blockNumber?: number };
+    }>;
+} {
+    const convertClient = (client as unknown as { convertClient?: any }).convertClient;
+    if (!convertClient?.performDeposit) {
+        throw new Error('EVM convert client is unavailable.');
+    }
+    return convertClient;
+}
+
+function ensureEvmUser(client: EvmStakingClient): void {
+    const ensureUser = (client as unknown as { ensureUser?: () => void }).ensureUser;
+    ensureUser?.call(client);
+}
+
+async function getEvmBlockTimestampMs(
+    provider: EvmLikeProvider,
+    blockNumber: number,
+): Promise<number | null> {
+    const block = await provider.getBlock(blockNumber).catch(() => null);
+    return block?.timestamp ? block.timestamp * 1000 : null;
+}

package/src/types.ts

@@ -1,7 +1,8 @@
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
 import { PublicKey as SolPubKey } from '@solana/web3.js';
-import { ChainID, EvmChainID, ExternalNetwork, PublicKey, SolChainID } from '@wireio/core';
+import { ChainID, ExternalNetwork, PublicKey } from '@wireio/core';
 import { ethers } from 'ethers';
+import type { SupportedEvmContractChainID, SupportedSolProgramChainID } from './chains';
 
 export type StakerConfig = {
     network: ExternalNetwork;
@@ -17,14 +18,8 @@ export type SquadsXConfig = {
     vaultIndex?: number;        // default 0
 };
 
-export enum SupportedEvmChainID {
-    Ethereum = EvmChainID.Ethereum,
-    Hoodi = EvmChainID.Hoodi,
-}
-export enum SupportedSolChainID {
-    Mainnet = SolChainID.Mainnet,
-    Devnet = SolChainID.Devnet,
-}
+export type SupportedEvmChainID = SupportedEvmContractChainID;
+export type SupportedSolChainID = SupportedSolProgramChainID;
 
 export type ChainSymbol = 'ETH' | 'SOL';
 export type WithdrawStatus = 'queued' | 'ready' | 'claimed';
@@ -36,7 +31,7 @@ export interface IStakingClient {
     /** Amount is in the chain's smallest unit (lamports/wei, etc.) */
     deposit(amount: bigint): Promise<string>;
     withdraw(amount: bigint): Promise<string>;
-    stake(amount: bigint): Promise<string>;
+    stake(amount: bigint, wireAccount?: string): Promise<string>;
     unstake(amount: bigint): Promise<string>;
     buy(amount: bigint): Promise<string>;
     
@@ -47,7 +42,7 @@ export interface IStakingClient {
     // claimLiqsolRewards?(): Promise<string>
 
     /** Atomically deposit native token to liq token, then stake that liq token. On Solana: amount in lamports. On Ethereum: amount in wei. */
-    depositAndStake(amount: bigint): Promise<string>
+    depositAndStake(amount: bigint, wireAccount?: string): Promise<string>
 
     /** Atomically deposit native token to liq token, then buy pretokens with that liq token. On Solana: amount in lamports. On Ethereum: amount in wei. */
     depositAndBuy(amount: bigint): Promise<string>