Hedera Integration

Integrate cross-chain swaps from Hedera to EVM chains using Squid. Hedera support is powered by Squid Intents — Squid's intent-based execution protocol for fast, solver-driven cross-chain settlement.

Squid Intents must be enabled on your integrator ID. Reach out to the Squid team to request Squid Intents access before integrating with Hedera.

---

Hedera Parameters

Parameter	Value
Chain ID	295

Supported Tokens

Token	Address
USDC	0x000000000000000000000000000000000006f89a

---

Key Concepts

Transaction Type: DEPOSIT_ADDRESS_WITH_SIGNATURE

Hedera routes use the DEPOSIT_ADDRESS_WITH_SIGNATURE transaction type. Unlike standard EVM routes, this type:

• Does not require ERC-20 approval — skip the approve() call entirely

• Requires signing an order hash — the route response includes a signatureRequired field containing an order hash that must be signed by the sender's wallet

• Returns a deposit address — funds are sent directly to a deposit address via a standard EVM transaction

Order Hash Signing

When the route response has transactionRequest.type === 'DEPOSIT_ADDRESS_WITH_SIGNATURE', the transactionRequest.signatureRequired field contains the order hash. Sign this hash using signer.signMessage() to produce the depositTxVerificationSignature:

const orderHash = transactionRequest.signatureRequired;
const depositTxVerificationSignature = await signer.signMessage(orderHash);

Important: The Squid indexer expects the signature of the literal UTF-8 hex string, not raw bytes. Use signMessage() (which applies EIP-191 prefix) directly on the order hash string.

Token Association Polling

Hedera uses the Hedera Token Service (HTS) which requires tokens to be explicitly associated with accounts before they can receive transfers. When Squid creates a deposit address for your route, it must complete a token association on the Hedera network. This process is asynchronous and takes a few seconds.

Poll estimateGas on the transaction before executing to confirm the token association is complete:

for (let i = 0; i < 15; i++) {
  try {
    await provider.estimateGas({
      from: signer.address,
      to: transactionRequest.target,
      data: transactionRequest.data,
      value: transactionRequest.value,
    });
    console.log("Token association complete. Proceeding...");
    break;
  } catch (e) {
    if (i === 14) {
      console.warn("Polling timed out. Attempting execution anyway...");
    } else {
      await new Promise((resolve) => setTimeout(resolve, 1000));
    }
  }
}

If the token has not yet been associated, estimateGas will throw an HTS system error (e.g., TOKEN_NOT_ASSOCIATED_TO_ACCOUNT). The loop retries up to 15 times with a 1-second delay (~15 seconds total).

---

API Integration

Route from Hedera (Hedera → EVM)

To route from Hedera to an EVM chain, set fromChain to 295 and provide an EVM-compatible Hedera address.

Full Working Example

import { ethers } from "ethers";
import axios from "axios";
import * as dotenv from "dotenv";
dotenv.config();

const privateKey: string = process.env.PRIVATE_KEY!;
const integratorId: string = process.env.INTEGRATOR_ID!;
const FROM_CHAIN_RPC: string = process.env.FROM_CHAIN_RPC_ENDPOINT!;

// Define chain and token parameters
const fromChainId = "295"; // Hedera Mainnet
const fromToken = "0x000000000000000000000000000000000006f89a"; // USDC on Hedera
const fromAmount = "2000";

const toChainId = "8453"; // Base (or any supported EVM chain)
const toToken = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"; // USDC on Base

// Set up provider and signer
const provider = new ethers.JsonRpcProvider(FROM_CHAIN_RPC);
const signer = new ethers.Wallet(privateKey, provider);

// Get route from Squid API
const getRoute = async (params: any) => {
  const result = await axios.post(
    "https://v2.api.squidrouter.com/v2/route",
    params,
    {
      headers: {
        "x-integrator-id": integratorId,
        "Content-Type": "application/json",
      },
    }
  );
  const requestId = result.headers["x-request-id"];
  return { data: result.data, requestId };
};

