Versioning

const headers = {
  "Content-Type": "application/json",
  "x-api-key": apiKey,
  "x-api-version": "2026-09.caucasus",
};

const baseUsdc = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
const arbitrumUsdc = "0xaf88d065e77c8cc2239327c5edb3a432268e5831";

// Before: Blanc
const blancBody = {
  account: {
    address: accountAddress,
    accountType: "EOA",
  },
  accountAccessList: {
    chainIds: ["eip155:8453"],
    tokens: [baseUsdc],
  },
  destinationChainId: "eip155:42161",
  tokenRequests: [{ tokenAddress: arbitrumUsdc, amount: "10000000" }],
};

// After: Caucasus
const caucasusBody = {
  account: {
    evm: {
      type: "eoa",
      address: accountAddress,
    },
  },
  source: {
    vm: "evm",
    chainId: "eip155:8453",
    token: baseUsdc,
  },
  destination: {
    vm: "evm",
    chainId: "eip155:42161",
    token: arbitrumUsdc,
    amount: "10000000",
  },
};

const account = {
  svm: {
    type: "swig",
    address: swigWalletAddress,
    swigAccount: swigStateAddress,
    authorization: {
      kind: "secp256k1",
      address: authorityAddress,
    },
  },
};

// Before: fields on the Blanc quote body
const blancExecution = {
  destinationExecutions: calls,
  destinationGasLimit: "200000",
};

// After: fields inside the Caucasus destination
const destination = {
  ...caucasusBody.destination,
  execution: {
    calls,
    gasLimit: "200000",
  },
};

// Before
const blancQuote = await postBlanc("/quotes", blancBody);
const { signData, tokenRequirements } = blancQuote.routes[0];

// After
const caucasusQuote = await postCaucasus("/quotes", caucasusBody);
if (caucasusQuote.status !== "quoted") {
  throw new Error("Unsupported quote outcome");
}

const route = caucasusQuote.routes[0];
const { plan, requirements, signingRequests } = route;

signingRequests[i] → proofs[i]

// Before: Blanc
const beforeRoute = blancQuote.routes[0];

const origin = [];
for (const data of beforeRoute.signData.origin) {
  if (data.kind !== "eip712") {
    throw new Error("This example only handles EIP-712");
  }
  origin.push(await signer.signTypedData(data));
}

const destinationSignature = beforeRoute.signData.destination
  ? await signer.signTypedData(beforeRoute.signData.destination)
  : undefined;

await postBlanc("/intents", {
  intentId: beforeRoute.intentId,
  signatures: {
    origin,
    destination: destinationSignature,
  },
});

// After: Caucasus
const proofs = [];

for (const request of route.signingRequests) {
  const payload = request.payload;

  if (payload.kind !== "eip712" || payload.signatureFormat !== "secp256k1") {
    throw new Error("This example only handles EOA EIP-712 proofs");
  }

  proofs.push({
    kind: "eip712",
    signature: await signer.signTypedData(payload.typedData),
  });
}

await postCaucasus("/intents", {
  intentId: route.intentId,
  proofs,
});

const proof = {
  kind: "eip712",
  signature: {
    preClaim,
    notarizedClaim,
  },
};

// Before
const blancOptions = {
  sponsorSettings: {
    gas: true,
    bridgeFees: true,
    swapFees: false,
  },
};

// After
const caucasusOptions = {
  sponsorship: {
    gas: true,
    bridgeFees: true,
    swapFees: false,
  },
};

const approvalInput = {
  contractVersion: "sdk-3.0.0-caucasus",
  account: body.account,
  ...(body.source !== undefined && { source: body.source }),
  destination: body.destination,
  options: body.options ?? {},
};

// Before
const before = await getBlanc(`/intents/${intentId}`);

const oldTransactions = before.operations.flatMap(({ chain, items }) =>
  items
    .filter((item) => item.txHash)
    .map((item) => ({ chain, txHash: item.txHash })),
);

// After
const after = await getCaucasus(`/intents/${intentId}`);

const transactions = after.operations.flatMap(({ items }) =>
  items.flatMap((item) =>
    "transaction" in item && item.transaction ? [item.transaction] : [],
  ),
);

// Before
const beforePage = await getBlanc("/intents?limit=20");

const oldSummaries = beforePage.data.map((item) => ({
  id: item.id,
  amount: item.amount,
  symbol: item.symbol,
}));

// After
const afterPage = await getCaucasus("/intents?limit=20");

const summaries = afterPage.data.map((item) => ({
  id: item.intentId,
  side: item.value?.side,
  amount: item.value?.amount,
  symbol: item.value?.symbol,
}));

// Before: Blanc, exact-in
const blancEstimate = {
  direction: "exactIn",
  sourceChainId: "eip155:8453",
  sourceToken: baseUsdc,
  destinationChainId: "eip155:42161",
  destinationToken: arbitrumUsdc,
  amountIn: "10000000",
  accountType: "SMART_ACCOUNT",
  accountDeployed: true,
};

