hak-axelar-plugin 1.0.0

package/dist/index.js

@@ -0,0 +1,605 @@
+import { BaseTool, handleTransaction } from '@hashgraph/hedera-agent-kit';
+import { z } from 'zod';
+import { ContractId, ContractExecuteTransaction, Hbar, ContractFunctionParameters } from '@hiero-ledger/sdk';
+import 'long';
+
+// src/tools/get-message-fee.ts
+
+// src/networks.ts
+var AXELAR_MAINNET = {
+  gatewayAddress: "0xe432150cce91c13a887f7D836923d5597adD8E31",
+  gasServiceAddress: "0x2d5d7d31F671F86C782533cc367F14109a082712",
+  itsAddress: "0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C",
+  itsFactoryAddress: "0x83a93500d23Fbc3e82B410aD07A6a9F7A0670D66",
+  whbarAddress: "0xb1F616b8134F602c3Bb465fB5b5e6565cCAd37Ed",
+  chainName: "hedera",
+  chainId: 295,
+  rpcUrl: "https://mainnet.hashio.io/api",
+  apiBaseUrl: "https://api.axelarscan.io",
+  gmpApiBaseUrl: "https://api.gmp.axelarscan.io",
+  nestServerUrl: "https://nest-server-mainnet.axelar.dev"
+};
+var AXELAR_TESTNET = {
+  gatewayAddress: "0xe432150cce91c13a887f7D836923d5597adD8E31",
+  gasServiceAddress: "0xbE406F0189A0B4cf3A05C286473D23791Dd44Cc6",
+  itsAddress: "0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C",
+  itsFactoryAddress: "0x83a93500d23Fbc3e82B410aD07A6a9F7A0670D66",
+  whbarAddress: "0xb1F616b8134F602c3Bb465fB5b5e6565cCAd37Ed",
+  chainName: "hedera",
+  chainId: 296,
+  rpcUrl: "https://testnet.hashio.io/api",
+  apiBaseUrl: "https://testnet.api.axelarscan.io",
+  gmpApiBaseUrl: "https://testnet.api.gmp.axelarscan.io",
+  nestServerUrl: "https://nest-server-testnet.axelar.dev"
+};
+var NETWORK_DEFAULTS = {
+  mainnet: AXELAR_MAINNET,
+  testnet: AXELAR_TESTNET
+};
+
+// src/utils/config.ts
+function readContextConfig(context) {
+  const ctx = context;
+  for (const key of ["pluginConfig", "config", "agentConfig"]) {
+    const bucket = ctx[key];
+    if (bucket && typeof bucket === "object") {
+      const b = bucket;
+      if (b["hak-axelar-plugin"] && typeof b["hak-axelar-plugin"] === "object") {
+        return b["hak-axelar-plugin"];
+      }
+      if (b.axelar && typeof b.axelar === "object") {
+        return b.axelar;
+      }
+    }
+  }
+  return {};
+}
+function readNetwork(value) {
+  if (value === "mainnet" || value === "testnet") return value;
+  return void 0;
+}
+function resolveNetworkDefaults(ctxConfig) {
+  const network = ctxConfig.network ?? readNetwork(process.env.AXELAR_NETWORK) ?? "mainnet";
+  const defaults = NETWORK_DEFAULTS[network];
+  return {
+    ...defaults,
+    gatewayAddress: ctxConfig.gatewayAddress ?? process.env.AXELAR_GATEWAY_ADDRESS ?? defaults.gatewayAddress,
+    gasServiceAddress: ctxConfig.gasServiceAddress ?? process.env.AXELAR_GAS_SERVICE_ADDRESS ?? defaults.gasServiceAddress,
+    itsAddress: ctxConfig.itsAddress ?? process.env.AXELAR_ITS_ADDRESS ?? defaults.itsAddress,
+    apiBaseUrl: ctxConfig.apiBaseUrl ?? defaults.apiBaseUrl,
+    gmpApiBaseUrl: ctxConfig.gmpApiBaseUrl ?? defaults.gmpApiBaseUrl,
+    nestServerUrl: ctxConfig.nestServerUrl ?? defaults.nestServerUrl
+  };
+}
+
+// src/tools/get-message-fee.ts
+var GetMessageFeeSchema = z.object({
+  destinationChain: z.string().min(1).describe(
+    'Axelar chain name for the destination (e.g. "ethereum", "base", "arbitrum", "xrpl"). Use axelar_get_supported_chains to list valid names.'
+  ),
+  gasLimit: z.number().int().positive().optional().default(2e5).describe("Gas limit for the destination contract execution (default: 200000)."),
+  network: z.enum(["mainnet", "testnet"]).optional().describe('Override network. Defaults to AXELAR_NETWORK env var or "mainnet".')
+});
+var GetMessageFeeTool = class extends BaseTool {
+  method = "axelar_get_message_fee";
+  name = "Axelar Get Message Fee";
+  description = "Estimates the HBAR fee required to send a cross-chain GMP message from Hedera via Axelar. Returns baseFee, executionFee, and total fee with multiplier, all denominated in tinybars. Call this before axelar_send_message to determine the gasTinybars parameter.";
+  parameters = GetMessageFeeSchema;
+  async normalizeParams(params, _context, _client) {
+    return GetMessageFeeSchema.parse(params);
+  }
+  async coreAction(args, context, _client) {
+    const ctxConfig = readContextConfig(context);
+    if (args.network) ctxConfig.network = args.network;
+    const net = resolveNetworkDefaults(ctxConfig);
+    try {
+      const fee = await fetchGasFee(
+        net.nestServerUrl,
+        net.chainName,
+        args.destinationChain,
+        args.gasLimit
+      );
+      return {
+        success: true,
+        network: ctxConfig.network ?? process.env.AXELAR_NETWORK ?? "mainnet",
+        sourceChain: net.chainName,
+        destinationChain: args.destinationChain,
+        gasLimit: args.gasLimit,
+        baseFee: fee.baseFee,
+        executionFee: fee.executionFee,
+        executionFeeWithMultiplier: fee.executionFeeWithMultiplier,
+        gasMultiplier: fee.gasMultiplier,
+        isExpressSupported: fee.isExpressSupported,
+        unit: "tinybars"
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+  async shouldSecondaryAction(coreResult, _context) {
+    return typeof coreResult === "object" && coreResult !== null && "transaction" in coreResult;
+  }
+  async secondaryAction() {
+    throw new Error("GetMessageFeeTool has no secondary action");
+  }
+};
+async function fetchGasFee(nestServerUrl, sourceChain, destinationChain, gasLimit) {
+  const res = await fetch(`${nestServerUrl}/getGasFee`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "application/json" },
+    body: JSON.stringify({
+      sourceChainName: sourceChain,
+      destinationChainName: destinationChain,
+      sourceTokenSymbol: "HBAR",
+      gasLimit: gasLimit.toString()
+    }),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Axelar fee API returned HTTP ${res.status}: ${await res.text().catch(() => "")}`
+    );
+  }
+  const body = await res.json();
+  const result = body.result ?? body;
+  return {
+    baseFee: String(result.baseFee ?? result.base_fee ?? "0"),
+    executionFee: String(result.executionFee ?? result.execution_fee ?? "0"),
+    executionFeeWithMultiplier: String(
+      result.executionFeeWithMultiplier ?? result.executionFee ?? "0"
+    ),
+    gasMultiplier: Number(result.gasMultiplier ?? result.gas_multiplier ?? 1),
+    isExpressSupported: Boolean(result.isExpressSupported ?? false)
+  };
+}
+var getMessageFeeTool = new GetMessageFeeTool();
+var GetMessageStatusSchema = z.object({
+  txHash: z.string().min(1).describe(
+    "The Hedera transaction hash of the axelar_send_message or axelar_send_token call (the callContract transaction, not the gas payment transaction)."
+  ),
+  network: z.enum(["mainnet", "testnet"]).optional().describe('Override network. Defaults to AXELAR_NETWORK env var or "mainnet".')
+});
+var GetMessageStatusTool = class extends BaseTool {
+  method = "axelar_get_message_status";
+  name = "Axelar Get Message Status";
+  description = "Checks the delivery status of a cross-chain message sent via Axelar from Hedera. Tracks all five stages: called \u2192 gas_paid \u2192 approved \u2192 executing \u2192 executed. Pass the Hedera transaction hash from axelar_send_message or axelar_send_token.";
+  parameters = GetMessageStatusSchema;
+  async normalizeParams(params, _context, _client) {
+    return GetMessageStatusSchema.parse(params);
+  }
+  async coreAction(args, context, _client) {
+    const ctxConfig = readContextConfig(context);
+    if (args.network) ctxConfig.network = args.network;
+    const net = resolveNetworkDefaults(ctxConfig);
+    try {
+      const url = `${net.gmpApiBaseUrl}/?method=searchGMP&sourceTransactionHash=${encodeURIComponent(args.txHash)}`;
+      const res = await fetch(url, {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!res.ok) {
+        return {
+          success: false,
+          error: `Axelar GMP API returned HTTP ${res.status}`
+        };
+      }
+      const body = await res.json();
+      const items = Array.isArray(body.data) ? body.data : Array.isArray(body) ? body : [];
+      if (items.length === 0) {
+        return buildStatus(args.txHash, "not_found", null, net);
+      }
+      const item = items[0];
+      return buildStatus(args.txHash, resolveStatus(item), item, net);
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+  async shouldSecondaryAction(coreResult, _context) {
+    return typeof coreResult === "object" && coreResult !== null && "transaction" in coreResult;
+  }
+  async secondaryAction() {
+    throw new Error("GetMessageStatusTool has no secondary action");
+  }
+};
+function resolveStatus(item) {
+  const status = String(item.status ?? item.simplified_status ?? "").toLowerCase();
+  const map = {
+    called: "called",
+    gas_paid: "gas_paid",
+    gas_paid_enough: "gas_paid_enough",
+    confirming: "confirming",
+    confirmed: "confirmed",
+    approved: "approved",
+    executing: "executing",
+    executed: "executed",
+    error: "error",
+    insufficient_fee: "insufficient_fee"
+  };
+  return map[status] ?? "called";
+}
+function buildStatus(txHash, status, item, net) {
+  const call = item?.call ?? {};
+  const execute = item?.executed ?? {};
+  const isMainnet = net.gmpApiBaseUrl.includes("testnet") ? false : true;
+  const scanBase = isMainnet ? "https://axelarscan.io" : "https://testnet.axelarscan.io";
+  return {
+    success: true,
+    status,
+    txHash,
+    sourceChain: String(item?.sourceChain ?? net.chainName),
+    destinationChain: item?.destinationChain ? String(item.destinationChain) : void 0,
+    destinationContract: call.destinationContractAddress ? String(call.destinationContractAddress) : void 0,
+    executionTxHash: execute.transactionHash ? String(execute.transactionHash) : void 0,
+    gasPaid: Boolean(item?.gasPaid ?? item?.gas_paid),
+    isExecuted: status === "executed",
+    isError: status === "error" || status === "insufficient_fee",
+    axelarScanUrl: `${scanBase}/gmp/${txHash}`
+  };
+}
+var getMessageStatusTool = new GetMessageStatusTool();
+var GetSupportedChainsSchema = z.object({
+  network: z.enum(["mainnet", "testnet"]).optional().describe('Override network selection. Defaults to AXELAR_NETWORK env var or "mainnet".')
+});
+var GetSupportedChainsTool = class extends BaseTool {
+  method = "axelar_get_supported_chains";
+  name = "Axelar Get Supported Chains";
+  description = "Returns all chains reachable from Hedera via Axelar Network. Includes chain IDs, names, and type (EVM / non-EVM). Use this before sending tokens or messages to confirm the destination chain is supported.";
+  parameters = GetSupportedChainsSchema;
+  async normalizeParams(params, _context, _client) {
+    return GetSupportedChainsSchema.parse(params);
+  }
+  async coreAction(args, context, _client) {
+    const ctxConfig = readContextConfig(context);
+    if (args.network) ctxConfig.network = args.network;
+    const net = resolveNetworkDefaults(ctxConfig);
+    try {
+      const url = `${net.apiBaseUrl}/api/getChains`;
+      const res = await fetch(url, {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!res.ok) {
+        return { success: false, error: `Axelar API returned HTTP ${res.status}` };
+      }
+      const data = await res.json();
+      const chains = parseChains(data);
+      return {
+        success: true,
+        network: ctxConfig.network ?? process.env.AXELAR_NETWORK ?? "mainnet",
+        sourceChain: net.chainName,
+        chains,
+        count: chains.length
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+  async shouldSecondaryAction(coreResult, _context) {
+    return typeof coreResult === "object" && coreResult !== null && "transaction" in coreResult;
+  }
+  async secondaryAction() {
+    throw new Error("GetSupportedChainsTool has no secondary action");
+  }
+};
+function parseChains(data) {
+  if (!data || typeof data !== "object") return [];
+  let raw = [];
+  if (Array.isArray(data)) {
+    raw = data;
+  } else {
+    const d = data;
+    if (Array.isArray(d.data)) raw = d.data;
+    else if (Array.isArray(d.result)) raw = d.result;
+  }
+  return raw.filter((c) => typeof c === "object" && c !== null).map((c) => ({
+    id: String(c.id ?? c.chain_id ?? c.axelarId ?? ""),
+    name: String(c.name ?? c.chain_name ?? c.id ?? ""),
+    chainId: typeof c.chain_id === "number" ? c.chain_id : void 0,
+    type: String(c.chain_type ?? (c.evm ? "evm" : "non-evm")),
+    status: typeof c.status === "string" ? c.status : void 0
+  })).filter((c) => c.id !== "hedera" && c.id !== "");
+}
+var getSupportedChainsTool = new GetSupportedChainsTool();
+var safeUint256 = (value) => String(value);
+var hexToBytes = (hex) => {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean.length > 0 && !/^[0-9a-fA-F]+$/.test(clean)) {
+    throw new Error(`Invalid hex string: "${hex}"`);
+  }
+  return Uint8Array.from(Buffer.from(clean, "hex"));
+};
+var encodeEvmAddress = (address) => {
+  const clean = address.replace(/^0x/i, "");
+  if (clean.length !== 40) {
+    throw new Error(`Invalid EVM address length: ${address}`);
+  }
+  return hexToBytes(clean);
+};
+var hexToBytes32 = (hex) => {
+  const clean = hex.replace(/^0x/i, "").padStart(64, "0");
+  return hexToBytes(clean);
+};
+
+// src/tools/send-message.ts
+var SendMessageSchema = z.object({
+  destinationChain: z.string().min(1).describe(
+    'Axelar chain name for the destination (e.g. "ethereum", "base", "arbitrum"). Use axelar_get_supported_chains to confirm the chain is reachable.'
+  ),
+  destinationContract: z.string().min(1).describe(
+    "EVM address of the destination contract. It MUST implement AxelarExecutable (inherit from @axelar-network/axelar-gmp-sdk-solidity AxelarExecutable.sol)."
+  ),
+  payload: z.string().optional().default("0x").describe(
+    'ABI-encoded payload bytes as a hex string (with or without 0x prefix). Use "0x" or omit for an empty payload (e.g. a ping).'
+  ),
+  gasTinybars: z.string().min(1).describe(
+    "HBAR amount in tinybars (1 HBAR = 100,000,000 tinybars) to pay for Axelar relay execution. Use axelar_get_message_fee to estimate the required amount. Example: '5000000' = 0.05 HBAR."
+  ),
+  network: z.enum(["mainnet", "testnet"]).optional().describe('Override network. Defaults to AXELAR_NETWORK env var or "mainnet".')
+});
+var SendMessageTool = class extends BaseTool {
+  method = "axelar_send_message";
+  name = "Axelar Send Cross-Chain Message";
+  description = "Sends a GMP (General Message Passing) message from Hedera to a contract on another chain via Axelar Network. The destination contract must implement AxelarExecutable. Submits two Hedera transactions: (1) gas payment to AxelarGasService, (2) callContract on AxelarGateway. Use axelar_get_message_fee first to estimate gasTinybars. Track delivery with axelar_get_message_status.";
+  parameters = SendMessageSchema;
+  async normalizeParams(params, _context, _client) {
+    return SendMessageSchema.parse(params);
+  }
+  async coreAction(args, context, client) {
+    const hederaClient = client;
+    const ctxConfig = readContextConfig(context);
+    if (args.network) ctxConfig.network = args.network;
+    const net = resolveNetworkDefaults(ctxConfig);
+    let senderEvmAddress;
+    try {
+      senderEvmAddress = hederaClient.operatorPublicKey?.toEvmAddress() ?? "";
+    } catch {
+      senderEvmAddress = "";
+    }
+    if (!senderEvmAddress) {
+      return {
+        success: false,
+        error: "Could not derive operator EVM address. Ensure the Hedera operator key is ECDSA-compatible (not Ed25519)."
+      };
+    }
+    let payloadBytes;
+    try {
+      payloadBytes = hexToBytes(args.payload ?? "0x");
+    } catch (e) {
+      return { success: false, error: `Invalid payload hex: ${e.message}` };
+    }
+    let gasTinybarsNum;
+    try {
+      gasTinybarsNum = Number(args.gasTinybars);
+      if (!Number.isFinite(gasTinybarsNum) || gasTinybarsNum <= 0) {
+        return { success: false, error: "gasTinybars must be a positive integer string" };
+      }
+    } catch {
+      return { success: false, error: "gasTinybars must be a positive integer string" };
+    }
+    try {
+      const gatewayId = ContractId.fromEvmAddress(0, 0, net.gatewayAddress);
+      const gasServiceId = ContractId.fromEvmAddress(0, 0, net.gasServiceAddress);
+      const gasPaymentTx = new ContractExecuteTransaction().setContractId(gasServiceId).setGas(4e5).setPayableAmount(Hbar.fromTinybars(gasTinybarsNum)).setFunction(
+        "payNativeGasForContractCall",
+        new ContractFunctionParameters().addAddress(senderEvmAddress).addString(args.destinationChain).addString(args.destinationContract).addBytes(payloadBytes).addAddress(senderEvmAddress)
+        // refundAddress
+      );
+      const callContractTx = new ContractExecuteTransaction().setContractId(gatewayId).setGas(4e5).setFunction(
+        "callContract",
+        new ContractFunctionParameters().addString(args.destinationChain).addString(args.destinationContract).addBytes(payloadBytes)
+      );
+      return {
+        transaction: gasPaymentTx,
+        extras: {
+          callContractTx,
+          destinationChain: args.destinationChain,
+          destinationContract: args.destinationContract,
+          payloadHex: args.payload ?? "0x",
+          gasTinybars: args.gasTinybars
+        }
+      };
+    } catch (e) {
+      return { success: false, error: `Failed to build transaction: ${e.message}` };
+    }
+  }
+  async shouldSecondaryAction(coreResult, _context) {
+    return typeof coreResult === "object" && coreResult !== null && "transaction" in coreResult;
+  }
+  async secondaryAction(payload, client, context) {
+    const hederaClient = client;
+    const ctxConfig = readContextConfig(context);
+    const net = resolveNetworkDefaults(ctxConfig);
+    const isMainnet = !net.gmpApiBaseUrl.includes("testnet");
+    const scanBase = isMainnet ? "https://axelarscan.io" : "https://testnet.axelarscan.io";
+    let gasTxId;
+    try {
+      const gasResult = await handleTransaction(payload.transaction, hederaClient, context);
+      gasTxId = gasResult.transactionId;
+    } catch (e) {
+      return {
+        success: false,
+        error: `Gas payment transaction failed: ${e.message}`,
+        destinationChain: payload.extras.destinationChain,
+        destinationContract: payload.extras.destinationContract,
+        payloadHex: payload.extras.payloadHex,
+        gasTinybars: payload.extras.gasTinybars
+      };
+    }
+    let callResult;
+    try {
+      callResult = await handleTransaction(
+        payload.extras.callContractTx,
+        hederaClient,
+        context
+      );
+    } catch (e) {
+      return {
+        success: false,
+        error: `callContract transaction failed: ${e.message}`,
+        gasTxId,
+        destinationChain: payload.extras.destinationChain,
+        destinationContract: payload.extras.destinationContract,
+        payloadHex: payload.extras.payloadHex,
+        gasTinybars: payload.extras.gasTinybars
+      };
+    }
+    const callTxId = callResult.transactionId;
+    const callTxHash = callTxId?.replace(/[@/]/g, "-") ?? "";
+    return {
+      success: true,
+      gasTxId,
+      callTxId,
+      sourceTxHash: callTxHash,
+      destinationChain: payload.extras.destinationChain,
+      destinationContract: payload.extras.destinationContract,
+      payloadHex: payload.extras.payloadHex,
+      gasTinybars: payload.extras.gasTinybars,
+      axelarScanUrl: callTxHash ? `${scanBase}/gmp/${callTxHash}` : void 0
+    };
+  }
+};
+var sendMessageTool = new SendMessageTool();
+var SendTokenSchema = z.object({
+  interchainTokenId: z.string().min(1).describe(
+    "The Axelar ITS token ID (bytes32 hex string, with or without 0x prefix). This is the token registry ID, NOT the ERC-20 contract address. Find token IDs via the Axelar ITS registry or the token deployer."
+  ),
+  destinationChain: z.string().min(1).describe(
+    'Axelar chain name for the destination (e.g. "ethereum", "base", "arbitrum"). The token must be registered on this chain in the ITS registry.'
+  ),
+  destinationAddress: z.string().min(1).describe(
+    "EVM address of the token recipient on the destination chain (0x-prefixed hex, 20 bytes)."
+  ),
+  amount: z.string().min(1).describe(
+    "Token amount to bridge in base units (smallest denomination). Example: to send 1 USDC (6 decimals), pass '1000000'."
+  ),
+  gasTinybars: z.string().min(1).describe(
+    "HBAR amount in tinybars to pay for Axelar relay execution on the destination chain. This HBAR is forwarded to AxelarGasService via the ITS contract. Use axelar_get_message_fee to estimate. Example: '5000000' = 0.05 HBAR."
+  ),
+  metadata: z.string().optional().default("0x").describe(
+    'ABI-encoded ITS metadata as hex string. Pass "0x" or omit for standard transfer.'
+  ),
+  network: z.enum(["mainnet", "testnet"]).optional().describe('Override network. Defaults to AXELAR_NETWORK env var or "mainnet".')
+});
+var SendTokenTool = class extends BaseTool {
+  method = "axelar_send_token";
+  name = "Axelar Send Interchain Token";
+  description = "Bridges a registered ITS (Interchain Token Service) token from Hedera to another chain via Axelar Network. Calls InterchainTokenService.interchainTransfer() in a single transaction, paying gas in HBAR. IMPORTANT: The token must be registered in the Axelar ITS registry. Classic axlUSDC deposit-address bridging is NOT supported on Hedera (Amplifier architecture). The recipient must have associated the HTS token on Hedera before receiving it back.";
+  parameters = SendTokenSchema;
+  async normalizeParams(params, _context, _client) {
+    return SendTokenSchema.parse(params);
+  }
+  async coreAction(args, context, _client) {
+    const ctxConfig = readContextConfig(context);
+    if (args.network) ctxConfig.network = args.network;
+    const net = resolveNetworkDefaults(ctxConfig);
+    let tokenIdBytes;
+    try {
+      tokenIdBytes = hexToBytes32(args.interchainTokenId);
+    } catch (e) {
+      return { success: false, error: `Invalid interchainTokenId: ${e.message}` };
+    }
+    let destAddressBytes;
+    try {
+      destAddressBytes = encodeEvmAddress(args.destinationAddress);
+    } catch (e) {
+      return { success: false, error: `Invalid destinationAddress: ${e.message}` };
+    }
+    let metadataBytes;
+    try {
+      const rawMeta = args.metadata ?? "0x";
+      metadataBytes = rawMeta === "0x" || rawMeta === "" ? new Uint8Array(0) : hexToBytes32(rawMeta);
+    } catch (e) {
+      return { success: false, error: `Invalid metadata: ${e.message}` };
+    }
+    let gasTinybarsNum;
+    try {
+      gasTinybarsNum = Number(args.gasTinybars);
+      if (!Number.isFinite(gasTinybarsNum) || gasTinybarsNum <= 0) {
+        return { success: false, error: "gasTinybars must be a positive integer string" };
+      }
+    } catch {
+      return { success: false, error: "gasTinybars must be a positive integer string" };
+    }
+    const gasValueWei = (BigInt(args.gasTinybars) * BigInt(1e10)).toString();
+    try {
+      const itsId = ContractId.fromEvmAddress(0, 0, net.itsAddress);
+      const tx = new ContractExecuteTransaction().setContractId(itsId).setGas(8e5).setPayableAmount(Hbar.fromTinybars(gasTinybarsNum)).setFunction(
+        "interchainTransfer",
+        new ContractFunctionParameters().addBytes32(tokenIdBytes).addString(args.destinationChain).addBytes(destAddressBytes).addUint256(safeUint256(args.amount)).addBytes(metadataBytes).addUint256(safeUint256(gasValueWei))
+      );
+      return {
+        transaction: tx,
+        extras: {
+          interchainTokenId: args.interchainTokenId,
+          destinationChain: args.destinationChain,
+          destinationAddress: args.destinationAddress,
+          amount: args.amount,
+          gasTinybars: args.gasTinybars
+        }
+      };
+    } catch (e) {
+      return { success: false, error: `Failed to build transaction: ${e.message}` };
+    }
+  }
+  async shouldSecondaryAction(coreResult, _context) {
+    return typeof coreResult === "object" && coreResult !== null && "transaction" in coreResult;
+  }
+  async secondaryAction(payload, client, context) {
+    const hederaClient = client;
+    const ctxConfig = readContextConfig(context);
+    const net = resolveNetworkDefaults(ctxConfig);
+    const isMainnet = !net.gmpApiBaseUrl.includes("testnet");
+    const scanBase = isMainnet ? "https://axelarscan.io" : "https://testnet.axelarscan.io";
+    let result;
+    try {
+      result = await handleTransaction(
+        payload.transaction,
+        hederaClient,
+        context
+      );
+    } catch (e) {
+      return {
+        success: false,
+        error: e.message,
+        ...payload.extras
+      };
+    }
+    const txId = result.transactionId;
+    const sourceTxHash = txId?.replace(/[@/]/g, "-") ?? "";
+    return {
+      success: true,
+      txId,
+      sourceTxHash,
+      ...payload.extras,
+      axelarScanUrl: sourceTxHash ? `${scanBase}/gmp/${sourceTxHash}` : void 0
+    };
+  }
+};
+var sendTokenTool = new SendTokenTool();
+
+// src/plugin.ts
+var axelarPlugin = {
+  name: "hak-axelar-plugin",
+  version: "1.0.0",
+  description: "Axelar Network cross-chain plugin for Hedera Agent Kit \u2014 bridge tokens and send GMP messages between Hedera and 60+ chains",
+  tools: (_context) => [
+    getSupportedChainsTool,
+    getMessageFeeTool,
+    sendMessageTool,
+    sendTokenTool,
+    getMessageStatusTool
+  ]
+};
+
+// src/index.ts
+var axelarPluginToolNames = {
+  AXELAR_GET_SUPPORTED_CHAINS: "axelar_get_supported_chains",
+  AXELAR_GET_MESSAGE_FEE: "axelar_get_message_fee",
+  AXELAR_SEND_MESSAGE: "axelar_send_message",
+  AXELAR_SEND_TOKEN: "axelar_send_token",
+  AXELAR_GET_MESSAGE_STATUS: "axelar_get_message_status"
+};
+
+export { AXELAR_MAINNET, AXELAR_TESTNET, NETWORK_DEFAULTS, axelarPlugin, axelarPluginToolNames, axelarPlugin as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map