Integrating Squid Intents

Integrating Squid Intents follows the same flow as a standard Squid integration. If you already have Squid integrated, the only steps are to have Squid Intents enabled on your integrator ID, poll for status with a quoteId, and handle the transaction request type.

Squid Intents must be enabled on your integrator ID. Reach out to the Squid team to get started.

Route Request

Squid Intents uses the /v2/route endpoint. When Squid Intents is enabled and a route is available, it will be automatically selected.

There are no expiry constraints — You do not need to submit the transaction within a time window.

EVM Route Request Example

const params = {
  fromAddress: signer.address,
  fromChain: "42161",          // Arbitrum
  fromToken: usdcAddress,
  fromAmount: amount,
  toChain: "1",                // Ethereum
  toToken: nativeToken,
  toAddress: signer.address,
  quoteOnly: false,
};

// Get the route
const routeResult = await axios.post(
  "https://v2.api.squidrouter.com/v2/route",
  params,
  {
    headers: {
      "x-integrator-id": integratorId,
      "Content-Type": "application/json",
    },
  }
);

const route = routeResult.data.route;
const quoteId = route.quoteId; // Save this — required for status tracking
console.log("Quote ID:", quoteId);

Transaction Request Types

The route response's transactionRequest object will include a transaction_request_type field that determines how to execute the transaction. There are three types:

TypeDescription

ON_CHAIN_EXECUTION

Standard on-chain transaction (EVM). Execute like any Squid transaction.

DEPOSIT_ADDRESS_CALLDATA

Deposit to the provided address with the specified calldata. Used for certain non-EVM chains.

DEPOSIT_ADDRESS_WITH_SIGNATURE

Submit a signed deposit to the provided address. Used for certain non-EVM chains.

Executing the Route

ON_CHAIN_EXECUTION (EVM Transactions)

For EVM-to-EVM Squid Intents routes where transaction_request_type is ON_CHAIN_EXECUTION, execution is the same as any Squid transaction:

const tx = await signer.sendTransaction({
  to: route.transactionRequest.target,
  data: route.transactionRequest.data,
  value: route.transactionRequest.value,
  gasLimit: route.transactionRequest.gasLimit,
  gasPrice: route.transactionRequest.gasPrice,
});

const receipt = await tx.wait();
console.log("Transaction hash:", receipt.transactionHash);

DEPOSIT_ADDRESS_CALLDATA & DEPOSIT_ADDRESS_WITH_SIGNATURE

For certain chains, Squid Intents uses a deposit address flow instead of standard on-chain execution. The transaction_request_type field will be one of:

• "DEPOSIT_ADDRESS_CALLDATA" — submit a deposit to the provided address with the specified calldata

• "DEPOSIT_ADDRESS_WITH_SIGNATURE" — submit a signed deposit to the provided address

const route = routeResult.data.route;
const transactionRequest = route.transactionRequest;

// Check the type to determine the execution flow
console.log("Transaction type:", transactionRequest.transaction_request_type);
// "ON_CHAIN_EXECUTION", "DEPOSIT_ADDRESS_CALLDATA", or "DEPOSIT_ADDRESS_WITH_SIGNATURE"

// Follow the deposit instructions in the transactionRequest
// The specific fields will vary by chain and type

Status Tracking

Status polling is required for Squid Intents. After executing a Squid Intent transaction, you must call the status API with the quoteId parameter. If quoteId is not included in the status call, the Squid Intents transaction will be refunded to the source chain.

Getting the Quote ID

The quoteId is returned at the top level of the route response:

{
    "route": {
        "quoteId": "6f388be5205ee044cd7fd5047a4ce72e"
    }
}

Polling for Status

// Function to get the status of a Squid Intents transaction
const getStatus = async (params) => {
  try {
    const result = await axios.get("https://v2.api.squidrouter.com/v2/status", {
      params: {
        transactionId: params.transactionId,
        fromChainId: params.fromChainId,
        toChainId: params.toChainId,
        quoteId: params.quoteId, // Required for Squid Intents
      },
      headers: {
        "x-integrator-id": integratorId,
      },
    });
    return result.data;
  } catch (error) {
    if (error.response) {
      console.error("API error:", error.response.data);
    }
    throw error;
  }
};

// Poll for transaction completion
const updateTransactionStatus = async (txHash, quoteId) => {
  const getStatusParams = {
    transactionId: txHash,
    fromChainId: fromChainId,
    toChainId: toChainId,
    quoteId: quoteId, // Required for Squid Intents
  };

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

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

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

Refund Behavior

When a Squid Intent transaction fails, funds are automatically refunded on the source chain. Refunds typically complete within ~15 minutes.

• Funds are transferred from the msg.sender on the source chain

• Refunds are sent to the order.fromAddress, which corresponds to the fromAddress in the route request

• This ensures refunds go to the actual user even if the transaction was initiated through a smart contract

Squid Intents Limitations

• Bitcoin and Solana support is coming soon