0xtrails 0.0.1 → 0.0.2

package/dist/cctp.js

@@ -0,0 +1,401 @@
+import { createPublicClient, encodeFunctionData, erc20Abi, getAddress, http, maxUint256, } from "viem";
+import * as chains from "viem/chains";
+import { attemptSwitchChain } from "./chainSwitch.js";
+const domains = {
+    [chains.mainnet.id]: 0,
+    [chains.sepolia.id]: 0,
+    [chains.avalanche.id]: 1,
+    [chains.avalancheFuji.id]: 1,
+    [chains.optimism.id]: 2,
+    [chains.optimismSepolia.id]: 2,
+    [chains.arbitrum.id]: 3,
+    [chains.arbitrumSepolia.id]: 3,
+    [chains.base.id]: 6,
+    [chains.baseSepolia.id]: 6,
+    [chains.polygon.id]: 7,
+    [chains.polygonAmoy.id]: 7,
+    [chains.unichain.id]: 10,
+    [chains.unichainSepolia.id]: 10,
+    [chains.linea.id]: 11,
+    [chains.lineaSepolia.id]: 11,
+    [chains.worldchain.id]: 14,
+    [chains.worldchainSepolia.id]: 14,
+};
+const tokenAddresses = {
+    [chains.mainnet.id]: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    [chains.sepolia.id]: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238",
+    [chains.avalanche.id]: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    [chains.avalancheFuji.id]: "0x5425890298aed601595a70AB815c96711a31Bc65",
+    [chains.optimism.id]: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    [chains.optimismSepolia.id]: "0x5fd84259d66Cd46123540766Be93DFE6D43130D7",
+    [chains.arbitrum.id]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    [chains.arbitrumSepolia.id]: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    [chains.base.id]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    [chains.baseSepolia.id]: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    [chains.polygon.id]: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    [chains.polygonAmoy.id]: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
+    [chains.unichain.id]: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
+    [chains.unichainSepolia.id]: "0x31d0220469e10c4E71834a79b1f276d740d3768F",
+    [chains.linea.id]: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff",
+    [chains.lineaSepolia.id]: "0xFEce4462D57bD51A6A552365A011b95f0E16d9B7",
+    [chains.worldchain.id]: "0x79A02482A880bCe3F13E09da970dC34dB4cD24D1",
+    [chains.worldchainSepolia.id]: "0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88",
+};
+const tokenMessengers = {
+    [chains.mainnet.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.sepolia.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.avalanche.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.avalancheFuji.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.optimism.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.optimismSepolia.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.arbitrum.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.arbitrumSepolia.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.base.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.baseSepolia.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.polygon.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.polygonAmoy.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.unichain.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.unichainSepolia.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.linea.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.lineaSepolia.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    [chains.worldchain.id]: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    [chains.worldchainSepolia.id]: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+};
+const messageTransmitters = {
+    [chains.mainnet.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.sepolia.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.avalanche.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.avalancheFuji.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.optimism.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.optimismSepolia.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.arbitrum.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.arbitrumSepolia.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.base.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.baseSepolia.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.polygon.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.polygonAmoy.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.unichain.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.unichainSepolia.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.linea.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.lineaSepolia.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    [chains.worldchain.id]: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    [chains.worldchainSepolia.id]: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+};
+export function getDomain(chainId) {
+    return domains[chainId] ?? null;
+}
+export function getTokenAddress(chainId) {
+    return tokenAddresses[chainId] ?? null;
+}
+export function getTokenMessenger(chainId) {
+    return tokenMessengers[chainId] ?? null;
+}
+export function getMessageTransmitter(chainId) {
+    return messageTransmitters[chainId] ?? null;
+}
+export async function cctpTransfer({ walletClient, originChain, destinationChain, amount, }) {
+    const originToken = getTokenAddress(originChain.id);
+    const originDomain = getDomain(originChain.id);
+    const destinationDomain = getDomain(destinationChain.id);
+    const originTokenMessenger = getTokenMessenger(originChain.id);
+    const destinationAddress = walletClient.account?.address;
+    if (!originToken ||
+        !originDomain ||
+        !originTokenMessenger ||
+        !destinationDomain ||
+        !destinationAddress) {
+        throw new Error("Invalid origin chain");
+    }
+    const originClient = createPublicClient({
+        chain: originChain,
+        transport: http(),
+    });
+    await attemptSwitchChain({
+        walletClient,
+        desiredChainId: originChain.id,
+    });
+    const account = walletClient.account?.address;
+    if (!account) {
+        throw new Error("No account found");
+    }
+    const needsApproval = await getNeedsApproval({
+        publicClient: originClient,
+        token: originToken,
+        account,
+        spender: originTokenMessenger,
+        amount: amount,
+    });
+    if (needsApproval) {
+        const txHash = await approveUSDC({
+            walletClient,
+            tokenAddress: originToken,
+            spender: originTokenMessenger,
+            amount: maxUint256,
+            chain: originChain,
+        });
+        console.log("waiting for approve", txHash);
+        await originClient.waitForTransactionReceipt({
+            hash: txHash,
+        });
+        console.log("approve done");
+    }
+    const maxFee = getMaxFee();
+    const txHash = await burnUSDC({
+        walletClient,
+        tokenMessenger: originTokenMessenger,
+        destinationDomain,
+        destinationAddress,
+        amount,
+        burnToken: originToken,
+        maxFee,
+        chain: originChain,
+    });
+    await originClient.waitForTransactionReceipt({
+        hash: txHash,
+    });
+    const attestation = await waitForAttestation({
+        domain: originDomain,
+        transactionHash: txHash,
+    });
+    if (!attestation) {
+        throw new Error("Failed to retrieve attestation");
+    }
+    return {
+        attestation,
+        txHash: txHash,
+    };
+}
+export async function cctpDestinationTx({ relayerClient, destinationChain, attestation, }) {
+    const destinationTokenMessenger = getMessageTransmitter(destinationChain.id);
+    if (!destinationTokenMessenger) {
+        throw new Error("Invalid destination chain");
+    }
+    await attemptSwitchChain({
+        walletClient: relayerClient,
+        desiredChainId: destinationChain.id,
+    });
+    const txHash = await mintUSDC({
+        walletClient: relayerClient,
+        tokenMessenger: destinationTokenMessenger,
+        attestation,
+        chain: destinationChain,
+    });
+    console.log("[trails-sdk] minted USDC");
+    return txHash;
+}
+export function getMaxFee() {
+    return 500n; // Set fast transfer max fee in 10^6 subunits (0.0005 USDC; change as needed)
+}
+export async function getNeedsApproval({ publicClient, token, account, spender, amount, }) {
+    const allowance = await publicClient.readContract({
+        address: token,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [getAddress(account), getAddress(spender)],
+    });
+    return allowance < amount;
+}
+export async function approveUSDC({ walletClient, tokenAddress, spender, amount, chain, }) {
+    const approvalData = await getApproveUSDCData({
+        tokenAddress,
+        spender,
+        amount,
+    });
+    console.log("[trails-sdk] approving USDC transfer", approvalData);
+    await attemptSwitchChain({
+        walletClient,
+        desiredChainId: chain.id,
+    });
+    const account = walletClient.account?.address;
+    if (!account) {
+        throw new Error("No account found");
+    }
+    return walletClient.sendTransaction({
+        ...approvalData,
+        account: account,
+        chain,
+    });
+}
+async function getApproveUSDCData({ tokenAddress, spender, amount, }) {
+    console.log("[trails-sdk] get approve USDC transfer data", {
+        tokenAddress,
+        spender,
+        amount,
+    });
+    return {
+        to: tokenAddress,
+        value: BigInt(0),
+        data: encodeFunctionData({
+            abi: [
+                {
+                    type: "function",
+                    name: "approve",
+                    stateMutability: "nonpayable",
+                    inputs: [
+                        { name: "spender", type: "address" },
+                        { name: "amount", type: "uint256" },
+                    ],
+                    outputs: [{ name: "", type: "bool" }],
+                },
+            ],
+            functionName: "approve",
+            args: [spender, amount],
+        }),
+    };
+}
+export async function burnUSDC({ walletClient, tokenMessenger, destinationDomain, destinationAddress, amount, burnToken, maxFee, chain, }) {
+    const burnData = await getBurnUSDCData({
+        tokenMessenger,
+        destinationDomain,
+        destinationAddress,
+        amount,
+        burnToken,
+        maxFee: maxFee,
+    });
+    await attemptSwitchChain({
+        walletClient,
+        desiredChainId: chain.id,
+    });
+    const account = walletClient.account?.address;
+    if (!account) {
+        throw new Error("No account found");
+    }
+    return walletClient.sendTransaction({
+        ...burnData,
+        account: account,
+        chain,
+    });
+}
+export async function getBurnUSDCData({ tokenMessenger, destinationDomain, destinationAddress, amount, burnToken, maxFee, }) {
+    console.log("[trails-sdk] get burn USDC data", {
+        tokenMessenger,
+        destinationDomain,
+        destinationAddress,
+        amount,
+        burnToken,
+        maxFee,
+    });
+    // Bytes32 Formatted Parameters
+    const DESTINATION_ADDRESS_BYTES32 = `0x000000000000000000000000${destinationAddress.slice(2)}`; // Destination address in bytes32 format
+    const DESTINATION_CALLER_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000"; // Empty bytes32 allows any address to call MessageTransmitterV2.receiveMessage()
+    return {
+        to: tokenMessenger,
+        value: BigInt(0),
+        data: encodeFunctionData({
+            abi: [
+                {
+                    type: "function",
+                    name: "depositForBurn",
+                    stateMutability: "nonpayable",
+                    inputs: [
+                        { name: "amount", type: "uint256" },
+                        { name: "destinationDomain", type: "uint32" },
+                        { name: "mintRecipient", type: "bytes32" },
+                        { name: "burnToken", type: "address" },
+                        { name: "destinationCaller", type: "bytes32" },
+                        { name: "maxFee", type: "uint256" },
+                        { name: "minFinalityThreshold", type: "uint32" },
+                    ],
+                    outputs: [],
+                },
+            ],
+            functionName: "depositForBurn",
+            args: [
+                amount,
+                destinationDomain,
+                DESTINATION_ADDRESS_BYTES32,
+                burnToken,
+                DESTINATION_CALLER_BYTES32,
+                maxFee,
+                1000, // minFinalityThreshold (1000 or less for Fast Transfer)
+            ],
+        }),
+    };
+}
+export async function retrieveAttestation({ domain, transactionHash, }) {
+    console.log("[trails-sdk] retrieving attestation", {
+        domain,
+        transactionHash,
+    });
+    const url = `https://iris-api-sandbox.circle.com/v2/messages/${domain}?transactionHash=${transactionHash}`;
+    while (true) {
+        try {
+            const response = await fetch(url);
+            const data = await response.json();
+            if (response.status === 404) {
+                console.log("[trails-sdk] waiting for attestation...");
+            }
+            if (data?.messages?.[0]?.status === "complete") {
+                console.log("[trails-sdk] attestation retrieved successfully!");
+                return data.messages[0];
+            }
+            console.log("[trails-sdk] waiting for attestation...");
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+        catch (error) {
+            console.error("[trails-sdk] error fetching attestation:", error instanceof Error ? error.message : String(error));
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+    }
+}
+export async function mintUSDC({ walletClient, tokenMessenger, attestation, chain, }) {
+    const mintData = await getMintUSDCData({
+        tokenMessenger,
+        attestation,
+    });
+    await attemptSwitchChain({
+        walletClient,
+        desiredChainId: chain.id,
+    });
+    const account = walletClient.account?.address;
+    if (!account) {
+        throw new Error("No account found");
+    }
+    return walletClient.sendTransaction({
+        ...mintData,
+        account: account,
+        chain,
+    });
+}
+export async function getMintUSDCData({ tokenMessenger, attestation, }) {
+    console.log("[trails-sdk] get mint USDC data", {
+        tokenMessenger,
+        attestation,
+    });
+    return {
+        to: tokenMessenger,
+        value: BigInt(0),
+        data: encodeFunctionData({
+            abi: [
+                {
+                    type: "function",
+                    name: "receiveMessage",
+                    stateMutability: "nonpayable",
+                    inputs: [
+                        { name: "message", type: "bytes" },
+                        { name: "attestation", type: "bytes" },
+                    ],
+                    outputs: [],
+                },
+            ],
+            functionName: "receiveMessage",
+            args: [attestation.message, attestation.attestation],
+        }),
+    };
+}
+export async function waitForAttestation({ domain, transactionHash, }) {
+    while (true) {
+        const attestation = await retrieveAttestation({
+            domain,
+            transactionHash,
+        });
+        if (attestation) {
+            return attestation;
+        }
+        console.log("[trails-sdk] waiting for attestation...");
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+}
+export function getIsUsdcAddress(address, chainId) {
+    return address?.toLowerCase() === tokenAddresses[chainId]?.toLowerCase();
+}

package/dist/chainSwitch.d.ts

@@ -0,0 +1,7 @@
+import type { WalletClient } from "viem";
+export type AttemptSwitchChainParams = {
+    walletClient: WalletClient;
+    desiredChainId: number;
+};
+export declare function attemptSwitchChain({ walletClient, desiredChainId, }: AttemptSwitchChainParams): Promise<void>;
+//# sourceMappingURL=chainSwitch.d.ts.map

package/dist/chainSwitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainSwitch.d.ts","sourceRoot":"","sources":["../src/chainSwitch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAGxC,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,EAAE,YAAY,CAAA;IAC1B,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,wBAAsB,kBAAkB,CAAC,EACvC,YAAY,EACZ,cAAc,GACf,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C1C"}

package/dist/chainSwitch.js

@@ -0,0 +1,33 @@
+import { getChainInfo } from "./chains.js";
+export async function attemptSwitchChain({ walletClient, desiredChainId, }) {
+    try {
+        // Check if the chain was switched successfully
+        let currentChainId = await walletClient.getChainId();
+        if (currentChainId === desiredChainId) {
+            console.log("[trails-sdk] Chain already switched to:", desiredChainId);
+            return;
+        }
+        console.log("[trails-sdk] Switching to chain:", desiredChainId, "currentChainId", currentChainId);
+        await walletClient.switchChain({ id: desiredChainId });
+        // Check if the chain was switched successfully
+        currentChainId = await walletClient.getChainId();
+        if (currentChainId !== desiredChainId) {
+            throw new Error("Failed to switch chain");
+        }
+        console.log("[trails-sdk] Chain switched to:", desiredChainId);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.includes("wallet_addEthereumChain")) {
+            const chainInfo = getChainInfo(desiredChainId);
+            if (chainInfo) {
+                await walletClient.addChain({
+                    chain: chainInfo,
+                });
+                return attemptSwitchChain({ walletClient, desiredChainId });
+            }
+        }
+        console.error("[trails-sdk] Chain switch failed:", error);
+        throw new Error(`[trails-sdk] Failed to switch chain: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+}

package/dist/chains.d.ts

@@ -0,0 +1,13 @@
+import type { Chain } from "viem";
+export declare const supportedSequenceChains: Record<number, Chain>;
+export declare const supportedSequenceTestnetChains: Record<number, Chain>;
+export declare function getChainInfo(chainId: number): Chain | null;
+export declare function getTestnetChainInfo(mainnetChain: Chain | number): Chain | null;
+export declare function getSupportedSequenceChains(): Promise<Chain[]>;
+export declare function getSupportedSequenceTestnetChains(): Promise<Chain[]>;
+export declare function getSupportedChains(): Promise<Chain[]>;
+export declare function useSupportedChains(): {
+    supportedChains: Chain[];
+    isLoadingChains: boolean;
+};
+//# sourceMappingURL=chains.d.ts.map

package/dist/chains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../src/chains.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAA;AAIjC,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAezD,CAAA;AAED,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAahE,CAAA;AAGD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAM1D;AAGD,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,KAAK,GAAG,MAAM,GAC3B,KAAK,GAAG,IAAI,CAKd;AAED,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC,CAEnE;AAED,wBAAsB,iCAAiC,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC,CAE1E;AA0BD,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC,CAgB3D;AAED,wBAAgB,kBAAkB,IAAI;IACpC,eAAe,EAAE,KAAK,EAAE,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;CACzB,CAcA"}

package/dist/chains.js

@@ -0,0 +1,95 @@
+import { useQuery } from "@tanstack/react-query";
+import * as chains from "viem/chains";
+import { getRelaySupportedChains } from "./relaySdk.js";
+export const supportedSequenceChains = {
+    [chains.apeChain.id]: chains.mainnet,
+    [chains.arbitrum.id]: chains.arbitrum,
+    [chains.arbitrumNova.id]: chains.arbitrumNova,
+    [chains.avalanche.id]: chains.avalanche,
+    [chains.b3.id]: chains.b3,
+    [chains.base.id]: chains.base,
+    [chains.blast.id]: chains.polygon,
+    // [chains.opBNB.id]: chains.opBNB, // Needs chain image
+    [chains.mainnet.id]: chains.mainnet,
+    [chains.gnosis.id]: chains.gnosis,
+    [chains.optimism.id]: chains.optimism,
+    [chains.polygon.id]: chains.polygon,
+    [chains.soneium.id]: chains.soneium,
+    [chains.xai.id]: chains.xai,
+};
+export const supportedSequenceTestnetChains = {
+    [chains.arbitrumSepolia.id]: chains.arbitrumSepolia,
+    [chains.avalancheFuji.id]: chains.avalancheFuji,
+    [chains.b3Sepolia.id]: chains.b3Sepolia,
+    [chains.baseSepolia.id]: chains.baseSepolia,
+    [chains.blastSepolia.id]: chains.blastSepolia,
+    [chains.opBNBTestnet.id]: chains.opBNBTestnet,
+    [chains.sepolia.id]: chains.sepolia,
+    [chains.gnosisChiado.id]: chains.gnosisChiado,
+    [chains.polygonAmoy.id]: chains.polygonAmoy,
+    [chains.optimismSepolia.id]: chains.optimismSepolia,
+    [chains.soneiumMinato.id]: chains.soneiumMinato,
+    [chains.xaiTestnet.id]: chains.xaiTestnet,
+};
+// Helper to get chain info
+export function getChainInfo(chainId) {
+    return (Object.values(chains).find((chain) => chain.id === chainId) || null);
+}
+// Get testnet chain info from mainnet chain as input
+export function getTestnetChainInfo(mainnetChain) {
+    if (typeof mainnetChain === "number") {
+        return supportedSequenceTestnetChains[mainnetChain] || null;
+    }
+    return supportedSequenceTestnetChains[mainnetChain.id] || null;
+}
+export async function getSupportedSequenceChains() {
+    return Object.values(supportedSequenceChains);
+}
+export async function getSupportedSequenceTestnetChains() {
+    return Object.values(supportedSequenceTestnetChains);
+}
+// Priority chains that should appear first in the list
+const PRIORITY_CHAIN_IDS = [1, 8453, 42161, 10, 137];
+// Sort function for chains with priority order and then by name
+function sortChains(chains) {
+    return chains.sort((a, b) => {
+        // 1. Priority chains first (1, 8453, 42161, 10, 137)
+        const aPriority = PRIORITY_CHAIN_IDS.indexOf(a.id);
+        const bPriority = PRIORITY_CHAIN_IDS.indexOf(b.id);
+        // If both are priority chains, sort by priority order
+        if (aPriority !== -1 && bPriority !== -1) {
+            return aPriority - bPriority;
+        }
+        // If only one is a priority chain, prioritize it
+        if (aPriority !== -1)
+            return -1;
+        if (bPriority !== -1)
+            return 1;
+        // 2. Sort by chain name alphabetically
+        return a.name.localeCompare(b.name);
+    });
+}
+export async function getSupportedChains() {
+    const sequenceChains = await getSupportedSequenceChains();
+    const relayChains = await getRelaySupportedChains();
+    // Find intersection of sequence chains and relay chains
+    const supportedChains = sequenceChains.filter((sequenceChain) => relayChains.some((relayChain) => relayChain.id === sequenceChain.id));
+    // Ensure unique chain IDs by filtering duplicates
+    const uniqueChains = supportedChains.filter((chain, index, self) => index === self.findIndex((c) => c.id === chain.id));
+    // Sort chains by priority and then by name
+    return sortChains(uniqueChains);
+}
+export function useSupportedChains() {
+    const { data: supportedChains = [], isLoading: isLoadingChains } = useQuery({
+        queryKey: ["supportedChains"],
+        queryFn: getSupportedChains,
+        staleTime: 60 * 60 * 1000, // 1 hour - chains rarely change
+        gcTime: 24 * 60 * 60 * 1000, // 24 hours - keep in cache for a full day
+        refetchOnWindowFocus: false, // Don't refetch when window regains focus
+        refetchOnReconnect: false, // Don't refetch on network reconnect
+    });
+    return {
+        supportedChains: supportedChains || [],
+        isLoadingChains,
+    };
+}

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const ATTESATION_SIGNER_ADDRESS = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+export declare const TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS = "0xd7571bd1e3af468c3a49966c9a92a2e907cdfa52";
+export declare const TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS = "0x9a013e7d186611af36a918ef23d81886e8c256f8";
+export declare const TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS = "0xc1A9B197eBb31Fc2B613C59dAC3f3E5698A429D0";
+export declare const DEFAULT_INDEXER_GATEWAY_URL = "https://dev-indexer.sequence.app";
+export declare const DEFAULT_API_URL = "https://v3-api.sequence.app";
+export declare const DEFAULT_ENV = "dev";
+export declare const intentEntrypoints: Record<number, `0x${string}`>;
+export declare const DEFAULT_SEQUENCE_PROJECT_ACCESS_KEY = "AQAAAAAAAAaq1E41OU0QxifQgrVBMgfqg7k";
+export declare const DEFAULT_USE_V3_RELAYERS = true;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,+CACQ,CAAA;AAE9C,eAAO,MAAM,kCAAkC,+CACD,CAAA;AAC9C,eAAO,MAAM,mCAAmC,+CACF,CAAA;AAC9C,eAAO,MAAM,kCAAkC,+CACD,CAAA;AAE9C,eAAO,MAAM,2BAA2B,qCAAqC,CAAA;AAC7E,eAAO,MAAM,eAAe,gCAAgC,CAAA;AAC5D,eAAO,MAAM,WAAW,QAAQ,CAAA;AAEhC,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,MAAM,EAAE,CAM3D,CAAA;AAED,eAAO,MAAM,mCAAmC,wCACT,CAAA;AAEvC,eAAO,MAAM,uBAAuB,OAAO,CAAA"}

package/dist/constants.js

@@ -0,0 +1,16 @@
+export const ATTESATION_SIGNER_ADDRESS = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+export const TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS = "0xd7571bd1e3af468c3a49966c9a92a2e907cdfa52";
+export const TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS = "0x9a013e7d186611af36a918ef23d81886e8c256f8";
+export const TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS = "0xc1A9B197eBb31Fc2B613C59dAC3f3E5698A429D0";
+export const DEFAULT_INDEXER_GATEWAY_URL = "https://dev-indexer.sequence.app";
+export const DEFAULT_API_URL = "https://v3-api.sequence.app";
+export const DEFAULT_ENV = "dev";
+export const intentEntrypoints = {
+    8453: "0x2bf4c63199eD7D8A737E8DB2cC19E0C0103F6bE3",
+    84532: "0xdcd9160492C6D43ABbd28D4d06F68ad77f1A0F2b",
+    421614: "0xf18A16E1C778baCA5d6f7F48cC4c9bb913e5e579",
+    42161: "0x674827B6BE8780DBdb96DC02c735275e3a982c90",
+    137: "0x4dBb20eA3A969F1A44d7653D4Dc8632B853E36DE",
+};
+export const DEFAULT_SEQUENCE_PROJECT_ACCESS_KEY = "AQAAAAAAAAaq1E41OU0QxifQgrVBMgfqg7k";
+export const DEFAULT_USE_V3_RELAYERS = true;

package/dist/encoders.d.ts

@@ -0,0 +1,7 @@
+import type { Hex } from "viem";
+export type ERC20TransferParams = {
+    recipient: string;
+    amount: bigint;
+};
+export declare function getERC20TransferData({ recipient, amount, }: ERC20TransferParams): Hex;
+//# sourceMappingURL=encoders.d.ts.map

package/dist/encoders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoders.d.ts","sourceRoot":"","sources":["../src/encoders.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE/B,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,oBAAoB,CAAC,EACnC,SAAS,EACT,MAAM,GACP,EAAE,mBAAmB,GAAG,GAAG,CAQ3B"}

package/dist/encoders.js

@@ -0,0 +1,8 @@
+import { AbiFunction } from "ox";
+export function getERC20TransferData({ recipient, amount, }) {
+    const erc20Transfer = AbiFunction.from("function transfer(address,uint256) returns (bool)");
+    return AbiFunction.encodeData(erc20Transfer, [
+        recipient,
+        amount,
+    ]);
+}

package/dist/error.d.ts

@@ -0,0 +1,2 @@
+export declare function getFullErrorMessage(err: any): string;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,GAAG,UAc3C"}

package/dist/error.js

@@ -0,0 +1,12 @@
+export function getFullErrorMessage(err) {
+    const messages = [];
+    let current = err;
+    while (current) {
+        if (current.message) {
+            messages.push(current.message);
+        }
+        // Check for nested error cause
+        current = current.cause ?? current.originalError ?? current.error ?? null;
+    }
+    return messages.join(" | Caused by: ");
+}

package/dist/explorer.d.ts

@@ -0,0 +1,12 @@
+export type ExplorerUrlParams = {
+    txHash: string;
+    chainId: number;
+};
+export type ExplorerUrlForAddressParams = {
+    address: string;
+    chainId: number;
+};
+export declare function getBaseExplorerUrl(chainId: number): string;
+export declare function getExplorerUrl({ txHash, chainId }: ExplorerUrlParams): string;
+export declare function getExplorerUrlForAddress({ address, chainId, }: ExplorerUrlForAddressParams): string;
+//# sourceMappingURL=explorer.d.ts.map

package/dist/explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorer.d.ts","sourceRoot":"","sources":["../src/explorer.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAW1D;AAED,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAG7E;AAED,wBAAgB,wBAAwB,CAAC,EACvC,OAAO,EACP,OAAO,GACR,EAAE,2BAA2B,GAAG,MAAM,CAGtC"}