// Get transaction status
const getStatus = async (params: any) => {
  const result = await axios.get("https://v2.api.squidrouter.com/v2/status", {
    params,
    headers: {
      "x-integrator-id": integratorId,
    },
  });
  return result.data;
};

(async () => {
  const params = {
    fromAddress: signer.address,
    fromChain: fromChainId,
    fromToken: fromToken,
    fromAmount: fromAmount,
    toChain: toChainId,
    toToken: toToken,
    toAddress: signer.address,
    quoteOnly: false,
  };

  console.log("Parameters:", params);

  // 1. Get the route
  const routeResult = await getRoute(params);
  const route = routeResult.data.route;
  const requestId = routeResult.requestId;

  // Extract quoteId (required for Squid Intents status tracking)
  const quoteId =
    route?.estimate?.actions?.[0]?.coralV2Order?.quoteId ||
    route?.estimate?.quoteId ||
    route?.quoteId ||
    routeResult.data?.quoteId;

  console.log("Route received. Expected output:", route.estimate.toAmount);
  console.log("quoteId:", quoteId);

  const transactionRequest = route.transactionRequest;
  let depositTxVerificationSignature: string | undefined;

  // 2. Handle DEPOSIT_ADDRESS_WITH_SIGNATURE route type
  if (
    transactionRequest.type === "DEPOSIT_ADDRESS_WITH_SIGNATURE" ||
    transactionRequest.routeType === "DEPOSIT_ADDRESS_WITH_SIGNATURE"
  ) {
    console.log("Route type is DEPOSIT_ADDRESS_WITH_SIGNATURE, skipping ERC-20 approval...");

    // Sign the order hash
    const orderHash = transactionRequest.signatureRequired;
    if (orderHash) {
      depositTxVerificationSignature = await signer.signMessage(orderHash);
      console.log("Generated deposit verification signature");
    }
  }

  // 3. Poll estimateGas to confirm token association
  console.log("Verifying Hedera token association on deposit address...");
  for (let i = 0; i < 15; i++) {
    try {
      await provider.estimateGas({
        from: signer.address,
        to: transactionRequest.target,
        data: transactionRequest.data,
        value: transactionRequest.value,
      });
      console.log("Token association confirmed. Proceeding with swap...");
      break;
    } catch (e) {
      if (i === 14) {
        console.warn("Token association polling timed out. Attempting execution anyway...");
      } else {
        await new Promise((resolve) => setTimeout(resolve, 1000));
      }
    }
  }

  // 4. Execute the transaction
  const tx = await signer.sendTransaction({
    to: transactionRequest.target,
    data: transactionRequest.data,
    value: transactionRequest.value,
    gasPrice: transactionRequest.gasPrice,
    gasLimit: transactionRequest.gasLimit,
  });
  console.log("Transaction broadcasted:", tx.hash);
  const txReceipt = await tx.wait();
  console.log("Transaction confirmed!");

  // 5. Poll status until complete
  const statusParams: any = {
    transactionId: txReceipt!.hash,
    requestId: requestId,
    fromChainId: fromChainId,
    toChainId: toChainId,
    bridgeType: "rfq",
    quoteId: quoteId,
  };

  // Attach the deposit verification signature for status tracking
  if (depositTxVerificationSignature) {
    statusParams.depositTxVerificationSignature = depositTxVerificationSignature;
  }

  const completedStatuses = ["success", "partial_success", "needs_gas", "not_found"];
  const maxRetries = 100;
  let retryCount = 0;
  let status;

  do {
    try {
      status = await getStatus(statusParams);
      console.log(`Status: ${status.squidTransactionStatus}`);
    } catch (error: any) {
      if (error.response && error.response.status === 404) {
        retryCount++;
        if (retryCount >= maxRetries) {
          console.error("Max retries reached.");
          break;
        }
        console.log("Transaction not found. Retrying in 5s...");
        await new Promise((resolve) => setTimeout(resolve, 5000));
        continue;
      }
      throw error;
    }

    if (status && !completedStatuses.includes(status.squidTransactionStatus)) {
      await new Promise((resolve) => setTimeout(resolve, 5000));
    }
  } while (!status || !completedStatuses.includes(status.squidTransactionStatus));

  console.log("Swap complete!");
  console.log(`Track on Squid Scanner: https://scan.squidrouter.com/tx/${txReceipt!.hash}`);
})();

