@wireio/stake 0.1.0 → 0.1.2

package/src/networks/ethereum/contract.ts

@@ -1,30 +1,25 @@
 /**
  * @module EthereumContractService
- * 
+ *
  * Provides a unified service for interacting with Ethereum smart contracts using ethers.js.
- * 
- * This module includes:
- * - ABI imports for ERC20, ERC721, and ERC1155 token standards.
- * - Address book and contract configuration types.
- * - A service class for managing contract instances, interfaces, and utility methods for read/write access.
- * - Utility for decoding custom errors and events using a combined interface of all known ABIs.
- * 
- * @remarks
- * - Update the `ADDRESSES` and `CONTRACTS` objects to match your deployment.
- * - The service supports both read-only and write-enabled contract handles, depending on the presence of a signer.
- * - The `omniInterface` property allows decoding of errors and events across all included ABIs.
- * 
- * @example
- * ```typescript
- * const service = new EthereumContractService({ provider, signer });
- * const stakeContract = service.getContract('Stake');
- * const address = service.getAddress('Stake');
- * ```
  */
+import AccountingArtifact from '../../assets/ethereum/ABI/liqEth/accounting.sol/Accounting.json';
+import DepositManagerArtifact from '../../assets/ethereum/ABI/liqEth/DepositManager.sol/DepositManager.json';
+import LiqEthArtifact from '../../assets/ethereum/ABI/liqEth/liqEth.sol/LiqEthToken.json';
+import LiqEthBurnArtifact from '../../assets/ethereum/ABI/liqEth/liqEthBurn.sol/LiqEthBurn.json';
+// import LiqEthCommonArtifact from '../../assets/ethereum/ABI/liqEth/liqEthCommon.sol/liqEthCommon.json';
+import LiqEthMintArtifact from '../../assets/ethereum/ABI/liqEth/liqEthMint.sol/LiqEthMint.json';
+// import RewardsERC20Artifact from '../../assets/ethereum/ABI/liqEth/RewardsERC20.sol/RewardsERC20.json';
+import StakingModuleArtifact from '../../assets/ethereum/ABI/liqEth/stakingModule.sol/StakingModule.json';
+// import ValidatorBalanceArtifact from '../../assets/ethereum/ABI/liqEth/ValidatorBalanceVerifier.sol/ValidatorBalanceVerifier.json';
+import WithdrawalQueueArtifact from '../../assets/ethereum/ABI/liqEth/withdrawalQueue.sol/WithdrawalQueue.json';
+import WithdrawalVaultArtifact from '../../assets/ethereum/ABI/liqEth/withdrawalVault.sol/WithdrawalVault.json';
+// import YieldArtifact from '../../assets/ethereum/ABI/liqEth/Yield.sol/YieldOracle.json';
 
 import ERC20Artifact from '../../assets/ethereum/ABI/token/ERC20Token.sol/ERC20Token.json';
 import ERC721Artifact from '../../assets/ethereum/ABI/token/ERC721Token.sol/ERC721Token.json';
 import ERC1155Artifact from '../../assets/ethereum/ABI/token/ERC1155Token.sol/ERC1155Token.json';
+
 import { AddressBook, ContractName } from './types';
 import { Contract, ethers, providers, Signer } from 'ethers';
 import { JsonFragment } from '@ethersproject/abi';
@@ -34,9 +29,20 @@ export const ERC20Abi = ERC20Artifact.abi;
 export const ERC721Abi = ERC721Artifact.abi;
 export const ERC1155Abi = ERC1155Artifact.abi;
 
