@wireio/stake 0.4.0 → 0.4.2

package/src/networks/ethereum/ethereum.ts

@@ -1,27 +1,32 @@
 import { BigNumber, ethers } from 'ethers';
-import { IStakingClient, Portfolio, StakerConfig, TrancheSnapshot } from '../../types';
 import { ChainID, EvmChainID, PublicKey as WirePubKey } from '@wireio/core';
+import {
+    IStakingClient,
+    OPPAssertion,
+    Portfolio,
+    StakerConfig,
+    TrancheSnapshot
+} from '../../types';
 import { EthereumContractService } from './contract';
 import { preLaunchReceipt } from './types';
-import { DepositClient } from './clients/deposit.client';
+import { buildEthereumTrancheSnapshot } from './utils';
+import { ConvertClient } from './clients/convert.client';
 import { StakeClient } from './clients/stake.client';
 import { PretokenClient } from './clients/pretoken.client';
-import { buildEthereumTrancheSnapshot } from './utils';
-import { LiqClient } from './clients/liq.client';
-
-
-
+import { OPPClient } from './clients/opp.client';
+import { ReceiptClient } from './clients/receipt.client';
 
 export class EthereumStakingClient implements IStakingClient {
+    private readonly provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
     public readonly pubKey?: WirePubKey;
-    private readonly provider: ethers.providers.Web3Provider;
-    private readonly signer: ethers.Signer;
+    private readonly signer?: ethers.Signer;
     private readonly contractService: EthereumContractService;
 
-    private depositClient: DepositClient;
-    private liqClient: LiqClient;
+    private convertClient: ConvertClient;
     private pretokenClient: PretokenClient;
     private stakeClient: StakeClient;
+    private oppClient: OPPClient;
+    private receiptClient: ReceiptClient;
 
 
     get contract() { return this.contractService.contract; }
@@ -29,28 +34,32 @@ export class EthereumStakingClient implements IStakingClient {
 
     constructor(private config: StakerConfig) {
         try {
-            this.provider = config.provider as ethers.providers.Web3Provider;
-            this.signer = this.provider.getSigner();
+            if (config.provider) {
+                this.provider = config.provider as ethers.providers.Web3Provider;
+                this.signer = this.provider.getSigner();
+            }
+            else {
+                this.provider = new ethers.providers.JsonRpcProvider(config.network.rpcUrls[0]);
+            }
             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.convertClient = new ConvertClient(this.contractService);
             this.pretokenClient = new PretokenClient(this.contractService);
             this.stakeClient = new StakeClient(this.contractService);
-        }   
+            this.oppClient = new OPPClient(this.contractService);
+            this.receiptClient = new ReceiptClient(this.contractService);
+        }
         catch (error) {
             // console.error('Error initializing EthereumStakingClient:', error);
             throw error;
-        }     
+        }
     }
 
-
-
     // ---------------------------------------------------------------------
     // Public IStakingClient Interface Methods
     // ---------------------------------------------------------------------