---

SDK Integration

The Squid SDK handles much of the Hedera-specific logic automatically. For DEPOSIT_ADDRESS_WITH_SIGNATURE routes, executeRoute() will:

• Automatically sign the order hash (signatureRequired)

• Execute the deposit transaction

• Return the depositTxVerificationSignature in the response

You are still responsible for:

• Polling estimateGas to wait for token association before calling executeRoute()

• Passing the depositTxVerificationSignature and quoteId to the status endpoint

Full Working Example

import { Squid } from "@0xsquid/sdk";
import { ethers } from "ethers";
import * as dotenv from "dotenv";
dotenv.config();

const privateKey: string = process.env.PRIVATE_KEY!;
const integratorId: string = process.env.INTEGRATOR_ID!;
const FROM_CHAIN_RPC: string = process.env.FROM_CHAIN_RPC_ENDPOINT!;

// Define chain and token parameters
const fromChainId = "295"; // Hedera
const fromToken = "0x000000000000000000000000000000000006f89a"; // USDC on Hedera
const fromAmount = "2000";

const toChainId = "42161"; // Arbitrum
const toToken = "0xaf88d065e77c8cc2239327c5edb3a432268e5831"; // USDC on Arbitrum

// Set up provider and signer
const provider = new ethers.JsonRpcProvider(FROM_CHAIN_RPC);
const signer = new ethers.Wallet(privateKey, provider);

// Initialize Squid SDK
const getSDK = (): Squid => {
  const squid = new Squid({
    baseUrl: "https://v2.api.squidrouter.com",
    integratorId: integratorId,
  });
  return squid;
};

