@wireio/stake 0.2.4 → 0.3.0

package/src/networks/ethereum/utils.ts

@@ -0,0 +1,308 @@
+
+import { ethers } from "ethers";
+import { TrancheLadderItem, TrancheSnapshot } from "../../types";
+import { ChainID } from "@wireio/core";
+
+
+const BPS = BigInt(10_000);
+
+export interface CustomContractError {
+    name?: string;
+    signature?: string;
+    args?: any[];
+    data?: any;
+    method?: string;
+    code?: any;
+    raw: string;
+}
+
+
+
+export function formatContractErrors(err: any): CustomContractError {
+    // Extract custom error details if present
+    if (err.errorName && err.errorArgs) {
+        const errorObj: CustomContractError = {
+            name: err.errorName,
+            signature: err.errorSignature,
+            args: err.errorArgs.map((arg: any) =>
+                arg && arg._isBigNumber ? ethers.BigNumber.from(arg).toString() : arg
+            ),
+            data: err.data,
+            method: err.method,
+            code: err.code,
+            raw: err,
+        };
+        console.error("Custom contract error:", errorObj);
+        return errorObj;
+    } else {
+        console.error("Contract Error:", err);
+        return {
+            raw: typeof err === 'string' ? err : (err?.message || String(err))
+        };
+    }
+}
+
+
+
+/**
+ * Finalize an OPP epoch. Optionally accept a gasLimit override (ethers BigNumberish).
+ * If gasLimit is not provided, the method will attempt estimateGas.finalizeEpoch()
+ * and pad it (1.2x). If estimateGas fails, a conservative fallback is used.
+ */
+export async function sendOPPFinalize(opp: ethers.Contract, gasLimit?: ethers.BigNumberish) {
+    const overrides: any = {};
+    try {
+        if (gasLimit === undefined) {
+            try {
+                const estimated = await opp.estimateGas.finalizeEpoch();
+                const padded = ethers.BigNumber.from(estimated).mul(12).div(10); // 1.2x
+                overrides.gasLimit = padded;
+                console.log('sendFinalize: estimated gas', estimated.toString(), 'padded to', overrides.gasLimit.toString());
+            } catch (estErr) {
+                // estimateGas can throw UNPREDICTABLE_GAS_LIMIT; fall back to a safe default
+                console.warn('sendFinalize: estimateGas.finalizeEpoch() failed, falling back to hardcoded gasLimit', estErr);
+                overrides.gasLimit = ethers.BigNumber.from(8000000);
+            }
+        } else {
+            overrides.gasLimit = ethers.BigNumber.from(gasLimit);
+            console.log('sendFinalize: using provided gasLimit override', overrides.gasLimit.toString());
+        }
+
+        const tx = await opp.finalizeEpoch(overrides); // submit tx with overrides
+        console.log('sendFinalize tx hash:', tx.hash, 'overrides:', overrides);
+
+        const receipt = await tx.wait(); // wait for mined
+        console.log('sendFinalize tx mined, block:', receipt.blockNumber);
+        return receipt;
+    } catch (err: any) {
+        // Verbose error logging to help debugging reverts / provider issues
+        console.error('sendFinalize() failed:', err?.message || err);
+
+        // Try to extract common raw payload locations used by ethers errors
+        const raw = err?.error?.data || err?.data || err?.body || err?.receipt || err?.transaction || err;
+        console.error('sendFinalize raw payload:', raw);
+
+        // Try parsing with contractService if available
+        try {
+            const parsed = formatContractErrors(raw);
+            console.error('sendFinalize parsed error:', parsed.name, parsed.args);
+        } catch (parseErr) {
+            // Fallback: decode Error(string) ABI encoded revert (0x08c379a0)
+            try {
+                const hex = (typeof raw === 'string') ? raw : (raw && raw.data) ? raw.data : null;
+                if (hex && typeof hex === 'string' && hex.startsWith('0x08c379a0')) {
+                    const reason = ethers.utils.defaultAbiCoder.decode(['string'], '0x' + hex.slice(10))[0];
+                    console.error('sendFinalize revert reason:', reason);
+                } else {
+                    console.error('sendFinalize: unable to decode revert payload (not standard Error(string))');
+                }
+            } catch (fallbackErr) {
+                console.error('sendFinalize: fallback decode failed:', fallbackErr);
+            }
+        }
+
+        // If there is a receipt, print it for extra context
+        if (err?.receipt) console.error('sendFinalize receipt:', err.receipt);
+        if (err?.transaction) console.error('sendFinalize transaction object:', err.transaction);
+
+        // Re-throw so callers can handle it as well
+        throw err;
+    }
+}
+
+
+
+/**
+ * Apply one forward growth step: value * (BPS + growthBps) / BPS.
+ * Simple integer round-half-up.
+ */
+function growOnce(value: bigint, growthBps: number): bigint {
+    const g = BigInt(growthBps);
+    return (value * (BPS + g) + BPS / BigInt(2)) / BPS;
+}
+
+
+/**
+ * Apply one backward step: value * BPS / (BPS + growthBps).
+ * Also integer round-half-up.
+ */
+function shrinkOnce(value: bigint, growthBps: number): bigint {
+    const g = BigInt(growthBps);
+    return (value * BPS + (BPS + g) / BigInt(2)) / (BPS + g);
+}
+
+
+/**
+ * Calculate the full supply for a given tranche using BigInt math.
+ * trancheNumber is 1-based (tranche 1 = startSupply)
+ */
+function getTrancheSize(startSupply: bigint, supplyGrowthBps: number, trancheNumber: number): bigint {
+    let supply = startSupply;
+    for (let i = 0; i < trancheNumber; i++) {
+        supply = (supply * (BPS + BigInt(supplyGrowthBps)) + BPS / BigInt(2)) / BPS;
+    }
+    return supply;
+}
+
+
+/**
+ * Build a local tranche ladder around the current tranche
+ * using only on-chain config + current state.
+ *
+ */
+export function buildEthereumTrancheLadder(options: {
+    currentTranche: number;
+    totalTrancheSupply: bigint,
+    initialTrancheSupply: bigint;
+    currentTrancheSupply: bigint;
+    currentPriceUsd: bigint;
+    supplyGrowthBps: number;
+    priceGrowthBps: number;
+    windowBefore?: number;
+    windowAfter?: number;
+}): TrancheLadderItem[] {
+    const {
+        currentTranche,
+        initialTrancheSupply,
+        currentTrancheSupply,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        windowBefore = 5,
+        windowAfter = 5,
+    } = options;
+
+    const startId = Math.max(0, currentTranche - windowBefore);
+    const endId = currentTranche + windowAfter;
+    
+    //calculate total tranche size (e.g. 60,600 on tranche 2)
+    const currentTrancheSize = getTrancheSize(initialTrancheSupply, supplyGrowthBps, currentTranche);
+
+    const capacity = new Map<number, bigint>();
+    const price = new Map<number, bigint>();
+
+    // Seed current
+    capacity.set(currentTranche, currentTrancheSize);
+    price.set(currentTranche, currentPriceUsd);
+
+    // Forward (future tranches)
+    for (let id = currentTranche + 1; id <= endId; id++) {
+        const prevCap = capacity.get(id - 1)!;
+        const prevPrice = price.get(id - 1)!;
+        capacity.set(id, growOnce(prevCap, supplyGrowthBps));
+        price.set(id, growOnce(prevPrice, priceGrowthBps));
+    }
+
+    // Backward (past tranches)
+    for (let id = currentTranche - 1; id >= startId; id--) {
+        const nextCap = capacity.get(id + 1)!;
+        const nextPrice = price.get(id + 1)!;
+        capacity.set(id, shrinkOnce(nextCap, supplyGrowthBps));
+        price.set(id, shrinkOnce(nextPrice, priceGrowthBps));
+    }
+
+    const ladder: TrancheLadderItem[] = [];
+    for (let id = startId; id <= endId; id++) {
+        const cap = capacity.get(id)!;
+        let sold: bigint;
+        if (id < currentTranche) {
+            sold = cap;
+        } else if (id === currentTranche) {
+            sold = cap - currentTrancheSupply;
+        } else {
+            sold = BigInt(0);
+        }
+
+        ladder.push({
+            id,
+            capacity: cap,
+            sold,
+            remaining: cap - sold,
+            priceUsd: price.get(id)!,
+        });
+    }
+
+    return ladder;
+}
+
+
+/**
+ * Turn raw liqsol_core accounts into a chain-agnostic TrancheSnapshot for SOL.
+ * All math stays here; TokenClient just wires accounts + connection.
+ */
+export async function buildEthereumTrancheSnapshot(options: {
+    chainID: ChainID;
+    totalSharesBn;
+    indexBn;
+    trancheNumberBn;
+    currentTrancheSupply;
+    tranchePriceWadBn;
+    totalTrancheSupply;
+    initialTrancheSupply;
+    supplyGrowthBps;
+    priceGrowthBps;
+    minPriceUsd;
+    maxPriceUsd;
+
+    ethPriceUsd?: bigint;
+    nativePriceTimestamp?: number;
+    ladderWindowBefore?: number;
+    ladderWindowAfter?: number;
+}): Promise<TrancheSnapshot> {
+    const {
+        chainID,
+        ethPriceUsd,
+        nativePriceTimestamp,
+        ladderWindowBefore,
+        ladderWindowAfter,
+
+        totalSharesBn, 
+        indexBn, 
+        trancheNumberBn, 
+        currentTrancheSupply, 
+        tranchePriceWadBn, 
+        totalTrancheSupply,
+        initialTrancheSupply,
+        supplyGrowthBps,
+        priceGrowthBps,
+        minPriceUsd, 
+        maxPriceUsd,
+    } = options;
+
+
+    // convert default BigNumber to bigint for hub to handle, and partially convert from 1e18 to 1e8 for the hub
+    const totalShares = BigInt(totalSharesBn.toString()) / BigInt(1e10);
+    const currentIndex = BigInt(indexBn.toString()); // RAY (1e27)
+    const currentTranche = Number(trancheNumberBn.toString());
+    const currentPriceUsd = BigInt(tranchePriceWadBn.toString()) / BigInt(1e10); // 1e18 WAD
+
+
+    const ladder = buildEthereumTrancheLadder({
+        currentTranche,
+        totalTrancheSupply,
+        initialTrancheSupply,
+        currentTrancheSupply,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        windowBefore: ladderWindowBefore,
+        windowAfter: ladderWindowAfter,
+    });
+
+
+    return {
+        chainID,
+        currentIndex,
+        totalShares,
+        currentTranche,
+        currentPriceUsd,
+        supplyGrowthBps,
+        priceGrowthBps,
+        currentTrancheSupply,
+        initialTrancheSupply,
+        totalPretokensSold: totalTrancheSupply,
+        nativePriceUsd: ethPriceUsd,
+        nativePriceTimestamp,
+        ladder,
+    };
+}

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

