@wireio/stake 0.1.3 → 0.2.1

package/src/networks/ethereum/ethereum.ts

@@ -1,10 +1,12 @@
-// src/networks/ethereum/ethereum.ts
-
-import { BigNumber, BigNumberish, ethers } from 'ethers';
+import { BigNumber, ethers } from 'ethers';
 import { IStakingClient, Portfolio, StakerConfig } from '../../staker/types';
 import { PublicKey as WirePubKey } from '@wireio/core';
-import { ERC20Abi, EthereumContractService } from './contract'; // TODO replace with staking contract ABI
-import { DepositEvent, DepositResult } from './types';
+import { EthereumContractService } from './contract';
+import { preLaunchReceipt, WithdrawRequestedEvent, WithdrawResult } from './types';
+import { DepositClient } from './clients/deposit.client';
+import { StakeClient } from './clients/stake.client';
+
+
 
 export class EthereumStakingClient implements IStakingClient {
     public readonly pubKey: WirePubKey;
@@ -12,6 +14,9 @@ export class EthereumStakingClient implements IStakingClient {
     private readonly signer: ethers.Signer;
     private readonly contractService: EthereumContractService;
 
+    private depositClient: DepositClient;
+    private stakeClient: StakeClient;
+
     get contract() { return this.contractService.contract; }
     get network() { return this.config.network; }
 
@@ -25,6 +30,8 @@ export class EthereumStakingClient implements IStakingClient {
                 provider: this.provider,
                 signer: this.signer,
             });
+            this.depositClient = new DepositClient(this.contractService);
+            this.stakeClient = new StakeClient(this.contractService);
         }   
         catch (error) {
             // console.error('Error initializing EthereumStakingClient:', error);
@@ -33,7 +40,7 @@ export class EthereumStakingClient implements IStakingClient {
     }
 
     // ---------------------------------------------------------------------
-    // Public IStakingClient.deposit
+    // Public IStakingClient Interface Methods
     // ---------------------------------------------------------------------
 
     /**
@@ -47,71 +54,67 @@ export class EthereumStakingClient implements IStakingClient {
             ? amount
             : BigNumber.from(amount);
 
-        const result = await this.performDeposit(amountWei);
-        // For now, IStakingClient contract is: just return tx hash.
-        // If/when you extend the interface, you can surface more here.
+        const result = await this.depositClient.performDeposit(amountWei);
         return result.txHash;
     }
 
-    
-    /**
-     * Simulate a deposit via callStatic.
-     *
-     * Useful for pre-flight checks; will throw with the same revert
-     * reason as a real tx if it would fail.
-     */
-    async simulateDeposit(amount: number | string | bigint | BigNumber): Promise<void> {
+
+    // TODO - In progress
+    async withdraw(amount: number | string | bigint | BigNumber): Promise<string> {
         const amountWei = BigNumber.isBigNumber(amount)
             ? amount
             : BigNumber.from(amount);
 
-        // callStatic executes the function locally without sending a tx.
-        // deposit() doesn't return anything, so we only care if it reverts.
-        await this.contract.DepositManager.callStatic.deposit({
-            value: amountWei,
-        });
+        const result = await this.requestWithdraw(amountWei);
+        return result.txHash;
     }
 
-    private async performDeposit(amountWei: BigNumber): Promise<DepositResult> {
-        // Pre-check minDeposit
-        const minDeposit: BigNumber = await this.contract.DepositManager.minDeposit();
-        if (amountWei.lt(minDeposit)) {
-            throw new Error(
-                `Deposit amount below minDeposit: ` +
-                `amount=${ethers.utils.formatEther(amountWei)} ETH, ` +
-                `min=${ethers.utils.formatEther(minDeposit)} ETH`
-            );
-        }
 
-        // Send the payable tx
-        const tx = await this.contract.DepositManager.deposit({
-            value: amountWei,
-        });
+    // TODO - In progress
+    async stake(amount: bigint): Promise<string> {
+        const walletAddress = await this.signer.getAddress();
+        const amountWei = BigNumber.from(amount);
 
-        // Wait for 1 confirmation 
-        const receipt = await tx.wait(1);
+        const result = await this.stakeClient.performStake(amountWei, walletAddress);
+        return result.txHash;
+    }
 
-        // Parse Deposited event if present
-        let deposited: DepositEvent | undefined;
-        const ev = receipt.events?.find((e) => e.event === 'Deposited');
 
-        if (ev && ev.args) {
-            const { user, netEth, fee, shares } = ev.args;
-            deposited = {
-                user,
-                netEth: BigNumber.from(netEth),
-                fee: BigNumber.from(fee),
-                shares: BigNumber.from(shares),
-            };
-        }
+    // TODO
+    async unstake(): Promise<string> {
+        throw new Error("Method not yet implemented.");
+    }
+
+    // TODO
+    async unstakePrelaunch(tokenId: bigint, recipient: string): Promise<string> {
+        const tokenIdBigNum = BigNumber.from(tokenId)
+        const result = await this.stakeClient.performWithdrawStake(tokenIdBigNum, recipient);
+        return result.txHash;
+    }
+
+
+    async fetchPrelaunchReceipts(address?: string): Promise<preLaunchReceipt[]> {
+        if(address === undefined) address = await this.signer.getAddress();
+        
+        let receipts = await this.stakeClient.fetchPreLaunchReceipts(address);
+        return receipts
+    }
+
+    
+    
+    async getEthStats(): Promise<any> {
+        let withdrawDelay = await this.contract.DepositManager.withdrawDelay();
+        let minDeposit = await this.contract.DepositManager.minDeposit();
+        let rewardCooldown = await this.contract.DepositManager.rewardCooldown();
 
         return {
-            txHash: tx.hash,
-            receipt,
-            deposited,
-        };
+            withdrawDelay,
+            minDeposit,
+            rewardCooldown,
+        }
     }
 
+    
     /**
      * Resolve the user's ETH + liqETH balances.
      *
@@ -122,40 +125,40 @@ export class EthereumStakingClient implements IStakingClient {
     async getPortfolio(): Promise<Portfolio> {
         const walletAddress = await this.signer.getAddress();
         // console.log('getPortfolio() wallet address', walletAddress)
+
+
         // 1) Native ETH balance
         const nativeBalance = await this.provider.getBalance(walletAddress);
-        // console.log('nativeBalance', nativeBalance);
         const nativeDecimals = this.network?.nativeCurrency?.decimals ?? 18;
         const nativeSymbol = this.network?.nativeCurrency?.symbol ?? 'ETH';
 
-        
-
         // 2) liqETH ERC-20 balance (actual)
         const liqBalance: ethers.BigNumber = await this.contract.LiqEth.balanceOf(walletAddress);
-        // console.log('liqBalance', liqBalance);
-        
-        const liqDecimals = this.network?.nativeCurrency?.decimals ?? 18;
         const liqSymbol = 'Liq' + (this.network?.nativeCurrency?.symbol ?? 'ETH');
 
+        // 3) staked liqEth ERC-20 balance (actual)
+        const stakedLiqBalance = await this.contract.Depositor.sharesOf(walletAddress);
+
+
         const portfolio: Portfolio = {
             native: {
-                amount: nativeBalance,
+                amount: nativeBalance.toBigInt(),
                 decimals: nativeDecimals,
                 symbol: nativeSymbol,
             },
             liq: {
-                amount: liqBalance,
-                decimals: liqDecimals,
+                amount: liqBalance.toBigInt(),
+                decimals: nativeDecimals,
                 symbol: liqSymbol,
             },
             tracked: {
-                amount: liqBalance,
-                decimals: liqDecimals,
+                amount: liqBalance.toBigInt(),
+                decimals: nativeDecimals,
                 symbol: liqSymbol,
             },
-            staked: { // TODO fetch staked balance from outpost
-                amount: BigNumber.from(0),
-                decimals: liqDecimals,
+            staked: {
+                amount: stakedLiqBalance.toBigInt(),
+                decimals: nativeDecimals,
                 symbol: liqSymbol,
             },
             chainID: this.network.chainId
@@ -164,5 +167,81 @@ export class EthereumStakingClient implements IStakingClient {
         return portfolio;
     }
 
-    // TODO: implement withdraw, claimRewards, etc.
+    
+    // ---------------------------------------------------------------------
+    // 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;
+    }
+
+
+
+    // TODO: implement claimRewards, etc.
 }

package/src/networks/ethereum/types.ts

@@ -1,22 +1,43 @@
 import { BigNumber, ethers } from 'ethers';
+import { BalanceView } from '../../staker/types';
 
 export const CONTRACT_NAMES = [
     'Accounting',
     'DepositManager',
     'LiqEth',
-    'LiqEthBurn',
-    'LiqEthMint',
+    // 'LiqEthBurn',
+    // 'LiqEthMint',
     // 'RewardsERC20',
     'StakingModule',
     // 'ValidatorBalance',
     'WithdrawalQueue',
     'WithdrawalVault',
     // 'Yield',
+
+    //Outpost contracts
+    'Depositor',
+    'ReceiptNFT',
+    'OutpostManager',
+    'BAR',
+    'OPP',
+    'OPPCommon',
+    'OPPInbound',
+    'Warrant',
+
 ] as const;
 
 export type ContractName = typeof CONTRACT_NAMES[number];
 export type AddressBook  = Record<ContractName, string>;
 
+
+interface Result {
+    /** EVM transaction hash */
+    txHash: string;
+    /** Full receipt, if you want it */
+    receipt: ethers.providers.TransactionReceipt;
+}
+
+
 export interface DepositEvent {
     user: string;
     netEth: BigNumber;
@@ -24,11 +45,57 @@ export interface DepositEvent {
     shares: BigNumber;
 }
 
-export interface DepositResult {
-    /** EVM transaction hash */
-    txHash: string;
-    /** Full receipt, if you want it */
-    receipt: ethers.providers.TransactionReceipt;
+export interface DepositResult extends Result {
     /** Parsed Deposited event, if present */
     deposited?: DepositEvent;
+}
+
+export interface WithdrawRequestedEvent {
+    user: string;
+    ethAmount: BigNumber;
+    nftId: BigNumber;
+    readyAt: string;
+}
+
+export interface WithdrawResult extends Result {
+    /** Parsed WithdrawRequested event, if present */
+    withdrawRequested?: WithdrawRequestedEvent;
+}
+
+
+export interface StakedEvent {
+    user: string;
+    amountLiq: BigNumber;
+    shares: BigNumber;
+    tokenId: BigNumber;
+}
+
+export interface StakedResult extends Result {
+    /** Parsed Staked event, if present */
+    staked?: StakedEvent;
+}
+
+
+export interface WithdrawnStakeEvent {
+    user: string;
+    tokenId: BigNumber;
+    tokenOut: BigNumber;
+}
+export interface WithdrawnStakeResult extends Result {
+    /** Parsed WithdrawnStake event, if present */
+    withdrawnstake?: WithdrawnStakeEvent;
+
+}
+
+export interface preLaunchReceipt {
+    tokenId: bigint;
+    receipt: {
+        account: string,
+        currency: number,
+        kind: number,
+        indexAtMint: BalanceView,
+        principal: BalanceView,
+        shares: BalanceView,
+        timestamp: string,
+    }
 }

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

@@ -34,22 +34,19 @@ import {
     derivePayoutStatePda,
     deriveEphemeralStakeAddress,
 } from '../constants';
+import { WalletLike } from '../types';
 
 export class DepositClient {
     private program: Program<LiqsolCore>;
 
+    get wallet(): WalletLike { return this.provider.wallet; }
+
     constructor(private provider: AnchorProvider) {
         const svc = new SolanaProgramService(provider);
         this.program = svc.getProgram('liqsolCore');
     }
 
-    async buildDepositTx(
-        user: PublicKey,
-        lamports: number
-    ): Promise<{ transaction: Transaction; ephemeralStake: PublicKey }> {
-
-        const program = this.program;
-
+    async buildDepositTx(amount: bigint, user = this.wallet.publicKey): Promise<Transaction> {
         // -------------------------------------------------------------
         // PDAs
         // -------------------------------------------------------------
@@ -91,8 +88,8 @@ export class DepositClient {
         // -------------------------------------------------------------
         // BUILD IX (MUST MATCH IDL)
         // -------------------------------------------------------------
-        const ix: TransactionInstruction = await program.methods
-            .deposit(new BN(lamports), seed)
+        const ix: TransactionInstruction = await this.program.methods
+            .deposit(new BN(amount.toString()), seed)
             .accounts({
                 user,
                 depositAuthority,
@@ -125,7 +122,6 @@ export class DepositClient {
             })
             .instruction();
 
-        const tx = new Transaction().add(ix);
-        return { transaction: tx, ephemeralStake };
+        return new Transaction().add(ix);
     }
 }

package/src/networks/solana/clients/distribution.client.ts

@@ -42,9 +42,7 @@ export class DistributionClient {
         this.program = svc.getProgram('liqsolCore');
     }
 
-    get connection() {
-        return this.provider.connection;
-    }
+    get connection() { return this.provider.connection; }
 
     /**
      * Fetch the global distribution state account.