// After: Caucasus, exact-in
const caucasusEstimate = {
  account: {
    evm: { type: "erc7579" },
  },
  source: {
    vm: "evm",
    chainId: "eip155:8453",
    token: baseUsdc,
    amount: "10000000",
    assumptions: { deployed: true },
  },
  destination: {
    vm: "evm",
    chainId: "eip155:42161",
    token: arbitrumUsdc,
  },
};

const { amount: _amount, ...source } = caucasusEstimate.source;

const exactOutEstimate = {
  ...caucasusEstimate,
  source,
  destination: {
    ...caucasusEstimate.destination,
    amount: "10000000",
  },
};

// Before
const beforeEstimate = await postBlanc("/quotes/estimate", blancEstimate);
const oldInput = beforeEstimate.routes[0].input;
const oldFees = beforeEstimate.routes[0].fees;

// After
const afterEstimate = await postCaucasus("/quotes/estimate", caucasusEstimate);
const input = afterEstimate.routes[0].cost.input[0];
const fees = afterEstimate.routes[0].cost.fees;
const assumptions = afterEstimate.routes[0].assumptions;

// Before: fields on a Blanc quote body
const blancHyperCore = {
  destinationChainId: "hypercore:perp",
  options: {
    hyperCore: { actions },
  },
  destinationExecutions: settlementCalls,
  destinationGasLimit: "200000",
};

// After: the Caucasus destination
const hyperCoreDestination = {
  vm: "hypercore",
  chainId: "hypercore:perp",
  token: hyperEvmUsdc,
  amount: "10000000",
  execution: {
    actions,
    settlement: {
      calls: settlementCalls,
      gasLimit: "200000",
    },
  },
};

const outcome = intent.operations
  .flatMap(({ items }) => items)
  .find((item) => item.type === "EXECUTION" && item.result.vm === "hypercore")
  ?.result.outcome;

// Before (alps) — client round-trips the full intentOp
const { intentOp } = await post("/intents/route", body);
const signatures = await sign(intentOp);
await post("/intent-operations", {
  signedIntentOp: { ...intentOp, ...signatures },
});

// After (blanc) — server stores the intent, client submits signatures by id
const { routes } = await post("/quotes", body);
const { intentId, signData } = routes[0];
const signatures = {
  origin: await Promise.all(signData.origin.map(signTypedData)),
  destination: await signTypedData(signData.destination),
};
await post("/intents", { intentId, signatures });

// Before (alps) — client hashes intent fields with hand-built EIP-712 types
const hash = getIntentHash(intentOp);
const sig = await signer.signTypedData(types, hash);

// After (blanc) — server provides the typed data directly
const sig = await signer.signTypedData(signData.origin[0]);

// Before (alps) — wrapped, with synthesised status
const { result } = await post("/intent-operations", body);
const id = result.id; // result.status was "PENDING" or synthesised "FAILED"

// After (blanc) — id only; simulation failures surface as 4xx
const { intentId } = await post("/intents", body);

// Before (alps)
const op = await get(`/intent-operation/${id}`);
const status = op.result.status;

// After (blanc)
const op = await get(`/intents/${intentId}`);
const status = op.status;

// Before (alps)
{ "chainId": 42161 }
{ "tokenRequirements": { "1": [...], "42161": [...] } }

// After (blanc)
{ "chainId": "eip155:42161" }
{ "tokenRequirements": { "eip155:1": [...], "eip155:42161": [...] } }

GET /accounts/0xabc/portfolio
  ?chainIds=eip155:1&chainIds=eip155:137
  &tokens=eip155:1:0xa0b...&tokens=eip155:137:0xa0b...

// Before (alps)
const gasUSD = response.feeBreakdownUSD.gas;
const inputAmount = response.tokensSpent[0].amount;

// After (blanc)
const gasUSD = route.cost.fees.breakdown.gas.usd;
const inputAmount = route.cost.input[0].amount;

// Before (alps)
{
  sponsorSettings: {
    gasSponsored: true,
    bridgeFeesSponsored: false,
    swapFeesSponsored: false,
  }
}

// After (blanc)
{
  sponsorSettings: {
    gas: true,
    bridgeFees: false,
    swapFees: false,
  }
}

// Before (alps)
{
  account: {
    accountType: "SMART_ACCOUNT",
    mockSignature: "0x...",
  }
}

// After (blanc)
{
  account: {
    accountType: "ERC7579",
    mockSignatures: {
      "eip155:1": "0x...",
      "eip155:42161": "0x...",
    },
  }
}

// Before (alps) — message-pattern matching
if (err.message === "Insufficient balance") { /* ... */ }
if (err.message.startsWith("Unsupported chain ")) { /* ... */ }

// After (blanc) — code-based dispatch
switch (err.code) {
  case "INSUFFICIENT_LIQUIDITY":
    // err.details: { availableIntents, unfillable }
    break;
  case "VALIDATION_ERROR":
    // err.details: [{ message, context? }]
    break;
}