@wireio/stake 0.2.4 → 0.3.0

package/src/networks/ethereum/ethereum.ts

@@ -1,22 +1,29 @@
 import { BigNumber, ethers } from 'ethers';
-import { IStakingClient, Portfolio, PurchaseAsset, PurchaseQuote, StakerConfig, TrancheSnapshot } from '../../types';
-import { PublicKey as WirePubKey } from '@wireio/core';
+import { IStakingClient, Portfolio, StakerConfig, TrancheSnapshot } from '../../types';
+import { ChainID, EvmChainID, PublicKey as WirePubKey } from '@wireio/core';
 import { EthereumContractService } from './contract';
-import { preLaunchReceipt, WithdrawRequestedEvent, WithdrawResult } from './types';
+import { preLaunchReceipt } from './types';
 import { DepositClient } from './clients/deposit.client';
 import { StakeClient } from './clients/stake.client';
+import { PretokenClient } from './clients/pretoken.client';
+import { buildEthereumTrancheSnapshot } from './utils';
+import { LiqClient } from './clients/liq.client';
+
 
 
 
 export class EthereumStakingClient implements IStakingClient {
-    public readonly pubKey: WirePubKey;
+    public readonly pubKey?: WirePubKey;
     private readonly provider: ethers.providers.Web3Provider;
     private readonly signer: ethers.Signer;
     private readonly contractService: EthereumContractService;
 
     private depositClient: DepositClient;
+    private liqClient: LiqClient;
+    private pretokenClient: PretokenClient;
     private stakeClient: StakeClient;
 
+
     get contract() { return this.contractService.contract; }
     get network() { return this.config.network; }
 
@@ -24,13 +31,16 @@ export class EthereumStakingClient implements IStakingClient {
         try {
             this.provider = config.provider as ethers.providers.Web3Provider;
             this.signer = this.provider.getSigner();
-            this.pubKey = config.pubKey as WirePubKey;
+            this.pubKey = config.pubKey;
             
             this.contractService = new EthereumContractService({
                 provider: this.provider,
                 signer: this.signer,
             });
+            
             this.depositClient = new DepositClient(this.contractService);
+            this.liqClient = new LiqClient(this.contractService);
+            this.pretokenClient = new PretokenClient(this.contractService);
             this.stakeClient = new StakeClient(this.contractService);
         }   
         catch (error) {
@@ -39,6 +49,8 @@ export class EthereumStakingClient implements IStakingClient {
         }     
     }
 
+
+
     // ---------------------------------------------------------------------
     // Public IStakingClient Interface Methods
     // ---------------------------------------------------------------------
@@ -59,18 +71,29 @@ export class EthereumStakingClient implements IStakingClient {
     }
 
 
-    // TODO - In progress
-    async withdraw(amount: number | string | bigint | BigNumber): Promise<string> {
-        const amountWei = BigNumber.isBigNumber(amount)
-            ? amount
-            : BigNumber.from(amount);
 
-        const result = await this.requestWithdraw(amountWei);
+    /**
+     * Withdraw native ETH from the liqETH protocol via the liqeth safeBurn function, which burns the LiqETH and adds the user to the withdrawal queue.
+     * @param amount  Amount in wei (or something convertible to BigNumber).
+     * @returns transaction hash
+     */
+    async withdraw(amount: bigint): Promise<string> {
+        const address = await this.signer.getAddress();
+        const amountWei = BigNumber.from(amount);
+        // const chainId = this.network?.chainId ?? (await this.provider.getNetwork()).chainId;
+        // const result = await this.depositClient.requestWithdraw(amountWei, this.signer, chainId);
+
+        const result = await this.liqClient.safeBurn(address, amountWei)
         return result.txHash;
     }
 
 
-    // TODO - In progress
+    /**
+     * Stake liqETH via DepositManager.
+     * @param amount  Amount in wei 
+     *                Keep this as a bigint / string in the caller; avoid JS floats.
+     * @returns transaction hash
+     */
     async stake(amount: bigint): Promise<string> {
         const walletAddress = await this.signer.getAddress();
         const amountWei = BigNumber.from(amount);
@@ -85,7 +108,13 @@ export class EthereumStakingClient implements IStakingClient {
         throw new Error("Method not yet implemented.");
     }
 
-    // TODO
+
+    /**
+     * ETH Prelaunch function to unstake liqEth
+     * @param tokenId ReceiptNFT tokenId for the owned NFT that will be burned
+     * @param recipient Address to receive the liqEth funds linked to the burned NFT
+     * @returns the transaction hash
+     */
     async unstakePrelaunch(tokenId: bigint, recipient: string): Promise<string> {
         const tokenIdBigNum = BigNumber.from(tokenId)
         const result = await this.stakeClient.performWithdrawStake(tokenIdBigNum, recipient);
@@ -93,6 +122,69 @@ export class EthereumStakingClient implements IStakingClient {
     }
 
 
+
+    async buy(amount: bigint): Promise<string> {
+        const buyer = await this.signer.getAddress();
+        const amountBigNum = BigNumber.from(amount)
+
+        // ! Hoodi only - check if the mock aggregator price is stale, and if so, update it before submitting the buy request
+        await this.updateMockAggregatorPrice();
+        
+
+        const bal = await this.contract.LiqEth.balanceOf(buyer);
+        const paused = await this.contract.Depositor.paused();
+        if(paused) {
+            throw new Error("Error - Depositor is in a paused state");
+        }
+
+        // if current liq balance is less than the requested buy amount, throw an error
+        if (bal.lt(amount)) {
+            throw new Error(`Balance insufficient for pre-token purchase`);
+        }
+
+        //check that the contract has allowance for the token
+        const depositorAddr = this.contract.Depositor.address;
+        const allowance = await this.contract.LiqEth.allowance(buyer, depositorAddr);
+
+        // if allowance is less than the requested stake amount, request permission to spend LiqEth
+        if (allowance.lt(amount)) {
+            const liqWrite = this.contractService.getWrite('LiqEth');
+
+            // 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()} < ${amount.toString()}); sending approve(${depositorAddr}, ${approveAmount.toString()})`);
+
+            const approveTx = await liqWrite.approve(depositorAddr, approveAmount);
+            await approveTx.wait(1);
+
+            // re-read allowance to ensure approval succeeded
+            const newAllowance = await this.contract.LiqEth.allowance(buyer, depositorAddr);
+            if (newAllowance.lt(amount)) {
+                throw new Error('Approval failed or allowance still insufficient after approve');
+            }
+        }
+
+
+        let result = await this.pretokenClient.purchasePretokensWithLiqETH(amountBigNum, buyer);
+
+        return result && result.txHash ? result.txHash : "Error - no resulting txHash";
+    }
+
+
+    
+
+    async getOPPStatus(): Promise<any> {
+        return await this.stakeClient.getOppStatus();
+    }
+
+
+    
+    /**
+     * ETH Prelaunch function to list the ReceiptNFTs owned by a specific user
+     * @param address address to query the receipts for
+     * @returns array of receipts
+     */
     async fetchPrelaunchReceipts(address?: string): Promise<preLaunchReceipt[]> {
         if(address === undefined) address = await this.signer.getAddress();
         
@@ -114,17 +206,6 @@ export class EthereumStakingClient implements IStakingClient {
         }
     }
 
-    // TODO
-    buy(amount: bigint, purchaseAsset: PurchaseAsset): Promise<string> {
-        throw new Error("Method not yet implemented.");
-    }
-
-    // TODO
-    getBuyQuote(amount: bigint, purchaseAsset: PurchaseAsset): Promise<PurchaseQuote> {
-        throw new Error("Method not yet implemented.");
-    }
-
-    
     /**
      * Resolve the user's ETH + liqETH balances.
      *
@@ -178,94 +259,136 @@ export class EthereumStakingClient implements IStakingClient {
             },
             chainID: this.network.chainId
         }
-        // console.log('ETH PORTFOLIO', portfolio);
         return portfolio;
     }
 
+
     /**
-     * Program-level prelaunch WIRE / tranche snapshot for Solana.
-     * Uses the same OutpostWireStateSnapshot primitive as getPortfolio().
-     * TODO! for eth
+     * Program-level prelaunch WIRE / tranche snapshot for Ethereum
      */
-    async getTrancheSnapshot(): Promise<TrancheSnapshot | null> {
-        return null
+    async getTrancheSnapshot(options?: {
+        chainID?: ChainID;
+        windowBefore?: number;
+        windowAfter?: number;
+    }): Promise<TrancheSnapshot> {
+        const {
+            chainID = EvmChainID.Hoodi,
+            windowBefore,
+            windowAfter,
+        } = options ?? {};
+
+
+        const blockNumber = await this.provider.getBlockNumber();
+        const blockTag = { blockTag: blockNumber };
+
+        // Fetch all required contract data
+        const [totalSharesBn, indexBn, trancheNumberBn, trancheSupplyBn, tranchePriceWadBn, totalSupplyBn, supplyGrowthBps, priceGrowthBps, minPriceUsd, maxPriceUsd] = await Promise.all([
+            this.contract.Depositor.totalShares(blockTag),
+            this.contract.Depositor.index(blockTag),
+            this.contract.Pretoken.trancheNumber(blockTag),
+            this.contract.Pretoken.trancheSupply(blockTag),
+            this.contract.Pretoken.tranchePriceUsd(blockTag),
+            this.contract.Pretoken.totalSupply(blockTag),
+            this.contract.Pretoken.supplyGrowthBps(blockTag),
+            this.contract.Pretoken.priceGrowthBps(blockTag),
+            this.contract.EthUsdPriceConsumer.MIN_PRICE(),
+            this.contract.EthUsdPriceConsumer.MAX_PRICE(),
+        ]);
+
+
+        const totalTrancheSupply = BigInt(totalSupplyBn.toString()) / BigInt(1e10);
+        const currentTrancheSupply = BigInt(trancheSupplyBn.toString()) / BigInt(1e10);
+
+
+        // fetch price and timestamp from aggregator
+        const [ roundId, answer, startedAt, updatedAt, answeredInRound ] = await this.contract.Aggregator.latestRoundData();
+        let ethPriceUsd: bigint = BigInt(answer.toString());
+        let nativePriceTimestamp: number = Number(updatedAt);
+
+        // ! Placeholder from hoodi deployment - don't think this can be fetched dynamically
+        const initialTrancheSupply = BigInt(60000) * BigInt(1e8); 
+
+        return buildEthereumTrancheSnapshot({
+            chainID,
+            totalSharesBn, 
+            indexBn, 
+            trancheNumberBn,
+            currentTrancheSupply, 
+            tranchePriceWadBn, 
+            totalTrancheSupply,
+            initialTrancheSupply,
+            supplyGrowthBps,
+            priceGrowthBps,
+            minPriceUsd, 
+            maxPriceUsd,
+
+            ethPriceUsd,
+            nativePriceTimestamp,
+            ladderWindowBefore: windowBefore,
+            ladderWindowAfter: windowAfter,
+        });
     }
 
+
+
     
     // ---------------------------------------------------------------------
     // Internal ETH Staking client helper functions
     // ---------------------------------------------------------------------
 
-    private async requestWithdraw(amountWei: BigNumber): 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 this.signer.getAddress();
-        const liqEthAddress = this.contractService.getAddress('LiqEth');
-
-        const nonce: BigNumber = await liqEth.nonces(owner);
-        const chainId = this.network?.chainId ?? (await this.provider.getNetwork()).chainId;
-        const domain = {
-            name: await liqEth.name(),
-            version: '1',
-            chainId,
-            verifyingContract: liqEthAddress,
-        } 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 (this.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;
+    
+
+    // ! This is a temporary measure for Hoodi testnet because there is no aggregator deployed
+    private async updateMockAggregatorPrice() {
+        const aggregator = this.contract.Aggregator;
+
+        // read latest round & compute age
+        const [roundId, answer, startedAt, updatedAt, answeredInRound] = await aggregator.latestRoundData();
+        const now = (await this.provider.getBlock("latest")).timestamp;
+        const ageSec = Number(now) - Number(updatedAt);
+
+        const ONE_HOUR = 1 * 3600;
+        // const ONE_HOUR = 10;
+        if (ageSec > ONE_HOUR) {
+            // safety check - only run in non-production contexts
+            const network = await this.provider.getNetwork();
+            const chainId = network.chainId;
+            const allowedTestChains = new Set([560048]); 
+            if (!allowedTestChains.has(chainId)) {
+                console.warn(`MockAggregator is stale (${ageSec}s) but chainId ${chainId} is not a test/local network — skipping update.`);
+                return;
+            }
+
+
+            //fetch the current ETH / USD price
+            const res = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
+            const data = await res.json();
+            const ethUsd = data.ethereum.usd;
+
+            const currentEthPrice = ethers.utils.parseUnits(ethUsd.toString(), 8);
+
+            try {
+                //update to be intentionally stale
+                // const alttx = await aggregator.updateStale(currentEthPrice, now - 7200);
+                // const altreceipt = await alttx.wait(1);
+                // console.log('stale update receipt', altreceipt)
+
+                //update answer with current timestamp
+                const tx = await aggregator.updateAnswer(currentEthPrice);
+                const txreceipt = await tx.wait(1);
+                // console.log('MockAggregator answer updated - receipt:', txreceipt)
+            } catch (err: any) {
+                console.error('MockAggregator updateAnswer failed', err?.message || err);
+            }
+        } else {
+            console.log(`MockAggregator updated ${ageSec}s ago — no update needed`);
+        }
     }
 
 
 
+
+
     // TODO: implement claimRewards, etc.
 }

package/src/networks/ethereum/types.ts

@@ -5,14 +5,9 @@ export const CONTRACT_NAMES = [
     'Accounting',
     'DepositManager',
     'LiqEth',
-    // 'LiqEthBurn',
-    // 'LiqEthMint',
-    // 'RewardsERC20',
     'StakingModule',
-    // 'ValidatorBalance',
     'WithdrawalQueue',
     'WithdrawalVault',
-    // 'Yield',
 
     //Outpost contracts
     'Depositor',
@@ -22,7 +17,9 @@ export const CONTRACT_NAMES = [
     'OPP',
     'OPPCommon',
     'OPPInbound',
-    'Warrant',
+    'Pretoken',
+    'Aggregator',
+    'EthUsdPriceConsumer',
 
 ] as const;
 
@@ -87,6 +84,12 @@ export interface WithdrawnStakeResult extends Result {
 
 }
 
+export interface SharesBurnedEvent {
+    from: string;
+    shares: BigNumber;
+    tokenValue: BigNumber;
+}
+
 export interface preLaunchReceipt {
     tokenId: bigint;
     receipt: {