mantle-agent-kit-sdk 1.0.2 → 1.0.3

package/README.md

@@ -296,6 +296,27 @@ const mainnetAgent = new MNTAgentKit(privateKey, "mainnet");
 const testnetAgent = new MNTAgentKit(privateKey, "testnet");
 ```
 
+### Demo/Simulation Mode
+
+The SDK includes a demo mode for testing and development without executing real blockchain transactions. In demo mode, all operations return simulated responses instead of making actual on-chain calls.
+
+```typescript
+// Initialize agent in demo mode
+const demoAgent = new MNTAgentKit(privateKey, "testnet-demo");
+
+// All operations return mock responses
+const result = await demoAgent.swapOnUniswap(tokenA, tokenB, amount);
+// Returns: { txHash: "0xdemo...", amountOut: "...", demo: true, message: "[DEMO] Uniswap swap simulated" }
+```
+
+Demo mode is useful for:
+- Testing application logic without spending real tokens
+- Development and debugging workflows
+- Integration testing in CI/CD pipelines
+- Demonstrating functionality without wallet funds
+
+All protocol methods (swaps, lending operations, cross-chain transfers) support demo mode and return consistent mock response structures with `demo: true` flag.
+
 ## Contract Addresses
 
 All protocol contract addresses are pre-configured for Mantle Mainnet:

package/dist/index.cjs

@@ -6,6 +6,7 @@ var chains = require('viem/chains');
 var actions = require('viem/actions');
 var axios6 = require('axios');
 var CryptoJS = require('crypto-js');
+var experimental = require('viem/experimental');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -17,11 +18,43 @@ 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: viem.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, viem.parseUnits(amount, decimals)]
+    });
+  } else {
+    hash = await agent.client.sendTransaction({
+      to,
+      value: viem.parseEther(amount)
+    });
+  }
   const receipt = await actions.getTransactionReceipt(agent.client, {
     hash
   });
@@ -195,9 +228,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) {
@@ -331,6 +440,9 @@ 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) {
@@ -387,6 +499,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);
@@ -498,11 +613,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);
@@ -669,11 +790,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);
@@ -772,6 +899,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,
@@ -800,6 +930,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,
@@ -939,6 +1072,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.`
     );
@@ -965,6 +1101,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.`
     );
@@ -986,6 +1125,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.`
     );
@@ -1008,6 +1150,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.`
     );
@@ -1088,6 +1233,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);
@@ -1160,6 +1308,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);
@@ -1192,6 +1343,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);
 };
@@ -1278,21 +1432,21 @@ function getProjectConfig() {
   }
   return cachedConfig;
 }
-
-// src/agent.ts
 var MNTAgentKit = class {
   account;
   client;
   chain;
+  demo;
   projectConfig;
   constructor(privateKey, chain) {
     this.account = accounts.privateKeyToAccount(privateKey);
-    this.chain = chain;
+    this.demo = chain === "testnet-demo";
+    this.chain = chain === "testnet-demo" ? "testnet" : chain;
     this.client = viem.createWalletClient({
-      chain: chain == "mainnet" ? chains.mantle : chains.mantleSepoliaTestnet,
+      chain: this.chain == "mainnet" ? chains.mantle : chains.mantleSepoliaTestnet,
       transport: viem.http(),
       account: this.account
-    }).extend(viem.publicActions);
+    }).extend(viem.publicActions).extend(experimental.erc7811Actions());
   }
   /**
    * Initialize the agent with platform validation
@@ -1327,15 +1481,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) {
@@ -1418,6 +1570,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