-// Update this to be your staking contract address book
+// -----------------------------------------------------------------------------
+// Address book
+// -----------------------------------------------------------------------------
+
+// Make sure ContractName in ./types includes all of these keys.
 export const ADDRESSES: AddressBook = {
-    Stake: '0xEeaCBa95852324eAc63fE2711aFe0283adf3bC93',
+    Accounting: "0xd51CC479c25dc7Cd23f568Ef5c1AdE1671a4D15b",
+    DepositManager: "0x2249D309f086363ABF5057Ae7f8057279162786B",
+    LiqEth: "0xd5bd3DC2fD86e917A46f7571708aBB88CbfCc197",
+    LiqEthMint: "0xdBAa1539eB7b80C29d825FCda76c0d7F8F0E6cFB",
+    LiqEthBurn: "0x02e0A02fE2311FAd661677B7117FDdc801c1216b",
+    StakingModule: "0x87047291c3b0D55A551C97B9194A02E1D84e06A9",
+    WithdrawalQueue: "0x7781368720294fE0bB6D97F14fE2E9275fFED071",
+    WithdrawalVault: "0x24457626938d4132556005ecA4d9e6F24F85297E",
 };
 
 export type Contracts<T extends string = ContractName> = Record<T, ContractConfig>;
@@ -44,12 +50,58 @@ export type Contracts<T extends string = ContractName> = Record<T, ContractConfi
 export type ContractConfig = {
     address: string;
     abi: JsonFragment[];
-}
+};
+
+// -----------------------------------------------------------------------------
+// Contract config
+// -----------------------------------------------------------------------------
 
 export const CONTRACTS: Contracts<ContractName> = {
-    Stake: { address: ADDRESSES.Stake, abi: undefined as any }, // Replace with actual ABI artifact when available
-    // Stake: { address: ADDRESSES.Stake, abi: Stake.abi },
-}
+    Accounting: {
+        address: ADDRESSES.Accounting,
+        abi: AccountingArtifact.abi as JsonFragment[],
+    },
+    LiqEth: {
+        address: ADDRESSES.LiqEth,
+        abi: LiqEthArtifact.abi as JsonFragment[],
+    },
+    DepositManager: {
+        address: ADDRESSES.DepositManager,
+        abi: DepositManagerArtifact.abi as JsonFragment[],
+    },
+    LiqEthMint: {
+        address: ADDRESSES.LiqEthMint,
+        abi: LiqEthMintArtifact.abi as JsonFragment[],
+    },
+    LiqEthBurn: {
+        address: ADDRESSES.LiqEthBurn,
+        abi: LiqEthBurnArtifact.abi as JsonFragment[],
+    },
+    // RewardsERC20: {
+    //     address: ADDRESSES.RewardsERC20,
+    //     abi: RewardsERC20Artifact.abi as JsonFragment[],
+    // },
+    StakingModule: {
+        address: ADDRESSES.StakingModule,
+        abi: StakingModuleArtifact.abi as JsonFragment[],
+    },
+    // ValidatorBalance: {
+    //     address: ADDRESSES.ValidatorBalance,
+    //     abi: ValidatorBalanceArtifact.abi as JsonFragment[],
+    // },
+    WithdrawalQueue: {
+        address: ADDRESSES.WithdrawalQueue,
+        abi: WithdrawalQueueArtifact.abi as JsonFragment[],
+    },
+    WithdrawalVault: {
+        address: ADDRESSES.WithdrawalVault,
+        abi: WithdrawalVaultArtifact.abi as JsonFragment[],
+    },
+    // Yield: {
+    //     address: ADDRESSES.Yield,
+    //     abi: YieldArtifact.abi as JsonFragment[],
+    // },
+};
 
 export interface ContractOptions {
     /** RPC endpoint or injected EIP-1193 provider */
@@ -58,7 +110,6 @@ export interface ContractOptions {
     signer?: Signer;
 }
 
-
 export class EthereumContractService {
     private provider?: providers.Provider;
     private signer?: Signer;
@@ -73,7 +124,11 @@ export class EthereumContractService {
         (Object.keys(CONTRACTS) as ContractName[]).forEach((name) => {
             const { address, abi } = CONTRACTS[name];
             this.iface[name] = new ethers.utils.Interface(abi);
-            this.contract[name] = new ethers.Contract(address, abi, this.signer ?? this.provider);
+            this.contract[name] = new ethers.Contract(
+                address,
+                abi,
+                this.signer ?? this.provider
+            );
         });
     }
 
@@ -83,13 +138,13 @@ export class EthereumContractService {
     }
 
     /** Utility: get a read-only handle even if signer is present */
-    getReadOnly(name: ContractName): Contract {
+    public getReadOnly(name: ContractName): Contract {
         const { address, abi } = CONTRACTS[name];
         return new Contract(address, abi, this.provider);
     }
 
     /** Utility: get a write-enabled handle (throws if no signer) */
-    getWrite(name: ContractName): Contract {
+    public getWrite(name: ContractName): Contract {
         if (!this.signer) throw new Error('No signer available for write calls');
         const { address, abi } = CONTRACTS[name];
         return new Contract(address, abi, this.signer);
@@ -119,27 +174,35 @@ export class EthereumContractService {
         return ctr;
     }
 
-    /** A unified Interface containing all ABIs (addresses + extra decoding-only)
-     *  to parse custom errors or events. */
+    /** A unified Interface containing all ABIs to parse custom errors or events. */
     public get omniInterface(): ethers.utils.Interface {
         const all: any[] = [];
 
-        // Add all artifacts to the interface
         const allArtifacts = [
             ERC20Artifact,
             ERC721Artifact,
             ERC1155Artifact,
-            // Add more artifacts as needed
+
+            // liqETH suite
+            AccountingArtifact,
+            DepositManagerArtifact,
+            LiqEthArtifact,
+            LiqEthBurnArtifact,
+            LiqEthMintArtifact,
+            // RewardsERC20Artifact,
+            StakingModuleArtifact,
+            // ValidatorBalanceArtifact,
+            WithdrawalQueueArtifact,
+            WithdrawalVaultArtifact,
+            // YieldArtifact,
         ];
 
-        // Add all ABIs to the omnibus interface
         allArtifacts.forEach(artifact => {
             if (artifact && artifact.abi) {
                 all.push(...artifact.abi);
             }
         });
 
-        // dedupe
         const seen = new Set<string>();
         const dedup: any[] = [];
         for (const item of all) {
@@ -150,7 +213,9 @@ export class EthereumContractService {
                     seen.add(key);
                     dedup.push(item);
                 }
-            } catch { }
+            } catch {
+                // ignore bad fragments
+            }
         }
 
         return new ethers.utils.Interface(dedup);

package/src/networks/ethereum/ethereum.ts

@@ -1,64 +1,160 @@
 // src/networks/ethereum/ethereum.ts
 
-import { ethers } from 'ethers';
-import { IStakingClient, StakerConfig } from '../../staker/types';
+import { BigNumber, BigNumberish, ethers } from 'ethers';
+import { IStakingClient, Portfolio, StakerConfig } from '../../staker/types';
 import { PublicKey as WirePubKey } from '@wireio/core';
-import { ERC20Abi } from './contract'; // TODO replace with staking contract ABI
-
-// — replace with your actual staking contract ABI & address —
-const STAKING_CONTRACT_ADDRESS = '0xYourStakingContractAddress';
+import { ERC20Abi, EthereumContractService } from './contract'; // TODO replace with staking contract ABI
+import { DepositEvent, DepositResult } from './types';
 
 // TODO extend to implement ISTAKINGCLIENT
-export class EthereumStakingClient {
+export class EthereumStakingClient implements IStakingClient {
     public readonly pubKey: WirePubKey;
     private readonly provider: ethers.providers.Web3Provider;
     private readonly signer: ethers.Signer;
-    private readonly contract: ethers.Contract;
+    private readonly contractService: EthereumContractService;
+
+    get contract() { return this.contractService.contract; }
+    get network() { return this.config.network; }
 
     constructor(private config: StakerConfig) {
-        // 1) unwrap & validate Ethers provider
-        if (!ethers.providers.Web3Provider.isProvider(config.provider as any)) {
-            throw new Error('Expected a Web3Provider for Ethereum');
-        }
-        this.provider = config.provider as ethers.providers.Web3Provider;
-
-        // 2) signer
-        this.signer = this.provider.getSigner();
-        this.pubKey = config.pubKey as WirePubKey;
-
-        // 4) instantiate your contract wrapper
-        this.contract = new ethers.Contract(
-            STAKING_CONTRACT_ADDRESS,
-            ERC20Abi,
-            this.signer
-        );
+        try {
+            this.provider = config.provider as ethers.providers.Web3Provider;
+            this.signer = this.provider.getSigner();
+            this.pubKey = config.pubKey as WirePubKey;
+            
+            this.contractService = new EthereumContractService({
+                provider: this.provider,
+                signer: this.signer,
+            });
+        }   
+        catch (error) {
+            // console.error('Error initializing EthereumStakingClient:', error);
+            throw error;
+        }     
     }
 
-    /** Submit a deposit; returns the transaction hash */
-    async deposit(amount: number): Promise<string> {
-        // build & send in one go
-        const txResponse = await this.contract.deposit(
-            ethers.BigNumber.from(amount),
-            {
-                // if your contract needs ETH value:
-                // value: ethers.BigNumber.from(amount),
-            }
-        );
-
-        // wait for on-chain confirmation (optional)
-        await txResponse.wait();
-        return txResponse.hash;
+    // ---------------------------------------------------------------------
+    // Public IStakingClient.deposit
+    // ---------------------------------------------------------------------
+
+    /**
+     * Deposit native ETH into 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 deposit(amount: number | string | bigint | BigNumber): Promise<string> {
+        const amountWei = BigNumber.isBigNumber(amount)
+            ? 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.
+        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> {
+        const amountWei = BigNumber.isBigNumber(amount)
+            ? amount
+            : BigNumber.from(amount);
 
-    /** (Optional) dry-run via eth_call */
-    async simulateDeposit(amount: number): Promise<any> {
-        return this.provider.call({
-            to: STAKING_CONTRACT_ADDRESS,
-            data: this.contract.interface.encodeFunctionData('deposit', [
-                ethers.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,
         });
     }
 
+    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,
+        });
+
+        // Wait for 1 confirmation 
+        const receipt = await tx.wait(1);
+
+        // 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),
+            };
+        }
+
+        return {
+            txHash: tx.hash,
+            receipt,
+            deposited,
+        };
+    }
+
+    /**
+     * Resolve the user's ETH + liqETH balances.
+     *
+     * native  = ETH in wallet
+     * actual  = liqETH token balance (ERC-20)
+     * tracked = liqETH tracked balance (protocol/accounting view)
+     */
+    async getPortfolio(): Promise<Portfolio> {
+        const walletAddress = await this.signer.getAddress();
+
+        // 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');
+
+        const portfolio: Portfolio = {
+            native: {
+                amount: nativeBalance,
+                decimals: nativeDecimals,
+                symbol: nativeSymbol,
+            },
+            liq: {
+                amount: liqBalance,
+                decimals: liqDecimals,
+                symbol: liqSymbol,
+            },
+            staked: { // TODO fetch staked balance from outpost
+                amount: BigNumber.from(0),
+                decimals: liqDecimals,
+                symbol: liqSymbol,
+            },
+            chainID: this.network.chainId
+        }
+        // console.log('ETH PORTFOLIO', portfolio);
+        return portfolio;
+    }
+
     // TODO: implement withdraw, claimRewards, etc.
 }

package/src/networks/ethereum/types.ts

@@ -1,6 +1,34 @@
+import { BigNumber, ethers } from 'ethers';
+
 export const CONTRACT_NAMES = [
-    'Stake',
+    'Accounting',
+    'DepositManager',
+    'LiqEth',
+    'LiqEthBurn',
+    'LiqEthMint',
+    // 'RewardsERC20',
+    'StakingModule',
+    // 'ValidatorBalance',
+    'WithdrawalQueue',
+    'WithdrawalVault',
+    // 'Yield',
 ] as const;
 
 export type ContractName = typeof CONTRACT_NAMES[number];
-export type AddressBook  = Record<ContractName, string>;
+export type AddressBook  = Record<ContractName, string>;
+
+export interface DepositEvent {
+    user: string;
+    netEth: BigNumber;
+    fee: BigNumber;
+    shares: BigNumber;
+}
+
+export interface DepositResult {
+    /** EVM transaction hash */
+    txHash: string;
+    /** Full receipt, if you want it */
+    receipt: ethers.providers.TransactionReceipt;
+    /** Parsed Deposited event, if present */
+    deposited?: DepositEvent;
+}