@wireio/stake 0.1.0 → 0.1.1

package/src/networks/ethereum/contract.ts

@@ -1,26 +1,22 @@
 /**
  * @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');
- * ```
  */
+// TODO: adjust these import paths to your actual artifact layout
+// import DepositManagerArtifact from '../../assets/ethereum/ABI/liqeth/DepositManager.sol/DepositManager.json';
+// import LiqEthArtifact from '../../assets/ethereum/ABI/liqeth/liqEth.sol/liqEth.json';
+// import LiqEthMintArtifact from '../../assets/ethereum/ABI/liqeth/liqEthMint.sol/liqEthMint.json';
+// import LiqEthBurnArtifact from '../../assets/ethereum/ABI/liqeth/liqEthBurn.sol/liqEthBurn.json';
+// import LiqEthTreasuryArtifact from '../../assets/ethereum/ABI/liqeth/liqEthTreasury.sol/liqEthTreasury.json';
+// import LiqEthCommonArtifact from '../../assets/ethereum/ABI/liqeth/LiqEthCommon.sol/LiqEthCommon.json';
+// import RewardsERC20Artifact from '../../assets/ethereum/ABI/liqeth/RewardsERC20.sol/RewardsERC20.json';
+// import ValidatorBalanceVerifierArtifact from '../../assets/ethereum/ABI/liqeth/ValidatorBalanceVerifier.sol/ValidatorBalanceVerifier.json';
+// import YieldArtifact from '../../assets/ethereum/ABI/liqeth/Yield.sol/Yield.json';
+// import AccountingArtifact from '../../assets/ethereum/ABI/liqeth/accounting.sol/accounting.json';
+// import StakingModuleArtifact from '../../assets/ethereum/ABI/liqeth/stakingModule.sol/stakingModule.json';
+// import WithdrawalQueueArtifact from '../../assets/ethereum/ABI/liqeth/withdrawalQueue.sol/withdrawalQueue.json';
+// import WithdrawalVaultArtifact from '../../assets/ethereum/ABI/liqeth/withdrawalVault.sol/withdrawalVault.json';
 
 import ERC20Artifact from '../../assets/ethereum/ABI/token/ERC20Token.sol/ERC20Token.json';
 import ERC721Artifact from '../../assets/ethereum/ABI/token/ERC721Token.sol/ERC721Token.json';
@@ -34,9 +30,29 @@ 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',
+    // Outpost/Stake entrypoint
+    Stake: '0xEeaCBa95852324eAc63fE2711aFe0283adf3bC93', // TODO
+
+    // liqETH protocol suite
+    DepositManager: '0xDepositManagerAddress',
+    LiqEth: '0xLiqEthTokenAddress',
+    LiqEthMint: '0xLiqEthMintAddress',
+    LiqEthBurn: '0xLiqEthBurnAddress',
+    LiqEthTreasury: '0xLiqEthTreasuryAddress',
+    LiqEthCommon: '0xLiqEthCommonAddress',
+    RewardsERC20: '0xRewardsErc20Address',
+    ValidatorBalanceVerifier: '0xValidatorBalanceVerifierAddress',
+    Yield: '0xYieldAddress',
+    Accounting: '0xAccountingAddress',
+    StakingModule: '0xStakingModuleAddress',
+    WithdrawalQueue: '0xWithdrawalQueueAddress',
+    WithdrawalVault: '0xWithdrawalVaultAddress',
 };
 
 export type Contracts<T extends string = ContractName> = Record<T, ContractConfig>;