(async () => {
  const squid = getSDK();
  await squid.init();
  console.log("Squid SDK initialized");

  // 1. Get the route
  const params = {
    fromAddress: signer.address,
    fromChain: fromChainId,
    fromToken: fromToken,
    fromAmount: fromAmount,
    toChain: toChainId,
    toToken: toToken,
    toAddress: signer.address,
  };

  const { route, requestId } = await squid.getRoute(params);

  // Extract quoteId (required for Squid Intents status tracking)
  const quoteId =
    (route as any).estimate?.actions?.[0]?.coralV2Order?.quoteId ||
    (route as any).estimate?.quoteId ||
    (route as any).quoteId;

  console.log("Route received. Expected output:", route.estimate.toAmount);

  // 2. Poll estimateGas to confirm token association
  if (route.transactionRequest) {
    const txReq = route.transactionRequest as any;
    console.log("Verifying Hedera token association on deposit address...");
    for (let i = 0; i < 15; i++) {
      try {
        await provider.estimateGas({
          from: signer.address,
          to: txReq.target,
          data: txReq.data,
          value: txReq.value,
        });
        console.log("Token association confirmed. Proceeding...");
        break;
      } catch (e) {
        if (i === 14) {
          console.warn("Polling timed out. Executing anyway...");
        } else {
          await new Promise((resolve) => setTimeout(resolve, 1000));
        }
      }
    }
  }

  // 3. Execute the route (SDK handles orderHash signing automatically)
  const response = await squid.executeRoute({
    signer: signer as any,
    route,
  });

  // 4. Extract transaction hash and deposit verification signature
  let txHash = "unknown";
  let depositTxVerificationSignature: string | undefined;

  if (response && typeof response === "object") {
    if ("hash" in response) {
      txHash = response.hash as string;
      await (response as any).wait?.();
    } else if ("transactionHash" in response) {
      txHash = (response as any).transactionHash;
    }

    if ("depositTxVerificationSignature" in response) {
      depositTxVerificationSignature = (response as any).depositTxVerificationSignature;
    }
  }

  console.log(`Transaction confirmed: ${txHash}`);
  console.log(`Track on Squid Scanner: https://scan.squidrouter.com/tx/${txHash}`);

  // 5. Poll status until complete
  const statusParams: any = {
    transactionId: txHash,
    requestId: requestId,
    integratorId: integratorId,
    fromChainId: fromChainId,
    toChainId: toChainId,
    bridgeType: "rfq",
    quoteId: quoteId,
  };

  if (depositTxVerificationSignature) {
    statusParams.depositTxVerificationSignature = depositTxVerificationSignature;
  }

  const completedStatuses = ["success", "partial_success", "needs_gas", "not_found"];
  const maxRetries = 100;
  let retryCount = 0;
  let status;

  do {
    try {
      await new Promise((resolve) => setTimeout(resolve, 5000));
      status = await squid.getStatus(statusParams);
      console.log(`Status: ${status.squidTransactionStatus}`);
    } catch (error: unknown) {
      if (
        error instanceof Error &&
        (error as any).response?.status === 404
      ) {
        retryCount++;
        if (retryCount >= maxRetries) {
          console.error("Max retries reached.");
          break;
        }
        console.log("Transaction not found. Retrying...");
        continue;
      }
      throw error;
    }
  } while (
    !status ||
    !completedStatuses.includes(status.squidTransactionStatus as string)
  );

  console.log("Swap complete!");
})();

---

Status Tracking

Hedera routes are powered by Squid Intents, which requires both quoteId and depositTxVerificationSignature for status polling.

Parameter	Description
transactionId	The deposit transaction hash
fromChainId	295 (Hedera)
toChainId	The destination chain ID
quoteId	Returned in the route response — required for Squid Intents
depositTxVerificationSignature	The signed order hash — required for Hedera routes
bridgeType	rfq

const statusParams = {
  transactionId: txHash,
  fromChainId: "295",
  toChainId: toChainId,
  quoteId: quoteId,
  depositTxVerificationSignature: depositTxVerificationSignature,
  bridgeType: "rfq",
};

const status = await axios.get("https://v2.api.squidrouter.com/v2/status", {
  params: statusParams,
  headers: { "x-integrator-id": "<your-integrator-id>" },
});

Important: A Squid Intents transaction will not be trackable unless status is polled with the quoteId. See the Integrating Squid Intents guide for full status polling details.

---

Code Examples

API Examples

Route	Example
Hedera → EVM	hederaToArbitrumSwap

SDK Examples

Route	Example
Hedera → EVM	hederaToArbitrumSwap

---

Important Notes

• EVM-compatible wallets only — Hedera integration uses Hedera's EVM-compatible layer. You need an Ethereum-style private key and can interact with Hedera using standard ethers.js tooling and a Hedera JSON-RPC endpoint.

• No ERC-20 approval needed — DEPOSIT_ADDRESS_WITH_SIGNATURE routes bypass the standard approval flow. Do not call approve() for these routes.

• Token association is asynchronous — Always poll estimateGas before sending the deposit transaction to ensure the deposit address has completed HTS token association. Skipping this step may result in a failed transaction.

• Order hash signing is mandatory — The signatureRequired field must be signed and the resulting depositTxVerificationSignature must be passed to the /v2/status endpoint for transaction tracking.

• quoteId is required for status calls — All Squid Intents transactions (including Hedera routes) require the quoteId parameter when polling the status endpoint.

For a full reference of all transaction types across all chains, see the Transaction Types page.