@wireio/stake 0.2.5 → 0.2.69

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

@@ -1,5 +1,12 @@
 import { BigNumber, ethers } from "ethers";
-import { preLaunchReceipt, StakedEvent, WithdrawnStakeEvent, WithdrawnStakeResult } from "../types";
+import {
+    StakedEvent,
+    WithdrawnStakeEvent,
+    WithdrawnStakeResult,
+    DepositAndStakeResult,
+    DepositAndPurchaseResult,
+    UnstakeAndWithdrawResult,
+} from "../types";
 import { EthereumContractService } from "../contract";
 import { formatContractErrors } from "../utils";
 
@@ -28,62 +35,6 @@ export class StakeClient {
     }
 
 
-    /**
-     * Read OPP / Outpost state used by the Depositor to decide whether staking is allowed.
-     * Returns various data
-     */
-    async getOppStatus(): Promise<any> {
-        const depositor = this.contract.Depositor;
-        const opp = this.contract.OPP;
-
-        
-        const oppAddress: string = await depositor.oppAddress();
-        const oppInboundAddress: string = await depositor.oppInboundAddress();
-        const prevEpochSent = await opp.prevEpochSent();
-        
-
-        const inbound = this.contractService.getReadOnly('OPPInbound');
-
-        // Query useful getters
-        const nextEpochBN: any = await inbound.nextEpochNum();
-        const pendingEpochRaw: any = await inbound.pendingEpoch();
-        const pendingMessageCount: any = await inbound.pendingMessageCount();
-        const previousEpochHash: string = await inbound.previousEpochHash();
-        const nextEpochNum = (nextEpochBN && typeof nextEpochBN.toNumber === 'function') ? nextEpochBN.toNumber() : Number(nextEpochBN || 0);
-
-        const pendingEpoch = (pendingEpochRaw && pendingEpochRaw.epochNumber !== undefined)
-            ? {
-                epochNumber: (pendingEpochRaw.epochNumber && typeof pendingEpochRaw.epochNumber.toNumber === 'function') ? pendingEpochRaw.epochNumber.toNumber() : Number(pendingEpochRaw.epochNumber || 0),
-                timestamp: (pendingEpochRaw.timestamp && typeof pendingEpochRaw.timestamp.toNumber === 'function') ? pendingEpochRaw.timestamp.toNumber() : Number(pendingEpochRaw.timestamp || 0),
-                prevEpochHash: pendingEpochRaw.prevEpochHash,
-                merkleRoot: pendingEpochRaw.merkleRoot,
-                firstMessageID: pendingEpochRaw.firstMessageID,
-                lastMessageID: pendingEpochRaw.lastMessageID,
-            }
-            : null;
-
-        const pendingMessagesBN = pendingMessageCount;
-        const pendingMessages = (pendingMessagesBN && typeof pendingMessagesBN.toString === 'function') ? pendingMessagesBN.toString() : String(pendingMessagesBN || '0');
-
-        const hasPendingMessages = (pendingMessagesBN && typeof pendingMessagesBN.gt === 'function') ? pendingMessagesBN.gt(0) : (Number(pendingMessages) > 0);
-
-        return {
-            oppAddress,
-            prevEpochSent,
-            oppInboundAddress,
-            nextEpochNum,
-            pendingEpoch,
-            pendingMessageCount: pendingMessages,
-            previousEpochHash,
-            hasPendingMessages,
-            raw: {
-                nextEpochBN,
-                pendingEpochRaw,
-                pendingMessageCount: pendingMessagesBN,
-            },
-        };
-    }
-
 
     /**
      * 
@@ -92,7 +43,7 @@ export class StakeClient {
      */
     async performStake(amountWei: BigNumber, signerAddress: string): Promise<any> {
         const depositor = this.contract.Depositor.address;
-        const liqRead = this.contract.LiqEth;
+        const liqRead = this.contract.LiqEthToken;
         const bal = await liqRead.balanceOf(signerAddress);
         const allowance = await liqRead.allowance(signerAddress, depositor);
 
@@ -101,16 +52,14 @@ export class StakeClient {
             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('LiqEth');
+            const liqWrite = this.contractService.getWrite('LiqEthToken');
 
-            // currently requested unlimited amount - potentially change to only request up to the current amount?
-            const approveAmount = ethers.constants.MaxUint256;
-
-            console.warn(`allowance insufficient (${allowance.toString()} < ${amountWei.toString()}); sending approve(${depositor}, ${approveAmount.toString()})`);
-            const approveTx = await liqWrite.approve(depositor, approveAmount);
+            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
@@ -153,110 +102,20 @@ export class StakeClient {
 
 
 
-    async getOwnedTokenIdsFor(
-        owner: string,
-        fromBlock = 1850820,
-        toBlock: number | string = "latest"
-    ): Promise<BigNumber[]> {
-        const receiptContract = this.contract.ReceiptNFT;
-
-        // Logs where address received tokens
-        const toLogs = await receiptContract.queryFilter(
-            receiptContract.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),
-            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));
-    }
-
-
-    /**
-     * 
-     * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
-     * @returns txHash (hash of the transaction), receipt, WithdrawnStake event
-     */
-    async fetchPreLaunchReceipts(address: string): Promise<preLaunchReceipt[]> {
-        const receiptContract = this.contract.ReceiptNFT;
-
-        // first figure out which tokenIds this address owns, from events
-        const tokenIds = await this.getOwnedTokenIdsFor(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);
-                const formattedReceipt = {
-                    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(),
-                }
-
-                // Only fetch staking receipts (kind 1 is a wire pretoken receipt)
-                if(receiptData.kind == 0) results.push({ tokenId: idBN.toBigInt(), receipt: formattedReceipt } as any);
-            } 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;
-            }
-        }
-
-        console.log('results of prelaunch receipts', results)
-        return results;
-    }
-
-
     /**
-     * 
-     * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
-     * @returns txHash (hash of the transaction), receipt, WithdrawnStake event
+     * 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 
+        // Wait for 1 confirmation
         const receipt = await tx.wait(1);
 
-        // Parse Staked event if present
+        // Parse WithdrawnStake event if present
         let withdrawnstake: WithdrawnStakeEvent | undefined;
         const ev = receipt.events?.find((e) => e.event === 'WithdrawnStake');
 
@@ -275,4 +134,70 @@ export class StakeClient {
             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,
+        };
+    }
+
+
+}