@@ -20,7 +20,6 @@ import {
 import { derivePriceHistoryPda } from '../constants';
 import type { } from '../types';
 import { ChainID, SolChainID } from '@wireio/core';
-import { PurchaseAsset, PurchaseQuote, TrancheSnapshot } from '../../../types';
 
 export class TokenClient {
     private readonly program: Program<LiqsolCore>;

package/src/networks/solana/solana.ts

@@ -27,8 +27,6 @@ import {
 import {
     IStakingClient,
     Portfolio,
-    PurchaseAsset,
-    PurchaseQuote,
     StakerConfig,
     TrancheSnapshot,
 } from '../../types';
@@ -62,7 +60,7 @@ const commitment: Commitment = 'confirmed';
  * This class composes lower-level clients; it does not know about UI.
  */
 export class SolanaStakingClient implements IStakingClient {
-    public pubKey: PublicKey;
+    public pubKey?: PublicKey;
     public connection: Connection;
     public anchor: AnchorProvider;
 
@@ -73,6 +71,7 @@ export class SolanaStakingClient implements IStakingClient {
     private tokenClient: TokenClient;
 
     get solPubKey(): SolPubKey {
+        if (!this.pubKey) throw new Error('pubKey is undefined');
         return new SolPubKey(this.pubKey.data.array);
     }
 
@@ -82,13 +81,17 @@ export class SolanaStakingClient implements IStakingClient {
 
     constructor(private config: StakerConfig) {
         const adapter = config.provider as BaseSignerWalletAdapter;
-        if (!adapter?.publicKey) throw new Error('Solana wallet adapter not connected');
+        // if (!adapter?.publicKey) throw new Error('Solana wallet adapter not connected');
         if (!config.network.rpcUrls.length) throw new Error('No RPC URLs provided');
-
-        const publicKey = adapter.publicKey;
-        const wirePub = new PublicKey(KeyType.ED, publicKey.toBytes());
-        if (!wirePub.equals(config.pubKey)) {
-            throw new Error("Passed-in pubKey doesn't match adapter.publicKey");
+        
+        const publicKey = adapter.publicKey || new SolPubKey(new Uint8Array(32))
+        if (config.pubKey){
+            // If pubKey provided, ensure it matches the adapter's pubkey
+            const wirePub = new PublicKey(KeyType.ED, publicKey.toBytes());
+            if (!wirePub.equals(config.pubKey)) 
+                throw new Error("Passed-in pubKey doesn't match adapter.publicKey");
+            // All good; assign it
+            this.pubKey = wirePub;
         }
 
         const opts: ConnectionConfig = { commitment };
@@ -111,7 +114,6 @@ export class SolanaStakingClient implements IStakingClient {
             },
         };
 
-        this.pubKey = wirePub;
         this.connection = new Connection(config.network.rpcUrls[0], opts);
         this.anchor = new AnchorProvider(this.connection, anchorWallet, { commitment });
 
@@ -120,7 +122,6 @@ export class SolanaStakingClient implements IStakingClient {
         this.leaderboardClient = new LeaderboardClient(this.anchor);
         this.outpostClient = new OutpostClient(this.anchor);
         this.tokenClient = new TokenClient(this.anchor);
-        this.tokenClient = new TokenClient(this.anchor);
     }
 
     // ---------------------------------------------------------------------
@@ -132,6 +133,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Handles tx build, sign, send, and confirmation.
      */
     async deposit(amountLamports: bigint): Promise<string> {
+        this.ensureWriteAccess();
         if (amountLamports <= BigInt(0)) {
             throw new Error('Deposit amount must be greater than zero.');
         }
@@ -152,6 +154,7 @@ export class SolanaStakingClient implements IStakingClient {
      * NOTE: placeholder until a withdraw flow is implemented in DepositClient.
      */
     async withdraw(_amountLamports: bigint): Promise<string> {
+        this.ensureWriteAccess();
         throw new Error('Withdraw method not yet implemented.');
     }
 
@@ -160,6 +163,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Ensures user ATA exists, then stakes via outpostClient.
      */
     async stake(amountLamports: bigint): Promise<string> {
+        this.ensureWriteAccess();
         if (amountLamports <= BigInt(0)) {
             throw new Error('Stake amount must be greater than zero.');
         }
@@ -180,6 +184,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Mirrors stake() but calls withdrawStake.
      */
     async unstake(amountLamports: bigint): Promise<string> {
+        this.ensureWriteAccess();
         if (amountLamports <= BigInt(0)) {
             throw new Error('Unstake amount must be greater than zero.');
         }
@@ -204,56 +209,17 @@ export class SolanaStakingClient implements IStakingClient {
      *
      * ETH / LIQETH are not valid on Solana.
      */
-    async buy(amountLamports: bigint, purchaseAsset: PurchaseAsset): Promise<string> {
+    async buy(amountLamports: bigint): Promise<string> {
+        this.ensureWriteAccess();
+        if (!amountLamports || amountLamports <= BigInt(0)) 
+            throw new Error('liqSOL pretoken purchase requires a positive amount.');
+        
         const user = this.solPubKey;
-        let ix: TransactionInstruction;
-        let preIxs: TransactionInstruction[] = [];
-
-        switch (purchaseAsset) {
-            case PurchaseAsset.SOL: {
-                if (!amountLamports || amountLamports <= BigInt(0)) {
-                    throw new Error('SOL pretoken purchase requires a positive amount.');
-                }
-                ix = await this.tokenClient.buildPurchaseWithSolIx(
-                    amountLamports,
-                    user,
-                );
-                break;
-            }
-
-            case PurchaseAsset.LIQSOL: {
-                if (!amountLamports || amountLamports <= BigInt(0)) {
-                    throw new Error(
-                        'liqSOL pretoken purchase requires a positive amount.',
-                    );
-                }
-                preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
-                ix = await this.tokenClient.buildPurchaseWithLiqsolIx(
-                    amountLamports,
-                    user,
-                );
-                break;
-            }
-
-            case PurchaseAsset.YIELD: {
-                // Amount is ignored by the on-chain program; it consumes tracked yield.
-                ix = await this.tokenClient.buildPurchaseFromYieldIx(user);
-                break;
-            }
-
-            case PurchaseAsset.ETH:
-            case PurchaseAsset.LIQETH: {
-                throw new Error(
-                    'ETH / LIQETH pretoken purchases are not supported on Solana.',
-                );
-            }
-
-            default:
-                throw new Error(`Unsupported pretoken purchase asset: ${String(
-                    purchaseAsset,
-                )}`);
-        }
-
+        const preIxs = await this.outpostClient.maybeBuildCreateUserAtaIx(user);
+        const ix = await this.tokenClient.buildPurchaseWithLiqsolIx(
+            amountLamports,
+            user,
+        );
         const tx = new Transaction().add(...preIxs, ix);
         const prepared = await this.prepareTx(tx);
         const signed = await this.signTransaction(prepared.tx);
@@ -270,6 +236,8 @@ export class SolanaStakingClient implements IStakingClient {
      *  - extras: useful internal addresses and raw state for debugging/UX
      */
     async getPortfolio(): Promise<Portfolio> {
+        if (!this.pubKey) throw new Error('User pubKey is undefined');
+
         const user = this.solPubKey;
 
         const reservePoolPDA = deriveReservePoolPda();
@@ -313,7 +281,7 @@ export class SolanaStakingClient implements IStakingClient {
             wireReceipt?.stakedLiqsol?.toString() ?? '0';
 
         const wireSharesStr =
-            userWarrantRecord?.totalWarrantsPurchased?.toString() ?? '0';
+            userWarrantRecord?.totalPretokensPurchased?.toString() ?? '0';
 
         return {
             native: {
@@ -369,6 +337,8 @@ export class SolanaStakingClient implements IStakingClient {
      * windowBefore/windowAfter control how many ladder rows we precompute
      * around the current tranche for UI, but you can pass nothing if you
      * only need current tranche info.
+     * 
+     * READ-ONLY allowed
      */
     async getTrancheSnapshot(options?: {
         chainID?: ChainID;
@@ -402,95 +372,12 @@ export class SolanaStakingClient implements IStakingClient {
         });
     }
 
-    /**
-     * Approximate prelaunch WIRE quote for a given amount & asset.
-     *
-     * Uses TrancheSnapshot + SOL/USD price for:
-     *  - SOL: amount is lamports
-     *  - LIQSOL: amount is liqSOL base units (decimals = 9)
-     *  - YIELD: amount is treated as SOL lamports-equivalent of yield
-     *
-     * NOTE: On-chain rounding may differ slightly (this is UI-only).
-     */
-    async getBuyQuote(
-        amount: bigint,
-        asset: PurchaseAsset,
-        opts?: { chainID?: ChainID },
-    ): Promise<PurchaseQuote> {
-        // For non-YIELD purchases we require a positive amount.
-        if (asset !== PurchaseAsset.YIELD && amount <= BigInt(0)) {
-            throw new Error('amount must be > 0 for non-YIELD purchases');
-        }
-
-        const snapshot = await this.getTrancheSnapshot({
-            chainID: opts?.chainID,
-        });
-
-        const wirePriceUsd = snapshot.currentPriceUsd; // 1e8
-        const solPriceUsd = snapshot.nativePriceUsd;   // 1e8
-
-        if (!wirePriceUsd || wirePriceUsd <= BigInt(0)) {
-            throw new Error('Invalid WIRE price in tranche snapshot');
-        }
-        if (!solPriceUsd || solPriceUsd <= BigInt(0)) {
-            throw new Error('No SOL/USD price available');
-        }
-
-        const ONE_E9 = BigInt(LAMPORTS_PER_SOL);    // 1e9
-        const ONE_E8 = BigInt(100_000_000);         // 1e8
-
-        let notionalUsd: bigint;
-
-        switch (asset) {
-            case PurchaseAsset.SOL: {
-                // lamports * solPriceUsd / 1e9  → 1e8 USD
-                notionalUsd = (amount * solPriceUsd) / ONE_E9;
-                break;
-            }
-
-            case PurchaseAsset.LIQSOL: {
-                // liqSOL also uses 9 decimals; use same conversion.
-                notionalUsd = (amount * solPriceUsd) / ONE_E9;
-                break;
-            }
-
-            case PurchaseAsset.YIELD: {
-                // Treat amount as lamports-equivalent of SOL yield (UI convention).
-                notionalUsd = (amount * solPriceUsd) / ONE_E9;
-                break;
-            }
-
-            case PurchaseAsset.ETH:
-            case PurchaseAsset.LIQETH:
-                throw new Error('getBuyQuote for ETH/LIQETH is not supported on Solana');
-
-            default:
-                throw new Error(`Unsupported purchase asset: ${String(asset)}`);
-        }
-
-        // WIRE shares (1e8) = (notionalUsd * 1e8) / wirePriceUsd
-        // Add a small bias to avoid truncating to 0 on tiny buys.
-        const numerator = notionalUsd * ONE_E8;
-        const wireShares =
-            numerator === BigInt(0)
-                ? BigInt(0)
-                : (numerator + wirePriceUsd - BigInt(1)) / wirePriceUsd;
-
-        return {
-            purchaseAsset: asset,
-            amountIn: amount,
-            wireShares,
-            wireDecimals: 8,
-            wirePriceUsd,
-            notionalUsd,
-        };
-    }
-
     /**
      * 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);
     }
 
@@ -500,6 +387,7 @@ export class SolanaStakingClient implements IStakingClient {
      *  - signs and sends the transaction if it can succeed
      */
     async correctBalance(amount?: bigint): Promise<string> {
+        this.ensureWriteAccess();
         const build = await this.distributionClient.buildCorrectRegisterTx({ amount });
         if (!build.canSucceed || !build.transaction) {
             throw new Error(build.reason ?? 'Unable to build Correct&Register transaction');
@@ -528,7 +416,8 @@ export class SolanaStakingClient implements IStakingClient {
         signed: SolanaTransaction,
         ctx: { blockhash: string; lastValidBlockHeight: number },
     ): Promise<string> {
-        const signature = await this.connection.sendRawTransaction(
+        this.ensureWriteAccess();
+            const signature = await this.connection.sendRawTransaction(
             signed.serialize(),
             {
                 skipPreflight: false,
@@ -557,6 +446,7 @@ export class SolanaStakingClient implements IStakingClient {
      * Sign a single Solana transaction using the connected wallet adapter.
      */
     async signTransaction(tx: SolanaTransaction): Promise<SolanaTransaction> {
+        this.ensureWriteAccess();
         return this.anchor.wallet.signTransaction(tx);
     }
 
@@ -565,6 +455,7 @@ export class SolanaStakingClient implements IStakingClient {
      * prepared and signed the transaction.
      */
     async sendTransaction(signed: SolanaTransaction): Promise<TransactionSignature> {
+        this.ensureWriteAccess();
         return this.anchor.sendAndConfirm(signed);
     }
 
@@ -581,4 +472,11 @@ export class SolanaStakingClient implements IStakingClient {
         tx.feePayer = this.solPubKey;
         return { tx, blockhash, lastValidBlockHeight };
     }
+
+    ensureWriteAccess() {
+        if (!this.pubKey || !this.anchor.wallet.publicKey)
+            throw new Error('User Authorization required: pubKey is undefined');
+        if (this.solPubKey.toBase58() !== this.anchor.wallet.publicKey.toBase58())
+            throw new Error('Write access requires connected wallet to match pubKey');
+    }
 }

package/src/networks/solana/types.ts

@@ -99,7 +99,7 @@ export type GlobalState = {
 export type UserWarrantRecord = {
     user: PublicKey;
     totalSolDeposited: BN;
-    totalWarrantsPurchased: BN;
+    totalPretokensPurchased: BN;
     lastTrancheNumber: BN;
     lastTranchePriceUsd: BN;
     bump: number;
@@ -110,7 +110,11 @@ export type TrancheState = {
     currentTrancheNumber: BN;
     currentTrancheSupply: BN;
     currentTranchePriceUsd: BN;
-    totalWarrantsSold: BN;
+    //Currently working on renaming Warrants to Pretokens, 
+    // current version of sol contracts appears to still 
+    // be using warrants phrasing for this variable
+    totalPretokensSold?: BN;
+    totalWarrantsSold?: BN;
     initialTrancheSupply: BN;
     supplyGrowthBps: number;
     priceGrowthBps: number;