@t2000/sdk 10.3.1 → 10.6.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { normalizeStructTag, isValidSuiAddress, normalizeSuiAddress, fromBase64 } from '@mysten/sui/utils';
+import { normalizeSuiAddress, normalizeStructTag, isValidSuiAddress, fromBase64 } from '@mysten/sui/utils';
 import { coinWithBalance, Transaction } from '@mysten/sui/transactions';
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
 import BN from 'bn.js';
@@ -17,6 +17,7 @@ import { sha256 } from '@noble/hashes/sha256';
 import { hexToBytes, bytesToHex } from '@noble/hashes/utils';
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { SuinsTransaction } from '@mysten/suins';
+import { bcs } from '@mysten/sui/bcs';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -3882,6 +3883,340 @@ function displayHandle(label, parentName = AUDRIC_PARENT_NAME) {
 // src/index.ts
 init_preflight();
 
-export { A2A_ESCROW_FEE_CONFIG_ID, A2A_ESCROW_PACKAGE_ID, AGENT_ID_PARENT, AGENT_ID_PARENT_NAME, AGENT_ID_PARENT_NFT_ID, AUDRIC_PARENT, AUDRIC_PARENT_NAME, AUDRIC_PARENT_NFT_ID, CETUS_USDC_SUI_POOL, CLOCK_ID, COIN_REGISTRY, DEFAULT_API_BASE, DEFAULT_COMMERCE_API_BASE, DEFAULT_GRPC_URL, DEFAULT_NETWORK, ETH_TYPE, GASLESS_MIN_STABLE_AMOUNT, GASLESS_STABLE_TYPES, GAS_RESERVE_MIN, IKA_TYPE, InvalidAddressError, JOB_STATES, KNOWN_TARGETS, KeypairSigner, LABEL_PATTERNS, LOFI_TYPE, LimitEnforcer, LimitExceededError, MANIFEST_TYPE, MAX_DELIVER_HORIZON_MS, MAX_JOB_USDC, MAX_REVIEW_WINDOW_MS, MIST_PER_SUI, NAVX_TYPE, OPERATION_ASSETS, OVERLAY_FEE_RATE, PREFLIGHT_MAX_AMOUNT, PREFLIGHT_OK, SENDABLE_ASSETS, SPONSORED_PYTH_DEPENDENT_PROVIDERS, STABLE_ASSETS, SUINS_NAME_REGEX, SUI_ADDRESS_REGEX, SUI_ADDRESS_STRICT_REGEX, SUI_DECIMALS, SUI_TYPE, SUPPORTED_ASSETS, SuinsNotRegisteredError, SuinsRpcError, T2000, T2000Error, T2000_OVERLAY_FEE_WALLET, TOKEN_MAP, USDC_DECIMALS, USDC_TYPE, USDE_TYPE, USDSUI_TYPE, USDT_TYPE, WAL_TYPE, WBTC_TYPE, WRITE_APPENDER_REGISTRY, ZkLoginSigner, addSendToTx, addSwapToTx, approxUsdValue, assertAllowedAsset, assertLimitConfig, buildAddLeafTx, buildCreateJobTx, buildDeliverJobTx, buildRefundJobTx, buildRejectJobTx, buildReleaseJobTx, buildRevokeLeafTx, buildSendTx, buildSwapTx, chatCompletion, chatCompletionStream, checkPositiveAmount, checkSuiAddress, classifyAction, classifyLabel, classifyTransaction, clearLimits, composeTx, dailySpentToday, deriveAllowedAddressesFromPtb, deserializeCetusRoute, displayHandle, executeTx, exportPrivateKey, extractAllUserLegs, extractTransferDetails, extractTxCommands, extractTxSender, fallbackLabel, fetchAllCoins, fetchService, findSwapRoute, formatAssetAmount, formatSui, formatUsd, fullHandle, generateKeypair, getAddress, getCoinMeta, getDecimals, getDecimalsForCoinType, getJob, getJobSpec, getLimits, getSponsoredSwapProviders, getSuiClient, getSuiGrpcClient, getSwapQuote, hasLimits, isAllowedAsset, isCetusRouteFresh, isInRegistry, jobActionsFor, keypairFromPrivateKey, listModels, listServices, loadKey, looksLikeSuiNs, mapMoveAbortCode, mapWalletError, mistToSui, normalizeAddressInput, normalizeAsset, normalizeCoinType, parseMppSuiChallenge, parseSuiRpcTx, payWithMpp, preflightCreateJob, preflightFail, preflightPay, preflightSend, preflightSwap, putJobSpec, queryBalance, queryHistory, queryTransaction, rawToStable, rawToUsdc, readLimitsFile, recordDailySpend, refineLendingLabel, resolveAddressToSuinsViaRpc, resolveSuinsViaRpc, resolveSymbol, resolveTokenType, saveBech32, saveKey, selectAndSplitCoin, selectSuiCoin, serializeCetusRoute, setLimits, simulateTransaction, stableToRaw, suiToMist, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, validateLabel, verifyCetusRouteCoinMatch, verifyJobForSeller, verifyReceipt, walletExists, writeLimitsFile };
+// src/capital/launch.ts
+init_errors();
+init_token_registry();
+init_coinSelection();
+
+// src/protocols/cetus-clmm.ts
+var CETUS_CLMM_PACKAGE_ID = process.env.CETUS_CLMM_PACKAGE_ID ?? "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb";
+var CETUS_CLMM_PUBLISHED_AT = process.env.CETUS_CLMM_PUBLISHED_AT ?? "0x25ebb9a7c50eb17b3fa9c5a30fb8b5ad8f97caaf4928943acbcff7153dfee5e3";
+var CETUS_GLOBAL_CONFIG_ID = process.env.CETUS_GLOBAL_CONFIG_ID ?? "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f";
+var CETUS_POOLS_ID = process.env.CETUS_POOLS_ID ?? "0xf699e7f2276f5c9a75944b37a0c5b5d9ddfd2471bf6242483b03ab2887d198d0";
+var CETUS_POSITION_TYPE = `${CETUS_CLMM_PACKAGE_ID}::position::Position`;
+var AGENT_POOL_TICK_SPACING = 200;
+function sqrtPriceX64FromAmounts(rawA, rawB) {
+  if (rawA <= 0n || rawB <= 0n) {
+    throw new Error("sqrtPriceX64FromAmounts: amounts must be positive");
+  }
+  return bigintSqrt((rawB << 128n) / rawA);
+}
+function bigintSqrt(n) {
+  if (n < 0n) throw new Error("bigintSqrt: negative input");
+  if (n < 2n) return n;
+  let x = 1n << BigInt(n.toString(2).length + 1) / 2n;
+  let prev = x + 1n;
+  while (x < prev) {
+    prev = x;
+    x = (x + n / x) / 2n;
+  }
+  return prev;
+}
+function createPoolV2(tx, args) {
+  const [tickLower, tickUpper] = fullRangeTickRange(tx);
+  return tx.moveCall({
+    target: `${CETUS_CLMM_PUBLISHED_AT}::pool_creator::create_pool_v2`,
+    typeArguments: [args.coinTypeA, args.coinTypeB],
+    arguments: [
+      tx.object(CETUS_GLOBAL_CONFIG_ID),
+      tx.object(CETUS_POOLS_ID),
+      tx.pure.u32(AGENT_POOL_TICK_SPACING),
+      tx.pure.u128(args.sqrtPriceX64),
+      tx.pure.string(args.url ?? ""),
+      tickLower,
+      tickUpper,
+      args.coinA,
+      args.coinB,
+      tx.object(args.metadataA),
+      tx.object(args.metadataB),
+      tx.pure.bool(args.fixAmountA),
+      tx.object.clock()
+    ]
+  });
+}
+function fullRangeTickRange(tx) {
+  const result = tx.moveCall({
+    target: `${CETUS_CLMM_PUBLISHED_AT}::pool_creator::full_range_tick_range`,
+    arguments: [tx.pure.u32(AGENT_POOL_TICK_SPACING)]
+  });
+  return [result[0], result[1]];
+}
+function positionPoolId(tx, position) {
+  return tx.moveCall({
+    target: `${CETUS_CLMM_PUBLISHED_AT}::position::pool_id`,
+    arguments: [position]
+  });
+}
+
+// src/capital/template.ts
+init_errors();
+
+// src/capital/template-bytecode.json
+var template_bytecode_default = {
+  modules: [
+    "oRzrCwcAAAUKAQAMAgwkAzAoBFgMBWRoB8wBzwEImwNgBvsDiQEKhAUFDIkFNAARAQ0CBwISAhMCFAADAgABAgcBAAACAAwBAAECAQwBAAECBAwBAAEEBQIABQYHAAAKAAEAARAFBgEAAggICQECAgsKCwEAAw4FAQEMAw8NAQEMBQwDBAABBAIHAwcFDAQOBA8CCAAHCAUAAgsDAQgACwQBCAABCgIBCAYBCQABCwEBCQABCAAHCQACCgIKAgoCCwEBCAYHCAUCCwQBCQALAwEJAAMHCwQBCQADBwgFAQsCAQkAAQsCAQgAAgkABQELAwEIAAELBAEIAARDb2luDENvaW5NZXRhZGF0YQZPcHRpb24IVEVNUExBVEULVHJlYXN1cnlDYXAJVHhDb250ZXh0A1VybARjb2luD2NyZWF0ZV9jdXJyZW5jeQtkdW1teV9maWVsZARpbml0BG1pbnQVbmV3X3Vuc2FmZV9mcm9tX2J5dGVzBm9wdGlvbhRwdWJsaWNfZnJlZXplX29iamVjdA9wdWJsaWNfdHJhbnNmZXIEc29tZQh0ZW1wbGF0ZQh0cmFuc2Zlcgp0eF9jb250ZXh0A3VybAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIBBgoCBQRUTVBMCgIODVRlbXBsYXRlIENvaW4KAh4dYnl0ZWNvZGUgdGVtcGxhdGUgcGxhY2Vob2xkZXIKAh0caHR0cHM6Ly9leGFtcGxlLmNvbS9pY29uLnN2ZwMIAIDGpH6NAwAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMr+AAIBCQEAAAAAAhcLAAcABwEHAgcDBwQRBjgACgE4AQwCDAMNAwcFCwE4AgcGOAMLAjgECwM4BQIAAA=="
+  ],
+  dependencies: [
+    "0x0000000000000000000000000000000000000000000000000000000000000001",
+    "0x0000000000000000000000000000000000000000000000000000000000000002"
+  ]};
+
+// src/capital/template.ts
+var TEMPLATE = {
+  module: "template",
+  otw: "TEMPLATE",
+  symbol: "TMPL",
+  name: "Template Coin",
+  description: "bytecode template placeholder",
+  iconUrl: "https://example.com/icon.svg",
+  totalSupply: 1000000000000000n,
+  recipient: normalizeSuiAddress("0xCAFE")
+};
+var AGENT_TOKEN_DECIMALS = 6;
+var AGENT_TOKEN_TOTAL_SUPPLY = 1000000000000000n;
+var AGENT_TOKEN_LP_ALLOCATION = AGENT_TOKEN_TOTAL_SUPPLY / 2n;
+var AGENT_TOKEN_TREASURY_ALLOCATION = AGENT_TOKEN_TOTAL_SUPPLY - AGENT_TOKEN_LP_ALLOCATION;
+var SYMBOL_BLOCKLIST = /* @__PURE__ */ new Set([
+  "SUI",
+  "USDC",
+  "USDT",
+  "USDSUI",
+  "WAL",
+  "CETUS",
+  "DEEP",
+  "NS",
+  "NAVX",
+  "SCA",
+  "AFSUI",
+  "HASUI",
+  "VSUI",
+  "BUCK",
+  "FUD",
+  "BLUB",
+  "HIPPO",
+  "BTC",
+  "WBTC",
+  "ETH",
+  "WETH",
+  "SOL",
+  "BNB",
+  "XRP",
+  "ADA",
+  "DOGE",
+  "AVAX",
+  "LINK",
+  "TRX",
+  "TON",
+  "SHIB",
+  "PEPE",
+  "USDE",
+  "DAI",
+  "GOLD",
+  "XAUM",
+  "T2000",
+  "T2K",
+  "AUDRIC"
+]);
+var SYMBOL_RE = /^[A-Z][A-Z0-9]{1,7}$/;
+function validateAgentCoinParams(params) {
+  const symbol = params.symbol.toUpperCase();
+  if (!SYMBOL_RE.test(symbol)) {
+    throw new T2000Error(
+      "INVALID_INPUT",
+      `symbol must be 2-8 chars, A-Z then A-Z0-9 (got "${params.symbol}")`
+    );
+  }
+  if (SYMBOL_BLOCKLIST.has(symbol)) {
+    throw new T2000Error(
+      "INVALID_INPUT",
+      `symbol ${symbol} impersonates an existing ticker`
+    );
+  }
+  if (!params.name.trim() || params.name.length > 64) {
+    throw new T2000Error("INVALID_INPUT", "name must be 1-64 chars");
+  }
+  if (params.description.length > 256) {
+    throw new T2000Error("INVALID_INPUT", "description must be \u2264256 chars");
+  }
+  if (!/^https:\/\/.+/.test(params.iconUrl) || params.iconUrl.length > 256) {
+    throw new T2000Error("INVALID_INPUT", "iconUrl must be https and \u2264256 chars");
+  }
+  if (!isValidSuiAddress(params.recipient)) {
+    throw new T2000Error("INVALID_ADDRESS", `bad recipient: ${params.recipient}`);
+  }
+}
+async function buildAgentCoinModule(params) {
+  const { deserialize, serialize, update_constants, update_identifiers } = await import('@mysten/move-bytecode-template');
+  validateAgentCoinParams(params);
+  const symbol = params.symbol.toUpperCase();
+  const moduleName = symbol.toLowerCase();
+  const recipient = normalizeSuiAddress(params.recipient);
+  let bytes = Uint8Array.from(
+    Buffer.from(template_bytecode_default.modules[0], "base64")
+  );
+  deserialize(bytes);
+  bytes = update_identifiers(bytes, {
+    [TEMPLATE.module]: moduleName,
+    [TEMPLATE.otw]: symbol
+  });
+  const str = (s) => bcs.string().serialize(s).toBytes();
+  const rewrites = [
+    [str(symbol), str(TEMPLATE.symbol), "Vector(U8)"],
+    [str(params.name), str(TEMPLATE.name), "Vector(U8)"],
+    [str(params.description), str(TEMPLATE.description), "Vector(U8)"],
+    [str(params.iconUrl), str(TEMPLATE.iconUrl), "Vector(U8)"],
+    [
+      bcs.Address.serialize(recipient).toBytes(),
+      bcs.Address.serialize(TEMPLATE.recipient).toBytes(),
+      "Address"
+    ],
+    // Supply + decimals are LOCKED v1 constants — not caller-parameterized —
+    // but rewritten anyway so a drifted template recompile can't silently
+    // change the economics out from under this module's exported constants.
+    [
+      bcs.u64().serialize(AGENT_TOKEN_TOTAL_SUPPLY).toBytes(),
+      bcs.u64().serialize(TEMPLATE.totalSupply).toBytes(),
+      "U64"
+    ]
+  ];
+  for (const [next, prev, type] of rewrites) {
+    bytes = update_constants(bytes, next, prev, type);
+  }
+  serialize(deserialize(bytes));
+  return {
+    modules: [Array.from(bytes)],
+    dependencies: template_bytecode_default.dependencies,
+    moduleName,
+    otw: symbol
+  };
+}
+
+// src/capital/launch.ts
+var AGENT_CAPITAL_PACKAGE_ID = process.env.AGENT_CAPITAL_PACKAGE_ID ?? "0x33a04c672381c1de7178f56221e4ebfc4712675feecc2a0b70c25efbb500fc25";
+var CAPITAL_REGISTRY_ID = process.env.CAPITAL_REGISTRY_ID ?? "0xd75a72e80c1a5181cc9bb095089cc236e3e20be11b5982ab21e76c54508bd2d7";
+var CAPITAL_REGISTRY_VERSION = Number(
+  process.env.CAPITAL_REGISTRY_VERSION ?? 951301211
+);
+function assertDeployed() {
+  if (!AGENT_CAPITAL_PACKAGE_ID || !CAPITAL_REGISTRY_ID) {
+    throw new T2000Error(
+      "PROTOCOL_UNAVAILABLE",
+      "agent_capital is not deployed on this network (set AGENT_CAPITAL_PACKAGE_ID + CAPITAL_REGISTRY_ID)"
+    );
+  }
+}
+var MIN_LP_USDC = 5000000n;
+var REGISTRY_MODULE = "registry";
+var LP_LOCK_MODULE = "lp_lock";
+async function buildPublishAgentCoinTx(args) {
+  if (!isValidSuiAddress(args.launcher)) {
+    throw new T2000Error("INVALID_ADDRESS", `bad launcher: ${args.launcher}`);
+  }
+  if (args.coin.recipient !== args.launcher) {
+    throw new T2000Error(
+      "INVALID_INPUT",
+      "coin.recipient must equal launcher \u2014 the full supply lands with the launch signer, never a third party"
+    );
+  }
+  const mod = await buildAgentCoinModule(args.coin);
+  const tx = new Transaction();
+  tx.setSender(args.launcher);
+  const [upgradeCap] = tx.publish({
+    modules: mod.modules,
+    dependencies: mod.dependencies
+  });
+  tx.moveCall({
+    target: "0x2::package::make_immutable",
+    arguments: [upgradeCap]
+  });
+  return { tx, moduleName: mod.moduleName, otw: mod.otw };
+}
+var USDC_COIN_METADATA_ID = "0x75cfbbf8c962d542e99a1d15731e6069f60a00db895407785b15d14f606f2b4a";
+async function buildTokenizeTx(args) {
+  assertDeployed();
+  if (!isValidSuiAddress(args.agent)) {
+    throw new T2000Error("INVALID_ADDRESS", `bad agent: ${args.agent}`);
+  }
+  if (!isValidSuiAddress(args.launcher)) {
+    throw new T2000Error("INVALID_ADDRESS", `bad launcher: ${args.launcher}`);
+  }
+  if (args.lpUsdcAmount < MIN_LP_USDC) {
+    throw new T2000Error(
+      "INVALID_AMOUNT",
+      `lpUsdcAmount ${args.lpUsdcAmount} < minimum ${MIN_LP_USDC} raw (5 USDC)`
+    );
+  }
+  const tx = new Transaction();
+  tx.setSender(args.launcher);
+  const registryArg = () => tx.sharedObjectRef({
+    objectId: CAPITAL_REGISTRY_ID,
+    initialSharedVersion: CAPITAL_REGISTRY_VERSION,
+    mutable: true
+  });
+  tx.moveCall({
+    target: `${AGENT_CAPITAL_PACKAGE_ID}::${REGISTRY_MODULE}::bind`,
+    typeArguments: [args.coinType],
+    arguments: [
+      registryArg(),
+      tx.object(args.agentRegistryId),
+      tx.pure.address(args.agent),
+      tx.object.clock()
+    ]
+  });
+  const supplyCoin = tx.object(args.supplyCoinId);
+  const [lpCoin] = tx.splitCoins(supplyCoin, [
+    tx.pure.u64(AGENT_TOKEN_LP_ALLOCATION)
+  ]);
+  const { coin: lpUsdc } = await selectAndSplitCoin(
+    tx,
+    args.client,
+    args.launcher,
+    USDC_TYPE,
+    args.lpUsdcAmount
+  );
+  const usdcFirst = args.usdcFirst ?? false;
+  const sqrtPrice = usdcFirst ? sqrtPriceX64FromAmounts(args.lpUsdcAmount, AGENT_TOKEN_LP_ALLOCATION) : sqrtPriceX64FromAmounts(AGENT_TOKEN_LP_ALLOCATION, args.lpUsdcAmount);
+  const usdcMeta = args.usdcMetadataId ?? USDC_COIN_METADATA_ID;
+  const poolResult = createPoolV2(tx, {
+    coinTypeA: usdcFirst ? USDC_TYPE : args.coinType,
+    coinTypeB: usdcFirst ? args.coinType : USDC_TYPE,
+    metadataA: usdcFirst ? usdcMeta : args.coinMetadataId,
+    metadataB: usdcFirst ? args.coinMetadataId : usdcMeta,
+    coinA: usdcFirst ? lpUsdc : lpCoin,
+    coinB: usdcFirst ? lpCoin : lpUsdc,
+    sqrtPriceX64: sqrtPrice,
+    fixAmountA: !usdcFirst,
+    // always fix the AGENT side
+    url: args.poolUrl
+  });
+  const position = poolResult[0];
+  const refundA = poolResult[1];
+  const refundB = poolResult[2];
+  const poolId = positionPoolId(tx, position);
+  const [lockId] = tx.moveCall({
+    target: `${AGENT_CAPITAL_PACKAGE_ID}::${LP_LOCK_MODULE}::lock`,
+    typeArguments: [CETUS_POSITION_TYPE],
+    arguments: [position, tx.pure.address(args.agent), tx.object.clock()]
+  });
+  tx.moveCall({
+    target: `${AGENT_CAPITAL_PACKAGE_ID}::${REGISTRY_MODULE}::finalize`,
+    typeArguments: [args.coinType],
+    arguments: [
+      registryArg(),
+      tx.object(args.agentRegistryId),
+      tx.pure.address(args.agent),
+      poolId,
+      lockId,
+      tx.object.clock()
+    ]
+  });
+  const agentRefund = usdcFirst ? refundB : refundA;
+  const usdcRefund = usdcFirst ? refundA : refundB;
+  tx.transferObjects([supplyCoin, agentRefund], tx.pure.address(args.agent));
+  tx.transferObjects([usdcRefund], tx.pure.address(args.launcher));
+  return tx;
+}
+
+export { A2A_ESCROW_FEE_CONFIG_ID, A2A_ESCROW_PACKAGE_ID, AGENT_CAPITAL_PACKAGE_ID, AGENT_ID_PARENT, AGENT_ID_PARENT_NAME, AGENT_ID_PARENT_NFT_ID, AGENT_POOL_TICK_SPACING, AGENT_TOKEN_DECIMALS, AGENT_TOKEN_LP_ALLOCATION, AGENT_TOKEN_TOTAL_SUPPLY, AGENT_TOKEN_TREASURY_ALLOCATION, AUDRIC_PARENT, AUDRIC_PARENT_NAME, AUDRIC_PARENT_NFT_ID, CAPITAL_REGISTRY_ID, CAPITAL_REGISTRY_VERSION, CETUS_CLMM_PACKAGE_ID, CETUS_GLOBAL_CONFIG_ID, CETUS_POOLS_ID, CETUS_POSITION_TYPE, CETUS_USDC_SUI_POOL, CLOCK_ID, COIN_REGISTRY, DEFAULT_API_BASE, DEFAULT_COMMERCE_API_BASE, DEFAULT_GRPC_URL, DEFAULT_NETWORK, ETH_TYPE, GASLESS_MIN_STABLE_AMOUNT, GASLESS_STABLE_TYPES, GAS_RESERVE_MIN, IKA_TYPE, InvalidAddressError, JOB_STATES, KNOWN_TARGETS, KeypairSigner, LABEL_PATTERNS, LOFI_TYPE, LimitEnforcer, LimitExceededError, MANIFEST_TYPE, MAX_DELIVER_HORIZON_MS, MAX_JOB_USDC, MAX_REVIEW_WINDOW_MS, MIN_LP_USDC, MIST_PER_SUI, NAVX_TYPE, OPERATION_ASSETS, OVERLAY_FEE_RATE, PREFLIGHT_MAX_AMOUNT, PREFLIGHT_OK, SENDABLE_ASSETS, SPONSORED_PYTH_DEPENDENT_PROVIDERS, STABLE_ASSETS, SUINS_NAME_REGEX, SUI_ADDRESS_REGEX, SUI_ADDRESS_STRICT_REGEX, SUI_DECIMALS, SUI_TYPE, SUPPORTED_ASSETS, SYMBOL_BLOCKLIST, SuinsNotRegisteredError, SuinsRpcError, T2000, T2000Error, T2000_OVERLAY_FEE_WALLET, TOKEN_MAP, USDC_COIN_METADATA_ID, USDC_DECIMALS, USDC_TYPE, USDE_TYPE, USDSUI_TYPE, USDT_TYPE, WAL_TYPE, WBTC_TYPE, WRITE_APPENDER_REGISTRY, ZkLoginSigner, addSendToTx, addSwapToTx, approxUsdValue, assertAllowedAsset, assertLimitConfig, buildAddLeafTx, buildAgentCoinModule, buildCreateJobTx, buildDeliverJobTx, buildPublishAgentCoinTx, buildRefundJobTx, buildRejectJobTx, buildReleaseJobTx, buildRevokeLeafTx, buildSendTx, buildSwapTx, buildTokenizeTx, chatCompletion, chatCompletionStream, checkPositiveAmount, checkSuiAddress, classifyAction, classifyLabel, classifyTransaction, clearLimits, composeTx, dailySpentToday, deriveAllowedAddressesFromPtb, deserializeCetusRoute, displayHandle, executeTx, exportPrivateKey, extractAllUserLegs, extractTransferDetails, extractTxCommands, extractTxSender, fallbackLabel, fetchAllCoins, fetchService, findSwapRoute, formatAssetAmount, formatSui, formatUsd, fullHandle, generateKeypair, getAddress, getCoinMeta, getDecimals, getDecimalsForCoinType, getJob, getJobSpec, getLimits, getSponsoredSwapProviders, getSuiClient, getSuiGrpcClient, getSwapQuote, hasLimits, isAllowedAsset, isCetusRouteFresh, isInRegistry, jobActionsFor, keypairFromPrivateKey, listModels, listServices, loadKey, looksLikeSuiNs, mapMoveAbortCode, mapWalletError, mistToSui, normalizeAddressInput, normalizeAsset, normalizeCoinType, parseMppSuiChallenge, parseSuiRpcTx, payWithMpp, preflightCreateJob, preflightFail, preflightPay, preflightSend, preflightSwap, putJobSpec, queryBalance, queryHistory, queryTransaction, rawToStable, rawToUsdc, readLimitsFile, recordDailySpend, refineLendingLabel, resolveAddressToSuinsViaRpc, resolveSuinsViaRpc, resolveSymbol, resolveTokenType, saveBech32, saveKey, selectAndSplitCoin, selectSuiCoin, serializeCetusRoute, setLimits, simulateTransaction, stableToRaw, suiToMist, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, validateAgentCoinParams, validateLabel, verifyCetusRouteCoinMatch, verifyJobForSeller, verifyReceipt, walletExists, writeLimitsFile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map