@wireio/stake 0.2.3 → 0.2.5

package/src/networks/ethereum/ethereum.ts

@@ -1,10 +1,12 @@
 import { BigNumber, ethers } from 'ethers';
 import { IStakingClient, Portfolio, PurchaseAsset, PurchaseQuote, StakerConfig, TrancheSnapshot } from '../../types';
-import { PublicKey as WirePubKey } from '@wireio/core';
+import { ChainID, EvmChainID, PublicKey as WirePubKey } from '@wireio/core';
 import { EthereumContractService } from './contract';
 import { preLaunchReceipt, WithdrawRequestedEvent, WithdrawResult } from './types';
 import { DepositClient } from './clients/deposit.client';
 import { StakeClient } from './clients/stake.client';
+import { PretokenClient } from './clients/pretoken.client';
+import { buildEthereumTrancheSnapshot, sendOPPFinalize } from './utils';
 
 
 
@@ -16,10 +18,13 @@ export class EthereumStakingClient implements IStakingClient {
 
     private depositClient: DepositClient;
     private stakeClient: StakeClient;
+    private pretokenClient: PretokenClient;
+
 
     get contract() { return this.contractService.contract; }
     get network() { return this.config.network; }
 
+
     constructor(private config: StakerConfig) {
         try {
             this.provider = config.provider as ethers.providers.Web3Provider;
@@ -32,6 +37,7 @@ export class EthereumStakingClient implements IStakingClient {
             });
             this.depositClient = new DepositClient(this.contractService);
             this.stakeClient = new StakeClient(this.contractService);
+            this.pretokenClient = new PretokenClient(this.contractService);
         }   
         catch (error) {
             // console.error('Error initializing EthereumStakingClient:', error);
@@ -59,18 +65,28 @@ 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);
-        return result.txHash;
+    /**
+     * Withdraw native ETH from the liqETH protocol via DepositManager.
+     * @param amount  Amount in wei (or something convertible to BigNumber).
+     *                Keep this as a bigint / string in the caller; avoid JS floats.
+     * @returns transaction hash
+     */
+    async withdraw(amount: bigint): Promise<string> {
+        // 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);
+        // return result.txHash;
+        throw new Error("Method not yet implemented.");
     }
 
 
-    // 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 +101,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 +115,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.purchaseWarrantsWithLiqETH(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,11 +199,8 @@ 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.");
@@ -178,94 +260,158 @@ 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.Warrant.trancheNumber(blockTag),
+            this.contract.Warrant.trancheSupply(blockTag),
+            this.contract.Warrant.tranchePriceUsd(blockTag),
+            this.contract.Warrant.totalSupply(blockTag),
+            this.contract.Warrant.supplyGrowthBps(blockTag),
+            this.contract.Warrant.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();
+        console.log('mockaggregator answer', answer.toString())
+        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); 
+        
+        console.log('options for building eth tranche snapshot', {
+            chainID,
+            totalSharesBn, 
+            indexBn, 
+            trancheNumberBn,
+            currentTrancheSupply: currentTrancheSupply.toString(), 
+            tranchePriceWadBn, 
+            totalTrancheSupply: totalTrancheSupply.toString(),
+            initialTrancheSupply: initialTrancheSupply.toString(),
+            supplyGrowthBps,
+            priceGrowthBps,
+            minPriceUsd, 
+            maxPriceUsd,
+
+            ethPriceUsd,
+            nativePriceTimestamp,
+            ladderWindowBefore: windowBefore,
+            ladderWindowAfter: windowAfter,
+        })
+
+        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

@@ -23,6 +23,8 @@ export const CONTRACT_NAMES = [
     'OPPCommon',
     'OPPInbound',
     'Warrant',
+    'Aggregator',
+    'EthUsdPriceConsumer',
 
 ] as const;