@@ -62,40 +71,41 @@ export class EthereumStakingClient implements IStakingClient {
      * @returns transaction hash
      */
     async deposit(amount: number | string | bigint | BigNumber): Promise<string> {
+        this.ensureUser();
+
         const amountWei = BigNumber.isBigNumber(amount)
             ? amount
             : BigNumber.from(amount);
 
-        const result = await this.depositClient.performDeposit(amountWei);
+        const result = await this.convertClient.performDeposit(amountWei);
         return result.txHash;
     }
 
-
-
     /**
      * 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();
+        this.ensureUser();
+
+        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)
+        const result = await this.convertClient.performWithdraw(address, amountWei)
         return result.txHash;
     }
 
 
     /**
      * Stake liqETH via DepositManager.
-     * @param amount  Amount in wei 
-     *                Keep this as a bigint / string in the caller; avoid JS floats.
+     * @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();
+        this.ensureUser();
+
+        const walletAddress = await this.signer!.getAddress();
         const amountWei = BigNumber.from(amount);
 
         const result = await this.stakeClient.performStake(amountWei, walletAddress);
@@ -116,96 +126,27 @@ export class EthereumStakingClient implements IStakingClient {
      * @returns the transaction hash
      */
     async unstakePrelaunch(tokenId: bigint, recipient: string): Promise<string> {
+        this.ensureUser();
+
         const tokenIdBigNum = BigNumber.from(tokenId)
         const result = await this.stakeClient.performWithdrawStake(tokenIdBigNum, recipient);
         return result.txHash;
     }
 
 
-
     async buy(amount: bigint): Promise<string> {
-        const buyer = await this.signer.getAddress();
-        const amountBigNum = BigNumber.from(amount)
+        this.ensureUser();
+
+        const buyer = await this.signer!.getAddress();
 
         // ! 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);
 
+        let result = await this.pretokenClient.purchasePretokensWithLiqETH(amount, 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();
-        
-        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 {
-            withdrawDelay,
-            minDeposit,
-            rewardCooldown,
-        }
-    }
-
     /**
      * Resolve the user's ETH + liqETH balances.
      *
@@ -214,9 +155,9 @@ export class EthereumStakingClient implements IStakingClient {
      * tracked = liqETH tracked balance (protocol/accounting view)
      */
     async getPortfolio(): Promise<Portfolio> {
-        const walletAddress = await this.signer.getAddress();
-        // console.log('getPortfolio() wallet address', walletAddress)
+        this.ensureUser();
 
+        const walletAddress = await this.signer!.getAddress();
 
         // 1) Native ETH balance
         const nativeBalance = await this.provider.getBalance(walletAddress);
@@ -227,9 +168,15 @@ export class EthereumStakingClient implements IStakingClient {
         const liqBalance: ethers.BigNumber = await this.contract.LiqEth.balanceOf(walletAddress);
         const liqSymbol = 'Liq' + (this.network?.nativeCurrency?.symbol ?? 'ETH');
 
-        // 3) staked liqEth ERC-20 balance (actual)
-        const stakedLiqBalance = await this.contract.Depositor.sharesOf(walletAddress);
+        // 3) staked liqEth ERC-20 balance (calculate from receipts)
+        let stakeReceipts = await this.receiptClient.stakeReceipts(walletAddress);
+        let stakeBalanceBN = BigNumber.from(0);
+        for (let r of stakeReceipts) {
+            stakeBalanceBN = stakeBalanceBN.add(BigNumber.from(r.receipt.principal.amount));
+        }
 
+        // 4) WIRE pretoken balance
+        const wireBalance: ethers.BigNumber = await this.contract.Pretoken.balanceOf(walletAddress);
 
         const portfolio: Portfolio = {
             native: {
@@ -243,13 +190,13 @@ export class EthereumStakingClient implements IStakingClient {
                 symbol: liqSymbol,
             },
             staked: {
-                amount: stakedLiqBalance.toBigInt(),
+                amount: stakeBalanceBN.toBigInt(),
                 decimals: nativeDecimals,
                 symbol: liqSymbol,
             },
             wire: {
-                amount: BigInt(0), // TODO
-                decimals: 0,
+                amount: wireBalance.toBigInt(),
+                decimals: 18,
                 symbol: '$WIRE',
             },
             chainID: this.network.chainId
@@ -257,9 +204,74 @@ export class EthereumStakingClient implements IStakingClient {
         return portfolio;
     }
 
+    /**
+     * ETH Prelaunch function to list the Stake ReceiptNFTs owned by a specific user
+     * @param address address to query the receipts for
+     * @returns array of receipts
+     */
+    async fetchPrelaunchReceipts(address?: string): Promise<preLaunchReceipt[]> {
+        this.ensureUser();
+
+        if (address === undefined) address = await this.signer!.getAddress();
+
+        //default to stake receipts
+        return await this.receiptClient.stakeReceipts(address);
+    }
+
+    async getOPPMessages(address?: string): Promise<OPPAssertion[]> {
+        this.ensureUser();
+
+        if (!address) address = await this.signer!.getAddress();
+
+        return await this.oppClient.getMessages(address);
+    }
+
+    // Ensure that signer wallet is available for write operations
+    private ensureUser() {
+        if (!this.signer) {
+            throw new Error(
+                'EthereumStakingClient: write operation requires a wallet-connected Web3 provider',
+            );
+        }
+    }
+
+
+    // ---------------------------------------------------------------------
+    // READ-ONLY Public Methods
+    // ---------------------------------------------------------------------
+
+    // Estimated total APY for staking yeild
+    getSystemAPY(): Promise<number> {
+        // TODO
+        return Promise.resolve(0);
+    }
+
+    // Protocol fee charged for deposit from Native to LIQ
+    getDepositFee(amount: bigint): Promise<bigint> {
+        // TODO
+        return Promise.resolve(BigInt(0));
+    }
+
+    async getOPPStatus(): Promise<any> {
+        return await this.oppClient.getStatus();
+    }
+
+    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 {
+            withdrawDelay,
+            minDeposit,
+            rewardCooldown,
+        }
+    }
 
     /**
      * Program-level prelaunch WIRE / tranche snapshot for Ethereum
+     * 
+     * SUPPORTS READ-ONLY ACcESS
      */
     async getTrancheSnapshot(options?: {
         chainID?: ChainID;
@@ -296,25 +308,25 @@ export class EthereumStakingClient implements IStakingClient {
 
 
         // fetch price and timestamp from aggregator
-        const [ roundId, answer, startedAt, updatedAt, answeredInRound ] = await this.contract.Aggregator.latestRoundData();
+        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); 
+        const initialTrancheSupply = BigInt(60000) * BigInt(1e8);
 
         return buildEthereumTrancheSnapshot({
             chainID,
-            totalSharesBn, 
-            indexBn, 
+            totalSharesBn,
+            indexBn,
             trancheNumberBn,
-            currentTrancheSupply, 
-            tranchePriceWadBn, 
+            currentTrancheSupply,
+            tranchePriceWadBn,
             totalTrancheSupply,
             initialTrancheSupply,
             supplyGrowthBps,
             priceGrowthBps,
-            minPriceUsd, 
+            minPriceUsd,
             maxPriceUsd,
 
             ethPriceUsd,
@@ -324,16 +336,10 @@ export class EthereumStakingClient implements IStakingClient {
         });
     }
 
-
-
-    
     // ---------------------------------------------------------------------
     // Internal ETH Staking client helper functions
     // ---------------------------------------------------------------------
 
-
-    
-
     // ! This is a temporary measure for Hoodi testnet because there is no aggregator deployed
     private async updateMockAggregatorPrice() {
         const aggregator = this.contract.Aggregator;
@@ -349,7 +355,7 @@ export class EthereumStakingClient implements IStakingClient {
             // safety check - only run in non-production contexts
             const network = await this.provider.getNetwork();
             const chainId = network.chainId;
-            const allowedTestChains = new Set([560048]); 
+            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;
@@ -380,10 +386,4 @@ export class EthereumStakingClient implements IStakingClient {
             console.log(`MockAggregator updated ${ageSec}s ago — no update needed`);
         }
     }
-
-
-
-
-
-    // TODO: implement claimRewards, etc.
 }

package/src/networks/ethereum/types.ts

@@ -20,6 +20,7 @@ export const CONTRACT_NAMES = [
     'Pretoken',
     'Aggregator',
     'EthUsdPriceConsumer',
+    'Pool',
 
 ] as const;
 

package/src/networks/solana/solana.ts

@@ -193,7 +193,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Handles tx build, sign, send, and confirmation.
      */
     async deposit(amountLamports: bigint): Promise<string> {
-        this.ensureWriteAccess();
+        this.ensureUser();
         if (amountLamports <= BigInt(0)) {
             throw new Error('Deposit amount must be greater than zero.');
         }
@@ -219,7 +219,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Actual SOL payout happens later via the operator-side flow.
      */
     async withdraw(amountLamports: bigint): Promise<string> {
-        this.ensureWriteAccess();
+        this.ensureUser();
         if (amountLamports <= BigInt(0)) {
             throw new Error('Withdraw amount must be greater than zero.');
         }
@@ -238,7 +238,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Stake liqSOL into Outpost (liqSOL → pool) via liqsol_core::synd.
      */
     async stake(amountLamports: bigint): Promise<string> {
-        this.ensureWriteAccess();
+        this.ensureUser();
 
         if (!amountLamports || amountLamports <= BigInt(0)) {
             throw new Error('Stake amount must be greater than zero.');
@@ -261,7 +261,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Unstake liqSOL from Outpost (pool → liqSOL) via liqsol_core::desynd.
      */
     async unstake(amountLamports: bigint): Promise<string> {
-        this.ensureWriteAccess();
+        this.ensureUser();
 
         if (!amountLamports || amountLamports <= BigInt(0)) {
             throw new Error('Unstake amount must be greater than zero.');
@@ -287,7 +287,7 @@ export class SolanaStakingClient implements IStakingClient {
      * instruction under the new IDL (no more native-SOL purchase).
      */
     async buy(amountLamports: bigint): Promise<string> {
-        this.ensureWriteAccess();
+        this.ensureUser();
         if (!amountLamports || amountLamports <= BigInt(0)) {
             throw new Error('liqSOL pretoken purchase requires a positive amount.');
         }
@@ -453,6 +453,32 @@ export class SolanaStakingClient implements IStakingClient {
         };
     }
 
+    /**
+     * Convenience helper to fetch the distribution userRecord for the current user.
+     * Used by balance-correction flows and debugging.
+     */
+    async getUserRecord() {
+        if (!this.pubKey) throw new Error('User pubKey is undefined');
+        return this.distributionClient.getUserRecord(this.solPubKey);
+    }
+
+    
+    // ---------------------------------------------------------------------
+    // READ-ONLY Public Methods
+    // ---------------------------------------------------------------------
+
+    // Estimated total APY for staking yeild
+    getSystemAPY(): Promise<number> {
+        // TODO
+        return Promise.resolve(0);
+    }
+
+    // Protocol fee charged for deposit from Native to LIQ
+    getDepositFee(amount: bigint): Promise<bigint> {
+        // TODO
+        return Promise.resolve(BigInt(0));
+    }
+
     /**
      * Unified, chain-agnostic tranche snapshot for Solana.
      *
@@ -493,15 +519,6 @@ export class SolanaStakingClient implements IStakingClient {
         });
     }
 
-    /**
-     * Convenience helper to fetch the distribution userRecord for the current user.
-     * Used by balance-correction flows and debugging.
-     */
-    async getUserRecord() {
-        if (!this.pubKey) throw new Error('User pubKey is undefined');
-        return this.distributionClient.getUserRecord(this.solPubKey);
-    }
-
     // ---------------------------------------------------------------------
     // Tx helpers
     // ---------------------------------------------------------------------
@@ -514,7 +531,7 @@ export class SolanaStakingClient implements IStakingClient {
         signed: SolanaTransaction,
         ctx: { blockhash: string; lastValidBlockHeight: number },
     ): Promise<string> {
-        this.ensureWriteAccess();
+        this.ensureUser();
 
         const signature = await this.connection.sendRawTransaction(
             signed.serialize(),
@@ -549,7 +566,7 @@ export class SolanaStakingClient implements IStakingClient {
     async signTransaction(
         tx: SolanaTransaction,
     ): Promise<SolanaTransaction> {
-        this.ensureWriteAccess();
+        this.ensureUser();
         return this.anchor.wallet.signTransaction(tx);
     }
 
@@ -560,7 +577,7 @@ export class SolanaStakingClient implements IStakingClient {
     async sendTransaction(
         signed: SolanaTransaction,
     ): Promise<TransactionSignature> {
-        this.ensureWriteAccess();
+        this.ensureUser();
         return this.anchor.sendAndConfirm(signed);
     }
 
@@ -586,7 +603,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Guard for all write operations (deposit/withdraw/stake/unstake/buy).
      * Ensures we have a Wire pubKey and an Anchor wallet pubKey, and that they match.
      */
-    ensureWriteAccess() {
+    ensureUser() {
         if (!this.pubKey || !this.anchor.wallet.publicKey) {
             throw new Error('User Authorization required: pubKey is undefined');
         }

package/src/types.ts

@@ -5,7 +5,7 @@ import { ethers } from 'ethers';
 
 export type StakerConfig = {
     network: ExternalNetwork;
-    provider: BaseSignerWalletAdapter | ethers.providers.Web3Provider;
+    provider?: BaseSignerWalletAdapter | ethers.providers.Web3Provider;
     pubKey?: PublicKey;
 }
 
@@ -23,6 +23,12 @@ export interface IStakingClient {
     /** Fetch the complete user portfolio */
     getPortfolio(): Promise<Portfolio>;
 
+    // Estimated total APY for staking yeild
+    getSystemAPY(): Promise<number>;
+
+    // Protocol fee charged for deposit from Native to LIQ
+    getDepositFee(amount: bigint): Promise<bigint>;
+
     /**
      * Program-level prelaunch WIRE/tranche snapshot for this chain.
      *
@@ -216,4 +222,57 @@ export interface TrancheSnapshot {
      * Used directly by the frontend for ladder graphs.
      */
     ladder: TrancheLadderItem[];
+}
+
+
+// Enum describing which asset is being used to buy pretoken
+export enum PurchaseAsset {
+    SOL = 'SOL',
+    LIQSOL = 'LIQSOL',
+    ETH = 'ETH',
+    LIQETH = 'LIQETH',
+    YIELD = 'YIELD',
+}
+
+export interface PurchaseQuote {
+    purchaseAsset: PurchaseAsset;
+    amountIn: bigint;       // lamports / wei / token units
+
+    /** Expected pretoken “shares” (pretokens) and decimals */
+    wireShares: bigint;     // 1e8 scale
+    wireDecimals: number;   // always 8 for now
+
+    /** Current price + notional in USD (1e8 scale) */
+    wirePriceUsd: bigint;
+    notionalUsd: bigint;
+}
+
+// export interface OPPEvent {
+//     type: 'liq_pretoken_purchase' | 'yield_pretoken_purchase' | 'pretoken_purchase' | 'stake' | 'unstake' | 'unknown';
+//     amount: bigint | null;
+//     chain: 'ETH' | 'SOL';
+//     timestamp: number | null;
+//     from: string | null;
+//     to: string | null;
+//     txHash: string;
+//     raw: any;
+//     assertions: OPPAssertion[]
+// }
+
+export interface OPPAssertion {
+    type: 'liq_pretoken_purchase' | 'yield_pretoken_purchase' | 'pretoken_purchase' | 'stake' | 'unstake' | 'bonded_actor' | 'unbonded_actor' | 'unknown',
+    data: any
+    chain: 'ETH' | 'SOL';
+    timestamp: number | null;
+    from: string | null;
+    to: string | null;
+    txHash: string;
+    raw: any;
+}
+
+
+
+export enum ReceiptNFTKind {
+    STAKE = 0,
+    PRETOKEN_PURCHASE = 1,
 }

package/src/networks/ethereum/clients/liq.client.ts

@@ -1,47 +0,0 @@
-import { BigNumber, ethers } from "ethers";
-import { preLaunchReceipt, SharesBurnedEvent, StakedEvent, WithdrawnStakeEvent, WithdrawnStakeResult } from "../types";
-import { EthereumContractService } from "../contract";
-import { formatContractErrors } from "../utils";
-
-export class LiqClient {
-
-    private readonly contractService: EthereumContractService;
-    
-    get contract() { return this.contractService.contract; }
-
-    constructor(contract: EthereumContractService) {
-        this.contractService = contract;
-    }
-    
-
-    public async safeBurn(signerAddress: string, amountWei: BigNumber): Promise<any> {
-        let tx, receipt;
-        try {
-            tx = await this.contract.LiqEth.safeBurn(signerAddress, amountWei);
-            receipt = await tx.wait(1);
-        } catch (err: any) {
-            let errorObj = formatContractErrors(err);
-            throw new Error(errorObj.name ?? errorObj.raw)
-        }
-
-        // Parse SharesBurned event if present
-        let event: SharesBurnedEvent | undefined;
-        const ev = receipt.events?.find((e) => e.event === 'SharesBurned');
-
-        if (ev && ev.args) {
-            const { from, shares, tokenValue } = ev.args;
-            event = {
-                from,
-                shares: BigNumber.from(shares),
-                tokenValue: BigNumber.from(tokenValue),
-            };
-        }
-
-        return {
-            txHash: tx.hash,
-            receipt,
-            event,
-        };
-    }
-
-}