@mento-protocol/mento-sdk 3.0.0-rc.0 → 3.0.0

package/dist/core/types/pool.d.ts

@@ -110,8 +110,10 @@ export interface FPMMPoolDetails extends Pool {
     reserve1: bigint;
     /** Block timestamp of last reserve update */
     blockTimestampLast: bigint;
-    /** Pricing and oracle data (null when FX market is closed) */
+    /** Pricing and oracle data (null when unavailable — see pricingUnavailableReason) */
     pricing: FPMMPricing | null;
+    /** Reason pricing data is unavailable, or null when pricing is present */
+    pricingUnavailableReason: string | null;
     /** Fee configuration */
     fees: FPMMFees;
     /** Rebalancing state */

package/dist/esm/index.js

@@ -49,14 +49,16 @@ import { BorrowService } from './services/borrow';
  *              const status = await mento.trading.getPoolTradabilityStatus(pool);
  *
  *              // Add liquidity to a pool
- *              const { approval0, approval1, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction(
- *                poolAddress, amount0, amount1, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
+ *              const { approvalA, approvalB, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction({
+ *                poolAddress, tokenA, amountA, tokenB, amountB, recipient, owner,
+ *                options: { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) },
+ *              });
  *
  *              // Add liquidity using a single token (zap in)
- *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction(
- *                poolAddress, tokenIn, amountIn, 0.5, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
+ *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction({
+ *                poolAddress, tokenIn, amountIn, amountInSplit: 0.5, recipient, owner,
+ *                options: { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) },
+ *              });
  */
 export class Mento {
     constructor(chainId, tokens, pools, routes, quotes, swap, trading, liquidity, borrow) {

package/dist/esm/services/borrow/index.js

@@ -1 +1,3 @@
 export * from './BorrowService';
+export * from './borrowHelpers';
+export * from './borrowMath';

package/dist/esm/services/index.js

@@ -4,3 +4,5 @@ export * from './quotes';
 export * from './swap';
 export * from './trading';
 export * from './borrow';
+export * from './tokens';
+export * from './liquidity';

package/dist/esm/services/liquidity/liquidityHelpers.js

@@ -22,11 +22,13 @@ export async function getAllowance(publicClient, token, owner, chainId) {
     }));
 }
 export function calculateMinAmount(amount, slippageTolerance) {
+    const MAX_SLIPPAGE_TOLERANCE = 20;
     if (slippageTolerance < 0) {
         throw new Error('Slippage tolerance cannot be negative');
     }
-    if (slippageTolerance > 100) {
-        throw new Error('Slippage tolerance cannot exceed 100%');
+    if (slippageTolerance > MAX_SLIPPAGE_TOLERANCE) {
+        throw new Error(`Slippage tolerance ${slippageTolerance}% exceeds maximum of ${MAX_SLIPPAGE_TOLERANCE}%. ` +
+            'High slippage makes transactions vulnerable to sandwich attacks.');
     }
     const basisPoints = BigInt(Math.floor(slippageTolerance * 100));
     const slippageMultiplier = 10000n - basisPoints;

package/dist/esm/services/pools/poolDetails.js

@@ -37,6 +37,7 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
         const liquidityStrategy = activeIndex >= 0 ? knownStrategies[activeIndex] : null;
         // Fetch pricing separately — graceful degradation when FX market is closed
         let pricing = null;
+        let pricingUnavailableReason = null;
         let inBand = null;
         try {
             const rebalancingStateResult = await publicClient.readContract({
@@ -58,8 +59,8 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
             };
             inBand = priceDifference < BigInt(rebalanceThreshold);
         }
-        catch {
-            // getRebalancingState() failed (likely FXMarketClosed) — pricing stays null
+        catch (error) {
+            pricingUnavailableReason = `getRebalancingState() reverted: ${error.message ?? 'unknown error'}`;
         }
         return {
             ...pool,
@@ -70,6 +71,7 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
             reserve1,
             blockTimestampLast,
             pricing,
+            pricingUnavailableReason,
             fees: {
                 lpFeeBps,
                 lpFeePercent: Number(lpFeeBps) / 100,
@@ -90,7 +92,9 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
         };
     }
     catch (error) {
-        throw new Error(`Failed to fetch FPMM pool details for ${pool.poolAddr}: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch FPMM pool details for ${pool.poolAddr}: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 /**
@@ -120,7 +124,9 @@ export async function fetchVirtualPoolDetails(publicClient, pool) {
         };
     }
     catch (error) {
-        throw new Error(`Failed to fetch Virtual pool details for ${pool.poolAddr}: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch Virtual pool details for ${pool.poolAddr}: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 /**

package/dist/esm/services/pools/poolDiscovery.js

@@ -44,7 +44,9 @@ export async function fetchFPMMPools(publicClient, chainId) {
         return await Promise.all(poolDataPromises);
     }
     catch (error) {
-        throw new Error(`Failed to fetch FPMM pools: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch FPMM pools: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 /**
@@ -104,6 +106,8 @@ export async function fetchVirtualPools(publicClient, chainId) {
         return await Promise.all(poolPromises);
     }
     catch (error) {
-        throw new Error(`Failed to fetch Virtual pools: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch Virtual pools: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }

package/dist/esm/services/swap/SwapService.js

@@ -27,6 +27,7 @@ export class SwapService {
      * @param options - Swap configuration options (slippage, deadline)
      * @param route - Optional pre-fetched route for better performance
      * @returns Combined transaction with approval (if needed) and swap params
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
      * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
      * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
      * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
@@ -54,6 +55,7 @@ export class SwapService {
      * ```
      */
     async buildSwapTransaction(tokenIn, tokenOut, amountIn, recipient, owner, options, route) {
+        this.validateAmountIn(amountIn);
         // Validate all address inputs
         validateAddress(tokenIn, 'tokenIn');
         validateAddress(tokenOut, 'tokenOut');
@@ -77,6 +79,7 @@ export class SwapService {
      * @param options - Swap configuration options (slippage, deadline)
      * @param route - Optional pre-fetched route for better performance
      * @returns Detailed swap parameters including transaction data
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
      * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
      * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
      * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
@@ -98,6 +101,7 @@ export class SwapService {
      * ```
      */
     async buildSwapParams(tokenIn, tokenOut, amountIn, recipient, options, route) {
+        this.validateAmountIn(amountIn);
         const deadline = options.deadline;
         if (deadline <= BigInt(Date.now()) / 1000n) {
             throw new Error('Deadline must be in the future');
@@ -155,6 +159,15 @@ export class SwapService {
             args: [owner, routerAddress],
         }));
     }
+    /**
+     * Validates that the input amount is strictly positive.
+     * @private
+     */
+    validateAmountIn(amountIn) {
+        if (amountIn <= 0n) {
+            throw new Error('amountIn must be greater than zero');
+        }
+    }
     /**
      * Calculates minimum output amount after applying slippage tolerance
      * @param amountOut - Expected output amount

package/dist/esm/services/trading/TradingLimitsService.js

@@ -1,3 +1,4 @@
+import { BaseError, ContractFunctionRevertedError } from 'viem';
 import { PoolType } from '../../core/types';
 import { FPMM_ABI, BROKER_ABI } from '../../core/abis';
 import { getContractAddress } from '../../core/constants';
@@ -70,9 +71,16 @@ export class TradingLimitsService {
             }
             return calculateTradingLimitsV2(config, state, token);
         }
-        catch {
-            // Token may not have limits configured, or invalid token
-            return [];
+        catch (error) {
+            // Contract reverts indicate limits aren't configured for this token — return empty
+            if (error instanceof BaseError) {
+                const revertError = error.walk((e) => e instanceof ContractFunctionRevertedError);
+                if (revertError instanceof ContractFunctionRevertedError) {
+                    return [];
+                }
+            }
+            // Re-throw non-revert errors (network failures, RPC timeouts, etc.)
+            throw error;
         }
     }
     /**
@@ -143,9 +151,16 @@ export class TradingLimitsService {
             const tokenDecimals = 0; // V1 stores values with 0 decimal precision
             return calculateTradingLimitsV1(config, state, token, tokenDecimals);
         }
-        catch {
-            // Trading limits may not be configured for this token
-            return [];
+        catch (error) {
+            // Contract reverts indicate limits aren't configured for this token — return empty
+            if (error instanceof BaseError) {
+                const revertError = error.walk((e) => e instanceof ContractFunctionRevertedError);
+                if (revertError instanceof ContractFunctionRevertedError) {
+                    return [];
+                }
+            }
+            // Re-throw non-revert errors (network failures, RPC timeouts, etc.)
+            throw error;
         }
     }
 }

package/dist/index.d.ts

@@ -47,14 +47,16 @@ import { BorrowService } from './services/borrow';
  *              const status = await mento.trading.getPoolTradabilityStatus(pool);
  *
  *              // Add liquidity to a pool
- *              const { approval0, approval1, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction(
- *                poolAddress, amount0, amount1, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
+ *              const { approvalA, approvalB, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction({
+ *                poolAddress, tokenA, amountA, tokenB, amountB, recipient, owner,
+ *                options: { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) },
+ *              });
  *
  *              // Add liquidity using a single token (zap in)
- *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction(
- *                poolAddress, tokenIn, amountIn, 0.5, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
+ *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction({
+ *                poolAddress, tokenIn, amountIn, amountInSplit: 0.5, recipient, owner,
+ *                options: { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) },
+ *              });
  */
 export declare class Mento {
     private chainId;

package/dist/index.js

@@ -66,14 +66,16 @@ const borrow_1 = require("./services/borrow");
  *              const status = await mento.trading.getPoolTradabilityStatus(pool);
  *
  *              // Add liquidity to a pool
- *              const { approval0, approval1, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction(
- *                poolAddress, amount0, amount1, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
+ *              const { approvalA, approvalB, addLiquidity } = await mento.liquidity.buildAddLiquidityTransaction({
+ *                poolAddress, tokenA, amountA, tokenB, amountB, recipient, owner,
+ *                options: { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) },
+ *              });
  *
  *              // Add liquidity using a single token (zap in)
- *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction(
- *                poolAddress, tokenIn, amountIn, 0.5, recipient, owner, { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) }
- *              );
+ *              const { approval, zapIn } = await mento.liquidity.buildZapInTransaction({
+ *                poolAddress, tokenIn, amountIn, amountInSplit: 0.5, recipient, owner,
+ *                options: { slippageTolerance: 0.5, deadline: deadlineFromMinutes(5) },
+ *              });
  */
 class Mento {
     constructor(chainId, tokens, pools, routes, quotes, swap, trading, liquidity, borrow) {

package/dist/services/borrow/index.d.ts

@@ -1,2 +1,4 @@
 export * from './BorrowService';
+export * from './borrowHelpers';
+export * from './borrowMath';
 //# sourceMappingURL=index.d.ts.map

package/dist/services/borrow/index.js

@@ -15,4 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./BorrowService"), exports);
+__exportStar(require("./borrowHelpers"), exports);
+__exportStar(require("./borrowMath"), exports);
 //# sourceMappingURL=index.js.map

package/dist/services/index.d.ts

@@ -4,4 +4,6 @@ export * from './quotes';
 export * from './swap';
 export * from './trading';
 export * from './borrow';
+export * from './tokens';
+export * from './liquidity';
 //# sourceMappingURL=index.d.ts.map

package/dist/services/index.js

@@ -20,4 +20,6 @@ __exportStar(require("./quotes"), exports);
 __exportStar(require("./swap"), exports);
 __exportStar(require("./trading"), exports);
 __exportStar(require("./borrow"), exports);
+__exportStar(require("./tokens"), exports);
+__exportStar(require("./liquidity"), exports);
 //# sourceMappingURL=index.js.map

package/dist/services/liquidity/liquidityHelpers.js

@@ -29,11 +29,13 @@ async function getAllowance(publicClient, token, owner, chainId) {
     }));
 }
 function calculateMinAmount(amount, slippageTolerance) {
+    const MAX_SLIPPAGE_TOLERANCE = 20;
     if (slippageTolerance < 0) {
         throw new Error('Slippage tolerance cannot be negative');
     }
-    if (slippageTolerance > 100) {
-        throw new Error('Slippage tolerance cannot exceed 100%');
+    if (slippageTolerance > MAX_SLIPPAGE_TOLERANCE) {
+        throw new Error(`Slippage tolerance ${slippageTolerance}% exceeds maximum of ${MAX_SLIPPAGE_TOLERANCE}%. ` +
+            'High slippage makes transactions vulnerable to sandwich attacks.');
     }
     const basisPoints = BigInt(Math.floor(slippageTolerance * 100));
     const slippageMultiplier = 10000n - basisPoints;

package/dist/services/pools/poolDetails.js

@@ -41,6 +41,7 @@ async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
         const liquidityStrategy = activeIndex >= 0 ? knownStrategies[activeIndex] : null;
         // Fetch pricing separately — graceful degradation when FX market is closed
         let pricing = null;
+        let pricingUnavailableReason = null;
         let inBand = null;
         try {
             const rebalancingStateResult = await publicClient.readContract({
@@ -62,8 +63,8 @@ async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
             };
             inBand = priceDifference < BigInt(rebalanceThreshold);
         }
-        catch {
-            // getRebalancingState() failed (likely FXMarketClosed) — pricing stays null
+        catch (error) {
+            pricingUnavailableReason = `getRebalancingState() reverted: ${error.message ?? 'unknown error'}`;
         }
         return {
             ...pool,
@@ -74,6 +75,7 @@ async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
             reserve1,
             blockTimestampLast,
             pricing,
+            pricingUnavailableReason,
             fees: {
                 lpFeeBps,
                 lpFeePercent: Number(lpFeeBps) / 100,
@@ -94,7 +96,9 @@ async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
         };
     }
     catch (error) {
-        throw new Error(`Failed to fetch FPMM pool details for ${pool.poolAddr}: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch FPMM pool details for ${pool.poolAddr}: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 /**
@@ -124,7 +128,9 @@ async function fetchVirtualPoolDetails(publicClient, pool) {
         };
     }
     catch (error) {
-        throw new Error(`Failed to fetch Virtual pool details for ${pool.poolAddr}: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch Virtual pool details for ${pool.poolAddr}: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 /**

package/dist/services/pools/poolDiscovery.js

@@ -48,7 +48,9 @@ async function fetchFPMMPools(publicClient, chainId) {
         return await Promise.all(poolDataPromises);
     }
     catch (error) {
-        throw new Error(`Failed to fetch FPMM pools: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch FPMM pools: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 /**
@@ -108,7 +110,9 @@ async function fetchVirtualPools(publicClient, chainId) {
         return await Promise.all(poolPromises);
     }
     catch (error) {
-        throw new Error(`Failed to fetch Virtual pools: ${error.message}`);
+        const wrapped = new Error(`Failed to fetch Virtual pools: ${error.message}`);
+        wrapped.cause = error;
+        throw wrapped;
     }
 }
 //# sourceMappingURL=poolDiscovery.js.map

package/dist/services/swap/SwapService.d.ts

@@ -85,6 +85,7 @@ export declare class SwapService {
      * @param options - Swap configuration options (slippage, deadline)
      * @param route - Optional pre-fetched route for better performance
      * @returns Combined transaction with approval (if needed) and swap params
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
      * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
      * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
      * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
@@ -123,6 +124,7 @@ export declare class SwapService {
      * @param options - Swap configuration options (slippage, deadline)
      * @param route - Optional pre-fetched route for better performance
      * @returns Detailed swap parameters including transaction data
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
      * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
      * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
      * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
@@ -154,6 +156,11 @@ export declare class SwapService {
      * @private
      */
     private getAllowance;
+    /**
+     * Validates that the input amount is strictly positive.
+     * @private
+     */
+    private validateAmountIn;
     /**
      * Calculates minimum output amount after applying slippage tolerance
      * @param amountOut - Expected output amount

package/dist/services/swap/SwapService.js

@@ -30,6 +30,7 @@ class SwapService {
      * @param options - Swap configuration options (slippage, deadline)
      * @param route - Optional pre-fetched route for better performance
      * @returns Combined transaction with approval (if needed) and swap params
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
      * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
      * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
      * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
@@ -57,6 +58,7 @@ class SwapService {
      * ```
      */
     async buildSwapTransaction(tokenIn, tokenOut, amountIn, recipient, owner, options, route) {
+        this.validateAmountIn(amountIn);
         // Validate all address inputs
         (0, validation_1.validateAddress)(tokenIn, 'tokenIn');
         (0, validation_1.validateAddress)(tokenOut, 'tokenOut');
@@ -80,6 +82,7 @@ class SwapService {
      * @param options - Swap configuration options (slippage, deadline)
      * @param route - Optional pre-fetched route for better performance
      * @returns Detailed swap parameters including transaction data
+     * @throws {Error} 'amountIn must be greater than zero' - if amountIn <= 0
      * @throws {Error} 'Slippage tolerance cannot be negative' - if slippageTolerance < 0
      * @throws {Error} 'Slippage tolerance exceeds maximum' - if slippageTolerance > 20%
      * @throws {Error} 'Deadline must be in the future' - if deadline is not a future timestamp
@@ -101,6 +104,7 @@ class SwapService {
      * ```
      */
     async buildSwapParams(tokenIn, tokenOut, amountIn, recipient, options, route) {
+        this.validateAmountIn(amountIn);
         const deadline = options.deadline;
         if (deadline <= BigInt(Date.now()) / 1000n) {
             throw new Error('Deadline must be in the future');
@@ -158,6 +162,15 @@ class SwapService {
             args: [owner, routerAddress],
         }));
     }
+    /**
+     * Validates that the input amount is strictly positive.
+     * @private
+     */
+    validateAmountIn(amountIn) {
+        if (amountIn <= 0n) {
+            throw new Error('amountIn must be greater than zero');
+        }
+    }
     /**
      * Calculates minimum output amount after applying slippage tolerance
      * @param amountOut - Expected output amount

package/dist/services/trading/TradingLimitsService.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradingLimitsService = void 0;
+const viem_1 = require("viem");
 const types_1 = require("../../core/types");
 const abis_1 = require("../../core/abis");
 const constants_1 = require("../../core/constants");
@@ -73,9 +74,16 @@ class TradingLimitsService {
             }
             return (0, tradingLimits_1.calculateTradingLimitsV2)(config, state, token);
         }
-        catch {
-            // Token may not have limits configured, or invalid token
-            return [];
+        catch (error) {
+            // Contract reverts indicate limits aren't configured for this token — return empty
+            if (error instanceof viem_1.BaseError) {
+                const revertError = error.walk((e) => e instanceof viem_1.ContractFunctionRevertedError);
+                if (revertError instanceof viem_1.ContractFunctionRevertedError) {
+                    return [];
+                }
+            }
+            // Re-throw non-revert errors (network failures, RPC timeouts, etc.)
+            throw error;
         }
     }
     /**
@@ -146,9 +154,16 @@ class TradingLimitsService {
             const tokenDecimals = 0; // V1 stores values with 0 decimal precision
             return (0, tradingLimits_1.calculateTradingLimitsV1)(config, state, token, tokenDecimals);
         }
-        catch {
-            // Trading limits may not be configured for this token
-            return [];
+        catch (error) {
+            // Contract reverts indicate limits aren't configured for this token — return empty
+            if (error instanceof viem_1.BaseError) {
+                const revertError = error.walk((e) => e instanceof viem_1.ContractFunctionRevertedError);
+                if (revertError instanceof viem_1.ContractFunctionRevertedError) {
+                    return [];
+                }
+            }
+            // Re-throw non-revert errors (network failures, RPC timeouts, etc.)
+            throw error;
         }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mento-protocol/mento-sdk",
   "description": "Official SDK for interacting with the Mento Protocol",
-  "version": "3.0.0-rc.0",
+  "version": "3.0.0",
   "license": "MIT",
   "author": "Mento Labs",
   "keywords": [

package/dist/core/types/provider.d.ts

@@ -1,45 +0,0 @@
-export interface ContractCallOptions {
-    address: string;
-    abi: string[] | unknown[];
-    functionName: string;
-    args?: unknown[];
-}
-/**
- * Contract write options for building call parameters
- *
- * Configuration for building transaction call parameters for write operations.
- * These parameters can be used by consumers to execute transactions themselves.
- */
-export interface ContractWriteOptions extends ContractCallOptions {
-    /**
-     * Optional gas limit override
-     * If not provided, will be estimated automatically
-     */
-    gasLimit?: bigint;
-    /**
-     * Transaction value in wei
-     * For payable functions only
-     */
-    value?: bigint;
-}
-/**
- * Call parameters for executing a contract transaction
- *
- * Contains all the data needed to execute a contract call.
- * Consumers can use these parameters with their own wallet/signer to execute transactions.
- */
-export interface CallParams {
-    /**
-     * Contract address to call
-     */
-    to: string;
-    /**
-     * Encoded function call data (hex string)
-     */
-    data: string;
-    /**
-     * Transaction value in wei (hex string with 0x prefix)
-     */
-    value: string;
-}
-//# sourceMappingURL=provider.d.ts.map

package/dist/core/types/provider.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=provider.js.map

package/dist/esm/core/types/provider.js

@@ -1 +0,0 @@
-export {};