@wireio/stake 0.2.4 → 0.2.5

package/package.json

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

package/src/assets/ethereum/ABI/outpost/Aggregator.sol/Aggregator.json

@@ -0,0 +1,82 @@
+{
+    "_format": "hh-sol-artifact-1",
+    "contractName": "Aggregator",
+    "sourceName": "contracts/outpost/Aggregator.sol",
+    "abi": [
+        {
+            "inputs": [
+            { "internalType": "address", "name": "_authority", "type": "address" },
+            { "internalType": "int256", "name": "initialPrice", "type": "int256" },
+            { "internalType": "uint8", "name": "__decimals", "type": "uint8" }
+            ],
+            "name": "initialize",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "decimals",
+            "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "description",
+            "outputs": [{ "internalType": "string", "name": "", "type": "string" }],
+            "stateMutability": "pure",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "version",
+            "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+            "stateMutability": "pure",
+            "type": "function"
+        },
+        {
+            "inputs": [{ "internalType": "uint80", "name": "", "type": "uint80" }],
+            "name": "getRoundData",
+            "outputs": [
+            { "internalType": "uint80", "name": "roundId", "type": "uint80" },
+            { "internalType": "int256", "name": "answer", "type": "int256" },
+            { "internalType": "uint256", "name": "startedAt", "type": "uint256" },
+            { "internalType": "uint256", "name": "updatedAt", "type": "uint256" },
+            { "internalType": "uint80", "name": "answeredInRound", "type": "uint80" }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [],
+            "name": "latestRoundData",
+            "outputs": [
+            { "internalType": "uint80", "name": "roundId", "type": "uint80" },
+            { "internalType": "int256", "name": "answer", "type": "int256" },
+            { "internalType": "uint256", "name": "startedAt", "type": "uint256" },
+            { "internalType": "uint256", "name": "updatedAt", "type": "uint256" },
+            { "internalType": "uint80", "name": "answeredInRound", "type": "uint80" }
+            ],
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "inputs": [{ "internalType": "int256", "name": "newPrice", "type": "int256" }],
+            "name": "updateAnswer",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "inputs": [
+            { "internalType": "int256", "name": "newPrice", "type": "int256" },
+            { "internalType": "uint256", "name": "oldTimestamp", "type": "uint256" }
+            ],
+            "name": "updateStale",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+    ]
+}

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

@@ -1,6 +1,7 @@
-import { BigNumber, ethers } from "ethers";
-import { DepositEvent, DepositResult } from "../types";
+import { BigNumber, ethers, Signer } from "ethers";
+import { DepositEvent, DepositResult, WithdrawRequestedEvent, WithdrawResult } from "../types";
 import { EthereumContractService } from "../contract";
+import { ChainID } from "@wireio/core";
 
 export class DepositClient {
 
@@ -79,4 +80,77 @@ export class DepositClient {
     }
 
 
+
+    
+    async requestWithdraw(amountWei: BigNumber, signer: Signer, chainId: ChainID): Promise<WithdrawResult> {
+        // deadline is a period of time in the future that the signature is valid for
+        const deadline = Math.floor(Date.now() / 1000) + 3600;
+
+        const liqEth = this.contract.LiqEth;
+        const owner = await signer.getAddress();
+        
+        const nonce: BigNumber = await liqEth.nonces(owner);
+        const domain = {
+            name: await liqEth.name(),
+            version: '1',
+            chainId,
+            verifyingContract: this.contract.LiqEth.address,
+        } as any;
+
+        const types = {
+            Permit: [
+                { name: 'owner', type: 'address' },
+                { name: 'spender', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'deadline', type: 'uint256' },
+            ],
+        } as any;
+
+        const values = {
+            owner,
+            spender: this.contractService.getAddress('DepositManager'),
+            value: amountWei,
+            nonce: nonce,
+            deadline,
+        } as any;
+
+        const signature = await (signer as any)._signTypedData(domain, types, values);
+        const split = ethers.utils.splitSignature(signature);
+
+        const tx = await this.contract.DepositManager.requestWithdrawal(
+            amountWei,
+            deadline,
+            split.v,
+            split.r,
+            split.s
+        );
+
+        // wait for 1 confirmation
+        const receipt = await tx.wait(1);
+
+        // if WithdrawRequested event exists, parse it and get arguments
+        let withdrawRequested: WithdrawRequestedEvent | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'WithdrawRequested');
+
+        if (ev && ev.args) {
+            const { user, ethAmount, nftId, readyAt } = ev.args;
+            withdrawRequested = {
+                user,
+                ethAmount: BigNumber.from(ethAmount),
+                nftId: BigNumber.from(nftId),
+                readyAt: readyAt,
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            withdrawRequested,
+        } as WithdrawResult;
+    }
+
+
+
+
 }

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

@@ -0,0 +1,130 @@
+import { BigNumber, ethers } from "ethers";
+import { EthereumContractService } from "../contract";
+import { formatContractErrors, sendOPPFinalize } from "../utils";
+import { PurchaseAsset } from "../../../types";
+
+
+
+export class PretokenClient {
+    private readonly contractService: EthereumContractService;
+    
+    get contract() { return this.contractService.contract; }
+
+    constructor(contract: EthereumContractService) {
+        this.contractService = contract;
+    }
+    
+
+
+    /**
+     * Purchase warrants by sending ETH to the Depositor.purchaseWarrantsWithETH(buyer) payable function.
+     * Returns txHash, receipt and parsed PurchasedWithETH event (if present).
+     */
+    async purchaseWarrantsWithETH(amountWei: BigNumber, buyer: string): Promise<any> {
+        // attempt a simulation of the purchase call
+        try {
+            await this.contract.Depositor.callStatic.purchaseWarrantsWithETH(buyer, { value: amountWei });
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+        // attempt the real purchase call
+        let tx, receipt;
+        try {
+            tx = await this.contract.Depositor.purchaseWarrantsWithETH(buyer, { value: amountWei });
+            receipt = await tx.wait(1);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+
+        // Attempt to parse PurchasedWithETH event
+        let purchased: any | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'PurchasedWithETH' || e.event === 'PurchasedWithETH(address,uint256,uint256,uint256)');
+
+        if (ev && ev.args) {
+            // event signature: PurchasedWithETH(address indexed user, uint256 ethIn, uint256 shares, uint256 tokenId)
+            const { user, ethIn, shares, tokenId } = ev.args as any;
+
+            purchased = {
+                buyer: user,
+                amount: BigNumber.from(ethIn),
+                shares: BigNumber.from(shares),
+                tokenId: BigNumber.from(tokenId),
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            purchased,
+        };
+    }
+
+    /**
+     * Purchase warrants by transferring liqETH into the pool (ERC-20) and calling Depositor.purchaseWarrantsWithLiqETH(amountLiq, buyer).
+     * Returns txHash, receipt and parsed PurchasedWithLiqETH event (if present).
+     */
+    async purchaseWarrantsWithLiqETH(amountLiq: BigNumber, buyer: string): Promise<any> {
+        // attempt a simulation of the purchase call
+        try {
+            await this.contract.Depositor.callStatic.purchaseWarrantsWithLiqETH(amountLiq, buyer);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+
+            // ! TEMP for testing
+            if(errorObj.name == "OPP_PreviousEpochUnsent") {
+                console.error("OPP Previous Epoch is unsent - trigger OPP finalizeEpoch()")
+                await sendOPPFinalize(this.contract.OPP);
+                throw new Error(errorObj.name+` - triggering OPP finalizeEpoch() please try again`);
+            }
+
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+        // attempt the real purchase call
+        let tx, receipt;
+        try {
+            tx = await this.contract.Depositor.purchaseWarrantsWithLiqETH(amountLiq, buyer);
+            receipt = await tx.wait(1);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+
+
+        // Attempt to parse PurchasedWithLiqETH event
+        let purchased: any | undefined;
+        const ev = receipt.events?.find((e) => e.event === 'PurchasedWithLiqETH' || (e.event && e.event.toString().startsWith('PurchasedWithLiqETH')));
+
+        if (ev && ev.args) {
+            // Event shape: PurchasedWithLiqETH(buyer, amountLiq, ethEqWei, shares, tokenId)
+            const args: any = ev.args;
+            // try named fields first, fallback to positional
+            const evtBuyer = args.buyer ?? args[0];
+            const evtAmountLiq = (args.amountLiq ?? args[1]) ? BigNumber.from(args.amountLiq ?? args[1]) : undefined;
+            const evtEthEqWei = (args.ethEqWei ?? args[2]) ? BigNumber.from(args.ethEqWei ?? args[2]) : undefined;
+            const evtShares = (args.shares ?? args[3]) ? BigNumber.from(args.shares ?? args[3]) : undefined;
+            const evtTokenId = (args.tokenId ?? args[4]) ? BigNumber.from(args.tokenId ?? args[4]) : undefined;
+
+            purchased = {
+                buyer: evtBuyer,
+                amountLiq: evtAmountLiq,
+                ethEqWei: evtEthEqWei,
+                shares: evtShares,
+                tokenId: evtTokenId,
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            purchased,
+        };
+    }
+
+
+
+}

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

@@ -1,6 +1,7 @@
 import { BigNumber, ethers } from "ethers";
-import { preLaunchReceipt, StakedEvent, StakedResult, WithdrawnStakeEvent, WithdrawnStakeResult } from "../types";
+import { preLaunchReceipt, StakedEvent, WithdrawnStakeEvent, WithdrawnStakeResult } from "../types";
 import { EthereumContractService } from "../contract";
+import { formatContractErrors } from "../utils";
 
 export class StakeClient {
 
@@ -15,19 +16,72 @@ export class StakeClient {
 
 
     /**
-     * Simulate a stake via callStatic.
-     *
-     * Useful for pre-flight checks; will throw with the same revert
-     * reason as a real tx if it would fail.
+     * Simulate a stake via callStatic
      */
-    async simulateStake(amount: number | string | bigint | BigNumber): Promise<void> {
-        const amountWei = BigNumber.isBigNumber(amount)
-            ? amount
-            : BigNumber.from(amount);
-
-        // callStatic executes the function locally without sending a tx.
-        // stakeLiqEth() doesn't return anything, so we only care if it reverts.
-        await this.contract.Depositor.callStatic.stakeLiqETH(amountWei);
+    async simulateStake(amountWei: BigNumber): Promise<void> {
+        try {
+            await this.contract.Depositor.callStatic.stakeLiqETH(amountWei);
+        } catch (err: any) {
+            let errorObj = formatContractErrors(err);
+            throw new Error(errorObj.name ?? errorObj.raw)
+        }
+    }
+
+
+    /**
+     * 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,
+            },
+        };
     }
 
 
@@ -36,12 +90,17 @@ export class StakeClient {
      * @param amountWei an amount of liqETH (in WEI) to stake to the Outpost
      * @returns txHash (hash of the transaction), receipt, Staked event
      */
-    async performStake(amountWei: BigNumber, signerAddress: string): Promise<StakedResult> {
-        const liq = this.contract.LiqEth;
-        const depositorAddress = this.contract.Depositor.address;
-        
-        // check allowance
-        const allowance = await liq.allowance(signerAddress, depositorAddress);
+    async performStake(amountWei: BigNumber, signerAddress: string): Promise<any> {
+        const depositor = this.contract.Depositor.address;
+        const liqRead = this.contract.LiqEth;
+        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 allowance is less than the requested stake amount, request permission to spend LiqEth
         if (allowance.lt(amountWei)) {
@@ -50,17 +109,20 @@ export class StakeClient {
             // 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(${depositorAddress}, ${approveAmount.toString()})`);
-            const approveTx = await liqWrite.approve(depositorAddress, approveAmount);
+            console.warn(`allowance insufficient (${allowance.toString()} < ${amountWei.toString()}); sending approve(${depositor}, ${approveAmount.toString()})`);
+            const approveTx = await liqWrite.approve(depositor, approveAmount);
             await approveTx.wait(1);
 
             // re-read allowance to ensure approval succeeded
-            const newAllowance = await liq.allowance(signerAddress, depositorAddress);
+            const newAllowance = await liqRead.allowance(signerAddress, depositor);
             if (newAllowance.lt(amountWei)) {
                 throw new Error('Approval failed or allowance still insufficient after approve');
             }
         }
         
+        
+        await this.simulateStake(amountWei);
+
 
         // send the tx to stake liqeth
         const tx = await this.contract.Depositor.stakeLiqETH(amountWei);
@@ -150,7 +212,6 @@ export class StakeClient {
         for (const idBN of tokenIds) {
             try {
                 const receiptData = await receiptContract.getReceipt(idBN);
-
                 const formattedReceipt = {
                     account: receiptData.account,
                     currency: receiptData.currency,
@@ -169,7 +230,8 @@ export class StakeClient {
                     timestamp: new Date(Number(receiptData.timestamp.toString()) * 1000).toLocaleString(),
                 }
 
-                results.push({ tokenId: idBN.toBigInt(), receipt: formattedReceipt } as any);
+                // 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);
@@ -177,6 +239,7 @@ export class StakeClient {
             }
         }
 
+        console.log('results of prelaunch receipts', results)
         return results;
     }
 

package/src/networks/ethereum/contract.ts

@@ -21,6 +21,8 @@ import OPPArtifact from '../../assets/ethereum/ABI/outpost/OPP.sol/OPP.json';
 import OPPCommonArtifact from '../../assets/ethereum/ABI/outpost/OPPCommon.sol/OPPCommon.json';
 import OPPInboundArtifact from '../../assets/ethereum/ABI/outpost/OPPInbound.sol/OPPInbound.json';
 import WarrantArtifact from '../../assets/ethereum/ABI/outpost/Warrant.sol/Warrant.json';
+import AggregatorArtifact from '../../assets/ethereum/ABI/outpost/Aggregator.sol/Aggregator.json';
+import EthUsdPriceConsumerArtifact from '../../assets/ethereum/ABI/outpost/EthUsdPriceConsumer.sol/EthUsdPriceConsumer.json';
 
 // Currently Unused Artifacts
 // import LiqEthCommonArtifact from '../../assets/ethereum/ABI/liqEth/liqEthCommon.sol/liqEthCommon.json';
@@ -64,6 +66,9 @@ export const ADDRESSES: AddressBook = {
     OPPCommon: "0x52C1d7F02B35176F79b03F6eF7E5b74b27d1dB8c",
     OPPInbound: "0x39feC7536BaEd4E376b1B5cf2f2e8182ab203418",
     Warrant: "0x9190bBcaB5cfeb4b7b6DE5Ae21105F3114753F10",
+
+    Aggregator: "0xd89F85Ce867E523Dc3E58578B06Ee72cdaBc39ec",
+    EthUsdPriceConsumer: "0xd02F512eAcCA4c713CA954DfD907DC6E8cFACf8e",
 };
 
 export type Contracts<T extends string = ContractName> = Record<T, ContractConfig>;
@@ -156,6 +161,14 @@ export const CONTRACTS: Contracts<ContractName> = {
     Warrant: {
         address: ADDRESSES.Warrant,
         abi: WarrantArtifact.abi as JsonFragment[],
+    },
+    Aggregator: {
+        address: ADDRESSES.Aggregator,
+        abi: AggregatorArtifact.abi as JsonFragment[],
+    },
+    EthUsdPriceConsumer: {
+        address: ADDRESSES.EthUsdPriceConsumer,
+        abi: EthUsdPriceConsumerArtifact.abi as JsonFragment[],
     }
 };