@wireio/stake 2.7.4 → 3.0.0

package/src/networks/{ethereum → evm}/clients/pretoken.client.ts

@@ -1,13 +1,13 @@
 import { BigNumber, ethers } from "ethers";
-import { EthereumContractService } from "../contract";
-import { formatContractErrors, sendOPPFinalize } from "../utils";
+import { EvmContractService } from "../contract";
+import { formatContractErrors, resolveContractWriteOverrides, sendOPPFinalize } from "../utils";
 
 export class PretokenClient {
-    private readonly contractService: EthereumContractService;
+    private readonly contractService: EvmContractService;
     
     get contract() { return this.contractService.contract; }
 
-    constructor(contract: EthereumContractService) {
+    constructor(contract: EvmContractService) {
         this.contractService = contract;
     }
     
@@ -72,7 +72,12 @@ export class PretokenClient {
         // attempt the real purchase call
         let tx, receipt;
         try {
-            tx = await this.contract.Depositor.purchasePretokensWithLiqETH(amountLiq, buyer);
+            const txOverrides = await resolveContractWriteOverrides(
+                this.contract.Depositor,
+                'purchasePretokensWithLiqETH',
+                [amountLiq, buyer],
+            );
+            tx = await this.contract.Depositor.purchasePretokensWithLiqETH(amountLiq, buyer, txOverrides);
             receipt = await tx.wait(1);
         } catch (err: any) {
             let errorObj = formatContractErrors(err);
@@ -162,4 +167,4 @@ export class PretokenClient {
 
     
 
-}
+}

package/src/networks/{ethereum → evm}/clients/receipt.client.ts

@@ -1,15 +1,15 @@
 import { BigNumber } from "ethers";
 import { preLaunchReceipt } from "../types";
 import { WithdrawReceipt, ReceiptNFTKind } from "../../../types";
-import { EthereumContractService } from "../contract";
+import { EvmContractService } from "../contract";
 
 export class ReceiptClient {
 
-    private readonly contractService: EthereumContractService;
+    private readonly contractService: EvmContractService;
     
     get contract() { return this.contractService.contract; }
 
-    constructor(contract: EthereumContractService) {
+    constructor(contract: EvmContractService) {
         this.contractService = contract;
     }
 

package/src/networks/{ethereum → evm}/clients/stake.client.ts

@@ -7,41 +7,101 @@ import {
     DepositAndPurchaseResult,
     UnstakeAndWithdrawResult,
 } from "../types";
-import { EthereumContractService } from "../contract";
-import { formatContractErrors } from "../utils";
+import { EvmContractService } from "../contract";
+import { formatContractErrors, resolveContractWriteOverrides } from "../utils";
 
 export class StakeClient {
 
-    private readonly contractService: EthereumContractService;
+    private readonly contractService: EvmContractService;
     
     get contract() { return this.contractService.contract; }
 
-    constructor(contract: EthereumContractService) {
+    constructor(contract: EvmContractService) {
         this.contractService = contract;
     }
     
 
-
     /**
-     * Simulate a stake via callStatic
+     * 
+     * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
+     * @returns txHash (hash of the transaction), receipt, Staked event
      */
-    async simulateStake(amountWei: BigNumber): Promise<void> {
+    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');
+            }
+        }
+        
+        // simulate stake via callStatic to catch any errors before sending the transaction and spending gas
         try {
             await this.contract.Depositor.callStatic.stakeLiqETH(amountWei);
         } catch (err: any) {
             let errorObj = formatContractErrors(err);
             throw new Error(errorObj.name ?? errorObj.raw)
         }
-    }
 
+        // send the tx to stake liqeth
+        const txOverrides = await resolveContractWriteOverrides(
+            this.contract.Depositor,
+            'stakeLiqETH',
+            [amountWei],
+        );
+        const tx = await this.contract.Depositor.stakeLiqETH(amountWei, txOverrides);
+
+        // 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,
+        };
+    }
 
 
     /**
      * 
      * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
+     * @param wireAccount Wire chain recipient account name. Required.
      * @returns txHash (hash of the transaction), receipt, Staked event
      */
-    async performStake(amountWei: BigNumber, signerAddress: string): Promise<any> {
+    async performStakeToWire(amountWei: BigNumber, signerAddress: string, wireAccount?: string): Promise<any> {
         const depositor = this.contract.Depositor.address;
         const liqRead = this.contract.LiqEthToken;
         const bal = await liqRead.balanceOf(signerAddress);
@@ -49,32 +109,44 @@ export class StakeClient {
 
         const paused = await this.contract.Depositor.paused();
         if(paused) {
-            throw new Error("Error - Depositor is in a paused state");
+            throw new Error("StakeClient.performStakeToWire: Depositor is in a paused state");
         }
 
-        if (bal.lt(amountWei)) throw new Error("Insufficient LiqETH balance");
+        if (!wireAccount?.trim()) {
+            throw new Error('StakeClient.performStakeToWire: wireAccount is required');
+        }
+
+        if (bal.lt(amountWei)) throw new Error("StakeClient.performStakeToWire: 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');
+                throw new Error('StakeClient.performStakeToWire: Liq allowance approval failed or allowance still insufficient after approve');
             }
         }
         
-        
-        await this.simulateStake(amountWei);
-
+        // simulate stake via callStatic to catch any errors before sending the transaction and spending gas
+        try {
+            await this.contract.Depositor.callStatic.stakeLiqETHToWire(amountWei, wireAccount);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(`StakeClient.performStakeToWire: ${errorObj.name ?? errorObj.raw}`);
+        }
 
         // send the tx to stake liqeth
-        const tx = await this.contract.Depositor.stakeLiqETH(amountWei);
+        const txOverrides = await resolveContractWriteOverrides(
+            this.contract.Depositor,
+            'stakeLiqETHToWire',
+            [amountWei, wireAccount],
+        );
+        const tx = await this.contract.Depositor.stakeLiqETHToWire(amountWei, wireAccount, txOverrides);
 
         // Wait for 1 confirmation 
         const receipt = await tx.wait(1);
@@ -101,7 +173,6 @@ export class StakeClient {
     }
 
 
-
     /**
      * Burn the STAKE ReceiptNFT and send principal liqETH to `recipient` (Depositor.withdrawStake).
      * @param tokenId  ReceiptNFT token id for the stake position
@@ -148,6 +219,48 @@ export class StakeClient {
             throw new Error(errorObj.name ?? errorObj.raw);
         }
 
+        const txOverrides = await resolveContractWriteOverrides(
+            this.contract.Depositor,
+            'depositAndStake',
+            [],
+            { value: amountWei },
+        );
+        const tx = await this.contract.Depositor.depositAndStake(txOverrides);
+        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 stake liqETH in a single transaction.
+     * @param amountWei  Amount of ETH in wei to deposit and stake
+     * @param wireAccount Wire chain recipient account name. Required.
+     * @returns txHash (hash of the transaction), receipt, Staked event
+     */
+    // ! CURRENTLY NOT IMPLEMENTED AS OF 4/14/26
+    async performDepositAndStakeToWire(amountWei: BigNumber, wireAccount?: string): Promise<DepositAndStakeResult> {
+        if (!wireAccount?.trim()) {
+            throw new Error('StakeClient.performDepositAndStakeToWire: wireAccount is required');
+        }
+
+        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;
@@ -178,7 +291,13 @@ export class StakeClient {
             throw new Error(errorObj.name ?? errorObj.raw);
         }
 
-        const tx = await this.contract.Depositor.depositAndPurchase({ value: amountWei });
+        const txOverrides = await resolveContractWriteOverrides(
+            this.contract.Depositor,
+            'depositAndPurchase',
+            [],
+            { value: amountWei },
+        );
+        const tx = await this.contract.Depositor.depositAndPurchase(txOverrides);
         const receipt = await tx.wait(1);
         return { txHash: tx.hash, receipt };
     }
@@ -196,7 +315,12 @@ export class StakeClient {
             throw new Error(errorObj.name ?? errorObj.raw);
         }
 
-        const tx = await this.contract.Depositor.unstakeAndRequestWithdraw(tokenId);
+        const txOverrides = await resolveContractWriteOverrides(
+            this.contract.Depositor,
+            'unstakeAndRequestWithdraw',
+            [tokenId],
+        );
+        const tx = await this.contract.Depositor.unstakeAndRequestWithdraw(tokenId, txOverrides);
         const receipt = await tx.wait(1);
         return { txHash: tx.hash, receipt };
     }

package/src/networks/{ethereum → evm}/clients/validator.client.ts

@@ -1,15 +1,15 @@
 import { BigNumber, ethers } from "ethers";
 import { ClaimedEvent, DepositEvent, DepositResult, SharesBurnedEvent, ValidatorDepositedEvent } from "../types";
-import { EthereumContractService } from "../contract";
+import { EvmContractService } from "../contract";
 import { formatContractErrors } from "../utils";
 
 export class ValidatorClient {
 
-    private readonly contractService: EthereumContractService;
+    private readonly contractService: EvmContractService;
     
     get contract() { return this.contractService.contract; }
 
-    constructor(contract: EthereumContractService) {
+    constructor(contract: EvmContractService) {
         this.contractService = contract;
     }