@wireio/stake 1.5.69 → 1.6.69

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireio/stake",
-    "version": "1.5.69",
+    "version": "1.6.69",
     "description": "LIQ Staking Module for Wire Network",
     "homepage": "https://gitea.gitgo.app/Wire/sdk-stake",
     "license": "FSL-1.1-Apache-2.0",

package/src/index.ts

@@ -1,6 +1,7 @@
 // Staker utilities
 export * from './staker';
 export * from './types';
+export * from './status';
 
 // NETWORKS
 export * from './networks/ethereum/ethereum';

package/src/networks/solana/clients/outpost.client.ts

@@ -112,8 +112,26 @@ export class OutpostClient {
      * Internal helper: get raw token balance (BN) for a given ATA.
      */
     private async getTokenBalance(ata: PublicKey): Promise<BN> {
-        const bal = await this.connection.getTokenAccountBalance(ata);
-        return new BN(bal.value.amount);
+        try {
+            const bal = await this.connection.getTokenAccountBalance(ata);
+            return new BN(bal.value.amount);
+        } catch (error) {
+            if (this.isMissingTokenAccountError(error)) {
+                return new BN(0);
+            }
+            throw error;
+        }
+    }
+
+    private isMissingTokenAccountError(error: unknown): boolean {
+        const message = String(
+            (error as { message?: string } | null)?.message ?? '',
+        ).toLowerCase();
+
+        return (
+            message.includes('failed to get token account balance') &&
+            message.includes('could not find account')
+        );
     }
 
     /**

package/src/networks/solana/constants.ts

@@ -37,7 +37,7 @@ const DEVNET_PROGRAM_IDS: SolanaProgramIds = {
     LIQSOL_TOKEN: new PublicKey(devnetLiqSolTokenIDL.address),
     VALIDATOR_LEADERBOARD: new PublicKey(devnetValidatorLeaderboardIDL.address),
     TRANSFER_HOOK: new PublicKey(devnetTransferHookIDL.address),
-    ALT: new PublicKey("3dm6p83nqBTLnbJBFEfbHJ988y6cfKtrGSoKJbGD3hqp")
+    ALT: new PublicKey("EG5pouZneDQxfw5coaWkkv5qeoJkRsgyMiq4r6bw7K2F")
 };
 
 export const PROGRAM_IDS_BY_CHAIN: Record<SupportedSolChainID, SolanaProgramIds> = {

package/src/networks/solana/solana.ts

@@ -323,6 +323,85 @@ export class SolanaStakingClient implements IStakingClient {
         }
     }
 
+    getLiqsolDestinationOwner(owner?: SolPubKey): SolPubKey {
+        return owner ?? this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+    }
+
+    getLiqsolDestinationAta(owner?: SolPubKey): SolPubKey {
+        const destinationOwner = this.getLiqsolDestinationOwner(owner);
+        const mint = this.program.deriveLiqsolMintPda();
+        return getAssociatedTokenAddressSync(
+            mint,
+            destinationOwner,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+        );
+    }
+
+    async getLiqsolDestinationAtaState(owner?: SolPubKey): Promise<{
+        owner: SolPubKey;
+        mint: SolPubKey;
+        ata: SolPubKey;
+        exists: boolean;
+    }> {
+        const destinationOwner = this.getLiqsolDestinationOwner(owner);
+        const mint = this.program.deriveLiqsolMintPda();
+        const ata = this.getLiqsolDestinationAta(destinationOwner);
+        const accountInfo = await this.connection.getAccountInfo(ata, 'confirmed');
+
+        return {
+            owner: destinationOwner,
+            mint,
+            ata,
+            exists: !!accountInfo,
+        };
+    }
+
+    async maybeBuildCreateLiqsolDestinationAtaIx(
+        owner?: SolPubKey,
+    ): Promise<TransactionInstruction | null> {
+        const state = await this.getLiqsolDestinationAtaState(owner);
+        if (state.exists) {
+            return null;
+        }
+
+        return createAssociatedTokenAccountInstruction(
+            this.feePayer,
+            state.ata,
+            state.owner,
+            state.mint,
+            TOKEN_2022_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+        );
+    }
+
+    async ensureLiqsolDestinationAta(owner?: SolPubKey): Promise<string | null> {
+        this.ensureUser();
+        const createAtaIx = await this.maybeBuildCreateLiqsolDestinationAtaIx(owner);
+        if (!createAtaIx) {
+            return null;
+        }
+
+        try {
+            return await this.buildAndSendIx(createAtaIx);
+        } catch (error) {
+            if (!this.isAtaAlreadyCreatedError(error)) {
+                throw error;
+            }
+            return null;
+        }
+    }
+
+    private async prependLiqsolDestinationAtaIx(
+        ix: TransactionInstruction | TransactionInstruction[],
+        owner?: SolPubKey,
+    ): Promise<TransactionInstruction[]> {
+        const ixs = Array.isArray(ix) ? [...ix] : [ix];
+        const createAtaIx = await this.maybeBuildCreateLiqsolDestinationAtaIx(owner);
+        return createAtaIx ? [createAtaIx, ...ixs] : ixs;
+    }
+
     /**
      * Claim accrued liqSOL distribution rewards (liqsol_core::claim_rewards).
      */
@@ -332,9 +411,10 @@ export class SolanaStakingClient implements IStakingClient {
 
         try {
             const ix = await this.distributionClient.buildClaimRewardsIx(owner);
+            const ixs = await this.prependLiqsolDestinationAtaIx(ix, owner);
             return !!this.squadsX
-                ? await this.sendSquadsIxs(ix)
-                : await this.buildAndSendIx(ix);
+                ? await this.sendSquadsIxs(ixs)
+                : await this.buildAndSendIx(ixs);
         } catch (err) {
             console.log(`Failed to claim liqSOL rewards on Solana: ${err}`);
             throw err;
@@ -374,10 +454,12 @@ export class SolanaStakingClient implements IStakingClient {
             throw new Error('Unstake amount must be greater than zero.');
 
         try {
+            const owner = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
             const ix = await this.outpostClient.buildUnstakeIx(amountLamports, this.squadsVaultPDA)
+            const ixs = await this.prependLiqsolDestinationAtaIx(ix, owner);
             return !!this.squadsX
-                ? await this.sendSquadsIxs(ix)
-                : await this.buildAndSendIx(ix)
+                ? await this.sendSquadsIxs(ixs)
+                : await this.buildAndSendIx(ixs)
         }
         catch (err) {
             console.log(`Failed to unstake Solana: ${err}`);
@@ -462,10 +544,11 @@ export class SolanaStakingClient implements IStakingClient {
             const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
             const unstakeIx = await this.outpostClient.buildUnstakeIx(amountLamports, user);
             const withdrawIx = await this.convertClient.buildWithdrawTx(amountLamports, user);
+            const ixs = await this.prependLiqsolDestinationAtaIx([unstakeIx, withdrawIx], user);
 
             return !!this.squadsX
-                ? await this.sendSquadsIxs([unstakeIx, withdrawIx])
-                : await this.buildAndSendIx([unstakeIx, withdrawIx]);
+                ? await this.sendSquadsIxs(ixs)
+                : await this.buildAndSendIx(ixs);
         } catch (err) {
             console.log(`Failed to unstake and withdraw: ${err}`);
             throw err;
@@ -897,6 +980,13 @@ export class SolanaStakingClient implements IStakingClient {
             || normalized.includes('custom program error: 0x1784');
     }
 
+    private isAtaAlreadyCreatedError(error: unknown): boolean {
+        const message = error instanceof Error ? error.message : String(error ?? '');
+        const normalized = message.toLowerCase();
+        return normalized.includes('already in use')
+            || normalized.includes('already exists');
+    }
+
     // ---------------------------------------------------------------------
     // READ-ONLY Public Methods
     // ---------------------------------------------------------------------

package/src/status.ts

@@ -0,0 +1,301 @@
+import { Connection } from '@solana/web3.js';
+import { BigNumber, ethers } from 'ethers';
+
+import { EthereumStakingClient } from './networks/ethereum/ethereum';
+import { formatContractErrors, resolveContractWriteOverrides } from './networks/ethereum/utils';
+import { SolanaStakingClient } from './networks/solana/solana';
+
+export type StakingTxChain = 'eth' | '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 EthereumSubmitStepResult {
+    stepId: 'deposit' | 'approve' | 'source';
+    label: string;
+    txId: string;
+    timestampMs: number | null;
+}
+
+export interface EthereumStakeSubmission {
+    finalTxId: string;
+    steps: EthereumSubmitStepResult[];
+}
+
+type EthereumLikeProvider =
+    | ethers.providers.Web3Provider
+    | ethers.providers.JsonRpcProvider;
+
+export async function getEthereumTransactionStatus(
+    source: EthereumStakingClient | EthereumLikeProvider,
+    txId: string,
+): Promise<StakingTransactionStatus> {
+    const provider = isEthereumStakingClient(source)
+        ? getEthereumProvider(source)
+        : source;
+    const tx = await provider.getTransaction(txId).catch(() => null);
+    const receipt = await provider.getTransactionReceipt(txId).catch(() => null);
+
+    if (!tx && !receipt) {
+        return {
+            chain: 'eth',
+            txId,
+            state: 'not_found',
+            timestampMs: null,
+        };
+    }
+
+    if (!receipt) {
+        return {
+            chain: 'eth',
+            txId,
+            state: 'pending',
+            timestampMs: null,
+            confirmations: tx?.confirmations ?? null,
+        };
+    }
+
+    const block = receipt.blockNumber != null
+        ? await provider.getBlock(receipt.blockNumber).catch(() => null)
+        : null;
+
+    return {
+        chain: 'eth',
+        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: EthereumStakingClient | SolanaStakingClient,
+    txId: string,
+): Promise<StakingTransactionStatus> {
+    if (isEthereumStakingClient(client)) {
+        return getEthereumTransactionStatus(client, txId);
+    }
+    return getSolanaTransactionStatus(client, txId);
+}
+
+export async function submitEthereumStakeToWireFlow(
+    client: EthereumStakingClient,
+    amount: bigint | string | number | BigNumber,
+    wireAccount: string,
+): Promise<EthereumStakeSubmission> {
+    ensureEthereumUser(client);
+
+    const amountWei = BigNumber.isBigNumber(amount)
+        ? amount
+        : BigNumber.from(amount);
+    const signerAddress = await client.address;
+    if (!signerAddress) {
+        throw new Error('Ethereum signer address is unavailable.');
+    }
+
+    const contractService = getEthereumContractService(client);
+    const depositor = client.contract.Depositor.address;
+    const liqRead = client.contract.LiqEthToken;
+    const liqWrite = contractService.getWrite('LiqEthToken');
+    const steps: EthereumSubmitStepResult[] = [];
+
+    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 getEthereumBlockTimestampMs(getEthereumProvider(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 getEthereumBlockTimestampMs(getEthereumProvider(client), stakeReceipt.blockNumber)
+            : null,
+    });
+
+    return {
+        finalTxId: stakeTx.hash,
+        steps,
+    };
+}
+
+export async function submitEthereumDepositAndStakeToWireFlow(
+    client: EthereumStakingClient,
+    amount: bigint | string | number | BigNumber,
+    wireAccount: string,
+): Promise<EthereumStakeSubmission> {
+    ensureEthereumUser(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 = getEthereumConvertClient(client);
+    const depositResult = await convertClient.performDeposit(amountWei);
+    const steps: EthereumSubmitStepResult[] = [{
+        stepId: 'deposit',
+        label: 'Deposit native ETH',
+        txId: depositResult.txHash,
+        timestampMs: depositResult.receipt?.blockNumber != null
+            ? await getEthereumBlockTimestampMs(getEthereumProvider(client), depositResult.receipt.blockNumber)
+            : null,
+    }];
+
+    const stake = await submitEthereumStakeToWireFlow(client, amountWei, wireAccount);
+    return {
+        finalTxId: stake.finalTxId,
+        steps: [...steps, ...stake.steps],
+    };
+}
+
+function isEthereumStakingClient(value: unknown): value is EthereumStakingClient {
+    return value instanceof EthereumStakingClient;
+}
+
+function isSolanaStakingClient(value: unknown): value is SolanaStakingClient {
+    return value instanceof SolanaStakingClient;
+}
+
+function getEthereumProvider(client: EthereumStakingClient): EthereumLikeProvider {
+    const provider = (client as unknown as { provider?: EthereumLikeProvider }).provider;
+    if (!provider) {
+        throw new Error('Ethereum provider is unavailable.');
+    }
+    return provider;
+}
+
+function getEthereumContractService(client: EthereumStakingClient): {
+    getWrite: (name: string) => any;
+} {
+    const contractService = (client as unknown as { contractService?: { getWrite: (name: string) => any } }).contractService;
+    if (!contractService) {
+        throw new Error('Ethereum contract service is unavailable.');
+    }
+    return contractService;
+}
+
+function getEthereumConvertClient(client: EthereumStakingClient): {
+    performDeposit: (amountWei: BigNumber) => Promise<{
+        txHash: string;
+        receipt?: { blockNumber?: number };
+    }>;
+} {
+    const convertClient = (client as unknown as { convertClient?: any }).convertClient;
+    if (!convertClient?.performDeposit) {
+        throw new Error('Ethereum convert client is unavailable.');
+    }
+    return convertClient;
+}
+
+function ensureEthereumUser(client: EthereumStakingClient): void {
+    const ensureUser = (client as unknown as { ensureUser?: () => void }).ensureUser;
+    ensureUser?.call(client);
+}
+
+async function getEthereumBlockTimestampMs(
+    provider: EthereumLikeProvider,
+    blockNumber: number,
+): Promise<number | null> {
+    const block = await provider.getBlock(blockNumber).catch(() => null);
+    return block?.timestamp ? block.timestamp * 1000 : null;
+}