mantle-agent-kit-sdk 1.0.1 → 1.0.3

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 import * as viem from 'viem';
 import { WalletClient, Transport, Chain, PublicActions, Address as Address$1, Hex } from 'viem';
 import { PrivateKeyAccount, Address } from 'viem/accounts';
+import { Erc7811Actions } from 'viem/experimental';
 
 interface SquidRoute {
     route: {
@@ -144,10 +145,11 @@ declare function getProjectConfig(): ProjectConfig;
 
 declare class MNTAgentKit {
     account: PrivateKeyAccount;
-    client: WalletClient<Transport, Chain, PrivateKeyAccount> & PublicActions;
+    client: WalletClient<Transport, Chain, PrivateKeyAccount> & PublicActions & Erc7811Actions;
     chain: "testnet" | "mainnet";
+    demo: boolean;
     projectConfig?: ProjectConfig;
-    constructor(privateKey: Address, chain: "mainnet" | "testnet");
+    constructor(privateKey: Address, chain: "mainnet" | "testnet" | "testnet-demo");
     /**
      * Initialize the agent with platform validation
      *
@@ -168,7 +170,7 @@ declare class MNTAgentKit {
     getSwapQuote(fromTokenAddress: string, toTokenAddress: string, amount: string, slippagePercentage?: string): Promise<any>;
     executeSwap(fromTokenAddress: string, toTokenAddress: string, amount: string, slippagePercentage?: string): Promise<{
         data: any;
-    } | undefined>;
+    }>;
     getOpenOceanQuote(fromToken: Address, toToken: Address, amount: string): Promise<OpenOceanQuote>;
     swapOnOpenOcean(fromToken: Address, toToken: Address, amount: string, slippage?: number): Promise<{
         txHash: string;
@@ -191,11 +193,25 @@ declare class MNTAgentKit {
     agniSwap(tokenIn: Address, tokenOut: Address, amountIn: string, slippagePercent?: number, feeTier?: number): Promise<`0x${string}`>;
     merchantMoeSwap(tokenIn: Address, tokenOut: Address, amountIn: string, slippagePercent?: number): Promise<`0x${string}`>;
     getMethTokenAddress(): "0x0000000000000000000000000000000000000000" | "0xcDA86A272531e8640cD7F1a92c01839911B90bb0";
-    getSquidRoute(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<SquidRoute>;
+    getSquidRoute(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<{
+        route: {
+            estimate: {
+                toAmount: string;
+            };
+            transactionRequest: {
+                targetAddress: string;
+                data: string;
+                value: string;
+                gasLimit: string;
+            };
+        };
+        demo: boolean;
+        message: string;
+    } | SquidRoute>;
     crossChainSwapViaSquid(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<`0x${string}`>;
 }
 
-declare const sendTransaction: (agent: MNTAgentKit, to: Address$1, amount: string) => Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
+declare const sendTransaction: (agent: MNTAgentKit, to: Address$1, amount: string, tokenAddress?: Address$1) => Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
 
 /**
  * Check allowance and get approve tx data if needed
@@ -318,7 +334,21 @@ declare function crossChainSwapViaSquid(agent: MNTAgentKit, fromToken: Address$1
  * @param slippage - Slippage tolerance percentage (default: 1%)
  * @returns Route data including estimated output and fees
  */
-declare function getSquidRoute(agent: MNTAgentKit, fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<SquidRoute>;
+declare function getSquidRoute(agent: MNTAgentKit, fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<{
+    route: {
+        estimate: {
+            toAmount: string;
+        };
+        transactionRequest: {
+            targetAddress: string;
+            data: string;
+            value: string;
+            gasLimit: string;
+        };
+    };
+    demo: boolean;
+    message: string;
+} | SquidRoute>;
 
 /**
  * Supply (deposit) tokens to Lendle Protocol

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as viem from 'viem';
 import { WalletClient, Transport, Chain, PublicActions, Address as Address$1, Hex } from 'viem';
 import { PrivateKeyAccount, Address } from 'viem/accounts';
+import { Erc7811Actions } from 'viem/experimental';
 
 interface SquidRoute {
     route: {
@@ -144,10 +145,11 @@ declare function getProjectConfig(): ProjectConfig;
 
 declare class MNTAgentKit {
     account: PrivateKeyAccount;
-    client: WalletClient<Transport, Chain, PrivateKeyAccount> & PublicActions;
+    client: WalletClient<Transport, Chain, PrivateKeyAccount> & PublicActions & Erc7811Actions;
     chain: "testnet" | "mainnet";
+    demo: boolean;
     projectConfig?: ProjectConfig;
-    constructor(privateKey: Address, chain: "mainnet" | "testnet");
+    constructor(privateKey: Address, chain: "mainnet" | "testnet" | "testnet-demo");
     /**
      * Initialize the agent with platform validation
      *
@@ -168,7 +170,7 @@ declare class MNTAgentKit {
     getSwapQuote(fromTokenAddress: string, toTokenAddress: string, amount: string, slippagePercentage?: string): Promise<any>;
     executeSwap(fromTokenAddress: string, toTokenAddress: string, amount: string, slippagePercentage?: string): Promise<{
         data: any;
-    } | undefined>;
+    }>;
     getOpenOceanQuote(fromToken: Address, toToken: Address, amount: string): Promise<OpenOceanQuote>;
     swapOnOpenOcean(fromToken: Address, toToken: Address, amount: string, slippage?: number): Promise<{
         txHash: string;
@@ -191,11 +193,25 @@ declare class MNTAgentKit {
     agniSwap(tokenIn: Address, tokenOut: Address, amountIn: string, slippagePercent?: number, feeTier?: number): Promise<`0x${string}`>;
     merchantMoeSwap(tokenIn: Address, tokenOut: Address, amountIn: string, slippagePercent?: number): Promise<`0x${string}`>;
     getMethTokenAddress(): "0x0000000000000000000000000000000000000000" | "0xcDA86A272531e8640cD7F1a92c01839911B90bb0";
-    getSquidRoute(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<SquidRoute>;
+    getSquidRoute(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<{
+        route: {
+            estimate: {
+                toAmount: string;
+            };
+            transactionRequest: {
+                targetAddress: string;
+                data: string;
+                value: string;
+                gasLimit: string;
+            };
+        };
+        demo: boolean;
+        message: string;
+    } | SquidRoute>;
     crossChainSwapViaSquid(fromToken: Address, toToken: Address, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<`0x${string}`>;
 }
 
-declare const sendTransaction: (agent: MNTAgentKit, to: Address$1, amount: string) => Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
+declare const sendTransaction: (agent: MNTAgentKit, to: Address$1, amount: string, tokenAddress?: Address$1) => Promise<viem.TransactionReceipt<bigint, number, "success" | "reverted", viem.TransactionType>>;
 
 /**
  * Check allowance and get approve tx data if needed
@@ -318,7 +334,21 @@ declare function crossChainSwapViaSquid(agent: MNTAgentKit, fromToken: Address$1
  * @param slippage - Slippage tolerance percentage (default: 1%)
  * @returns Route data including estimated output and fees
  */
-declare function getSquidRoute(agent: MNTAgentKit, fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<SquidRoute>;
+declare function getSquidRoute(agent: MNTAgentKit, fromToken: Address$1, toToken: Address$1, fromChain: number, toChain: number, amount: string, slippage?: number): Promise<{
+    route: {
+        estimate: {
+            toAmount: string;
+        };
+        transactionRequest: {
+            targetAddress: string;
+            data: string;
+            value: string;
+            gasLimit: string;
+        };
+    };
+    demo: boolean;
+    message: string;
+} | SquidRoute>;
 
 /**
  * Supply (deposit) tokens to Lendle Protocol

package/dist/index.js

@@ -1,20 +1,53 @@
-import { parseEther, encodeFunctionData, createWalletClient, http, publicActions, erc20Abi } from 'viem';
+import { parseUnits, parseEther, encodeFunctionData, createWalletClient, http, publicActions, erc20Abi as erc20Abi$1 } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { mantle, mantleSepoliaTestnet } from 'viem/chains';
 import { getTransactionReceipt } from 'viem/actions';
 import axios6 from 'axios';
 import CryptoJS from 'crypto-js';
+import { erc7811Actions } from 'viem/experimental';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var sendTransaction = async (agent, to, amount) => {
-  const hash = await agent.client.sendTransaction({
-    to,
-    value: parseEther(amount)
-  });
+var erc20Abi = [
+  {
+    name: "transfer",
+    type: "function",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  }
+];
+var sendTransaction = async (agent, to, amount, tokenAddress) => {
+  let hash;
+  if (tokenAddress) {
+    const decimals = await agent.client.readContract({
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "decimals"
+    });
+    hash = await agent.client.writeContract({
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [to, parseUnits(amount, decimals)]
+    });
+  } else {
+    hash = await agent.client.sendTransaction({
+      to,
+      value: parseEther(amount)
+    });
+  }
   const receipt = await getTransactionReceipt(agent.client, {
     hash
   });
@@ -24,7 +57,7 @@ async function checkAllowance(agent, tokenAddress, ownerAddress, spenderAddress)
   try {
     const allowance = await agent.client.readContract({
       address: tokenAddress,
-      abi: erc20Abi,
+      abi: erc20Abi$1,
       functionName: "allowance",
       args: [ownerAddress, spenderAddress]
     });
@@ -188,9 +221,85 @@ async function getSwapTransaction(fromTokenAddress, toTokenAddress, amount, user
     throw error;
   }
 }
+var DEMO_TX_HASH = "0xdemo000000000000000000000000000000000000000000000000000000000001";
+function createMockSwapResponse(protocol, inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    amountOut: inputAmount,
+    demo: true,
+    message: `[DEMO] ${protocol} swap simulated`
+  };
+}
+function createMockQuoteResponse(protocol, inputAmount) {
+  return {
+    estimatedAmount: inputAmount,
+    demo: true,
+    message: `[DEMO] ${protocol} quote simulated`
+  };
+}
+function createMockLendleResponse(action, amount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    amount,
+    demo: true,
+    message: `[DEMO] Lendle ${action} simulated`
+  };
+}
+function createMockTxHash() {
+  return DEMO_TX_HASH;
+}
+function createMock1inchSwapResponse(inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    dstAmount: inputAmount,
+    demo: true,
+    message: "[DEMO] 1inch swap simulated"
+  };
+}
+function createMockOkxSwapResponse(inputAmount) {
+  return {
+    data: DEMO_TX_HASH,
+    demo: true,
+    message: "[DEMO] OKX swap simulated"
+  };
+}
+function createMockOpenOceanSwapResponse(inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    outAmount: inputAmount,
+    demo: true,
+    message: "[DEMO] OpenOcean swap simulated"
+  };
+}
+function createMockUniswapSwapResponse(inputAmount) {
+  return {
+    txHash: DEMO_TX_HASH,
+    amountOut: inputAmount,
+    demo: true,
+    message: "[DEMO] Uniswap swap simulated"
+  };
+}
+function createMockSquidRoute(amount) {
+  return {
+    route: {
+      estimate: { toAmount: amount },
+      transactionRequest: {
+        targetAddress: "0x0000000000000000000000000000000000000000",
+        data: "0x",
+        value: "0",
+        gasLimit: "0"
+      }
+    },
+    demo: true,
+    message: "[DEMO] Squid route simulated"
+  };
+}
 
 // src/tools/okx/swap.ts
 async function executeSwap(agent, fromTokenAddress, toTokenAddress, amount, slippagePercent) {
+  if (agent.demo) {
+    return createMockOkxSwapResponse();
+  }
   const chainIndex = agent.chain === "mainnet" ? "5000" : "5003";
   const walletAddress = agent.account.address;
   if (fromTokenAddress !== ETH_ADDRESS) {
@@ -324,13 +433,16 @@ async function getSwapData(fromToken, toToken, amount, userAddress, slippage, ch
 
 // src/tools/openocean/getQuote.ts
 async function getOpenOceanQuote(agent, fromToken, toToken, amount) {
+  if (agent.demo) {
+    return createMockQuoteResponse("OpenOcean", amount);
+  }
   return await getQuoteData(fromToken, toToken, amount, agent.chain);
 }
 async function checkAllowance2(agent, tokenAddress, ownerAddress, spenderAddress) {
   try {
     const allowance = await agent.client.readContract({
       address: tokenAddress,
-      abi: erc20Abi,
+      abi: erc20Abi$1,
       functionName: "allowance",
       args: [ownerAddress, spenderAddress]
     });
@@ -355,7 +467,7 @@ async function approveToken2(agent, tokenAddress, spenderAddress, amount) {
   console.log("Insufficient allowance, approving tokens...");
   const { encodeFunctionData: encodeFunctionData8 } = await import('viem');
   const approveData = encodeFunctionData8({
-    abi: erc20Abi,
+    abi: erc20Abi$1,
     functionName: "approve",
     args: [spenderAddress, BigInt(amount)]
   });
@@ -380,6 +492,9 @@ async function approveToken2(agent, tokenAddress, spenderAddress, amount) {
 
 // src/tools/openocean/swap.ts
 async function swapOnOpenOcean(agent, fromToken, toToken, amount, slippage = "1") {
+  if (agent.demo) {
+    return createMockOpenOceanSwapResponse(amount);
+  }
   const walletAddress = agent.account.address;
   if (fromToken.toLowerCase() !== NATIVE_TOKEN_ADDRESS.toLowerCase()) {
     await approveToken2(agent, fromToken, OPENOCEAN_EXCHANGE_PROXY, amount);
@@ -491,11 +606,17 @@ async function getSwapData2(fromToken, toToken, amount, userAddress, slippage, c
 
 // src/tools/oneinch/getQuote.ts
 async function get1inchQuote(agent, fromToken, toToken, amount) {
+  if (agent.demo) {
+    return createMockQuoteResponse("1inch", amount);
+  }
   return await getQuoteData2(fromToken, toToken, amount, agent.chain);
 }
 
 // src/tools/oneinch/swap.ts
 async function swapOn1inch(agent, fromToken, toToken, amount, slippage = "1") {
+  if (agent.demo) {
+    return createMock1inchSwapResponse(amount);
+  }
   const walletAddress = agent.account.address;
   if (fromToken.toLowerCase() !== NATIVE_TOKEN_ADDRESS2.toLowerCase()) {
     await approveToken2(agent, fromToken, ONEINCH_ROUTER_ADDRESS, amount);
@@ -662,11 +783,17 @@ function buildSwapCalldata(params, fee = DEFAULT_POOL_FEE) {
 
 // src/tools/uniswap/getQuote.ts
 async function getUniswapQuote(agent, fromToken, toToken, amount, fee = DEFAULT_POOL_FEE) {
+  if (agent.demo) {
+    return createMockQuoteResponse("Uniswap", amount);
+  }
   return await getUniswapQuoteData(agent, fromToken, toToken, amount, fee);
 }
 
 // src/tools/uniswap/swap.ts
 async function swapOnUniswap(agent, fromToken, toToken, amount, slippage = "0.5", fee = DEFAULT_POOL_FEE) {
+  if (agent.demo) {
+    return createMockUniswapSwapResponse(amount);
+  }
   const walletAddress = agent.account.address;
   const isNativeIn = fromToken.toLowerCase() === NATIVE_TOKEN_ADDRESS3.toLowerCase();
   const quote = await getUniswapQuoteData(agent, fromToken, toToken, amount, fee);
@@ -765,6 +892,9 @@ async function getRouteData(fromToken, toToken, fromChain, toChain, amount, from
 
 // src/tools/squid/crossChainSwap.ts
 async function crossChainSwapViaSquid(agent, fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+  if (agent.demo) {
+    return createMockTxHash();
+  }
   const routeData = await getRouteData(
     fromToken,
     toToken,
@@ -793,6 +923,9 @@ async function crossChainSwapViaSquid(agent, fromToken, toToken, fromChain, toCh
   return hash;
 }
 async function getSquidRoute(agent, fromToken, toToken, fromChain, toChain, amount, slippage = 1) {
+  if (agent.demo) {
+    return createMockSquidRoute(amount);
+  }
   return await getRouteData(
     fromToken,
     toToken,
@@ -932,6 +1065,9 @@ var LENDING_POOL_ABI = [
 async function lendleSupply(agent, tokenAddress, amount) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("supply", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -958,6 +1094,9 @@ async function lendleSupply(agent, tokenAddress, amount) {
 async function lendleWithdraw(agent, tokenAddress, amount, to) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("withdraw", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -979,6 +1118,9 @@ async function lendleWithdraw(agent, tokenAddress, amount, to) {
 async function lendleBorrow(agent, tokenAddress, amount, interestRateMode = INTEREST_RATE_MODE.VARIABLE, onBehalfOf) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("borrow", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -1001,6 +1143,9 @@ async function lendleBorrow(agent, tokenAddress, amount, interestRateMode = INTE
 async function lendleRepay(agent, tokenAddress, amount, rateMode = INTEREST_RATE_MODE.VARIABLE, onBehalfOf) {
   const lendingPoolAddress = LENDING_POOL[agent.chain];
   if (lendingPoolAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockLendleResponse("repay", amount).txHash;
+    }
     throw new Error(
       `Lendle LendingPool not configured for ${agent.chain}. Only available on mainnet.`
     );
@@ -1081,6 +1226,9 @@ var FEE_TIERS2 = {
 async function agniSwap(agent, tokenIn, tokenOut, amountIn, slippagePercent = 0.5, feeTier = FEE_TIERS2.MEDIUM) {
   const swapRouterAddress = SWAP_ROUTER[agent.chain];
   if (swapRouterAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockSwapResponse("Agni", amountIn).txHash;
+    }
     throw new Error(`Agni SwapRouter not available on ${agent.chain}`);
   }
   const amountInBigInt = BigInt(amountIn);
@@ -1153,6 +1301,9 @@ var LB_ROUTER_ABI = [
 async function merchantMoeSwap(agent, tokenIn, tokenOut, amountIn, slippagePercent = 0.5) {
   const routerAddress = LB_ROUTER[agent.chain];
   if (routerAddress === "0x0000000000000000000000000000000000000000") {
+    if (agent.demo) {
+      return createMockSwapResponse("MerchantMoe", amountIn).txHash;
+    }
     throw new Error(`Merchant Moe LB Router not available on ${agent.chain}`);
   }
   const amountInBigInt = BigInt(amountIn);
@@ -1185,6 +1336,9 @@ var METH_TOKEN = {
 
 // src/tools/okx/getSwapQuote.ts
 var getSwapQuote = async (agent, from, to, amount, slippagePercentage) => {
+  if (agent.demo) {
+    return createMockQuoteResponse("OKX", amount);
+  }
   const chainIndex = agent.chain === "mainnet" ? "5000" : "5003";
   return getSwapTransaction(from, to, amount, chainIndex, slippagePercentage);
 };
@@ -1271,21 +1425,21 @@ function getProjectConfig() {
   }
   return cachedConfig;
 }
-
-// src/agent.ts
 var MNTAgentKit = class {
   account;
   client;
   chain;
+  demo;
   projectConfig;
   constructor(privateKey, chain) {
     this.account = privateKeyToAccount(privateKey);
-    this.chain = chain;
+    this.demo = chain === "testnet-demo";
+    this.chain = chain === "testnet-demo" ? "testnet" : chain;
     this.client = createWalletClient({
-      chain: chain == "mainnet" ? mantle : mantleSepoliaTestnet,
+      chain: this.chain == "mainnet" ? mantle : mantleSepoliaTestnet,
       transport: http(),
       account: this.account
-    }).extend(publicActions);
+    }).extend(publicActions).extend(erc7811Actions());
   }
   /**
    * Initialize the agent with platform validation
@@ -1320,15 +1474,13 @@ var MNTAgentKit = class {
     );
   }
   async executeSwap(fromTokenAddress, toTokenAddress, amount, slippagePercentage = "0.5") {
-    if (this.chain === "mainnet") {
-      return await executeSwap(
-        this,
-        fromTokenAddress,
-        toTokenAddress,
-        amount,
-        slippagePercentage
-      );
-    }
+    return await executeSwap(
+      this,
+      fromTokenAddress,
+      toTokenAddress,
+      amount,
+      slippagePercentage
+    );
   }
   // OpenOcean DEX Aggregator
   async getOpenOceanQuote(fromToken, toToken, amount) {
@@ -1411,6 +1563,9 @@ var MNTAgentKit = class {
   }
   // mETH Protocol - Liquid Staking Token
   getMethTokenAddress() {
+    if (this.demo) {
+      return METH_TOKEN.mainnet;
+    }
     return METH_TOKEN[this.chain];
   }
   // Squid Router Cross-chain