@@ -44,12 +60,83 @@ 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 },
-}
+    // Outpost/Stake (wire ABI when available)
+    Stake: { address: ADDRESSES.Stake, abi: undefined as any }, // TODO: Stake artifact
+
+    // liqETH suite
+    LiqEth: {
+        address: ADDRESSES.LiqEth,
+        abi: undefined as any,
+        // abi: LiqEthArtifact.abi as JsonFragment[],
+    },
+    DepositManager: {
+        address: ADDRESSES.DepositManager,
+        abi: undefined as any,
+        // abi: DepositManagerArtifact.abi as JsonFragment[],
+    },
+    LiqEthMint: {
+        address: ADDRESSES.LiqEthMint,
+        abi: undefined as any,
+        // abi: LiqEthMintArtifact.abi as JsonFragment[],
+    },
+    LiqEthBurn: {
+        address: ADDRESSES.LiqEthBurn,
+        abi: undefined as any,
+        // abi: LiqEthBurnArtifact.abi as JsonFragment[],
+    },
+    LiqEthTreasury: {
+        address: ADDRESSES.LiqEthTreasury,
+        abi: undefined as any,
+        // abi: LiqEthTreasuryArtifact.abi as JsonFragment[],
+    },
+    LiqEthCommon: {
+        address: ADDRESSES.LiqEthCommon,
+        abi: undefined as any,
+        // abi: LiqEthCommonArtifact.abi as JsonFragment[],
+    },
+    RewardsERC20: {
+        address: ADDRESSES.RewardsERC20,
+        abi: undefined as any,
+        // abi: RewardsERC20Artifact.abi as JsonFragment[],
+    },
+    ValidatorBalanceVerifier: {
+        address: ADDRESSES.ValidatorBalanceVerifier,
+        abi: undefined as any,
+        // abi: ValidatorBalanceVerifierArtifact.abi as JsonFragment[],
+    },
+    Yield: {
+        address: ADDRESSES.Yield,
+        abi: undefined as any,
+        // abi: YieldArtifact.abi as JsonFragment[],
+    },
+    Accounting: {
+        address: ADDRESSES.Accounting,
+        abi: undefined as any,
+        // abi: AccountingArtifact.abi as JsonFragment[],
+    },
+    StakingModule: {
+        address: ADDRESSES.StakingModule,
+        abi: undefined as any,
+        // abi: StakingModuleArtifact.abi as JsonFragment[],
+    },
+    WithdrawalQueue: {
+        address: ADDRESSES.WithdrawalQueue,
+        abi: undefined as any,
+        // abi: WithdrawalQueueArtifact.abi as JsonFragment[],
+    },
+    WithdrawalVault: {
+        address: ADDRESSES.WithdrawalVault,
+        abi: undefined as any,
+        // abi: WithdrawalVaultArtifact.abi as JsonFragment[],
+    },
+};
 
 export interface ContractOptions {
     /** RPC endpoint or injected EIP-1193 provider */
@@ -58,7 +145,6 @@ export interface ContractOptions {
     signer?: Signer;
 }
 
-
 export class EthereumContractService {
     private provider?: providers.Provider;
     private signer?: Signer;
@@ -73,7 +159,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 +173,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 +209,37 @@ 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
+            // DepositManagerArtifact,
+            // LiqEthArtifact,
+            // LiqEthMintArtifact,
+            // LiqEthBurnArtifact,
+            // LiqEthTreasuryArtifact,
+            // LiqEthCommonArtifact,
+            // RewardsERC20Artifact,
+            // ValidatorBalanceVerifierArtifact,
+            // YieldArtifact,
+            // AccountingArtifact,
+            // StakingModuleArtifact,
+            // WithdrawalQueueArtifact,
+            // WithdrawalVaultArtifact,
         ];
 
-        // 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 +250,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,193 @@
 // 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)) {
+        if (!ethers.providers.Web3Provider.isProvider(config.provider)) {
             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
-        );
+        this.contractService = new EthereumContractService({
+            provider: this.provider,
+            signer: this.signer,
+        });
     }
 
-    /** 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),
-            }
-        );
+    // ---------------------------------------------------------------------
+    // 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);
 
-        // wait for on-chain confirmation (optional)
-        await txResponse.wait();
-        return txResponse.hash;
+        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,
+        };
+    }
+
+    /**
+     * Build, sign, and submit a single transaction that:
+     *  - Corrects other users (if needed) to free available balance, then
+     *  - Registers the caller’s untracked liqSOL.
+     *
+     * @param amount  Optional: register a smaller amount than your full untracked balance.
+     * @returns signature string
+     */
+    async register(amount?: bigint): Promise<string> {
+        try {
+            return 'Not implemented yet for Ethereum';
+        } catch (error) {
+            console.error('Error in register:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * 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);
+        const nativeDecimals =
+            this.network?.nativeCurrency?.decimals ?? 18;
+        const nativeSymbol =
+            this.network?.nativeCurrency?.symbol ?? 'ETH';
+
+        // 2) liqETH ERC-20 balance (actual)
+        const actualBalance: ethers.BigNumber = await this.contract.LiqEth.balanceOf(walletAddress);
+        const liqDecimals = 18;   // if you want, read decimals() once and cache
+        const liqSymbol = 'liqETH';
+
+        // 3) Protocol "tracked" balance (Accounting)
+        let trackedBalance: ethers.BigNumber = actualBalance;
+
+        try {
+            // Adjust this to your real view method:
+            // e.g. function getUserBalance(address user)
+            const result = await this.contract.Accounting.getUserBalance(walletAddress);
+
+            // Support either struct or plain uint256
+            if (result && typeof result === 'object' && 'amount' in result) {
+                trackedBalance = result.amount;
+                // if result.decimals exists and differs, override liqDecimals if desired
+            } else if (result != null) {
+                trackedBalance = result;
+            }
+        } catch (err) {
+            console.warn(
+                '[EthereumStakingClient] getPortfolio: Accounting view unavailable, using actual balance as tracked.',
+                err
+            );
+            trackedBalance = actualBalance;
+        }
+
+        return {
+            native: {
+                amount: nativeBalance,
+                decimals: nativeDecimals,
+                symbol: nativeSymbol,
+            },
+            actual: {
+                amount: actualBalance,
+                decimals: liqDecimals,
+                symbol: liqSymbol,
+            },
+            tracked: {
+                amount: trackedBalance,
+                decimals: liqDecimals,
+                symbol: liqSymbol,
+            },
+        };
+    }
+
     // TODO: implement withdraw, claimRewards, etc.
 }

package/src/networks/ethereum/types.ts

@@ -1,6 +1,37 @@
+import { BigNumber, ethers } from 'ethers';
+
 export const CONTRACT_NAMES = [
     'Stake',
+    'LiqEth',
+    'DepositManager',
+    'LiqEthMint',
+    'LiqEthBurn',
+    'LiqEthTreasury',
+    'LiqEthCommon',
+    'RewardsERC20',
+    'ValidatorBalanceVerifier',
+    'Yield',
+    'Accounting',
+    'StakingModule',
+    'WithdrawalQueue',
+    'WithdrawalVault',
 ] 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;
+}