- {#await quoteRequest}
-
- Quote
-
- {:then _}
-
- {#if quoteExpires !== 0}
-
-
Quote
- {:else}
-
-
No Quote
- {/if}
- {/await}
+ {#await quoteRequest}
+
+ Quote
+
+ {:then _}
+
+ {#if quoteExpires !== 0}
+
+
Quote
+ {:else}
+
+
No Quote
+ {/if}
+ {/await}
-
- This web app showcases a chain-abstracted flow using the
- Open Intents Framework . It currently supports a Resource Lock flow using
- The Compact and an ERC 7683-compliant escrow flow.
-
+
+ This webapp demonstrates chain abstraction using the
+ Open Intents Framework . It currently support a seamless resource lock flow using
+ The Compact and a traditional escrow flow, along with a work in progress multichain flow.
+
-
+
-
Why Resource Locks?
-
- Resource Locks improve asset availability guarantees in cross-chain contexts and asynchronous
- environments, offering several key advantages:
-
+
Multichain
+
+ A multichain intent is an intent that collects inputs on multiple chains, providing the result
+ on one or more chains. In other words, a multichain intent is an any to any intent.
+ Multichain intents are currently work in progress and will break in the future. If you are using
+ this interface for testing, ensure the multichain flag is not shown.
+
-
- Funds are only debited after successful delivery has been proven.
-
- Enables efficient short-lived interactions—intents can expire within seconds without
- consequence.
-
- No upfront deposit or initiation transaction are required.
- Fully composable with other protocols and settlement layers.
-
-
-
- Learn more about
- Resource Locks .
-
+
-
+
Why Resource Locks?
+
+ Resource Locks improve asset availability guarantees in cross-chain contexts and asynchronous
+ environments, offering several key advantages:
+
-
Why the Open Intents Framework?
-
- The Open Intents Framework (OIF) is an open coordination layer for standardizing and scaling
- intent-based workflows across chains. The goal is to:
-
+
+ Funds are only debited after successful delivery has been proven.
+
+ Enables efficient short-lived interactions—intents can expire within seconds without
+ consequence.
+
+ No upfront deposit or initiation transaction are required.
+ Fully composable with other protocols and settlement layers.
+
-
- Standardise cross-chain interactions.
- Define a permissionless intent implementation that can scale across all chains.
- Create a reference implementation for cross-chain solvers & searchers.
- Provide tooling for wallet and app developers.
-
-
-
- Learn more about
- Open Intents Framework .
-
+
+ Learn more about
+ Resource Locks .
+
-
+
-
Same Chain
-
- A same chain intent is an intent that only has inputs and outputs on the same chain. The oracle
- is configured different to a cross-chain intent. SetAttestation has to be called on the output
- settler to expose the filled output. Learm more about same chain intents or explore a demo of how to collect inputs before delivering outputs.
-
+
Why the Open Intents Framework?
+
+ The Open Intents Framework (OIF) is an open coordination layer for standardizing and scaling
+ intent-based workflows across chains. The goal is to:
+
-
+
+ Standardise cross-chain interactions.
+ Define a permissionless intent implementation that can scale across all chains.
+ Create a reference implementation for cross-chain solvers & searchers.
+ Provide tooling for wallet and app developers.
+
+
+ Learn more about
+ Open Intents Framework .
+
-
Multichain
-
- A multichain intent is an intent that collects inputs on multiple chains, providing the result
- on one or more chains. In other words, a multichain intent is an any to any intent.
- Multichain intents are currently a work in progress and will break in the future. If you are
- using this interface for testing, ensure the multichain flag is not shown.
-
+
-
+
Same Chain
+
+ A same chain intent is an intent that only has inputs and outputs on the same chain. The oracle
+ is configured different to a cross-chain intent. SetAttestation has to be called on the output
+ settler to expose the filled output. Learm more about same chain intents or explore a demo of how to collect inputs before delivering outputs.
+
-
- Progress
-
-
-
- {#each steps as step, i (step.id)}
-
step.clickable && onStepClick?.(step)}
- >
- {step.label}
-
- {#if i < steps.length - 1}
-
- {/if}
- {/each}
-
-
+
+
+ Progress
+
+
+
+ {#each steps as step, i (step.id)}
+
step.clickable && onStepClick?.(step)}
+ >
+ {step.label}
+
+ {#if i < steps.length - 1}
+
+ {/if}
+ {/each}
+
+
+
+
diff --git a/src/lib/components/ui/FlowStepTracker.svelte b/src/lib/components/ui/FlowStepTracker.svelte
index 31f7e79..434ed6b 100644
--- a/src/lib/components/ui/FlowStepTracker.svelte
+++ b/src/lib/components/ui/FlowStepTracker.svelte
@@ -1,230 +1,230 @@
diff --git a/src/lib/components/ui/FormControl.svelte b/src/lib/components/ui/FormControl.svelte
index 1553054..bc4e34a 100644
--- a/src/lib/components/ui/FormControl.svelte
+++ b/src/lib/components/ui/FormControl.svelte
@@ -1,60 +1,60 @@
{#if as === "select"}
-
- {@render children?.()}
-
+
+ {@render children?.()}
+
{:else}
-
+
{/if}
diff --git a/src/lib/components/ui/InlineMetaField.svelte b/src/lib/components/ui/InlineMetaField.svelte
index c1adac7..95e2eb4 100644
--- a/src/lib/components/ui/InlineMetaField.svelte
+++ b/src/lib/components/ui/InlineMetaField.svelte
@@ -1,27 +1,27 @@
-
-
- {metaPrefix}
- {metaText}
-
+
+
+ {metaPrefix}
+ {metaText}
+
diff --git a/src/lib/components/ui/ScreenFrame.svelte b/src/lib/components/ui/ScreenFrame.svelte
index b9b30ed..b3ad6fb 100644
--- a/src/lib/components/ui/ScreenFrame.svelte
+++ b/src/lib/components/ui/ScreenFrame.svelte
@@ -1,29 +1,29 @@
- {#if title}
-
{title}
- {/if}
- {#if description}
-
{description}
- {/if}
-
- {@render children?.()}
-
+ {#if title}
+
{title}
+ {/if}
+ {#if description}
+
{description}
+ {/if}
+
+ {@render children?.()}
+
diff --git a/src/lib/components/ui/SectionCard.svelte b/src/lib/components/ui/SectionCard.svelte
index ed08b64..d03bffc 100644
--- a/src/lib/components/ui/SectionCard.svelte
+++ b/src/lib/components/ui/SectionCard.svelte
@@ -1,40 +1,40 @@
- {#if title || headerRight}
-
- {#if title}
-
{title}
- {/if}
- {#if headerRight}
-
- {@render headerRight()}
-
- {/if}
-
- {/if}
-
- {@render children?.()}
-
+ {#if title || headerRight}
+
+ {#if title}
+
{title}
+ {/if}
+ {#if headerRight}
+
+ {@render headerRight()}
+
+ {/if}
+
+ {/if}
+
+ {@render children?.()}
+
diff --git a/src/lib/components/ui/SegmentedControl.svelte b/src/lib/components/ui/SegmentedControl.svelte
index 959d745..2812812 100644
--- a/src/lib/components/ui/SegmentedControl.svelte
+++ b/src/lib/components/ui/SegmentedControl.svelte
@@ -1,45 +1,45 @@
- {#each options as option, i (option.value)}
- 0 ? "border-l border-gray-200" : "",
- "transition-colors",
- value === option.value
- ? "bg-gray-100 font-semibold text-gray-800"
- : "bg-white text-gray-700 hover:bg-gray-50"
- ]}
- onclick={() => {
- value = option.value;
- onChange?.(option.value);
- }}
- >
- {option.label}
-
- {/each}
+ {#each options as option, i (option.value)}
+ 0 ? "border-l border-gray-200" : "",
+ "transition-colors",
+ value === option.value
+ ? "bg-gray-100 font-semibold text-gray-800"
+ : "bg-white text-gray-700 hover:bg-gray-50"
+ ]}
+ onclick={() => {
+ value = option.value;
+ onChange?.(option.value);
+ }}
+ >
+ {option.label}
+
+ {/each}
diff --git a/src/lib/components/ui/TokenAmountChip.svelte b/src/lib/components/ui/TokenAmountChip.svelte
index bf953f2..efeafbc 100644
--- a/src/lib/components/ui/TokenAmountChip.svelte
+++ b/src/lib/components/ui/TokenAmountChip.svelte
@@ -1,34 +1,34 @@
- {amountText}
- {symbol.toUpperCase()}
+ {amountText}
+ {symbol.toUpperCase()}
diff --git a/src/lib/config.ts b/src/lib/config.ts
index 18b3e03..2d5e2c8 100644
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -1,464 +1,555 @@
import { createPublicClient, createWalletClient, custom, defineChain, fallback, http } from "viem";
import {
- arbitrum,
- arbitrumSepolia,
- base,
- baseSepolia,
- mainnet as ethereum,
- optimismSepolia,
- sepolia,
- polygon,
- bsc,
- katana,
- megaeth
+ arbitrum,
+ arbitrumSepolia,
+ base,
+ baseSepolia,
+ mainnet as ethereum,
+ optimismSepolia,
+ sepolia,
+ polygon,
+ bsc,
+ katana,
+ megaeth,
+ optimism,
+ arcTestnet
} from "viem/chains";
export const pharos = defineChain({
- id: 1672,
- name: "Pharos",
- nativeCurrency: { name: "PROS", symbol: "PROS", decimals: 18 },
- rpcUrls: {
- default: { http: ["https://rpc.pharos.xyz"] }
- }
+ id: 1672,
+ name: "Pharos",
+ nativeCurrency: { name: "PROS", symbol: "PROS", decimals: 18 },
+ rpcUrls: {
+ default: { http: ["https://rpc.pharos.xyz"] }
+ }
});
export const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000" as const;
export const BYTES32_ZERO =
- "0x0000000000000000000000000000000000000000000000000000000000000000" as const;
+ "0x0000000000000000000000000000000000000000000000000000000000000000" as const;
export const COMPACT = "0x00000000000000171ede64904551eeDF3C6C9788" as const;
export const INPUT_SETTLER_COMPACT_LIFI = "0x0000000000cd5f7fDEc90a03a31F79E5Fbc6A9Cf" as const;
export const INPUT_SETTLER_ESCROW_LIFI = "0x000025c3226C00B2Cdc200005a1600509f4e00C0" as const;
export const MULTICHAIN_INPUT_SETTLER_ESCROW =
- "0xb912b4c38ab54b94D45Ac001484dEBcbb519Bc2B" as const;
+ "0xb912b4c38ab54b94D45Ac001484dEBcbb519Bc2B" as const;
export const MULTICHAIN_INPUT_SETTLER_COMPACT =
- "0x1fccC0807F25A58eB531a0B5b4bf3dCE88808Ed7" as const;
+ "0x1fccC0807F25A58eB531a0B5b4bf3dCE88808Ed7" as const;
export const ALWAYS_OK_ALLOCATOR = "281773970620737143753120258" as const;
export const POLYMER_ALLOCATOR = "116450367070547927622991121" as const; // 0x02ecC89C25A5DCB1206053530c58E002a737BD11 signing by 0x934244C8cd6BeBDBd0696A659D77C9BDfE86Efe6
export const COIN_FILLER = "0x0000000000eC36B683C2E6AC89e9A75989C22a2e" as const;
-export const WORMHOLE_ORACLE = {
- ethereum: "0x0000000000000000000000000000000000000000",
- arbitrum: "0x0000000000000000000000000000000000000000",
- base: "0x0000000000000000000000000000000000000000"
-} as const;
-export const POLYMER_ORACLE = {
- ethereum: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- arbitrum: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- base: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- megaeth: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- katana: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- polygon: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- bsc: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- pharos: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- // testnet
- sepolia: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
- baseSepolia: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
- arbitrumSepolia: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
- optimismSepolia: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00"
-} as const;
+export const WORMHOLE_ORACLE: Partial
> = {
+ [ethereum.id]: "0x0000000000000000000000000000000000000000",
+ [arbitrum.id]: "0x0000000000000000000000000000000000000000",
+ [base.id]: "0x0000000000000000000000000000000000000000"
+};
+export const POLYMER_ORACLE: Partial> = {
+ [ethereum.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [arbitrum.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [base.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [megaeth.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [katana.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [polygon.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [bsc.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [pharos.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ // testnet
+ [sepolia.id]: "0xe15b438C6267B0011aDa1e40fD8757Aa8Fe1E5a0",
+ [baseSepolia.id]: "0xe15b438C6267B0011aDa1e40fD8757Aa8Fe1E5a0",
+ [arbitrumSepolia.id]: "0xe15b438C6267B0011aDa1e40fD8757Aa8Fe1E5a0",
+ [optimismSepolia.id]: "0xe15b438C6267B0011aDa1e40fD8757Aa8Fe1E5a0",
+ [arcTestnet.id]: "0xe15b438C6267B0011aDa1e40fD8757Aa8Fe1E5a0"
+};
export type availableAllocators = typeof ALWAYS_OK_ALLOCATOR | typeof POLYMER_ALLOCATOR;
export type availableInputSettlers =
- | typeof INPUT_SETTLER_COMPACT_LIFI
- | typeof INPUT_SETTLER_ESCROW_LIFI;
+ | typeof INPUT_SETTLER_COMPACT_LIFI
+ | typeof INPUT_SETTLER_ESCROW_LIFI;
export const chainMap = {
- ethereum,
- base,
- arbitrum,
- sepolia,
- arbitrumSepolia,
- optimismSepolia,
- baseSepolia,
- katana,
- megaeth,
- bsc,
- polygon,
- pharos
+ ethereum,
+ base,
+ arbitrum,
+ optimism,
+ sepolia,
+ arbitrumSepolia,
+ optimismSepolia,
+ baseSepolia,
+ katana,
+ megaeth,
+ bsc,
+ polygon,
+ pharos,
+ arcTestnet
} as const;
-export const chains = Object.keys(chainMap) as (keyof typeof chainMap)[];
-export type chain = (typeof chains)[number];
+type ChainName = keyof typeof chainMap;
+export const chains = Object.keys(chainMap) as ChainName[];
export const chainList = (mainnet: boolean) => {
- if (mainnet == true) {
- return ["ethereum", "base", "arbitrum", "megaeth", "katana", "polygon", "bsc", "pharos"];
- } else return ["sepolia", "optimismSepolia", "baseSepolia", "arbitrumSepolia"];
+ if (mainnet == true) {
+ return [
+ "ethereum",
+ "base",
+ "arbitrum",
+ "megaeth",
+ "katana",
+ "polygon",
+ "bsc",
+ "pharos"
+ ] as ChainName[];
+ } else
+ return [
+ "sepolia",
+ "optimismSepolia",
+ "baseSepolia",
+ "arbitrumSepolia",
+ "arcTestnet"
+ ] as ChainName[];
};
-export type balanceQuery = Record>>;
+export const chainIdList = (mainnet: boolean) => {
+ return chainList(mainnet).map((name) => chainMap[name].id);
+};
+
+const chainEntries = chains.map((name) => [chainMap[name].id, chainMap[name]] as const);
+const chainNameEntries = chains.map((name) => [chainMap[name].id, name] as const);
+
+export type balanceQuery = Record>>;
export type Token = {
- address: `0x${string}`;
- name: string;
- chain: chain;
- decimals: number;
+ address: `0x${string}`;
+ name: string;
+ chainId: number;
+ decimals: number;
};
export const coinList = (mainnet: boolean) => {
- if (mainnet == true)
- return [
- {
- address: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`,
- name: "usdc",
- chain: "base",
- decimals: 6
- },
- {
- address: `0xaf88d065e77c8cC2239327C5EDb3A432268e5831`,
- name: "usdc",
- chain: "arbitrum",
- decimals: 6
- },
- {
- address: `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`,
- name: "usdc",
- chain: "ethereum",
- decimals: 6
- },
- {
- address: ADDRESS_ZERO,
- name: "eth",
- chain: "base",
- decimals: 18
- },
- {
- address: ADDRESS_ZERO,
- name: "eth",
- chain: "arbitrum",
- decimals: 18
- },
- {
- address: ADDRESS_ZERO,
- name: "eth",
- chain: "ethereum",
- decimals: 18
- },
- {
- address: `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`,
- name: "weth",
- chain: "ethereum",
- decimals: 18
- },
- {
- address: `0x4200000000000000000000000000000000000006`,
- name: "weth",
- chain: "base",
- decimals: 18
- },
- {
- address: `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`,
- name: "weth",
- chain: "arbitrum",
- decimals: 18
- },
- {
- address: `0x4200000000000000000000000000000000000006`,
- name: "weth",
- chain: "megaeth",
- decimals: 18
- },
- {
- address: `0xFAfDdbb3FC7688494971a79cc65DCa3EF82079E7`,
- name: "usdm",
- chain: "megaeth",
- decimals: 18
- },
- {
- address: `0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d`,
- name: "usdc-b",
- chain: "bsc",
- decimals: 18
- },
- {
- address: `0x55d398326f99059ff775485246999027b3197955`,
- name: "usdt-b",
- chain: "bsc",
- decimals: 18
- },
- {
- address: `0x203a662b0bd271a6ed5a60edfbd04bfce608fd36`,
- name: "vbUSDC",
- chain: "katana",
- decimals: 6
- },
- {
- address: `0x7ceb23fd6bc0add59e62ac25578270cff1b9f619`,
- name: "weth",
- chain: "polygon",
- decimals: 18
- },
- {
- address: `0x3c499c542cef5e3811e1192ce70d8cc03d5c3359`,
- name: "usdc",
- chain: "polygon",
- decimals: 6
- },
- {
- address: `0x2791bca1f2de4661ed88a30c99a7a9449aa84174`,
- name: "usdc.e",
- chain: "polygon",
- decimals: 6
- },
- {
- address: `0xc879c018db60520f4355c26ed1a6d572cdac1815`,
- name: "usdc",
- chain: "pharos",
- decimals: 6
- }
- ] as const;
- else
- return [
- {
- address: `0x5fd84259d66Cd46123540766Be93DFE6D43130D7`,
- name: "usdc",
- chain: "optimismSepolia",
- decimals: 6
- },
- {
- address: `0x036CbD53842c5426634e7929541eC2318f3dCF7e`,
- name: "usdc",
- chain: "baseSepolia",
- decimals: 6
- },
- {
- address: `0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238`,
- name: "usdc",
- chain: "sepolia",
- decimals: 6
- },
- {
- address: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
- name: "usdc",
- chain: "arbitrumSepolia",
- decimals: 6
- },
- {
- address: ADDRESS_ZERO,
- name: "eth",
- chain: "sepolia",
- decimals: 18
- },
- {
- address: ADDRESS_ZERO,
- name: "eth",
- chain: "baseSepolia",
- decimals: 18
- },
- {
- address: ADDRESS_ZERO,
- name: "eth",
- chain: "optimismSepolia",
- decimals: 18
- },
- {
- address: ADDRESS_ZERO,
- name: "eth",
- chain: "arbitrumSepolia",
- decimals: 6
- },
- {
- address: `0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14`,
- name: "weth",
- chain: "sepolia",
- decimals: 18
- },
- {
- address: `0x4200000000000000000000000000000000000006`,
- name: "weth",
- chain: "baseSepolia",
- decimals: 18
- },
- {
- address: `0x4200000000000000000000000000000000000006`,
- name: "weth",
- chain: "optimismSepolia",
- decimals: 18
- },
- {
- address: `0x980B62Da83eFf3D4576C647993b0c1D7faf17c73`,
- name: "weth",
- chain: "arbitrumSepolia",
- decimals: 18
- }
- ] as const;
+ if (mainnet == true)
+ return [
+ {
+ address: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`,
+ name: "usdc",
+ chainId: base.id,
+ decimals: 6
+ },
+ {
+ address: `0xaf88d065e77c8cC2239327C5EDb3A432268e5831`,
+ name: "usdc",
+ chainId: arbitrum.id,
+ decimals: 6
+ },
+ {
+ address: `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`,
+ name: "usdc",
+ chainId: ethereum.id,
+ decimals: 6
+ },
+ {
+ address: ADDRESS_ZERO,
+ name: "eth",
+ chainId: base.id,
+ decimals: 18
+ },
+ {
+ address: ADDRESS_ZERO,
+ name: "eth",
+ chainId: arbitrum.id,
+ decimals: 18
+ },
+ {
+ address: ADDRESS_ZERO,
+ name: "eth",
+ chainId: ethereum.id,
+ decimals: 18
+ },
+ {
+ address: `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`,
+ name: "weth",
+ chainId: ethereum.id,
+ decimals: 18
+ },
+ {
+ address: `0x82106347dDbB23cE44Cf4cE4053Ef1adf8b9323B`,
+ name: "wmton",
+ chainId: ethereum.id,
+ decimals: 18
+ },
+ {
+ address: `0x4200000000000000000000000000000000000006`,
+ name: "weth",
+ chainId: base.id,
+ decimals: 18
+ },
+ {
+ address: `0x4200000000000000000000000000000000000006`,
+ name: "weth",
+ chainId: optimism.id,
+ decimals: 18
+ },
+ {
+ address: `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`,
+ name: "weth",
+ chainId: arbitrum.id,
+ decimals: 18
+ },
+ {
+ address: `0x4200000000000000000000000000000000000006`,
+ name: "weth",
+ chainId: megaeth.id,
+ decimals: 18
+ },
+ {
+ address: `0xFAfDdbb3FC7688494971a79cc65DCa3EF82079E7`,
+ name: "usdm",
+ chainId: megaeth.id,
+ decimals: 18
+ },
+ {
+ address: `0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d`,
+ name: "usdc-b",
+ chainId: bsc.id,
+ decimals: 18
+ },
+ {
+ address: `0x55d398326f99059ff775485246999027b3197955`,
+ name: "usdt-b",
+ chainId: bsc.id,
+ decimals: 18
+ },
+ {
+ address: `0x203a662b0bd271a6ed5a60edfbd04bfce608fd36`,
+ name: "vbUSDC",
+ chainId: katana.id,
+ decimals: 6
+ },
+ {
+ address: `0x7ceb23fd6bc0add59e62ac25578270cff1b9f619`,
+ name: "weth",
+ chainId: polygon.id,
+ decimals: 18
+ },
+ {
+ address: `0x3c499c542cef5e3811e1192ce70d8cc03d5c3359`,
+ name: "usdc",
+ chainId: polygon.id,
+ decimals: 6
+ },
+ {
+ address: `0x2791bca1f2de4661ed88a30c99a7a9449aa84174`,
+ name: "usdc.e",
+ chainId: polygon.id,
+ decimals: 6
+ }
+ ] as const;
+ else
+ return [
+ {
+ address: `0x5fd84259d66Cd46123540766Be93DFE6D43130D7`,
+ name: "usdc",
+ chainId: optimismSepolia.id,
+ decimals: 6
+ },
+ {
+ address: `0x036CbD53842c5426634e7929541eC2318f3dCF7e`,
+ name: "usdc",
+ chainId: baseSepolia.id,
+ decimals: 6
+ },
+ {
+ address: `0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238`,
+ name: "usdc",
+ chainId: sepolia.id,
+ decimals: 6
+ },
+ {
+ address: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+ name: "usdc",
+ chainId: arbitrumSepolia.id,
+ decimals: 6
+ },
+ {
+ address: ADDRESS_ZERO,
+ name: "eth",
+ chainId: sepolia.id,
+ decimals: 18
+ },
+ {
+ address: ADDRESS_ZERO,
+ name: "eth",
+ chainId: baseSepolia.id,
+ decimals: 18
+ },
+ {
+ address: ADDRESS_ZERO,
+ name: "eth",
+ chainId: optimismSepolia.id,
+ decimals: 18
+ },
+ {
+ address: ADDRESS_ZERO,
+ name: "eth",
+ chainId: arbitrumSepolia.id,
+ decimals: 6
+ },
+ {
+ address: `0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14`,
+ name: "weth",
+ chainId: sepolia.id,
+ decimals: 18
+ },
+ {
+ address: `0x4200000000000000000000000000000000000006`,
+ name: "weth",
+ chainId: baseSepolia.id,
+ decimals: 18
+ },
+ {
+ address: `0x4200000000000000000000000000000000000006`,
+ name: "weth",
+ chainId: optimismSepolia.id,
+ decimals: 18
+ },
+ {
+ address: `0x980B62Da83eFf3D4576C647993b0c1D7faf17c73`,
+ name: "weth",
+ chainId: arbitrumSepolia.id,
+ decimals: 18
+ },
+ {
+ address: `0x3600000000000000000000000000000000000000`,
+ name: "usdc",
+ chainId: arcTestnet.id,
+ decimals: 6
+ }
+ ] as const;
};
export function printToken(token: Token) {
- return `${token.name.toUpperCase()}, ${token.chain}`;
+ return `${token.name.toUpperCase()}, ${getChainName(token.chainId)}`;
}
export function formatTokenAmount(amount: bigint, tokenDecimals: number, decimals = 4) {
- const formattedAmount = Number(amount) / 10 ** tokenDecimals;
- return formattedAmount.toFixed(decimals);
+ const formattedAmount = Number(amount) / 10 ** tokenDecimals;
+ return formattedAmount.toFixed(decimals);
}
export function getIndexOf(token: Token) {
- for (let i = 0; i < coinList.length; ++i) {
- const elem = coinList(!chainMap[token.chain].testnet)[i];
- if (token.chain === elem.chain && token.address === elem.address) return i;
- }
- return -1;
+ const coins = coinList(!isChainIdTestnet(token.chainId));
+ for (let i = 0; i < coins.length; ++i) {
+ const elem = coins[i];
+ if (token.chainId === elem.chainId && token.address === elem.address) return i;
+ }
+ return -1;
}
export type coin = ReturnType[number]["address"];
export const wormholeChainIds = {
- sepolia: 10002,
- arbitrumSepolia: 10003,
- baseSepolia: 10004,
- optimismSepolia: 10005
+ sepolia: 10002,
+ arbitrumSepolia: 10003,
+ baseSepolia: 10004,
+ optimismSepolia: 10005
} as const;
export const polymerChainIds = {
- ethereum: ethereum.id,
- base: base.id,
- arbitrum: arbitrum.id,
- sepolia: sepolia.id,
- arbitrumSepolia: arbitrumSepolia.id,
- baseSepolia: baseSepolia.id,
- optimismSepolia: optimismSepolia.id,
- megaeth: megaeth.id,
- katana: katana.id,
- bsc: bsc.id,
- polygon: polygon.id,
- pharos: pharos.id
+ ethereum: ethereum.id,
+ base: base.id,
+ arbitrum: arbitrum.id,
+ sepolia: sepolia.id,
+ arbitrumSepolia: arbitrumSepolia.id,
+ baseSepolia: baseSepolia.id,
+ optimismSepolia: optimismSepolia.id,
+ optimism: optimism.id,
+ megaeth: megaeth.id,
+ katana: katana.id,
+ bsc: bsc.id,
+ polygon: polygon.id,
+ pharos: pharos.id,
+ arcTestnet: arcTestnet.id
} as const;
export type Verifier = "wormhole" | "polymer";
export function getCoin(
- args:
- | { name: string; chain: chain; address?: undefined }
- | {
- address: `0x${string}`;
- chain: chain;
- name?: undefined;
- }
+ args:
+ | { name: string; chainId: number | bigint | string; address?: undefined }
+ | {
+ address: `0x${string}`;
+ chainId: number | bigint | string;
+ name?: undefined;
+ }
) {
- const { name = undefined, address = undefined, chain } = args;
- // ensure the address is ERC20-sized.
- const concatedAddress =
- "0x" + address?.replace("0x", "")?.slice(address.length - 42, address.length);
- for (const token of coinList(!chainMap[chain].testnet)) {
- // check chain first.
- if (token.chain === chain) {
- if (name === undefined) {
- if (concatedAddress?.toLowerCase() === token.address.toLowerCase()) return token;
- }
- if (name?.toLowerCase() === token.name.toLowerCase()) return token;
- }
- }
- return {
- name: name ?? "Unknown",
- address: address ?? ADDRESS_ZERO,
- chain,
- decimals: 1
- };
- // throw new Error(`No coins found for chain: ${concatedAddress} ${chain}`);
+ const { name = undefined, address = undefined } = args;
+ const chainId = normalizeChainId(args.chainId);
+ // ensure the address is ERC20-sized.
+ const concatedAddress =
+ "0x" + address?.replace("0x", "")?.slice(address.length - 42, address.length);
+ for (const token of coinList(!isChainIdTestnet(chainId))) {
+ // check chain first.
+ if (token.chainId === chainId) {
+ if (name === undefined) {
+ if (concatedAddress?.toLowerCase() === token.address.toLowerCase()) return token;
+ }
+ if (name?.toLowerCase() === token.name.toLowerCase()) return token;
+ }
+ }
+ return {
+ name: name ?? "Unknown",
+ address: address ?? ADDRESS_ZERO,
+ chainId,
+ decimals: 1
+ };
+ // throw new Error(`No coins found for chain: ${concatedAddress} ${chain}`);
+}
+
+function normalizeChainId(chainId: number | bigint | string) {
+ if (typeof chainId === "string") return Number(chainId);
+ if (typeof chainId === "bigint") return Number(chainId);
+ return chainId;
+}
+
+export function isChainIdTestnet(chainId: number | bigint | string) {
+ const normalized = normalizeChainId(chainId);
+ const chain = chainById[normalized];
+ if (!chain) throw new Error(`Chain is not known: ${normalized}`);
+ return chain.testnet;
}
export function getChainName(chainId: number | bigint | string) {
- if (typeof chainId === "string") chainId = Number(chainId);
- if (typeof chainId === "bigint") chainId = Number(chainId);
- for (const key of chains) {
- if (chainMap[key].id === chainId) {
- return key;
- }
- }
- throw new Error(`Chain is not known: ${chainId}`);
+ const normalized = normalizeChainId(chainId);
+ const name = chainNameById[normalized];
+ if (!name) throw new Error(`Chain is not known: ${normalized}`);
+ return name;
}
export function formatTokenDecimals(
- value: bigint | number,
- coin: Token,
- as: "number" | "string" = "string"
+ value: bigint | number,
+ coin: Token,
+ as: "number" | "string" = "string"
) {
- const decimals = coin.decimals;
- const result = Number(value) / 10 ** decimals;
- return as === "string" ? result.toString() : result;
+ const decimals = coin.decimals;
+ const result = Number(value) / 10 ** decimals;
+ return as === "string" ? result.toString() : result;
+}
+
+export function getOracle(verifier: Verifier, chainId: number | bigint | string) {
+ const normalized = normalizeChainId(chainId);
+ if (verifier === "polymer") return POLYMER_ORACLE[normalized];
+ if (verifier === "wormhole") return WORMHOLE_ORACLE[normalized];
+ return undefined;
}
-export function getOracle(verifier: Verifier, chain: chain) {
- if (verifier === "polymer") return POLYMER_ORACLE[chain];
- // if (verifier === "wormhole") return (WORMHOLE_ORACLE[chain] ?? ADDRESS_ZERO);
+export function getChain(chainId: number | bigint | string) {
+ const normalized = normalizeChainId(chainId);
+ const chain = chainById[normalized];
+ if (!chain) throw new Error(`Could not find chain for chainId ${normalized}`);
+ return chain;
}
export function getClient(chainId: number | bigint | string) {
- const chainName = getChainName(Number(chainId));
- if (!chainName) new Error("Could not find chain");
- return clients[chainName];
+ const normalized = normalizeChainId(chainId);
+ const client = clientsById[normalized];
+ if (!client) throw new Error(`Could not find client for chainId ${normalized}`);
+ return client;
}
export const clients = {
- ethereum: createPublicClient({
- chain: ethereum,
- transport: fallback([
- http("https://ethereum-rpc.publicnode.com"),
- ...ethereum.rpcUrls.default.http.map((v) => http(v))
- ])
- }),
- arbitrum: createPublicClient({
- chain: arbitrum,
- transport: fallback([
- http("https://arbitrum-rpc.publicnode.com"),
- ...arbitrum.rpcUrls.default.http.map((v) => http(v))
- ])
- }),
- base: createPublicClient({
- chain: base,
- transport: fallback([
- http("https://base-rpc.publicnode.com"),
- ...base.rpcUrls.default.http.map((v) => http(v))
- ])
- }),
- bsc: createPublicClient({
- chain: bsc,
- transport: fallback([...bsc.rpcUrls.default.http.map((v) => http(v))])
- }),
- polygon: createPublicClient({
- chain: base,
- transport: fallback([...polygon.rpcUrls.default.http.map((v) => http(v))])
- }),
- megaeth: createPublicClient({
- chain: megaeth,
- transport: fallback([...megaeth.rpcUrls.default.http.map((v) => http(v))])
- }),
- katana: createPublicClient({
- chain: katana,
- transport: fallback([...katana.rpcUrls.default.http.map((v) => http(v))])
- }),
- pharos: createPublicClient({
- chain: pharos,
- transport: fallback([...pharos.rpcUrls.default.http.map((v) => http(v))])
- }),
- // Testnet
- sepolia: createPublicClient({
- chain: sepolia,
- transport: fallback([
- http("https://ethereum-sepolia-rpc.publicnode.com"),
- ...sepolia.rpcUrls.default.http.map((v) => http(v))
- ])
- }),
- arbitrumSepolia: createPublicClient({
- chain: arbitrumSepolia,
- transport: fallback([
- http("https://arbitrum-sepolia-rpc.publicnode.com"),
- ...arbitrumSepolia.rpcUrls.default.http.map((v) => http(v))
- ])
- }),
- baseSepolia: createPublicClient({
- chain: baseSepolia,
- transport: fallback([
- http("https://base-sepolia-rpc.publicnode.com"),
- ...baseSepolia.rpcUrls.default.http.map((v) => http(v))
- ])
- }),
- optimismSepolia: createPublicClient({
- chain: optimismSepolia,
- transport: fallback([
- http("https://optimism-sepolia-rpc.publicnode.com"),
- ...optimismSepolia.rpcUrls.default.http.map((v) => http(v))
- ])
- })
+ ethereum: createPublicClient({
+ chain: ethereum,
+ transport: fallback([
+ http("https://ethereum-rpc.publicnode.com"),
+ ...ethereum.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ arbitrum: createPublicClient({
+ chain: arbitrum,
+ transport: fallback([
+ http("https://arbitrum-rpc.publicnode.com"),
+ ...arbitrum.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ base: createPublicClient({
+ chain: base,
+ transport: fallback([
+ http("https://base-rpc.publicnode.com"),
+ ...base.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ optimism: createPublicClient({
+ chain: optimism,
+ transport: fallback([
+ http("https://optimism-rpc.publicnode.com"),
+ ...optimism.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ bsc: createPublicClient({
+ chain: bsc,
+ transport: fallback([
+ http("https://bsc-rpc.publicnode.com"),
+ ...bsc.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ polygon: createPublicClient({
+ chain: base,
+ transport: fallback([
+ http("https://polygon-bor-rpc.publicnode.com"),
+ ...polygon.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ megaeth: createPublicClient({
+ chain: megaeth,
+ transport: fallback([...megaeth.rpcUrls.default.http.map((v) => http(v))])
+ }),
+ katana: createPublicClient({
+ chain: katana,
+ transport: fallback([...katana.rpcUrls.default.http.map((v) => http(v))])
+ }),
+ pharos: createPublicClient({
+ chain: pharos,
+ transport: fallback([...pharos.rpcUrls.default.http.map((v) => http(v))])
+ }),
+ // Testnet
+ sepolia: createPublicClient({
+ chain: sepolia,
+ transport: fallback([
+ http("https://ethereum-sepolia-rpc.publicnode.com"),
+ ...sepolia.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ arbitrumSepolia: createPublicClient({
+ chain: arbitrumSepolia,
+ transport: fallback([
+ http("https://arbitrum-sepolia-rpc.publicnode.com"),
+ ...arbitrumSepolia.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ baseSepolia: createPublicClient({
+ chain: baseSepolia,
+ transport: fallback([
+ http("https://base-sepolia-rpc.publicnode.com"),
+ ...baseSepolia.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ optimismSepolia: createPublicClient({
+ chain: optimismSepolia,
+ transport: fallback([
+ http("https://optimism-sepolia-rpc.publicnode.com"),
+ ...optimismSepolia.rpcUrls.default.http.map((v) => http(v))
+ ])
+ }),
+ arcTestnet: createPublicClient({
+ chain: arcTestnet,
+ transport: fallback([...arcTestnet.rpcUrls.default.http.map((v) => http(v))])
+ })
} as const;
+export const chainById = Object.fromEntries(chainEntries) as Record<
+ number,
+ (typeof chainMap)[keyof typeof chainMap]
+>;
+
+export const chainNameById = Object.fromEntries(chainNameEntries) as Record;
+
+export const clientsById = Object.fromEntries(
+ chains.map((name) => [chainMap[name].id, clients[name]])
+) as Record;
+
export type WC = ReturnType<
- typeof createWalletClient, undefined, undefined, undefined>
+ typeof createWalletClient, undefined, undefined, undefined>
>;
diff --git a/src/lib/db.ts b/src/lib/db.ts
index 4cbcba7..23116dc 100644
--- a/src/lib/db.ts
+++ b/src/lib/db.ts
@@ -9,35 +9,36 @@ export let db: ReturnType | undefined;
let initDbPromise: Promise | undefined> | null = null;
async function migrateDb(instance: ReturnType) {
- // dialect and session will appear to not exist...but they do on the pglite drizzle instance
- // @ts-ignore
- await instance.dialect.migrate(migrations, instance.session, {
- migrationsTable: "drizzle_migrations"
- } satisfies Omit);
+ // dialect and session will appear to not exist...but they do on the pglite drizzle instance
+ // @ts-expect-error pglite drizzle exposes migrate internals not present in the public type
+ await instance.dialect.migrate(migrations, instance.session, {
+ migrationsTable: "drizzle_migrations"
+ } satisfies Omit);
}
export async function initDb() {
- if (db) return db;
- if (!browser) return undefined;
- if (initDbPromise) return initDbPromise;
+ if (db) return db;
+ if (!browser) return undefined;
+ if (initDbPromise) return initDbPromise;
- initDbPromise = (async () => {
- // Open a PGLite database; this will persist to IndexedDB in the browser
- const pglite = new PGlite("idb://orders");
+ initDbPromise = (async () => {
+ // Open a PGLite database; this will persist to IndexedDB in the browser
+ const pglite = new PGlite("idb://orders");
- // Create a Drizzle instance over the opened SQLite-compatible database
- db = drizzle(pglite);
+ // Create a Drizzle instance over the opened SQLite-compatible database
+ const instance = drizzle(pglite);
- // Run migrations so tables are created on first load
- await migrateDb(db);
+ // Run migrations so tables are created on first load
+ await migrateDb(instance);
- return db;
- })().catch((error) => {
- initDbPromise = null;
- throw error;
- });
+ db = instance;
+ return db;
+ })().catch((error) => {
+ initDbPromise = null;
+ throw error;
+ });
- return initDbPromise;
+ return initDbPromise;
}
export default initDb;
diff --git a/src/lib/libraries/assetSelection.ts b/src/lib/libraries/assetSelection.ts
index 810ea4b..0aad289 100644
--- a/src/lib/libraries/assetSelection.ts
+++ b/src/lib/libraries/assetSelection.ts
@@ -1,80 +1,80 @@
const bigIntSum = (...nums: bigint[]) => nums.reduce((a, b) => a + b, 0n);
export class AssetSelection {
- goal: bigint;
- values: bigint[];
- weights?: bigint[];
-
- sortedValues: bigint[];
-
- static Sum(values: bigint[]) {
- return bigIntSum(...values);
- }
-
- static feasible(goal: bigint, values: bigint[]) {
- if (bigIntSum(...values) < goal)
- throw Error(`Values makes ${bigIntSum(...values)} cannot sum ${goal}`);
- }
-
- static zip(arr: bigint[]): [bigint, number][] {
- return arr.map((v, i) => [v, i]);
- }
-
- static unzip(arr: [bigint, number][]): bigint[] {
- arr.sort((a, b) => a[1] - b[1]);
- return arr.map((v) => v[0]);
- }
-
- static takeFromArray(goal: bigint, values: [bigint, T][]) {
- let sum = 0n;
- for (let i = 0; i < values.length; ++i) {
- const value = values[i][0];
- const less = goal - sum;
- const diff = less < value ? less : value;
- sum += diff;
- values[i][0] = diff;
- }
- }
-
- constructor(opts: { goal: bigint; values: bigint[]; weights?: bigint[] }) {
- AssetSelection.feasible(opts.goal, opts.values);
- this.goal = opts.goal;
- this.values = opts.values;
- this.weights = opts.weights;
-
- this.sortedValues = this.values;
- }
-
- // --- Get sorted values as --- //
-
- asValues() {
- return this.sortedValues;
- }
-
- asIndices() {
- const zipped = AssetSelection.zip(this.sortedValues);
- return zipped.filter((v) => v[0] > 0);
- }
-
- // --- Sorting Methods --- //
-
- largest() {
- const values = AssetSelection.zip(this.values);
- values.sort((a, b) => Number(b[0] - a[0]));
-
- AssetSelection.takeFromArray(this.goal, values);
-
- this.sortedValues = AssetSelection.unzip(values);
- return this;
- }
-
- smallest() {
- const values = AssetSelection.zip(this.values);
- values.sort((a, b) => Number(a[0] - b[0]));
-
- AssetSelection.takeFromArray(this.goal, values);
-
- this.sortedValues = AssetSelection.unzip(values);
- return this;
- }
+ goal: bigint;
+ values: bigint[];
+ weights?: bigint[];
+
+ sortedValues: bigint[];
+
+ static Sum(values: bigint[]) {
+ return bigIntSum(...values);
+ }
+
+ static feasible(goal: bigint, values: bigint[]) {
+ if (bigIntSum(...values) < goal)
+ throw Error(`Values makes ${bigIntSum(...values)} cannot sum ${goal}`);
+ }
+
+ static zip(arr: bigint[]): [bigint, number][] {
+ return arr.map((v, i) => [v, i]);
+ }
+
+ static unzip(arr: [bigint, number][]): bigint[] {
+ arr.sort((a, b) => a[1] - b[1]);
+ return arr.map((v) => v[0]);
+ }
+
+ static takeFromArray(goal: bigint, values: [bigint, T][]) {
+ let sum = 0n;
+ for (let i = 0; i < values.length; ++i) {
+ const value = values[i][0];
+ const less = goal - sum;
+ const diff = less < value ? less : value;
+ sum += diff;
+ values[i][0] = diff;
+ }
+ }
+
+ constructor(opts: { goal: bigint; values: bigint[]; weights?: bigint[] }) {
+ AssetSelection.feasible(opts.goal, opts.values);
+ this.goal = opts.goal;
+ this.values = opts.values;
+ this.weights = opts.weights;
+
+ this.sortedValues = this.values;
+ }
+
+ // --- Get sorted values as --- //
+
+ asValues() {
+ return this.sortedValues;
+ }
+
+ asIndices() {
+ const zipped = AssetSelection.zip(this.sortedValues);
+ return zipped.filter((v) => v[0] > 0);
+ }
+
+ // --- Sorting Methods --- //
+
+ largest() {
+ const values = AssetSelection.zip(this.values);
+ values.sort((a, b) => Number(b[0] - a[0]));
+
+ AssetSelection.takeFromArray(this.goal, values);
+
+ this.sortedValues = AssetSelection.unzip(values);
+ return this;
+ }
+
+ smallest() {
+ const values = AssetSelection.zip(this.values);
+ values.sort((a, b) => Number(a[0] - b[0]));
+
+ AssetSelection.takeFromArray(this.goal, values);
+
+ this.sortedValues = AssetSelection.unzip(values);
+ return this;
+ }
}
diff --git a/src/lib/libraries/compactLib.ts b/src/lib/libraries/compactLib.ts
index be1786f..594f0d4 100644
--- a/src/lib/libraries/compactLib.ts
+++ b/src/lib/libraries/compactLib.ts
@@ -1,167 +1,157 @@
/// -- Compact -- ///
import { maxInt32, maxUint256, toHex } from "viem";
-import { ResetPeriod, toId } from "$lib/utils/idLib";
-import {
- ADDRESS_ZERO,
- type chain,
- chainMap,
- clients,
- COMPACT,
- type Token,
- type WC
-} from "$lib/config";
+import { ResetPeriod, toId } from "@lifi/intent";
+import { ADDRESS_ZERO, getChain, getClient, COMPACT, type WC } from "$lib/config";
import { COMPACT_ABI } from "$lib/abi/compact";
-import { addressToBytes32 } from "$lib/utils/convert";
+import { addressToBytes32 } from "@lifi/intent";
import { ERC20_ABI } from "$lib/abi/erc20";
-import type { TokenContext } from "$lib/state.svelte";
+import type { AppTokenContext } from "$lib/appTypes";
export class CompactLib {
- static compactDeposit(
- walletClient: WC,
- opts: {
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- inputToken: TokenContext;
- account: () => `0x${string}`;
- allocatorId: string;
- }
- ) {
- return async () => {
- const { preHook, postHook, inputToken, account, allocatorId } = opts;
- const { token, amount } = inputToken;
- const publicClients = clients;
- if (preHook) await preHook(token.chain);
- const lockTag: `0x${string}` = `0x${toHex(
- toId(true, ResetPeriod.OneDay, allocatorId, ADDRESS_ZERO),
- {
- size: 32
- }
- )
- .replace("0x", "")
- .slice(0, 24)}`;
- const recipient = ADDRESS_ZERO; // This means sender.
+ static compactDeposit(
+ walletClient: WC,
+ opts: {
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ inputToken: AppTokenContext;
+ account: () => `0x${string}`;
+ allocatorId: string;
+ }
+ ) {
+ return async () => {
+ const { preHook, postHook, inputToken, account, allocatorId } = opts;
+ const { token, amount } = inputToken;
+ if (preHook) await preHook(token.chainId);
+ const lockTag: `0x${string}` = `0x${toHex(
+ toId(true, ResetPeriod.OneDay, allocatorId, ADDRESS_ZERO),
+ {
+ size: 32
+ }
+ )
+ .replace("0x", "")
+ .slice(0, 24)}`;
+ const recipient = ADDRESS_ZERO; // This means sender.
- let transactionHash: `0x${string}`;
- if (token.address === ADDRESS_ZERO) {
- transactionHash = await walletClient.writeContract({
- chain: chainMap[token.chain],
- account: account(),
- address: COMPACT,
- abi: COMPACT_ABI,
- functionName: "depositNative",
- value: amount,
- args: [lockTag, recipient]
- });
- } else {
- transactionHash = await walletClient.writeContract({
- chain: chainMap[token.chain],
- account: account(),
- address: COMPACT,
- abi: COMPACT_ABI,
- functionName: "depositERC20",
- args: [token.address, lockTag, amount, recipient]
- });
- }
- await publicClients[token.chain].waitForTransactionReceipt({
- hash: await transactionHash
- });
- if (postHook) await postHook();
- return transactionHash;
- };
- }
+ let transactionHash: `0x${string}`;
+ if (token.address === ADDRESS_ZERO) {
+ transactionHash = await walletClient.writeContract({
+ chain: getChain(token.chainId),
+ account: account(),
+ address: COMPACT,
+ abi: COMPACT_ABI,
+ functionName: "depositNative",
+ value: amount,
+ args: [lockTag, recipient]
+ });
+ } else {
+ transactionHash = await walletClient.writeContract({
+ chain: getChain(token.chainId),
+ account: account(),
+ address: COMPACT,
+ abi: COMPACT_ABI,
+ functionName: "depositERC20",
+ args: [token.address, lockTag, amount, recipient]
+ });
+ }
+ await getClient(token.chainId).waitForTransactionReceipt({
+ hash: await transactionHash
+ });
+ if (postHook) await postHook();
+ return transactionHash;
+ };
+ }
- static compactWithdraw(
- walletClient: WC,
- opts: {
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- inputToken: TokenContext;
- account: () => `0x${string}`;
- allocatorId: string;
- }
- ) {
- return async () => {
- const { preHook, postHook, inputToken, account, allocatorId } = opts;
- const { token, amount } = inputToken;
- const publicClients = clients;
- const assetId = toId(true, ResetPeriod.OneDay, allocatorId, token.address);
+ static compactWithdraw(
+ walletClient: WC,
+ opts: {
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ inputToken: AppTokenContext;
+ account: () => `0x${string}`;
+ allocatorId: string;
+ }
+ ) {
+ return async () => {
+ const { preHook, postHook, inputToken, account, allocatorId } = opts;
+ const { token, amount } = inputToken;
+ const assetId = toId(true, ResetPeriod.OneDay, allocatorId, token.address);
- const allocatedTransferStruct: {
- allocatorData: `0x${string}`;
- nonce: bigint;
- expires: bigint;
- id: bigint;
- recipients: {
- claimant: bigint;
- amount: bigint;
- }[];
- } = {
- allocatorData: "0x", // TODO: Get from allocator
- nonce: BigInt(Math.floor(Math.random() * 2 ** 32)),
- expires: maxInt32, // TODO:
- id: assetId,
- recipients: [
- {
- claimant: BigInt(addressToBytes32(account())),
- amount: amount
- }
- ]
- };
+ const allocatedTransferStruct: {
+ allocatorData: `0x${string}`;
+ nonce: bigint;
+ expires: bigint;
+ id: bigint;
+ recipients: {
+ claimant: bigint;
+ amount: bigint;
+ }[];
+ } = {
+ allocatorData: "0x", // TODO: Get from allocator
+ nonce: BigInt(Math.floor(Math.random() * 2 ** 32)),
+ expires: maxInt32, // TODO:
+ id: assetId,
+ recipients: [
+ {
+ claimant: BigInt(addressToBytes32(account())),
+ amount: amount
+ }
+ ]
+ };
- if (preHook) await preHook(token.chain);
- const transactionHash = walletClient.writeContract({
- chain: chainMap[token.chain],
- account: account(),
- address: COMPACT,
- abi: COMPACT_ABI,
- functionName: "allocatedTransfer",
- args: [allocatedTransferStruct]
- });
- await publicClients[token.chain].waitForTransactionReceipt({
- hash: await transactionHash
- });
- if (postHook) await postHook();
- return transactionHash;
- };
- }
+ if (preHook) await preHook(token.chainId);
+ const transactionHash = walletClient.writeContract({
+ chain: getChain(token.chainId),
+ account: account(),
+ address: COMPACT,
+ abi: COMPACT_ABI,
+ functionName: "allocatedTransfer",
+ args: [allocatedTransferStruct]
+ });
+ await getClient(token.chainId).waitForTransactionReceipt({
+ hash: await transactionHash
+ });
+ if (postHook) await postHook();
+ return transactionHash;
+ };
+ }
- static compactApprove(
- walletClient: WC,
- opts: {
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- inputTokens: TokenContext[];
- account: () => `0x${string}`;
- }
- ) {
- return async () => {
- const { preHook, postHook, inputTokens, account } = opts;
- for (let i = 0; i < inputTokens.length; ++i) {
- const { token: inputToken, amount } = inputTokens[i];
- if (preHook) await preHook(inputToken.chain);
- const publicClient = clients[inputToken.chain];
- // Check if we have sufficient allowance already.
- const currentAllowance = await publicClient.readContract({
- address: inputToken.address,
- abi: ERC20_ABI,
- functionName: "allowance",
- args: [account(), COMPACT]
- });
- if (currentAllowance >= amount) continue;
- const transactionHash = walletClient.writeContract({
- chain: chainMap[inputToken.chain],
- account: account(),
- address: inputToken.address,
- abi: ERC20_ABI,
- functionName: "approve",
- args: [COMPACT, maxUint256]
- });
+ static compactApprove(
+ walletClient: WC,
+ opts: {
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ inputTokens: AppTokenContext[];
+ account: () => `0x${string}`;
+ }
+ ) {
+ return async () => {
+ const { preHook, postHook, inputTokens, account } = opts;
+ for (let i = 0; i < inputTokens.length; ++i) {
+ const { token: inputToken, amount } = inputTokens[i];
+ if (preHook) await preHook(inputToken.chainId);
+ const publicClient = getClient(inputToken.chainId);
+ // Check if we have sufficient allowance already.
+ const currentAllowance = await publicClient.readContract({
+ address: inputToken.address,
+ abi: ERC20_ABI,
+ functionName: "allowance",
+ args: [account(), COMPACT]
+ });
+ if (currentAllowance >= amount) continue;
+ const transactionHash = walletClient.writeContract({
+ chain: getChain(inputToken.chainId),
+ account: account(),
+ address: inputToken.address,
+ abi: ERC20_ABI,
+ functionName: "approve",
+ args: [COMPACT, maxUint256]
+ });
- await publicClient.waitForTransactionReceipt({
- hash: await transactionHash
- });
- }
- if (postHook) await postHook();
- };
- }
+ await publicClient.waitForTransactionReceipt({
+ hash: await transactionHash
+ });
+ }
+ if (postHook) await postHook();
+ };
+ }
}
diff --git a/src/lib/libraries/coreDeps.ts b/src/lib/libraries/coreDeps.ts
new file mode 100644
index 0000000..947449d
--- /dev/null
+++ b/src/lib/libraries/coreDeps.ts
@@ -0,0 +1,54 @@
+import {
+ COIN_FILLER,
+ INPUT_SETTLER_COMPACT_LIFI,
+ MULTICHAIN_INPUT_SETTLER_COMPACT,
+ POLYMER_ORACLE,
+ WORMHOLE_ORACLE
+} from "$lib/config";
+import type { IntentDeps, OrderContainerValidationDeps } from "@lifi/intent";
+
+function isNonZeroAddress(value: string | undefined): value is `0x${string}` {
+ return !!value && value.toLowerCase() !== "0x0000000000000000000000000000000000000000";
+}
+
+export const intentDeps: IntentDeps = {
+ getOracle(verifier, chainId) {
+ const key = Number(chainId);
+ if (!Number.isFinite(key)) return undefined;
+ if (verifier === "polymer") return POLYMER_ORACLE[key];
+ if (verifier === "wormhole") {
+ return WORMHOLE_ORACLE[key];
+ }
+ return undefined;
+ }
+};
+
+export const orderValidationDeps: OrderContainerValidationDeps = {
+ inputSettlers: [INPUT_SETTLER_COMPACT_LIFI, MULTICHAIN_INPUT_SETTLER_COMPACT],
+ allowedInputOracles({ chainId, sameChainFill }) {
+ const key = Number(chainId);
+ if (!Number.isFinite(key)) return undefined;
+ const polymer = POLYMER_ORACLE[key];
+ const wormhole = WORMHOLE_ORACLE[key];
+ const allowed: `0x${string}`[] = [];
+ if (polymer) allowed.push(polymer);
+ if (isNonZeroAddress(wormhole)) allowed.push(wormhole);
+ if (allowed.length === 0) return undefined;
+ if (sameChainFill) allowed.push(COIN_FILLER);
+ return allowed;
+ },
+ allowedOutputOracles(chainId) {
+ const key = Number(chainId);
+ if (!Number.isFinite(key)) return undefined;
+ const polymer = POLYMER_ORACLE[key];
+ const wormhole = WORMHOLE_ORACLE[key];
+ const allowed: `0x${string}`[] = [];
+ if (polymer) allowed.push(polymer);
+ if (isNonZeroAddress(wormhole)) allowed.push(wormhole);
+ if (allowed.length === 0) return undefined;
+ return allowed;
+ },
+ allowedOutputSettlers() {
+ return [COIN_FILLER];
+ }
+};
diff --git a/src/lib/libraries/flowProgress.ts b/src/lib/libraries/flowProgress.ts
index ae0c7cf..ccdfb29 100644
--- a/src/lib/libraries/flowProgress.ts
+++ b/src/lib/libraries/flowProgress.ts
@@ -1,23 +1,23 @@
import {
- BYTES32_ZERO,
- COMPACT,
- INPUT_SETTLER_COMPACT_LIFI,
- INPUT_SETTLER_ESCROW_LIFI,
- MULTICHAIN_INPUT_SETTLER_COMPACT,
- MULTICHAIN_INPUT_SETTLER_ESCROW,
- getClient
+ BYTES32_ZERO,
+ COMPACT,
+ INPUT_SETTLER_COMPACT_LIFI,
+ INPUT_SETTLER_ESCROW_LIFI,
+ MULTICHAIN_INPUT_SETTLER_COMPACT,
+ MULTICHAIN_INPUT_SETTLER_ESCROW,
+ getClient
} from "$lib/config";
import { COIN_FILLER_ABI } from "$lib/abi/outputsettler";
import { POLYMER_ORACLE_ABI } from "$lib/abi/polymeroracle";
import { SETTLER_ESCROW_ABI } from "$lib/abi/escrow";
import { COMPACT_ABI } from "$lib/abi/compact";
import { hashStruct, keccak256 } from "viem";
-import { compactTypes } from "$lib/utils/typedMessage";
-import { getOutputHash, encodeMandateOutput } from "$lib/utils/orderLib";
-import { addressToBytes32, bytes32ToAddress } from "$lib/utils/convert";
-import { orderToIntent } from "$lib/libraries/intent";
+import { compactTypes } from "@lifi/intent";
+import { getOutputHash, encodeMandateOutput } from "@lifi/intent";
+import { addressToBytes32, bytes32ToAddress } from "@lifi/intent";
+import { containerToIntent } from "$lib/utils/intent";
import { getOrFetchRpc } from "$lib/libraries/rpcCache";
-import type { MandateOutput, OrderContainer } from "../../types";
+import type { MandateOutput, OrderContainer } from "@lifi/intent";
import store from "$lib/state.svelte";
const PROGRESS_TTL_MS = 30_000;
@@ -25,209 +25,209 @@ const OrderStatus_Claimed = 2;
const OrderStatus_Refunded = 3;
export type FlowCheckState = {
- allFilled: boolean;
- allValidated: boolean;
- allFinalised: boolean;
+ allFilled: boolean;
+ allValidated: boolean;
+ allFinalised: boolean;
};
export function getOutputStorageKey(output: MandateOutput) {
- return hashStruct({
- data: output,
- types: compactTypes,
- primaryType: "MandateOutput"
- });
+ return hashStruct({
+ data: output,
+ types: compactTypes,
+ primaryType: "MandateOutput"
+ });
}
function isValidHash(hash: string | undefined): hash is `0x${string}` {
- return !!hash && hash.startsWith("0x") && hash.length === 66;
+ return !!hash && hash.startsWith("0x") && hash.length === 66;
}
async function isOutputFilled(orderId: `0x${string}`, output: MandateOutput) {
- const outputKey = getOutputStorageKey(output);
- return getOrFetchRpc(
- `progress:filled:${orderId}:${outputKey}`,
- async () => {
- const outputClient = getClient(output.chainId);
- const outputHash = getOutputHash(output);
- const result = await outputClient.readContract({
- address: bytes32ToAddress(output.settler),
- abi: COIN_FILLER_ABI,
- functionName: "getFillRecord",
- args: [orderId, outputHash]
- });
- return result !== BYTES32_ZERO;
- },
- { ttlMs: PROGRESS_TTL_MS }
- );
+ const outputKey = getOutputStorageKey(output);
+ return getOrFetchRpc(
+ `progress:filled:${orderId}:${outputKey}`,
+ async () => {
+ const outputClient = getClient(output.chainId);
+ const outputHash = getOutputHash(output);
+ const result = await outputClient.readContract({
+ address: bytes32ToAddress(output.settler),
+ abi: COIN_FILLER_ABI,
+ functionName: "getFillRecord",
+ args: [orderId, outputHash]
+ });
+ return result !== BYTES32_ZERO;
+ },
+ { ttlMs: PROGRESS_TTL_MS }
+ );
}
async function isOutputValidatedOnChain(
- orderId: `0x${string}`,
- inputChain: bigint,
- orderContainer: OrderContainer,
- output: MandateOutput,
- fillTransactionHash: `0x${string}`
+ orderId: `0x${string}`,
+ inputChain: bigint,
+ orderContainer: OrderContainer,
+ output: MandateOutput,
+ fillTransactionHash: `0x${string}`
) {
- const outputKey = getOutputStorageKey(output);
- const cachedReceipt = store.getTransactionReceipt(output.chainId, fillTransactionHash);
- const receipt = (
- cachedReceipt
- ? cachedReceipt
- : await getOrFetchRpc(
- `progress:receipt:${output.chainId.toString()}:${fillTransactionHash}`,
- async () => {
- const outputClient = getClient(output.chainId);
- return outputClient.getTransactionReceipt({
- hash: fillTransactionHash
- });
- },
- { ttlMs: PROGRESS_TTL_MS }
- )
- ) as {
- blockHash: `0x${string}`;
- from: `0x${string}`;
- };
- if (!cachedReceipt) {
- store
- .saveTransactionReceipt(output.chainId, fillTransactionHash, receipt)
- .catch((error) => console.warn("saveTransactionReceipt error", error));
- }
-
- const block = await getOrFetchRpc(
- `progress:block:${output.chainId.toString()}:${receipt.blockHash}`,
- async () => {
- const outputClient = getClient(output.chainId);
- return outputClient.getBlock({ blockHash: receipt.blockHash });
- },
- { ttlMs: PROGRESS_TTL_MS }
- );
-
- const encodedOutput = encodeMandateOutput(
- addressToBytes32(receipt.from),
- orderId,
- Number(block.timestamp),
- output
- );
- const outputHash = keccak256(encodedOutput);
-
- return getOrFetchRpc(
- `progress:proven:${orderId}:${inputChain.toString()}:${outputKey}:${fillTransactionHash}`,
- async () => {
- const sourceChainClient = getClient(inputChain);
- return sourceChainClient.readContract({
- address: orderContainer.order.inputOracle,
- abi: POLYMER_ORACLE_ABI,
- functionName: "isProven",
- args: [output.chainId, output.oracle, output.settler, outputHash]
- });
- },
- { ttlMs: PROGRESS_TTL_MS }
- );
+ const outputKey = getOutputStorageKey(output);
+ const cachedReceipt = store.getTransactionReceipt(output.chainId, fillTransactionHash);
+ const receipt = (
+ cachedReceipt
+ ? cachedReceipt
+ : await getOrFetchRpc(
+ `progress:receipt:${output.chainId.toString()}:${fillTransactionHash}`,
+ async () => {
+ const outputClient = getClient(output.chainId);
+ return outputClient.getTransactionReceipt({
+ hash: fillTransactionHash
+ });
+ },
+ { ttlMs: PROGRESS_TTL_MS }
+ )
+ ) as {
+ blockHash: `0x${string}`;
+ from: `0x${string}`;
+ };
+ if (!cachedReceipt) {
+ store
+ .saveTransactionReceipt(output.chainId, fillTransactionHash, receipt)
+ .catch((error) => console.warn("saveTransactionReceipt error", error));
+ }
+
+ const block = await getOrFetchRpc(
+ `progress:block:${output.chainId.toString()}:${receipt.blockHash}`,
+ async () => {
+ const outputClient = getClient(output.chainId);
+ return outputClient.getBlock({ blockHash: receipt.blockHash });
+ },
+ { ttlMs: PROGRESS_TTL_MS }
+ );
+
+ const encodedOutput = encodeMandateOutput({
+ solver: addressToBytes32(receipt.from),
+ orderId,
+ timestamp: Number(block.timestamp),
+ output
+ });
+ const outputHash = keccak256(encodedOutput);
+
+ return getOrFetchRpc(
+ `progress:proven:${orderId}:${inputChain.toString()}:${outputKey}:${fillTransactionHash}`,
+ async () => {
+ const sourceChainClient = getClient(inputChain);
+ return sourceChainClient.readContract({
+ address: orderContainer.order.inputOracle,
+ abi: POLYMER_ORACLE_ABI,
+ functionName: "isProven",
+ args: [output.chainId, output.oracle, output.settler, outputHash]
+ });
+ },
+ { ttlMs: PROGRESS_TTL_MS }
+ );
}
async function isInputChainFinalised(chainId: bigint, container: OrderContainer) {
- const { order, inputSettler } = container;
- const inputChainClient = getClient(chainId);
- const intent = orderToIntent(container);
- const orderId = intent.orderId();
-
- if (
- inputSettler === INPUT_SETTLER_ESCROW_LIFI ||
- inputSettler === MULTICHAIN_INPUT_SETTLER_ESCROW
- ) {
- return getOrFetchRpc(
- `progress:finalised:escrow:${orderId}:${chainId.toString()}`,
- async () => {
- const orderStatus = await inputChainClient.readContract({
- address: inputSettler,
- abi: SETTLER_ESCROW_ABI,
- functionName: "orderStatus",
- args: [orderId]
- });
- return orderStatus === OrderStatus_Claimed || orderStatus === OrderStatus_Refunded;
- },
- { ttlMs: PROGRESS_TTL_MS }
- );
- }
-
- if (
- inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
- inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT
- ) {
- const flattenedInputs = "originChainId" in order ? order.inputs : order.inputs[0]?.inputs;
- if (!flattenedInputs || flattenedInputs.length === 0) return false;
-
- return getOrFetchRpc(
- `progress:finalised:compact:${orderId}:${chainId.toString()}`,
- async () => {
- const [, allocator] = await inputChainClient.readContract({
- address: COMPACT,
- abi: COMPACT_ABI,
- functionName: "getLockDetails",
- args: [flattenedInputs[0][0]]
- });
- return inputChainClient.readContract({
- address: COMPACT,
- abi: COMPACT_ABI,
- functionName: "hasConsumedAllocatorNonce",
- args: [order.nonce, allocator]
- });
- },
- { ttlMs: PROGRESS_TTL_MS }
- );
- }
-
- return false;
+ const { order, inputSettler } = container;
+ const inputChainClient = getClient(chainId);
+ const intent = containerToIntent(container);
+ const orderId = intent.orderId();
+
+ if (
+ inputSettler === INPUT_SETTLER_ESCROW_LIFI ||
+ inputSettler === MULTICHAIN_INPUT_SETTLER_ESCROW
+ ) {
+ return getOrFetchRpc(
+ `progress:finalised:escrow:${orderId}:${chainId.toString()}`,
+ async () => {
+ const orderStatus = await inputChainClient.readContract({
+ address: inputSettler,
+ abi: SETTLER_ESCROW_ABI,
+ functionName: "orderStatus",
+ args: [orderId]
+ });
+ return orderStatus === OrderStatus_Claimed || orderStatus === OrderStatus_Refunded;
+ },
+ { ttlMs: PROGRESS_TTL_MS }
+ );
+ }
+
+ if (
+ inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
+ inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT
+ ) {
+ const flattenedInputs = "originChainId" in order ? order.inputs : order.inputs[0]?.inputs;
+ if (!flattenedInputs || flattenedInputs.length === 0) return false;
+
+ return getOrFetchRpc(
+ `progress:finalised:compact:${orderId}:${chainId.toString()}`,
+ async () => {
+ const [, allocator] = await inputChainClient.readContract({
+ address: COMPACT,
+ abi: COMPACT_ABI,
+ functionName: "getLockDetails",
+ args: [flattenedInputs[0][0]]
+ });
+ return inputChainClient.readContract({
+ address: COMPACT,
+ abi: COMPACT_ABI,
+ functionName: "hasConsumedAllocatorNonce",
+ args: [order.nonce, allocator]
+ });
+ },
+ { ttlMs: PROGRESS_TTL_MS }
+ );
+ }
+
+ return false;
}
export async function getOrderProgressChecks(
- orderContainer: OrderContainer,
- fillTransactions: Record
+ orderContainer: OrderContainer,
+ fillTransactions: Record
): Promise {
- try {
- const intent = orderToIntent(orderContainer);
- const orderId = intent.orderId();
- const inputChains = intent.inputChains();
- const outputs = orderContainer.order.outputs;
-
- const filledStates = await Promise.all(
- outputs.map((output) => isOutputFilled(orderId, output))
- );
- const allFilled = outputs.length > 0 && filledStates.every(Boolean);
-
- let allValidated = false;
- if (allFilled && inputChains.length > 0) {
- const validatedPairs = await Promise.all(
- inputChains.flatMap((inputChain) =>
- outputs.map(async (output) => {
- const fillHash = fillTransactions[getOutputStorageKey(output)];
- if (!isValidHash(fillHash)) return false;
- return isOutputValidatedOnChain(orderId, inputChain, orderContainer, output, fillHash);
- })
- )
- );
- allValidated = validatedPairs.length > 0 && validatedPairs.every(Boolean);
- }
-
- let allFinalised = false;
- if (allValidated && inputChains.length > 0) {
- const finalisedStates = await Promise.all(
- inputChains.map((chainId) => isInputChainFinalised(chainId, orderContainer))
- );
- allFinalised = finalisedStates.every(Boolean);
- }
-
- return {
- allFilled,
- allValidated,
- allFinalised
- };
- } catch (error) {
- console.warn("progress checks failed", error);
- return {
- allFilled: false,
- allValidated: false,
- allFinalised: false
- };
- }
+ try {
+ const intent = containerToIntent(orderContainer);
+ const orderId = intent.orderId();
+ const inputChains = intent.inputChains();
+ const outputs = orderContainer.order.outputs;
+
+ const filledStates = await Promise.all(
+ outputs.map((output) => isOutputFilled(orderId, output))
+ );
+ const allFilled = outputs.length > 0 && filledStates.every(Boolean);
+
+ let allValidated = false;
+ if (allFilled && inputChains.length > 0) {
+ const validatedPairs = await Promise.all(
+ inputChains.flatMap((inputChain) =>
+ outputs.map(async (output) => {
+ const fillHash = fillTransactions[getOutputStorageKey(output)];
+ if (!isValidHash(fillHash)) return false;
+ return isOutputValidatedOnChain(orderId, inputChain, orderContainer, output, fillHash);
+ })
+ )
+ );
+ allValidated = validatedPairs.length > 0 && validatedPairs.every(Boolean);
+ }
+
+ let allFinalised = false;
+ if (allValidated && inputChains.length > 0) {
+ const finalisedStates = await Promise.all(
+ inputChains.map((chainId) => isInputChainFinalised(chainId, orderContainer))
+ );
+ allFinalised = finalisedStates.every(Boolean);
+ }
+
+ return {
+ allFilled,
+ allValidated,
+ allFinalised
+ };
+ } catch (error) {
+ console.warn("progress checks failed", error);
+ return {
+ allFilled: false,
+ allValidated: false,
+ allFinalised: false
+ };
+ }
}
diff --git a/src/lib/libraries/intent.ts b/src/lib/libraries/intent.ts
deleted file mode 100644
index 7d630d2..0000000
--- a/src/lib/libraries/intent.ts
+++ /dev/null
@@ -1,924 +0,0 @@
-import { encodeAbiParameters, encodePacked, hashStruct, keccak256, parseAbiParameters } from "viem";
-import type {
- BatchCompact,
- CompactMandate,
- Element,
- MandateOutput,
- MultichainCompact,
- MultichainOrder,
- MultichainOrderComponent,
- NoSignature,
- Signature,
- StandardOrder
-} from "../../types";
-import { COMPACT_ABI } from "../abi/compact";
-import {
- chainMap,
- clients,
- COIN_FILLER,
- COMPACT,
- getChainName,
- getOracle,
- INPUT_SETTLER_COMPACT_LIFI,
- INPUT_SETTLER_ESCROW_LIFI,
- MULTICHAIN_INPUT_SETTLER_COMPACT,
- MULTICHAIN_INPUT_SETTLER_ESCROW,
- type chain,
- type Verifier,
- type WC
-} from "../config";
-import { ResetPeriod, toId } from "../utils/idLib";
-import { compact_type_hash, compactTypes } from "../utils/typedMessage";
-import { addressToBytes32 } from "../utils/convert";
-import { SETTLER_ESCROW_ABI } from "../abi/escrow";
-import type { TokenContext } from "$lib/state.svelte";
-import { MULTICHAIN_SETTLER_ESCROW_ABI } from "$lib/abi/multichain_escrow";
-import { SETTLER_COMPACT_ABI } from "$lib/abi/settlercompact";
-import { toHex } from "$lib/utils/interopableAddresses";
-import { MULTICHAIN_SETTLER_COMPACT_ABI } from "$lib/abi/multichain_compact";
-
-type Lock = {
- lockTag: `0x${string}`;
- token: `0x${string}`;
- amount: bigint;
-};
-
-export type EscrowLock = {
- type: "escrow";
-};
-
-export type CompactLock = {
- type: "compact";
- resetPeriod: ResetPeriod;
- allocatorId: string;
-};
-
-export type CreateIntentOptionsEscrow = {
- exclusiveFor: string;
- inputTokens: TokenContext[];
- outputTokens: TokenContext[];
- verifier: Verifier;
- account: () => `0x${string}`;
- lock: EscrowLock;
-};
-
-export type CreateIntentOptionsCompact = {
- exclusiveFor: string;
- inputTokens: TokenContext[];
- outputTokens: TokenContext[];
- verifier: Verifier;
- account: () => `0x${string}`;
- lock: CompactLock;
-};
-
-export type CreateIntentOptions = CreateIntentOptionsEscrow | CreateIntentOptionsCompact;
-
-function findChain(chainId: bigint) {
- for (const [name, data] of Object.entries(chainMap)) {
- if (BigInt(data.id) === chainId) {
- return chainMap[name as chain];
- }
- }
- return undefined;
-}
-
-function selectAllBut(arr: T[], index: number): T[] {
- return [...arr.slice(0, index), ...arr.slice(index + 1, arr.length)];
-}
-
-function encodeOutputs(outputs: MandateOutput[]) {
- return encodeAbiParameters(
- parseAbiParameters(
- "(bytes32 oracle, bytes32 settler, uint256 chainId, bytes32 token, uint256 amount, bytes32 recipient, bytes callbackData, bytes context)[]"
- ),
- [outputs]
- );
-}
-
-const ONE_MINUTE = 60;
-const ONE_HOUR = 60 * ONE_MINUTE;
-const ONE_DAY = 24 * ONE_HOUR;
-
-/**
- * @notice Class representing a Li.Fi Intent. Contains intent abstractions and helpers.
- */
-export class Intent {
- private lock: EscrowLock | CompactLock;
-
- // User facing order options
- private user: () => `0x${string}`;
- private inputs: TokenContext[];
- private outputs: TokenContext[];
- private verifier: Verifier;
-
- private exclusiveFor?: `0x${string}`;
-
- private _nonce?: bigint;
-
- private expiry = ONE_DAY;
- private fillDeadline = 2 * ONE_HOUR;
-
- constructor(opts: CreateIntentOptionsEscrow | CreateIntentOptionsCompact) {
- this.lock = opts.lock;
-
- this.user = opts.account;
- this.inputs = opts.inputTokens;
- this.outputs = opts.outputTokens;
- this.verifier = opts.verifier;
-
- this.exclusiveFor = this.normalizeExclusiveFor(opts.exclusiveFor);
- }
-
- private normalizeExclusiveFor(exclusiveFor: string): `0x${string}` | undefined {
- const trimmed = exclusiveFor.trim();
- if (trimmed.length === 0) return undefined;
- const normalized = trimmed.toLowerCase();
- if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
- throw new Error(`ExclusiveFor not formatted correctly ${exclusiveFor}`);
- }
- return normalized as `0x${string}`;
- }
-
- numInputChains() {
- const tokenChains = this.inputs.map(({ token }) => token.chain);
- return [...new Set(tokenChains)].length;
- }
-
- isMultichain() {
- return this.numInputChains() > 1;
- }
-
- isSameChain() {
- // Multichain intents cannot be same chain. Normal "Output oracle" will be used.
- if (this.isMultichain()) return false;
-
- // Only 1 input chain is used.
- const inputChain = this.inputs[0].token.chain;
- const outputChains = this.outputs.map((o) => o.token.chain);
- const numOutputChains = [...new Set(outputChains)].length;
- if (numOutputChains > 1) return false;
- // Only 1 output chain is used.
- const outputChain = this.outputs[0].token.chain;
- return inputChain === outputChain;
- }
-
- nonce() {
- if (this._nonce) return this._nonce;
- this._nonce = BigInt(Math.floor(Math.random() * 2 ** 32));
- return this._nonce;
- }
-
- inputSettler(multichain: boolean) {
- if (this.lock.type === "compact" && multichain === false) return INPUT_SETTLER_COMPACT_LIFI;
- if (this.lock.type === "compact" && multichain === true)
- return MULTICHAIN_INPUT_SETTLER_COMPACT;
- if (this.lock.type === "escrow" && multichain === false) return INPUT_SETTLER_ESCROW_LIFI;
- if (this.lock.type === "escrow" && multichain === true) return MULTICHAIN_INPUT_SETTLER_ESCROW;
-
- throw new Error(`Not supported | multichain: ${multichain}, type: ${this.lock.type}`);
- }
-
- encodeOutputs(currentTime: number) {
- // Get the current epoch timestamp:
- currentTime;
- const ONE_MINUTE = 60;
-
- let context: `0x${string}` = "0x";
- if (this.exclusiveFor) {
- const paddedExclusiveFor: `0x${string}` = `0x${this.exclusiveFor.replace("0x", "").padStart(64, "0")}`;
- context = encodePacked(
- ["bytes1", "bytes32", "uint32"],
- ["0xe0", paddedExclusiveFor, currentTime + ONE_MINUTE]
- );
- }
-
- const outputSettler = COIN_FILLER;
- const sameChain = this.isSameChain();
-
- return this.outputs.map(({ token, amount }) => {
- const outputOracle = sameChain
- ? addressToBytes32(outputSettler)
- : addressToBytes32(getOracle(this.verifier, token.chain)!);
- return {
- oracle: outputOracle,
- settler: addressToBytes32(outputSettler),
- chainId: BigInt(chainMap[token.chain].id),
- token: addressToBytes32(token.address),
- amount: amount,
- recipient: addressToBytes32(this.user()),
- callbackData: "0x",
- context
- };
- }) as MandateOutput[];
- }
-
- singlechain() {
- if (this.isMultichain())
- throw new Error(`Not supported as single chain with ${this.numInputChains()} chains`);
-
- const inputChain = this.inputs[0].token.chain;
-
- const inputs: [bigint, bigint][] = this.inputs.map(({ token, amount }) => [
- this.lock.type === "compact"
- ? toId(true, this.lock.resetPeriod, this.lock.allocatorId, token.address)
- : BigInt(token.address),
- amount
- ]);
-
- const currentTime = Math.floor(Date.now() / 1000);
-
- const inputOracle = this.isSameChain() ? COIN_FILLER : getOracle(this.verifier, inputChain)!;
-
- const order: StandardOrder = {
- user: this.user(),
- nonce: this.nonce(),
- originChainId: BigInt(chainMap[inputChain].id),
- fillDeadline: currentTime + this.fillDeadline,
- expires: currentTime + this.expiry,
- inputOracle: inputOracle,
- inputs: inputs,
- outputs: this.encodeOutputs(currentTime)
- };
-
- return new StandardOrderIntent(this.inputSettler(false), order);
- }
-
- multichain() {
- const currentTime = Math.floor(Date.now() / 1000);
-
- // TODO: Fix before release. The input oracle is not the same on every chain.
- const inputOracle = getOracle(this.verifier, this.inputs[0].token.chain)!;
-
- // Get all unique chains and then get all inputs for each chain.
- const inputs: { chainId: bigint; inputs: [bigint, bigint][] }[] = [
- ...new Set(this.inputs.map(({ token }) => token.chain))
- ].map((chain) => {
- const chainInputs = this.inputs.filter(({ token }) => token.chain === chain);
-
- return {
- chainId: BigInt(chainMap[chain].id),
- inputs: chainInputs.map(({ token, amount }) => [
- this.lock.type === "compact"
- ? toId(true, this.lock.resetPeriod, this.lock.allocatorId, token.address)
- : BigInt(token.address),
- amount
- ])
- };
- });
-
- const order: MultichainOrder = {
- user: this.user(),
- nonce: this.nonce(),
- fillDeadline: currentTime + this.fillDeadline,
- expires: currentTime + this.expiry,
- inputOracle: inputOracle,
- outputs: this.encodeOutputs(currentTime),
- inputs: inputs
- };
-
- return new MultichainOrderIntent(this.inputSettler(true), order, this.lock);
- }
-
- order() {
- if (this.isMultichain()) return this.multichain();
- return this.singlechain();
- }
-}
-
-/// @notice Helper function that allows you to provide an order and it will correctly generate the appropriate order.
-export function orderToIntent(options: {
- inputSettler: `0x${string}`;
- order: StandardOrder;
- lock?: { type: string };
-}): StandardOrderIntent;
-export function orderToIntent(options: {
- inputSettler: `0x${string}`;
- order: MultichainOrder;
- lock?: { type: string };
-}): MultichainOrderIntent;
-export function orderToIntent(options: {
- inputSettler: `0x${string}`;
- order: StandardOrder | MultichainOrder;
- lock?: { type: string };
-}): StandardOrderIntent | MultichainOrderIntent;
-export function orderToIntent(options: {
- inputSettler: `0x${string}`;
- order: StandardOrder | MultichainOrder;
- lock?: { type: string };
-}): StandardOrderIntent | MultichainOrderIntent {
- const { inputSettler, order, lock } = options;
- // Use presence of originChainId to discriminate StandardOrder vs MultichainOrder
- if ("originChainId" in order) {
- return new StandardOrderIntent(inputSettler, order as StandardOrder);
- }
- return new MultichainOrderIntent(inputSettler, order as MultichainOrder, lock);
-}
-
-export class StandardOrderIntent {
- inputSettler: `0x${string}`;
- order: StandardOrder;
-
- constructor(inputSetter: `0x${string}`, order: StandardOrder) {
- this.inputSettler = inputSetter;
- this.order = order;
- }
-
- // -- Order Representations -- //
-
- /**
- * @notice Returns for logging
- */
- asOrder(): StandardOrder {
- return this.order;
- }
-
- /**
- * @notice Returns the order as a StandardOrder.
- * @returns Order as StandardOrder
- */
- asStandardOrder(): StandardOrder {
- return this.order;
- }
-
- /**
- * @notice Returns the order as a BatchCompact.
- * @returns Order as BatchCompact (signed object for Compact)
- */
- asBatchCompact(): BatchCompact {
- const { order } = this;
- const mandate: CompactMandate = {
- fillDeadline: order.fillDeadline,
- inputOracle: order.inputOracle,
- outputs: order.outputs
- };
- const commitments = order.inputs.map(([tokenId, amount]) => {
- const lockTag: `0x${string}` = `0x${toHex(tokenId, 32).slice(0, 12 * 2)}`;
- const token: `0x${string}` = `0x${toHex(tokenId, 32).slice(12 * 2, 32 * 2)}`;
- return {
- lockTag,
- token,
- amount
- };
- });
- return {
- arbiter: INPUT_SETTLER_COMPACT_LIFI,
- sponsor: order.user,
- nonce: order.nonce,
- expires: BigInt(order.expires),
- commitments,
- mandate
- };
- }
-
- inputChains(): bigint[] {
- return [this.order.originChainId];
- }
-
- orderId(): `0x${string}` {
- return keccak256(
- encodePacked(
- [
- "uint256",
- "address",
- "address",
- "uint256",
- "uint32",
- "uint32",
- "address",
- "bytes32",
- "bytes"
- ],
- [
- this.order.originChainId,
- this.inputSettler,
- this.order.user,
- this.order.nonce,
- this.order.expires,
- this.order.fillDeadline,
- this.order.inputOracle,
- keccak256(encodePacked(["uint256[2][]"], [this.order.inputs])),
- encodeOutputs(this.order.outputs)
- ]
- )
- );
- }
-
- // -- Escrow Helpers -- //
-
- /**
- * @notice Opens an intent using the escrow input settler by depositing into it.
- * @param account Account that calls open.
- * @param walletClient Wallet client for sending the call to.
- * @returns transactionHash for the on-chain call.
- */
- async openEscrow(account: `0x${string}`, walletClient: WC): Promise<[`0x${string}`]> {
- const chain = findChain(this.order.originChainId);
- walletClient.switchChain({ id: Number(this.order.originChainId) });
- if (!chain)
- throw new Error("Chain not found for chainId " + this.order.originChainId.toString());
- return [
- await walletClient.writeContract({
- chain,
- account,
- address: INPUT_SETTLER_ESCROW_LIFI,
- abi: SETTLER_ESCROW_ABI,
- functionName: "open",
- args: [this.order]
- })
- ];
- }
-
- // -- Compact Helpers -- //
-
- compactClaimHash(): `0x${string}` {
- const claimHash = hashStruct({
- data: this.asBatchCompact(),
- types: compactTypes,
- primaryType: "BatchCompact"
- });
- return claimHash;
- }
-
- signCompact(account: `0x${string}`, walletClient: WC): Promise<`0x${string}`> {
- const chainId = this.order.originChainId;
- return walletClient.signTypedData({
- account,
- domain: {
- name: "The Compact",
- version: "1",
- chainId,
- verifyingContract: COMPACT
- } as const,
- types: compactTypes,
- primaryType: "BatchCompact",
- message: this.asBatchCompact()
- });
- }
-
- depositAndRegisterCompact(account: `0x${string}`, walletClient: WC): Promise<`0x${string}`> {
- const chain = findChain(this.order.originChainId);
- if (!chain)
- throw new Error("Chain not found for chainId " + this.order.originChainId.toString());
- return walletClient.writeContract({
- chain,
- account,
- address: COMPACT,
- abi: COMPACT_ABI,
- functionName: "batchDepositAndRegisterMultiple",
- args: [this.order.inputs, [[this.compactClaimHash(), compact_type_hash]]]
- });
- }
-
- async finalise(options: {
- sourceChain: chain;
- account: `0x${string}`;
- walletClient: WC;
- solveParams: { timestamp: number; solver: `0x${string}` }[];
- signatures: {
- sponsorSignature: Signature | NoSignature;
- allocatorSignature: Signature | NoSignature;
- };
- }) {
- const { sourceChain, account, walletClient, solveParams, signatures } = options;
- const actionChain = chainMap[sourceChain];
- if (actionChain.id !== Number(this.order.originChainId))
- throw new Error(
- `Origin chain id and action ID does not match: ${this.order.originChainId}, ${actionChain.id}`
- );
-
- if (this.inputSettler.toLowerCase() === INPUT_SETTLER_ESCROW_LIFI.toLowerCase()) {
- return await walletClient.writeContract({
- chain: actionChain,
- account: account,
- address: this.inputSettler,
- abi: SETTLER_ESCROW_ABI,
- functionName: "finalise",
- args: [this.order, solveParams, addressToBytes32(account), "0x"]
- });
- } else if (this.inputSettler.toLowerCase() === INPUT_SETTLER_COMPACT_LIFI.toLowerCase()) {
- // Check whether or not we have a signature.
- const { sponsorSignature, allocatorSignature } = signatures;
- console.log({
- sponsorSignature,
- allocatorSignature
- });
- const combinedSignatures = encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
- sponsorSignature.payload ?? "0x",
- allocatorSignature.payload
- ]);
- return await walletClient.writeContract({
- chain: actionChain,
- account: account,
- address: this.inputSettler,
- abi: SETTLER_COMPACT_ABI,
- functionName: "finalise",
- args: [this.order, combinedSignatures, solveParams, addressToBytes32(account), "0x"]
- });
- } else {
- throw new Error(`Could not detect settler type ${this.inputSettler}`);
- }
- }
-}
-
-export class MultichainOrderIntent {
- lock?: { type: string } | EscrowLock | CompactLock;
-
- // Notice that this has to be the same address on every chain.
- inputSettler: `0x${string}`;
- order: MultichainOrder;
-
- constructor(inputSetter: `0x${string}`, order: MultichainOrder, lock?: { type: string }) {
- this.inputSettler = inputSetter;
- this.order = order;
-
- const isCompact =
- this.inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
- this.inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT;
-
- this.lock = lock ?? { type: isCompact ? "compact" : "escrow" };
- }
-
- selfTest() {
- this.asOrder();
- this.inputChains();
- this.asComponents();
-
- this.orderId();
- }
-
- /**
- * @notice Returns for logging
- */
- asOrder(): MultichainOrder {
- return this.order;
- }
-
- inputChains(): bigint[] {
- return [...new Set(this.order.inputs.map((i) => i.chainId))];
- }
-
- orderId(): `0x${string}` {
- // We need a random order components.
- const components = this.asComponents();
- const computedOrderIds = components.map((c) =>
- this.lock?.type === "escrow"
- ? MultichainOrderIntent.escrowOrderId(this.inputSettler, c.orderComponent, c.chainId)
- : MultichainOrderIntent.compactOrderid(this.inputSettler, c.orderComponent, c.chainId)
- );
-
- const orderId = computedOrderIds[0];
- computedOrderIds.map((v) => {
- if (v !== orderId) throw new Error(`Order ids are not equal ${computedOrderIds}`);
- });
- if (this.lock?.type === "compact") {
- const multichainCompactHash = hashStruct({
- data: this.asMultichainBatchCompact(),
- types: compactTypes,
- primaryType: "MultichainCompact"
- });
- if (multichainCompactHash !== orderId)
- throw new Error(
- `MultichainCompact does not match orderId, ${multichainCompactHash} ${orderId}`
- );
- }
- return orderId;
- }
-
- async orderIdCheck() {
- const components = this.asComponents();
- const computedOrderId = this.orderId();
- const onChainOrderIds = await Promise.all(
- components.map(async (component) => {
- const onChainId = await clients[getChainName(component.chainId)].readContract({
- address: this.inputSettler,
- abi: MULTICHAIN_SETTLER_COMPACT_ABI,
- functionName: "orderIdentifier",
- args: [component.orderComponent]
- });
- return onChainId;
- })
- );
- console.log({ computedOrderId, onChainOrderIds });
- }
-
- static escrowOrderId(
- inputSettler: `0x${string}`,
- orderComponent: MultichainOrderComponent,
- _: bigint
- ) {
- return keccak256(
- encodePacked(
- ["address", "address", "uint256", "uint32", "uint32", "address", "bytes32", "bytes"],
- [
- inputSettler,
- orderComponent.user,
- orderComponent.nonce,
- orderComponent.expires,
- orderComponent.fillDeadline,
- orderComponent.inputOracle,
- MultichainOrderIntent.constructInputHash(
- orderComponent.chainIdField,
- orderComponent.chainIndex,
- orderComponent.inputs,
- orderComponent.additionalChains
- ),
- encodeOutputs(orderComponent.outputs)
- ]
- )
- );
- }
-
- static compactOrderid(
- inputSettler: `0x${string}`,
- orderComponent: MultichainOrderComponent,
- chainId: bigint
- ) {
- const MULTICHAIN_COMPACT_TYPEHASH_WITH_WITNESS = keccak256(
- encodePacked(
- ["string"],
- [
- "MultichainCompact(address sponsor,uint256 nonce,uint256 expires,Element[] elements)Element(address arbiter,uint256 chainId,Lock[] commitments,Mandate mandate)Lock(bytes12 lockTag,address token,uint256 amount)Mandate(uint32 fillDeadline,address inputOracle,MandateOutput[] outputs)MandateOutput(bytes32 oracle,bytes32 settler,uint256 chainId,bytes32 token,uint256 amount,bytes32 recipient,bytes callbackData,bytes context)"
- ]
- )
- );
- const { fillDeadline, inputOracle, outputs, inputs } = orderComponent;
- const mandate: CompactMandate = {
- fillDeadline,
- inputOracle,
- outputs
- };
- const element: Element = {
- arbiter: inputSettler,
- chainId: chainId,
- commitments: MultichainOrderIntent.inputsToLocks(inputs),
- mandate
- };
-
- const elementHash = hashStruct({
- types: compactTypes,
- primaryType: "Element",
- data: element
- });
-
- const elementHashes = [
- ...orderComponent.additionalChains.slice(0, Number(orderComponent.chainIndex)),
- elementHash,
- ...orderComponent.additionalChains.slice(Number(orderComponent.chainIndex))
- ];
-
- return keccak256(
- encodeAbiParameters(
- parseAbiParameters(["bytes32", "address", "uint256", "uint256", "bytes32"]),
- [
- MULTICHAIN_COMPACT_TYPEHASH_WITH_WITNESS,
- orderComponent.user,
- orderComponent.nonce,
- BigInt(orderComponent.expires),
- keccak256(encodePacked(["bytes32[]"], [elementHashes]))
- ]
- )
- );
- }
-
- static hashInputs(chainId: bigint, inputs: [bigint, bigint][]) {
- return keccak256(encodePacked(["uint256", "uint256[2][]"], [chainId, inputs]));
- }
-
- static constructInputHash(
- inputsChainId: bigint,
- chainIndex: bigint,
- inputs: [bigint, bigint][],
- additionalChains: `0x${string}`[]
- ) {
- const inputHash = MultichainOrderIntent.hashInputs(inputsChainId, inputs);
- const numSegments = additionalChains.length + 1;
- if (numSegments <= chainIndex)
- throw new Error(`ChainIndexOutOfRange(${chainIndex},${numSegments})`);
- const claimStructure: `0x${string}`[] = [];
- for (let i = 0; i < numSegments; ++i) {
- const additionalChainsIndex = i > chainIndex ? i - 1 : i;
- const inputHashElement =
- chainIndex == BigInt(i) ? inputHash : additionalChains[additionalChainsIndex];
- claimStructure[i] = inputHashElement;
- }
- return keccak256(encodePacked(["bytes32[]"], [claimStructure]));
- }
-
- static inputsToLocks(inputs: [bigint, bigint][]): Lock[] {
- return inputs.map((input) => {
- const bytes32 = toHex(input[0], 32);
- return {
- lockTag: `0x${bytes32.slice(0, 12 * 2)}`,
- token: `0x${bytes32.slice(12 * 2, 32 * 2)}`,
- amount: input[1]
- };
- });
- }
-
- secondariesEcsrow(): { chainIdField: bigint; additionalChains: `0x${string}`[] }[] {
- const inputsHash: `0x${string}`[] = this.order.inputs.map((input) =>
- keccak256(encodePacked(["uint256", "uint256[2][]"], [input.chainId, input.inputs]))
- );
- return this.order.inputs.map((v, i) => {
- return {
- chainIdField: v.chainId,
- additionalChains: selectAllBut(inputsHash, i)
- };
- });
- }
-
- asCompactElements() {
- const { fillDeadline, inputOracle, outputs, inputs } = this.order;
- const mandate: CompactMandate = {
- fillDeadline,
- inputOracle,
- outputs
- };
- return inputs.map((inputs) => {
- const element: Element = {
- arbiter: this.inputSettler,
- chainId: inputs.chainId,
- commitments: MultichainOrderIntent.inputsToLocks(inputs.inputs),
- mandate
- };
- return element;
- });
- }
-
- secondariesCompact(): { chainIdField: bigint; additionalChains: `0x${string}`[] }[] {
- const { inputs } = this.order;
- const elements = this.asCompactElements().map((element) => {
- const hash = hashStruct({
- types: compactTypes,
- primaryType: "Element",
- data: element
- });
- return hash;
- });
- return inputs.map((_, i) => {
- return {
- chainIdField: inputs[0].chainId,
- additionalChains: selectAllBut(elements, i)
- };
- });
- }
-
- asComponents(): { chainId: bigint; orderComponent: MultichainOrderComponent }[] {
- const { inputs, user, nonce, expires, fillDeadline, inputOracle, outputs } = this.order;
- if (!this.lock) throw new Error(`No lock provided, cannot compute secondaries.`);
- const secondaries =
- this.lock.type == "escrow" ? this.secondariesEcsrow() : this.secondariesCompact();
- const components: { chainId: bigint; orderComponent: MultichainOrderComponent }[] = [];
- for (let i = 0; i < inputs.length; ++i) {
- const { chainIdField, additionalChains } = secondaries[i];
-
- const orderComponent: MultichainOrderComponent = {
- user: user,
- nonce: nonce,
- chainIdField: chainIdField,
- chainIndex: BigInt(i),
- expires: expires,
- fillDeadline: fillDeadline,
- inputOracle: inputOracle,
- inputs: inputs[i].inputs,
- outputs: outputs,
- additionalChains: additionalChains
- };
- components.push({ chainId: inputs[i].chainId, orderComponent });
- }
- return components;
- }
-
- // -- Compact Helpers -- //
-
- asMultichainBatchCompact(): MultichainCompact {
- const { order } = this;
- const mandate: CompactMandate = {
- fillDeadline: order.fillDeadline,
- inputOracle: order.inputOracle,
- outputs: order.outputs
- };
- const result = {
- sponsor: order.user,
- nonce: order.nonce,
- expires: BigInt(order.expires),
- elements: this.asCompactElements(),
- mandate
- };
- return result;
- }
-
- compactClaimHash(): `0x${string}` {
- const claimHash = hashStruct({
- data: this.asMultichainBatchCompact(),
- types: compactTypes,
- primaryType: "MultichainCompact"
- });
- return claimHash;
- }
-
- signCompact(account: `0x${string}`, walletClient: WC): Promise<`0x${string}`> {
- this.selfTest();
- const chainId = this.order.inputs[0].chainId;
- return walletClient.signTypedData({
- account,
- domain: {
- name: "The Compact",
- version: "1",
- chainId,
- verifyingContract: COMPACT
- } as const,
- types: compactTypes,
- primaryType: "MultichainCompact",
- message: this.asMultichainBatchCompact()
- });
- }
-
- // This code is depreciated and needs to be updated.
- async openEscrow(account: `0x${string}`, walletClient: WC) {
- this.selfTest();
- const components = this.asComponents();
- const results: `0x${string}`[] = [];
- for (const { chainId, orderComponent } of components) {
- const chain = findChain(chainId)!;
- walletClient.switchChain({ id: chain.id });
- results.push(
- await walletClient.writeContract({
- chain,
- account,
- address: this.inputSettler,
- abi: MULTICHAIN_SETTLER_ESCROW_ABI,
- functionName: "open",
- args: [orderComponent]
- })
- );
- console.log(results);
- }
- return results;
- }
-
- async finalise(options: {
- sourceChain: chain;
- account: `0x${string}`;
- walletClient: WC;
- solveParams: { timestamp: number; solver: `0x${string}` }[];
- signatures: {
- sponsorSignature: Signature | NoSignature;
- allocatorSignature: Signature | NoSignature;
- };
- }) {
- this.asMultichainBatchCompact();
- const { sourceChain, account, walletClient, solveParams, signatures } = options;
- const actionChain = chainMap[sourceChain];
- const inputChainIds = this.inputChains().map((v) => Number(v));
- if (!inputChainIds.includes(actionChain.id))
- throw new Error(
- `Action chain must be one of input chains for finalise: ${inputChainIds}, action=${actionChain.id}`
- );
- // Get all components for our chain.
- const components = this.asComponents().filter((c) => Number(c.chainId) === actionChain.id);
- if (components.length === 0) {
- throw new Error(
- `No multichain order component found for action chain ${actionChain.id} (${sourceChain}).`
- );
- }
-
- for (const { orderComponent, chainId } of components) {
- if (this.inputSettler.toLowerCase() === MULTICHAIN_INPUT_SETTLER_ESCROW.toLowerCase()) {
- return await walletClient.writeContract({
- chain: actionChain,
- account: account,
- address: this.inputSettler,
- abi: MULTICHAIN_SETTLER_ESCROW_ABI,
- functionName: "finalise",
- args: [orderComponent, solveParams, addressToBytes32(account), "0x"]
- });
- } else if (
- this.inputSettler.toLowerCase() === MULTICHAIN_INPUT_SETTLER_COMPACT.toLowerCase()
- ) {
- const { sponsorSignature, allocatorSignature } = signatures;
- console.log({
- orderComponent,
- sponsorSignature,
- allocatorSignature
- });
-
- const combinedSignatures = encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
- sponsorSignature.payload ?? "0x",
- allocatorSignature.payload
- ]);
- return await walletClient.writeContract({
- chain: actionChain,
- account: account,
- address: this.inputSettler,
- abi: MULTICHAIN_SETTLER_COMPACT_ABI,
- functionName: "finalise",
- args: [orderComponent, combinedSignatures, solveParams, addressToBytes32(account), "0x"]
- });
- } else {
- throw new Error(`Could not detect settler type ${this.inputSettler}`);
- }
- }
- throw new Error(`Failed to finalise multichain order on chain ${sourceChain}.`);
- }
-}
diff --git a/src/lib/libraries/intentExecution.ts b/src/lib/libraries/intentExecution.ts
new file mode 100644
index 0000000..780ecb7
--- /dev/null
+++ b/src/lib/libraries/intentExecution.ts
@@ -0,0 +1,193 @@
+import { encodeAbiParameters, parseAbiParameters } from "viem";
+import { COMPACT_ABI } from "$lib/abi/compact";
+import { MULTICHAIN_SETTLER_COMPACT_ABI } from "$lib/abi/multichain_compact";
+import { MULTICHAIN_SETTLER_ESCROW_ABI } from "$lib/abi/multichain_escrow";
+import { SETTLER_ESCROW_ABI } from "$lib/abi/escrow";
+import { SETTLER_COMPACT_ABI } from "$lib/abi/settlercompact";
+import {
+ COMPACT,
+ INPUT_SETTLER_COMPACT_LIFI,
+ INPUT_SETTLER_ESCROW_LIFI,
+ MULTICHAIN_INPUT_SETTLER_COMPACT,
+ MULTICHAIN_INPUT_SETTLER_ESCROW,
+ getChain,
+ type WC
+} from "$lib/config";
+import { compact_type_hash } from "@lifi/intent";
+import { addressToBytes32 } from "@lifi/intent";
+import { signMultichainCompact, signStandardCompact } from "@lifi/intent";
+import { MultichainOrderIntent, StandardEVMIntent } from "@lifi/intent";
+import type { NoSignature, Signature } from "@lifi/intent";
+import type { TypedDataSigner } from "@lifi/intent";
+import { switchWalletChain } from "$lib/utils/walletClientRuntime";
+
+function combineSignatures(signatures: {
+ sponsorSignature: Signature | NoSignature;
+ allocatorSignature: Signature | NoSignature;
+}) {
+ const { sponsorSignature, allocatorSignature } = signatures;
+ return encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
+ sponsorSignature.payload ?? "0x",
+ allocatorSignature.payload
+ ]);
+}
+
+export function signIntentCompact(
+ intent: StandardEVMIntent | MultichainOrderIntent,
+ account: `0x${string}`,
+ walletClient: WC
+): Promise<`0x${string}`> {
+ const signer = walletClient as unknown as TypedDataSigner;
+ if (intent instanceof StandardEVMIntent) {
+ const order = intent.asOrder();
+ return signStandardCompact(account, signer, order.originChainId, intent.asBatchCompact());
+ }
+ const order = intent.asOrder();
+ return signMultichainCompact(
+ account,
+ signer,
+ order.inputs[0].chainId,
+ intent.asMultichainBatchCompact()
+ );
+}
+
+export async function depositAndRegisterCompact(
+ intent: StandardEVMIntent,
+ account: `0x${string}`,
+ walletClient: WC
+): Promise<`0x${string}`> {
+ const order = intent.asOrder();
+ const chain = getChain(order.originChainId);
+ return walletClient.writeContract({
+ chain,
+ account,
+ address: COMPACT,
+ abi: COMPACT_ABI,
+ functionName: "batchDepositAndRegisterMultiple",
+ args: [order.inputs, [[intent.compactClaimHash(), compact_type_hash]]]
+ });
+}
+
+export async function openEscrowIntent(
+ intent: StandardEVMIntent | MultichainOrderIntent,
+ account: `0x${string}`,
+ walletClient: WC
+): Promise<`0x${string}`[]> {
+ if (intent instanceof StandardEVMIntent) {
+ const order = intent.asOrder();
+ await switchWalletChain(walletClient, Number(order.originChainId));
+ const chain = getChain(order.originChainId);
+ return [
+ await walletClient.writeContract({
+ chain,
+ account,
+ address: INPUT_SETTLER_ESCROW_LIFI,
+ abi: SETTLER_ESCROW_ABI,
+ functionName: "open",
+ args: [order]
+ })
+ ];
+ }
+
+ const components = intent.asComponents();
+ const results: `0x${string}`[] = [];
+ for (const { chainId, orderComponent } of components) {
+ const chain = getChain(chainId);
+ await switchWalletChain(walletClient, chain.id);
+ results.push(
+ await walletClient.writeContract({
+ chain,
+ account,
+ address: intent.inputSettler,
+ abi: MULTICHAIN_SETTLER_ESCROW_ABI,
+ functionName: "open",
+ args: [orderComponent]
+ })
+ );
+ }
+ return results;
+}
+
+export async function finaliseIntent(options: {
+ intent: StandardEVMIntent | MultichainOrderIntent;
+ sourceChainId: number | bigint;
+ account: `0x${string}`;
+ walletClient: WC;
+ solveParams: { timestamp: number; solver: `0x${string}` }[];
+ signatures: {
+ sponsorSignature: Signature | NoSignature;
+ allocatorSignature: Signature | NoSignature;
+ };
+}) {
+ const { intent, sourceChainId, account, walletClient, solveParams, signatures } = options;
+ const actionChain = getChain(sourceChainId);
+
+ if (intent instanceof StandardEVMIntent) {
+ const order = intent.asOrder();
+ if (actionChain.id !== Number(order.originChainId)) {
+ throw new Error(
+ `Origin chain id and action ID does not match: ${order.originChainId}, ${actionChain.id}`
+ );
+ }
+ if (intent.inputSettler.toLowerCase() === INPUT_SETTLER_ESCROW_LIFI.toLowerCase()) {
+ return walletClient.writeContract({
+ chain: actionChain,
+ account,
+ address: intent.inputSettler,
+ abi: SETTLER_ESCROW_ABI,
+ functionName: "finalise",
+ args: [order, solveParams, addressToBytes32(account), "0x"]
+ });
+ }
+ if (intent.inputSettler.toLowerCase() === INPUT_SETTLER_COMPACT_LIFI.toLowerCase()) {
+ const combinedSignatures = combineSignatures(signatures);
+ return walletClient.writeContract({
+ chain: actionChain,
+ account,
+ address: intent.inputSettler,
+ abi: SETTLER_COMPACT_ABI,
+ functionName: "finalise",
+ args: [order, combinedSignatures, solveParams, addressToBytes32(account), "0x"]
+ });
+ }
+ throw new Error(`Could not detect settler type ${intent.inputSettler}`);
+ }
+
+ const inputChainIds = intent.inputChains().map((v) => Number(v));
+ if (!inputChainIds.includes(actionChain.id)) {
+ throw new Error(
+ `Action chain must be one of input chains for finalise: ${inputChainIds}, action=${actionChain.id}`
+ );
+ }
+ const components = intent.asComponents().filter((c) => Number(c.chainId) === actionChain.id);
+ if (components.length === 0) {
+ throw new Error(`No multichain order component found for action chain ${actionChain.id}.`);
+ }
+
+ for (const { orderComponent } of components) {
+ if (intent.inputSettler.toLowerCase() === MULTICHAIN_INPUT_SETTLER_ESCROW.toLowerCase()) {
+ return walletClient.writeContract({
+ chain: actionChain,
+ account,
+ address: intent.inputSettler,
+ abi: MULTICHAIN_SETTLER_ESCROW_ABI,
+ functionName: "finalise",
+ args: [orderComponent, solveParams, addressToBytes32(account), "0x"]
+ });
+ }
+ if (intent.inputSettler.toLowerCase() === MULTICHAIN_INPUT_SETTLER_COMPACT.toLowerCase()) {
+ const combinedSignatures = combineSignatures(signatures);
+ return walletClient.writeContract({
+ chain: actionChain,
+ account,
+ address: intent.inputSettler,
+ abi: MULTICHAIN_SETTLER_COMPACT_ABI,
+ functionName: "finalise",
+ args: [orderComponent, combinedSignatures, solveParams, addressToBytes32(account), "0x"]
+ });
+ }
+ throw new Error(`Could not detect settler type ${intent.inputSettler}`);
+ }
+
+ throw new Error(`Failed to finalise multichain order on chain ${actionChain.id}.`);
+}
diff --git a/src/lib/libraries/intentFactory.ts b/src/lib/libraries/intentFactory.ts
index 04a4740..557381e 100644
--- a/src/lib/libraries/intentFactory.ts
+++ b/src/lib/libraries/intentFactory.ts
@@ -1,222 +1,334 @@
import {
- type chain,
- chainMap,
- clients,
- INPUT_SETTLER_COMPACT_LIFI,
- INPUT_SETTLER_ESCROW_LIFI,
- MULTICHAIN_INPUT_SETTLER_ESCROW,
- type Token,
- type WC
+ getChain,
+ getClient,
+ INPUT_SETTLER_COMPACT_LIFI,
+ INPUT_SETTLER_ESCROW_LIFI,
+ MULTICHAIN_INPUT_SETTLER_ESCROW,
+ type WC
} from "$lib/config";
-import { maxUint256 } from "viem";
+import { encodePacked, maxUint256 } from "viem";
import type {
- MultichainOrder,
- NoSignature,
- OrderContainer,
- Signature,
- StandardOrder
-} from "../../types";
+ CreateIntentOptions,
+ TokenContext,
+ MultichainOrder,
+ NoSignature,
+ OrderContainer,
+ Signature,
+ StandardOrder
+} from "@lifi/intent";
+import {
+ Intent,
+ IntentApi,
+ StandardSolanaIntent,
+ SOLANA_MAINNET_CHAIN_ID,
+ SOLANA_TESTNET_CHAIN_ID,
+ SOLANA_DEVNET_CHAIN_ID
+} from "@lifi/intent";
+import type { AppCreateIntentOptions, AppTokenContext } from "$lib/appTypes";
import { ERC20_ABI } from "$lib/abi/erc20";
-import { Intent } from "$lib/libraries/intent";
-import { OrderServer } from "$lib/libraries/orderServer";
-import type { CreateIntentOptions } from "$lib/libraries/intent";
-import { store, type TokenContext } from "$lib/state.svelte";
+import { store } from "$lib/state.svelte";
+import { depositAndRegisterCompact, openEscrowIntent, signIntentCompact } from "./intentExecution";
+import { intentDeps } from "./coreDeps";
+
+const SOLANA_CHAIN_IDS = new Set([
+ SOLANA_MAINNET_CHAIN_ID,
+ SOLANA_TESTNET_CHAIN_ID,
+ SOLANA_DEVNET_CHAIN_ID
+]);
+
+const SAME_CHAIN_DURATION_SECONDS = 10 * 60; // 10 minutes
+const SAME_CHAIN_EXCLUSIVITY_SECONDS = 12 * 3; // 36 seconds
+
+function applySameChainTimings(intent: Intent): void {
+ if (!intent.isSameChain()) return;
+ const mutable = intent as unknown as { expiry: number; fillDeadline: number };
+ mutable.expiry = SAME_CHAIN_DURATION_SECONDS;
+ mutable.fillDeadline = SAME_CHAIN_DURATION_SECONDS;
+}
+
+function applyExclusivityOverride(
+ orderIntent: ReturnType,
+ exclusiveFor: string | undefined,
+ isSameChain: boolean
+): void {
+ if (!isSameChain || !exclusiveFor) return;
+ const order = orderIntent.asOrder() as StandardOrder;
+ const currentTime = Math.floor(Date.now() / 1000);
+ const paddedExclusiveFor =
+ `0x${exclusiveFor.replace("0x", "").padStart(64, "0")}` as `0x${string}`;
+ const newContext = encodePacked(
+ ["bytes1", "bytes32", "uint32"],
+ ["0xe0", paddedExclusiveFor, currentTime + SAME_CHAIN_EXCLUSIVITY_SECONDS]
+ );
+ for (const output of order.outputs) {
+ if (output.context !== "0x") {
+ output.context = newContext;
+ }
+ }
+}
+
+function toCoreTokenContext(input: AppTokenContext): TokenContext {
+ const chainId = BigInt(input.token.chainId);
+ return {
+ token: {
+ address: input.token.address,
+ name: input.token.name,
+ chainId,
+ decimals: input.token.decimals,
+ chainNamespace: SOLANA_CHAIN_IDS.has(chainId) ? "solana" : "eip155"
+ },
+ amount: input.amount
+ };
+}
+
+function toCoreCreateIntentOptions(opts: AppCreateIntentOptions): CreateIntentOptions {
+ const account = opts.account();
+ if (opts.lock.type === "compact") {
+ return {
+ exclusiveFor: opts.exclusiveFor,
+ inputTokens: opts.inputTokens.map(toCoreTokenContext),
+ outputTokens: opts.outputTokens.map(toCoreTokenContext),
+ verifier: opts.verifier,
+ account,
+ outputRecipient: opts.outputRecipient,
+ lock: {
+ type: "compact",
+ resetPeriod: opts.lock.resetPeriod,
+ allocatorId: opts.lock.allocatorId
+ }
+ };
+ }
+
+ return {
+ exclusiveFor: opts.exclusiveFor,
+ inputTokens: opts.inputTokens.map(toCoreTokenContext),
+ outputTokens: opts.outputTokens.map(toCoreTokenContext),
+ verifier: opts.verifier,
+ account,
+ outputRecipient: opts.outputRecipient,
+ lock: {
+ type: "escrow"
+ }
+ };
+}
/**
* @notice Factory class for creating and managing intents. Functions called by integrators.
*/
export class IntentFactory {
- mainnet: boolean;
- orderServer: OrderServer;
-
- walletClient: WC;
-
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
-
- orders: OrderContainer[] = [];
-
- constructor(options: {
- mainnet: boolean;
- walletClient: WC;
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- ordersPointer?: OrderContainer[];
- }) {
- const { mainnet, walletClient, preHook, postHook, ordersPointer } = options;
- this.mainnet = mainnet;
- this.orderServer = new OrderServer(mainnet);
- this.walletClient = walletClient;
-
- this.preHook = preHook;
- this.postHook = postHook;
-
- if (ordersPointer) this.orders = ordersPointer;
- }
-
- private saveOrder(options: {
- order: StandardOrder | MultichainOrder;
- inputSettler: `0x${string}`;
- sponsorSignature?: Signature | NoSignature;
- allocatorSignature?: Signature | NoSignature;
- }) {
- const { order, inputSettler, sponsorSignature, allocatorSignature } = options;
-
- const orderContainer: OrderContainer = {
- order,
- inputSettler,
- sponsorSignature: sponsorSignature ?? {
- type: "None",
- payload: "0x"
- },
- allocatorSignature: allocatorSignature ?? {
- type: "None",
- payload: "0x"
- }
- };
- this.orders.push(orderContainer);
- store.saveOrderToDb(orderContainer).catch((e) => console.warn("saveOrderToDb error", e));
- }
-
- compact(opts: CreateIntentOptions) {
- return async () => {
- const { account, inputTokens } = opts;
- const inputChain = inputTokens[0].token.chain;
- if (this.preHook) await this.preHook(inputChain);
- const intent = new Intent(opts).order();
-
- const sponsorSignature = await intent.signCompact(account(), this.walletClient);
-
- console.log({
- order: intent.asOrder(),
- sponsorSignature
- });
-
- this.saveOrder({
- order: intent.asOrder(),
- inputSettler: intent.inputSettler,
- sponsorSignature: {
- type: "ECDSA",
- payload: sponsorSignature
- }
- });
-
- const signedOrder = await this.orderServer.submitOrder({
- orderType: "CatalystCompactOrder",
- order: intent.asOrder() as StandardOrder,
- inputSettler: INPUT_SETTLER_COMPACT_LIFI,
- sponsorSignature,
- allocatorSignature: "0x"
- });
- console.log("signedOrder", signedOrder);
-
- if (this.postHook) await this.postHook();
- };
- }
-
- compactDepositAndRegister(opts: CreateIntentOptions) {
- return async () => {
- const { inputTokens, account } = opts;
- const publicClients = clients;
- const intent = new Intent(opts).singlechain();
-
- if (this.preHook) await this.preHook(inputTokens[0].token.chain);
-
- let transactionHash = await intent.depositAndRegisterCompact(account(), this.walletClient);
-
- const receipt = await publicClients[inputTokens[0].token.chain].waitForTransactionReceipt({
- hash: transactionHash
- });
-
- // If you use another allocator than polymer, there should be logic for potentially getting the allocator signature here.
- // You may consider getting the allocator signature before you call depositAndRegisterCompact
-
- // Add the order to our local order list.
- this.saveOrder({
- order: intent.asStandardOrder(),
- inputSettler: INPUT_SETTLER_COMPACT_LIFI
- });
-
- // Submit the order to the order server.
- const unsignedOrder = await this.orderServer.submitOrder({
- orderType: "CatalystCompactOrder",
- order: intent.asStandardOrder(),
- inputSettler: INPUT_SETTLER_COMPACT_LIFI,
- compactRegistrationTxHash: transactionHash
- });
-
- console.log("unsignedOrder", unsignedOrder);
- if (this.postHook) await this.postHook();
- };
- }
-
- openIntent(opts: CreateIntentOptions) {
- return async () => {
- const { inputTokens, account } = opts;
- const intent = new Intent(opts).order();
-
- const inputChain = inputTokens[0].token.chain;
- if (this.preHook) await this.preHook(inputChain);
-
- // Execute the open.
- const transactionHashes = await intent.openEscrow(account(), this.walletClient);
- console.log({ tsh: transactionHashes });
-
- // for (const hash of transactionHashes) {
- // await clients[inputChain].waitForTransactionReceipt({
- // hash: await hash
- // });
- // }
-
- if (this.postHook) await this.postHook();
-
- this.saveOrder({
- order: intent.asOrder(),
- inputSettler: store.inputSettler
- });
-
- return transactionHashes;
- };
- }
+ mainnet: boolean;
+ intentApi: IntentApi;
+
+ walletClient: WC;
+
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+
+ orders: OrderContainer[] = [];
+
+ constructor(options: {
+ mainnet: boolean;
+ useProductionApi?: boolean | null;
+ walletClient: WC;
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ ordersPointer?: OrderContainer[];
+ }) {
+ const { mainnet, useProductionApi, walletClient, preHook, postHook, ordersPointer } = options;
+ this.mainnet = mainnet;
+ this.intentApi = new IntentApi(useProductionApi ?? mainnet);
+ this.walletClient = walletClient;
+
+ this.preHook = preHook;
+ this.postHook = postHook;
+
+ if (ordersPointer) this.orders = ordersPointer;
+ }
+
+ private async saveOrder(options: {
+ order: StandardOrder | MultichainOrder;
+ inputSettler: `0x${string}`;
+ sponsorSignature?: Signature | NoSignature;
+ allocatorSignature?: Signature | NoSignature;
+ }) {
+ const { order, inputSettler, sponsorSignature, allocatorSignature } = options;
+
+ const orderContainer: OrderContainer = {
+ order,
+ inputSettler,
+ sponsorSignature: sponsorSignature ?? {
+ type: "None",
+ payload: "0x"
+ },
+ allocatorSignature: allocatorSignature ?? {
+ type: "None",
+ payload: "0x"
+ }
+ };
+ this.orders.push(orderContainer);
+ await store.saveOrderToDb(orderContainer);
+ }
+
+ compact(opts: AppCreateIntentOptions) {
+ return async () => {
+ const { account, inputTokens } = opts;
+ const inputChain = inputTokens[0].token.chainId;
+ if (this.preHook) await this.preHook(inputChain);
+ const intentInstance = new Intent(toCoreCreateIntentOptions(opts), intentDeps);
+ applySameChainTimings(intentInstance);
+ const sameChain = intentInstance.isSameChain();
+ const intent = intentInstance.order();
+ if (intent instanceof StandardSolanaIntent)
+ throw new Error("Compact signing is not supported for Solana intents.");
+ applyExclusivityOverride(intent, opts.exclusiveFor, sameChain);
+
+ const sponsorSignature = await signIntentCompact(intent, account(), this.walletClient);
+
+ console.log({
+ order: intent.asOrder(),
+ sponsorSignature
+ });
+
+ await this.saveOrder({
+ order: intent.asOrder(),
+ inputSettler: intent.inputSettler,
+ sponsorSignature: {
+ type: "ECDSA",
+ payload: sponsorSignature
+ }
+ });
+
+ const order = intent.asOrder();
+ if (!("originChainId" in order)) {
+ throw new Error("CatalystCompactOrder submission currently supports standard orders.");
+ }
+ const signedOrder = await this.intentApi.submitOrder({
+ orderType: "CatalystCompactOrder",
+ order,
+ inputSettler: INPUT_SETTLER_COMPACT_LIFI,
+ sponsorSignature,
+ allocatorSignature: "0x"
+ });
+ console.log("signedOrder", signedOrder);
+
+ if (this.postHook) await this.postHook();
+ };
+ }
+
+ compactDepositAndRegister(opts: AppCreateIntentOptions) {
+ return async () => {
+ const { inputTokens, account } = opts;
+ const intentInstance2 = new Intent(toCoreCreateIntentOptions(opts), intentDeps);
+ applySameChainTimings(intentInstance2);
+ const sameChain2 = intentInstance2.isSameChain();
+ const intent = intentInstance2.singlechain();
+ if (intent instanceof StandardSolanaIntent)
+ throw new Error("Compact deposit and register is not supported for Solana intents.");
+ applyExclusivityOverride(intent, opts.exclusiveFor, sameChain2);
+
+ if (this.preHook) await this.preHook(inputTokens[0].token.chainId);
+
+ let transactionHash = await depositAndRegisterCompact(intent, account(), this.walletClient);
+
+ const receipt = await getClient(inputTokens[0].token.chainId).waitForTransactionReceipt({
+ hash: transactionHash
+ });
+
+ // If you use another allocator than polymer, there should be logic for potentially getting the allocator signature here.
+ // You may consider getting the allocator signature before you call depositAndRegisterCompact
+
+ // Add the order to our local order list.
+ await this.saveOrder({
+ order: intent.asOrder(),
+ inputSettler: INPUT_SETTLER_COMPACT_LIFI
+ });
+
+ // Submit the order to the intent-api.
+ const unsignedOrder = await this.intentApi.submitOrder({
+ orderType: "CatalystCompactOrder",
+ order: intent.asOrder(),
+ inputSettler: INPUT_SETTLER_COMPACT_LIFI,
+ compactRegistrationTxHash: transactionHash
+ });
+
+ console.log("unsignedOrder", unsignedOrder);
+ if (this.postHook) await this.postHook();
+ };
+ }
+
+ openIntent(opts: AppCreateIntentOptions) {
+ return async () => {
+ const { inputTokens, account } = opts;
+ const intentInstance3 = new Intent(toCoreCreateIntentOptions(opts), intentDeps);
+ applySameChainTimings(intentInstance3);
+ const sameChain3 = intentInstance3.isSameChain();
+ const intent = intentInstance3.order();
+ if (intent instanceof StandardSolanaIntent)
+ throw new Error("openEscrowIntent is not supported for Solana intents.");
+ applyExclusivityOverride(intent, opts.exclusiveFor, sameChain3);
+
+ const inputChain = inputTokens[0].token.chainId;
+ if (this.preHook) await this.preHook(inputChain);
+
+ // Execute the open.
+ const transactionHashes = await openEscrowIntent(intent, account(), this.walletClient);
+ console.log({ tsh: transactionHashes });
+
+ // for (const hash of transactionHashes) {
+ // await clients[inputChain].waitForTransactionReceipt({
+ // hash: await hash
+ // });
+ // }
+
+ if (this.postHook) await this.postHook();
+
+ await this.saveOrder({
+ order: intent.asOrder(),
+ inputSettler: store.inputSettler
+ });
+
+ return transactionHashes;
+ };
+ }
}
export function escrowApprove(
- walletClient: WC,
- opts: {
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- inputTokens: TokenContext[];
- account: () => `0x${string}`;
- }
+ walletClient: WC,
+ opts: {
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ inputTokens: AppTokenContext[];
+ account: () => `0x${string}`;
+ }
) {
- return async () => {
- const settler = store.multichain ? MULTICHAIN_INPUT_SETTLER_ESCROW : INPUT_SETTLER_ESCROW_LIFI;
-
- const { preHook, postHook, inputTokens, account } = opts;
- for (let i = 0; i < inputTokens.length; ++i) {
- const { token, amount } = inputTokens[i];
- if (preHook) await preHook(token.chain);
- const publicClient = clients[token.chain];
- const currentAllowance = await publicClient.readContract({
- address: token.address,
- abi: ERC20_ABI,
- functionName: "allowance",
- args: [account(), settler]
- });
- if (currentAllowance >= amount) continue;
- const transactionHash = walletClient.writeContract({
- chain: chainMap[token.chain],
- account: account(),
- address: token.address,
- abi: ERC20_ABI,
- functionName: "approve",
- args: [settler, maxUint256]
- });
-
- await publicClient.waitForTransactionReceipt({
- hash: await transactionHash
- });
- }
- if (postHook) await postHook();
- };
+ return async () => {
+ const settler = store.multichain ? MULTICHAIN_INPUT_SETTLER_ESCROW : INPUT_SETTLER_ESCROW_LIFI;
+
+ const { preHook, postHook, inputTokens, account } = opts;
+ for (let i = 0; i < inputTokens.length; ++i) {
+ const { token, amount } = inputTokens[i];
+ if (preHook) await preHook(token.chainId);
+ const publicClient = getClient(token.chainId);
+ const currentAllowance = await publicClient.readContract({
+ address: token.address,
+ abi: ERC20_ABI,
+ functionName: "allowance",
+ args: [account(), settler]
+ });
+ if (currentAllowance >= amount) continue;
+ const transactionHash = walletClient.writeContract({
+ chain: getChain(token.chainId),
+ account: account(),
+ address: token.address,
+ abi: ERC20_ABI,
+ functionName: "approve",
+ args: [settler, maxUint256]
+ });
+
+ await publicClient.waitForTransactionReceipt({
+ hash: await transactionHash
+ });
+ }
+ if (postHook) await postHook();
+ };
}
diff --git a/src/lib/libraries/intentList.ts b/src/lib/libraries/intentList.ts
index 6ff1267..3630fc7 100644
--- a/src/lib/libraries/intentList.ts
+++ b/src/lib/libraries/intentList.ts
@@ -1,270 +1,277 @@
import {
- formatTokenAmount,
- getChainName,
- getCoin,
- type chain,
- INPUT_SETTLER_ESCROW_LIFI,
- INPUT_SETTLER_COMPACT_LIFI,
- MULTICHAIN_INPUT_SETTLER_ESCROW,
- MULTICHAIN_INPUT_SETTLER_COMPACT
+ formatTokenAmount,
+ getChainName,
+ getCoin,
+ INPUT_SETTLER_ESCROW_LIFI,
+ INPUT_SETTLER_COMPACT_LIFI,
+ MULTICHAIN_INPUT_SETTLER_ESCROW,
+ MULTICHAIN_INPUT_SETTLER_COMPACT
} from "../config";
-import { orderToIntent } from "./intent";
-import { bytes32ToAddress, idToToken } from "../utils/convert";
-import type { OrderContainer, StandardOrder, MultichainOrder } from "../../types";
-import { validateOrderContainerWithReason } from "$lib/utils/orderLib";
+import { bytes32ToAddress, idToToken } from "@lifi/intent";
+import { containerToIntent } from "$lib/utils/intent";
+import type { OrderContainer, StandardOrder, MultichainOrder } from "@lifi/intent";
+import { validateOrderContainerWithReason } from "@lifi/intent";
+import { orderValidationDeps } from "./coreDeps";
export type Chip = {
- key: string;
- text: string;
+ key: string;
+ text: string;
};
export type Status = "active" | "expiring" | "expired";
export type ChainScope = "singlechain" | "multichain" | "samechain";
export type BaseIntentRow = {
- orderContainer: OrderContainer;
- orderId: string;
- orderIdShort: string;
- userShort: string;
- fillDeadline: number;
- inputCount: number;
- outputCount: number;
- chainScope: ChainScope;
- chainScopeBadge: string;
- inputSchemeBadge?: string;
- orderTypeBadge?: string;
- exclusiveForAddress?: string;
- exclusiveUntil?: number;
- inputChips: Chip[];
- inputOverflow: number;
- outputChips: Chip[];
- outputOverflow: number;
- validationPassed: boolean;
- validationReason: string;
+ orderContainer: OrderContainer;
+ orderId: string;
+ orderIdShort: string;
+ userShort: string;
+ fillDeadline: number;
+ inputCount: number;
+ outputCount: number;
+ chainScope: ChainScope;
+ chainScopeBadge: string;
+ inputSchemeBadge?: string;
+ orderTypeBadge?: string;
+ exclusiveForAddress?: string;
+ exclusiveUntil?: number;
+ inputChips: Chip[];
+ inputOverflow: number;
+ outputChips: Chip[];
+ outputOverflow: number;
+ validationPassed: boolean;
+ validationReason: string;
};
export type TimedIntentRow = BaseIntentRow & {
- status: Status;
- secondsToDeadline: number;
- protocolBadges: string[];
+ status: Status;
+ secondsToDeadline: number;
+ protocolBadges: string[];
};
export const EXPIRING_THRESHOLD_SECONDS = 5 * 60;
export const MAX_CHIPS_PER_SIDE = 2;
function flattenInputs(inputs: { chainId: bigint; inputs: [bigint, bigint][] }[]) {
- return inputs.flatMap((chainInput) => {
- return chainInput.inputs.map((input) => ({
- chainId: chainInput.chainId,
- input
- }));
- });
+ return inputs.flatMap((chainInput) => {
+ return chainInput.inputs.map((input) => ({
+ chainId: chainInput.chainId,
+ input
+ }));
+ });
}
-function safeChainName(chainId: bigint): chain | undefined {
- try {
- return getChainName(chainId);
- } catch {
- return undefined;
- }
+function safeChainName(chainId: bigint): string | undefined {
+ try {
+ return getChainName(chainId);
+ } catch {
+ return undefined;
+ }
}
function shortAddress(value: string, start = 6, end = 4) {
- if (value.length <= start + end) return value;
- return `${value.slice(0, start)}...${value.slice(-end)}`;
+ if (value.length <= start + end) return value;
+ return `${value.slice(0, start)}...${value.slice(-end)}`;
}
function summarizeInput(chainId: bigint, tokenId: bigint, amount: bigint): string {
- const chain = safeChainName(chainId);
- const tokenAddress = idToToken(tokenId);
- if (!chain) return `${shortAddress(tokenAddress)} on chain-${chainId.toString()}`;
- const coin = getCoin({ address: tokenAddress, chain });
- const amountText = formatTokenAmount(amount, coin.decimals);
- return `${amountText} ${coin.name.toUpperCase()} on ${chain}`;
+ const tokenAddress = idToToken(tokenId);
+ const chainName = safeChainName(chainId);
+ if (!chainName) {
+ return `${amount.toString()} ${shortAddress(tokenAddress)} on chain-${chainId.toString()}`;
+ }
+ const coin = getCoin({ address: tokenAddress, chainId });
+ const amountText = formatTokenAmount(amount, coin.decimals);
+ return `${amountText} ${coin.name.toUpperCase()} on ${chainName}`;
}
function summarizeOutput(chainId: bigint, token: `0x${string}`, amount: bigint): string {
- const chain = safeChainName(chainId);
- if (!chain) return `${shortAddress(token)} on chain-${chainId.toString()}`;
- const coin = getCoin({ address: token, chain });
- const amountText = formatTokenAmount(amount, coin.decimals);
- return `${amountText} ${coin.name.toUpperCase()} on ${chain}`;
+ const chainName = safeChainName(chainId);
+ if (!chainName) {
+ return `${amount.toString()} ${shortAddress(token)} on chain-${chainId.toString()}`;
+ }
+ const coin = getCoin({ address: token, chainId });
+ const amountText = formatTokenAmount(amount, coin.decimals);
+ return `${amountText} ${coin.name.toUpperCase()} on ${chainName}`;
}
function getInputs(order: StandardOrder | MultichainOrder) {
- if ("originChainId" in order) {
- return order.inputs.map((input, index) => ({
- key: `s-${index}-${input[0].toString()}`,
- text: summarizeInput(order.originChainId, input[0], input[1])
- }));
- }
-
- return flattenInputs(order.inputs).map((input, index) => ({
- key: `m-${index}-${input.input[0].toString()}`,
- text: summarizeInput(input.chainId, input.input[0], input.input[1])
- }));
+ if ("originChainId" in order) {
+ return order.inputs.map((input, index) => ({
+ key: `s-${index}-${input[0].toString()}`,
+ text: summarizeInput(order.originChainId, input[0], input[1])
+ }));
+ }
+
+ return flattenInputs(order.inputs).map((input, index) => ({
+ key: `m-${index}-${input.input[0].toString()}`,
+ text: summarizeInput(input.chainId, input.input[0], input.input[1])
+ }));
}
function getOutputs(order: StandardOrder | MultichainOrder) {
- return order.outputs.map((output, index) => ({
- key: `o-${index}-${output.token}`,
- text: summarizeOutput(output.chainId, output.token, output.amount)
- }));
+ return order.outputs.map((output, index) => ({
+ key: `o-${index}-${output.token}`,
+ text: summarizeOutput(output.chainId, output.token, output.amount)
+ }));
}
function getChainScope(order: StandardOrder | MultichainOrder): ChainScope {
- if (!("originChainId" in order)) return "multichain";
- const isSameChain = order.outputs.every((output) => output.chainId === order.originChainId);
- return isSameChain ? "samechain" : "singlechain";
+ if (!("originChainId" in order)) return "multichain";
+ const isSameChain = order.outputs.every((output) => output.chainId === order.originChainId);
+ return isSameChain ? "samechain" : "singlechain";
}
function toChainScopeBadge(scope: ChainScope) {
- if (scope === "samechain") return "SameChain";
- if (scope === "singlechain") return "SingleChain";
- return "MultiChain";
+ if (scope === "samechain") return "SameChain";
+ if (scope === "singlechain") return "SingleChain";
+ return "MultiChain";
}
function shortHexAddress(value: `0x${string}`) {
- return `${value.slice(0, 6)}...${value.slice(-4)}`;
+ return `${value.slice(0, 6)}...${value.slice(-4)}`;
}
function normalizeAddress(value: string) {
- return value.toLowerCase();
+ return value.toLowerCase();
}
function mapInputScheme(inputSettler: `0x${string}`): string | undefined {
- const settler = normalizeAddress(inputSettler);
- if (settler === normalizeAddress(INPUT_SETTLER_ESCROW_LIFI)) return "Escrow";
- if (settler === normalizeAddress(INPUT_SETTLER_COMPACT_LIFI)) return "Compact";
- if (settler === normalizeAddress(MULTICHAIN_INPUT_SETTLER_ESCROW)) return "MultichainEscrow";
- if (settler === normalizeAddress(MULTICHAIN_INPUT_SETTLER_COMPACT)) return "MultichainCompact";
- return undefined;
+ const settler = normalizeAddress(inputSettler);
+ if (settler === normalizeAddress(INPUT_SETTLER_ESCROW_LIFI)) return "Escrow";
+ if (settler === normalizeAddress(INPUT_SETTLER_COMPACT_LIFI)) return "Compact";
+ if (settler === normalizeAddress(MULTICHAIN_INPUT_SETTLER_ESCROW)) return "MultichainEscrow";
+ if (settler === normalizeAddress(MULTICHAIN_INPUT_SETTLER_COMPACT)) return "MultichainCompact";
+ return undefined;
}
function parseContextType(context: `0x${string}`) {
- if (context === "0x" || context === "0x00") return "Limit";
- const typeByte = context.slice(2, 4).toLowerCase();
- if (typeByte === "00") return "Limit";
- if (typeByte === "01") return "Dutch";
- if (typeByte === "e0") return "Limit";
- if (typeByte === "e1") return "Dutch";
- return undefined;
+ if (context === "0x" || context === "0x00") return "Limit";
+ const typeByte = context.slice(2, 4).toLowerCase();
+ if (typeByte === "00") return "Limit";
+ if (typeByte === "01") return "Dutch";
+ if (typeByte === "e0") return "Limit";
+ if (typeByte === "e1") return "Dutch";
+ return undefined;
}
function decodeExclusiveFor(context: `0x${string}`): `0x${string}` | undefined {
- if (context.length < 2 + 2 + 64) return undefined;
- const exclusiveHex = context.slice(4, 68);
- try {
- return bytes32ToAddress(`0x${exclusiveHex}`);
- } catch {
- return undefined;
- }
+ if (context.length < 2 + 2 + 64) return undefined;
+ const exclusiveHex = context.slice(4, 68);
+ try {
+ return bytes32ToAddress(`0x${exclusiveHex}`);
+ } catch {
+ return undefined;
+ }
}
type ContextDetails = {
- orderTypeBadge?: string;
- exclusiveForAddress?: string;
- exclusiveUntil?: number;
+ orderTypeBadge?: string;
+ exclusiveForAddress?: string;
+ exclusiveUntil?: number;
};
function getContextDetails(orderContainer: OrderContainer): ContextDetails {
- const order = orderContainer.order;
- const details: ContextDetails = {};
+ const order = orderContainer.order;
+ const details: ContextDetails = {};
- const contexts = order.outputs.map((o) => o.context);
- const firstContext = contexts[0];
- const allContextsMatch = contexts.every((c) => c === firstContext);
- if (!firstContext || !allContextsMatch) return details;
+ const contexts = order.outputs.map((o) => o.context);
+ const firstContext = contexts[0];
+ const allContextsMatch = contexts.every((c) => c === firstContext);
+ if (!firstContext || !allContextsMatch) return details;
- details.orderTypeBadge = parseContextType(firstContext);
+ details.orderTypeBadge = parseContextType(firstContext);
- const typeByte = firstContext.slice(2, 4).toLowerCase();
- const isExclusive = typeByte === "e0" || typeByte === "e1";
- if (!isExclusive) return details;
+ const typeByte = firstContext.slice(2, 4).toLowerCase();
+ const isExclusive = typeByte === "e0" || typeByte === "e1";
+ if (!isExclusive) return details;
- const exclusiveFor = decodeExclusiveFor(firstContext);
- if (exclusiveFor) details.exclusiveForAddress = shortHexAddress(exclusiveFor);
+ const exclusiveFor = decodeExclusiveFor(firstContext);
+ if (exclusiveFor) details.exclusiveForAddress = shortHexAddress(exclusiveFor);
- // bytes1 + bytes32 + uint32 (big-endian)
- if (firstContext.length >= 76) {
- const untilHex = firstContext.slice(68, 76);
- const until = Number.parseInt(untilHex, 16);
- if (!Number.isNaN(until)) details.exclusiveUntil = until;
- }
+ // bytes1 + bytes32 + uint32 (big-endian)
+ if (firstContext.length >= 76) {
+ const untilHex = firstContext.slice(68, 76);
+ const until = Number.parseInt(untilHex, 16);
+ if (!Number.isNaN(until)) details.exclusiveUntil = until;
+ }
- return details;
+ return details;
}
export function buildBaseIntentRow(orderContainer: OrderContainer): BaseIntentRow {
- const order = orderContainer.order;
- const orderId = orderToIntent(orderContainer).orderId();
- const inputChipsRaw = getInputs(order);
- const outputChipsRaw = getOutputs(order);
- const chainScope = getChainScope(order);
- const contextDetails = getContextDetails(orderContainer);
-
- const validation = validateOrderContainerWithReason(orderContainer);
-
- return {
- orderContainer,
- orderId,
- orderIdShort: shortAddress(orderId, 10, 4),
- userShort: shortAddress(order.user, 8, 4),
- fillDeadline: order.fillDeadline,
- inputCount: inputChipsRaw.length,
- outputCount: outputChipsRaw.length,
- chainScope,
- chainScopeBadge: toChainScopeBadge(chainScope),
- inputSchemeBadge: mapInputScheme(orderContainer.inputSettler),
- orderTypeBadge: contextDetails.orderTypeBadge,
- exclusiveForAddress: contextDetails.exclusiveForAddress,
- exclusiveUntil: contextDetails.exclusiveUntil,
- inputChips: inputChipsRaw.slice(0, MAX_CHIPS_PER_SIDE),
- inputOverflow: Math.max(0, inputChipsRaw.length - MAX_CHIPS_PER_SIDE),
- outputChips: outputChipsRaw.slice(0, MAX_CHIPS_PER_SIDE),
- outputOverflow: Math.max(0, outputChipsRaw.length - MAX_CHIPS_PER_SIDE),
- validationPassed: validation.passed,
- validationReason: validation.reason
- };
+ const order = orderContainer.order;
+ const orderId = containerToIntent(orderContainer).orderId();
+ const inputChipsRaw = getInputs(order);
+ const outputChipsRaw = getOutputs(order);
+ const chainScope = getChainScope(order);
+ const contextDetails = getContextDetails(orderContainer);
+
+ const validation = validateOrderContainerWithReason({
+ orderContainer,
+ deps: orderValidationDeps
+ });
+
+ return {
+ orderContainer,
+ orderId,
+ orderIdShort: shortAddress(orderId, 10, 4),
+ userShort: shortAddress(order.user, 8, 4),
+ fillDeadline: order.fillDeadline,
+ inputCount: inputChipsRaw.length,
+ outputCount: outputChipsRaw.length,
+ chainScope,
+ chainScopeBadge: toChainScopeBadge(chainScope),
+ inputSchemeBadge: mapInputScheme(orderContainer.inputSettler),
+ orderTypeBadge: contextDetails.orderTypeBadge,
+ exclusiveForAddress: contextDetails.exclusiveForAddress,
+ exclusiveUntil: contextDetails.exclusiveUntil,
+ inputChips: inputChipsRaw.slice(0, MAX_CHIPS_PER_SIDE),
+ inputOverflow: Math.max(0, inputChipsRaw.length - MAX_CHIPS_PER_SIDE),
+ outputChips: outputChipsRaw.slice(0, MAX_CHIPS_PER_SIDE),
+ outputOverflow: Math.max(0, outputChipsRaw.length - MAX_CHIPS_PER_SIDE),
+ validationPassed: validation.passed,
+ validationReason: validation.reason
+ };
}
export function withTiming(baseRow: BaseIntentRow, nowSeconds: number): TimedIntentRow {
- const secondsToDeadline = baseRow.fillDeadline - nowSeconds;
- const status: Status =
- secondsToDeadline <= 0
- ? "expired"
- : secondsToDeadline <= EXPIRING_THRESHOLD_SECONDS
- ? "expiring"
- : "active";
-
- const protocolBadges: string[] = [];
- if (baseRow.orderTypeBadge) protocolBadges.push(baseRow.orderTypeBadge);
- if (baseRow.exclusiveForAddress)
- protocolBadges.push(`Exclusive for ${baseRow.exclusiveForAddress}`);
- if (baseRow.exclusiveUntil !== undefined) {
- const secondsRemaining = baseRow.exclusiveUntil - nowSeconds;
- if (secondsRemaining > 0) {
- protocolBadges.push(`Exclusive until ${formatRemaining(secondsRemaining)}`);
- }
- }
-
- return { ...baseRow, status, secondsToDeadline, protocolBadges };
+ const secondsToDeadline = baseRow.fillDeadline - nowSeconds;
+ const status: Status =
+ secondsToDeadline <= 0
+ ? "expired"
+ : secondsToDeadline <= EXPIRING_THRESHOLD_SECONDS
+ ? "expiring"
+ : "active";
+
+ const protocolBadges: string[] = [];
+ if (baseRow.orderTypeBadge) protocolBadges.push(baseRow.orderTypeBadge);
+ if (baseRow.exclusiveForAddress)
+ protocolBadges.push(`Exclusive for ${baseRow.exclusiveForAddress}`);
+ if (baseRow.exclusiveUntil !== undefined) {
+ const secondsRemaining = baseRow.exclusiveUntil - nowSeconds;
+ if (secondsRemaining > 0) {
+ protocolBadges.push(`Exclusive until ${formatRemaining(secondsRemaining)}`);
+ }
+ }
+
+ return { ...baseRow, status, secondsToDeadline, protocolBadges };
}
export function formatRelativeDeadline(secondsToDeadline: number) {
- const abs = Math.abs(secondsToDeadline);
- if (abs < 60) return secondsToDeadline >= 0 ? `in ${abs}s` : `${abs}s ago`;
- const minutes = Math.floor(abs / 60);
- if (minutes < 60) return secondsToDeadline >= 0 ? `in ${minutes}m` : `${minutes}m ago`;
- const hours = Math.floor(minutes / 60);
- return secondsToDeadline >= 0 ? `in ${hours}h` : `${hours}h ago`;
+ const abs = Math.abs(secondsToDeadline);
+ if (abs < 60) return secondsToDeadline >= 0 ? `in ${abs}s` : `${abs}s ago`;
+ const minutes = Math.floor(abs / 60);
+ if (minutes < 60) return secondsToDeadline >= 0 ? `in ${minutes}m` : `${minutes}m ago`;
+ const hours = Math.floor(minutes / 60);
+ return secondsToDeadline >= 0 ? `in ${hours}h` : `${hours}h ago`;
}
export function formatRemaining(secondsToDeadline: number) {
- const clamped = Math.max(0, secondsToDeadline);
- if (clamped < 60) return `${clamped}s`;
- const minutes = Math.floor(clamped / 60);
- if (minutes < 60) return `${minutes}m`;
- const hours = Math.floor(minutes / 60);
- return `${hours}h`;
+ const clamped = Math.max(0, secondsToDeadline);
+ if (clamped < 60) return `${clamped}s`;
+ const minutes = Math.floor(clamped / 60);
+ if (minutes < 60) return `${minutes}m`;
+ const hours = Math.floor(minutes / 60);
+ return `${hours}h`;
}
diff --git a/src/lib/libraries/orderServer.ts b/src/lib/libraries/orderServer.ts
deleted file mode 100644
index 213a506..0000000
--- a/src/lib/libraries/orderServer.ts
+++ /dev/null
@@ -1,570 +0,0 @@
-import axios from "axios";
-import type {
- MultichainOrder,
- NoSignature,
- OrderContainer,
- Quote,
- Signature,
- StandardOrder
-} from "../../types";
-import { type chain, chainMap } from "$lib/config";
-import { getInteropableAddress } from "../utils/interopableAddresses";
-
-type OrderStatus = "Signed" | "Delivered" | "Settled";
-
-type SubmitOrderDto = {
- orderType: "CatalystCompactOrder";
- order: StandardOrder;
- inputSettler: `0x${string}`;
- sponsorSignature?: `0x${string}`;
- allocatorSignature?: `0x${string}`;
- compactRegistrationTxHash?: `0x${string}`;
-};
-
-type orderPush = (orderArr: {
- order: StandardOrder;
- inputSettler: `0x${string}`;
- sponsorSignature?: `0x${string}`;
- allocatorSignature?: `0x${string}`;
-}) => void;
-
-type GetOrderResponse = {
- data: {
- order: StandardOrder;
- quote: Quote;
- sponsorSignature: `0x${string}` | null;
- allocatorSignature?: `0x${string}` | null;
- inputSettler: `0x${string}`;
- meta: {
- submitTime: number;
- orderStatus: OrderStatus;
- destinationAddress: `0x${string}`;
- orderIdentifier: string;
- onChainOrderId: `0x${string}`;
- signedAt: string;
- expiredAt: string | null;
- };
- }[];
- meta: {
- limit: number;
- offset: number;
- total: number;
- };
-};
-
-type GetQuoteOptions = {
- user: `0x${string}`;
- userChain: chain;
- inputs: {
- sender: `0x${string}`;
- asset: `0x${string}`;
- chain: chain;
- amount: bigint;
- }[];
- outputs: {
- receiver: `0x${string}`;
- asset: `0x${string}`;
- chain: chain;
- amount: bigint;
- }[];
- minValidUntil?: number;
- exclusiveFor?: `0x${string}`[];
-};
-
-type GetQuoteResponse = {
- quotes: {
- order: null;
- eta: null;
- validUntil: null;
- quoteId: null;
- metadata: {
- exclusiveFor: `0x${string}` | `0x${string}`[];
- };
- preview: {
- inputs: {
- user: `0x${string}`;
- asset: `0x${string}`;
- amount: string;
- }[];
- outputs: {
- receiver: `0x${string}`;
- asset: `0x${string}`;
- amount: string;
- }[];
- };
- provider: null;
- partialFill: false;
- failureHandling: "refund-automatic";
- }[];
-};
-
-function normalizeHexAddress(value: T): T {
- return value.toLowerCase() as T;
-}
-
-type OrderEnvelope = {
- order: unknown;
- inputSettler: unknown;
- sponsorSignature?: unknown;
- allocatorSignature?: unknown;
-};
-
-function toHexString(value: unknown, field: string): `0x${string}` {
- if (typeof value !== "string" || !value.startsWith("0x")) {
- throw new Error(`Order payload invalid: ${field}`);
- }
- return value as `0x${string}`;
-}
-
-function toBigIntValue(value: unknown, field: string): bigint {
- if (typeof value === "bigint") return value;
- if (typeof value === "number" && Number.isFinite(value)) return BigInt(value);
- if (typeof value === "string" && value.length > 0) return BigInt(value);
- throw new Error(`Order payload invalid: ${field}`);
-}
-
-function toNumberValue(value: unknown, field: string): number {
- if (typeof value === "number" && Number.isFinite(value)) return value;
- if (typeof value === "bigint") return Number(value);
- if (typeof value === "string" && value.length > 0) return Number(value);
- throw new Error(`Order payload invalid: ${field}`);
-}
-
-function normalizeSignature(value: unknown): Signature | NoSignature {
- if (!value) return { type: "None", payload: "0x" };
- return {
- type: "ECDSA",
- payload: toHexString(value, "signature")
- };
-}
-
-function normalizeOutputs(value: unknown) {
- if (!Array.isArray(value)) throw new Error("Order payload invalid: outputs");
- return value.map((output, index) => {
- if (!output || typeof output !== "object") {
- throw new Error(`Order payload invalid: outputs[${index}]`);
- }
- const o = output as Record;
- return {
- oracle: toHexString(o.oracle, `outputs[${index}].oracle`),
- settler: toHexString(o.settler, `outputs[${index}].settler`),
- chainId: toBigIntValue(o.chainId, `outputs[${index}].chainId`),
- token: toHexString(o.token, `outputs[${index}].token`),
- amount: toBigIntValue(o.amount, `outputs[${index}].amount`),
- recipient: toHexString(o.recipient, `outputs[${index}].recipient`),
- callbackData: toHexString(o.callbackData ?? "0x", `outputs[${index}].callbackData`),
- context: toHexString(o.context ?? "0x", `outputs[${index}].context`)
- };
- });
-}
-
-function normalizeStandardOrder(order: Record): StandardOrder {
- if (!Array.isArray(order.inputs)) throw new Error("Order payload invalid: inputs");
- return {
- user: toHexString(order.user, "order.user"),
- nonce: toBigIntValue(order.nonce, "order.nonce"),
- originChainId: toBigIntValue(order.originChainId, "order.originChainId"),
- expires: toNumberValue(order.expires, "order.expires"),
- fillDeadline: toNumberValue(order.fillDeadline, "order.fillDeadline"),
- inputOracle: toHexString(order.inputOracle, "order.inputOracle"),
- inputs: order.inputs.map((input, index) => {
- if (!Array.isArray(input) || input.length !== 2) {
- throw new Error(`Order payload invalid: inputs[${index}]`);
- }
- return [
- toBigIntValue(input[0], `inputs[${index}][0]`),
- toBigIntValue(input[1], `inputs[${index}][1]`)
- ];
- }),
- outputs: normalizeOutputs(order.outputs)
- };
-}
-
-function normalizeMultichainOrder(order: Record): MultichainOrder {
- if (!Array.isArray(order.inputs)) throw new Error("Order payload invalid: inputs");
- return {
- user: toHexString(order.user, "order.user"),
- nonce: toBigIntValue(order.nonce, "order.nonce"),
- expires: toNumberValue(order.expires, "order.expires"),
- fillDeadline: toNumberValue(order.fillDeadline, "order.fillDeadline"),
- inputOracle: toHexString(order.inputOracle, "order.inputOracle"),
- outputs: normalizeOutputs(order.outputs),
- inputs: order.inputs.map((input, index) => {
- if (!input || typeof input !== "object") {
- throw new Error(`Order payload invalid: inputs[${index}]`);
- }
- const i = input as Record;
- if (!Array.isArray(i.inputs)) {
- throw new Error(`Order payload invalid: inputs[${index}].inputs`);
- }
- return {
- chainId: toBigIntValue(i.chainId, `inputs[${index}].chainId`),
- inputs: i.inputs.map((tuple, tupleIndex) => {
- if (!Array.isArray(tuple) || tuple.length !== 2) {
- throw new Error(`Order payload invalid: inputs[${index}].inputs[${tupleIndex}]`);
- }
- return [
- toBigIntValue(tuple[0], `inputs[${index}].inputs[${tupleIndex}][0]`),
- toBigIntValue(tuple[1], `inputs[${index}].inputs[${tupleIndex}][1]`)
- ];
- })
- };
- })
- };
-}
-
-function extractOrderEnvelope(payload: unknown): OrderEnvelope {
- const root =
- payload && typeof payload === "object" && "data" in payload
- ? (payload as Record).data
- : payload;
- const candidateRaw = Array.isArray(root) ? root[0] : root;
- if (!candidateRaw || typeof candidateRaw !== "object") {
- throw new Error("Order payload invalid: data");
- }
- const candidate = candidateRaw as Record;
- const c =
- candidate.intent && typeof candidate.intent === "object"
- ? (candidate.intent as Record)
- : candidate;
- if (!("order" in c) || !("inputSettler" in c)) {
- throw new Error("Order payload invalid: missing order fields");
- }
- return c as OrderEnvelope;
-}
-
-export function parseOrderStatusPayload(payload: unknown): OrderContainer {
- const envelope = extractOrderEnvelope(payload);
- const rawOrder = envelope.order as Record;
- if (!rawOrder || typeof rawOrder !== "object") {
- throw new Error("Order payload invalid: order");
- }
- const order =
- "originChainId" in rawOrder
- ? normalizeStandardOrder(rawOrder)
- : normalizeMultichainOrder(rawOrder);
-
- return {
- inputSettler: toHexString(envelope.inputSettler, "inputSettler"),
- order,
- sponsorSignature: normalizeSignature(envelope.sponsorSignature),
- allocatorSignature: normalizeSignature(envelope.allocatorSignature)
- };
-}
-
-export class OrderServer {
- baseUrl: string;
- websocketUrl: string;
-
- api;
-
- constructor(mainnet: boolean) {
- this.baseUrl = OrderServer.getOrderServerUrl(mainnet);
- this.websocketUrl = OrderServer.getOrderServerWssUrl(mainnet);
-
- this.api = axios.create({
- baseURL: this.baseUrl,
- timeout: 15000
- });
- }
-
- private static sleep(ms: number) {
- return new Promise((resolve) => setTimeout(resolve, ms));
- }
-
- private static isNetworkError(error: unknown): boolean {
- if (!axios.isAxiosError(error)) return false;
- return error.code === "ERR_NETWORK" || error.code === "ECONNABORTED";
- }
-
- private async waitForOnline(maxWaitMs = 15000) {
- if (typeof window === "undefined" || typeof navigator === "undefined") return;
- if (navigator.onLine) return;
- await Promise.race([
- new Promise((resolve) => {
- const onOnline = () => {
- window.removeEventListener("online", onOnline);
- resolve();
- };
- window.addEventListener("online", onOnline, { once: true });
- }),
- OrderServer.sleep(maxWaitMs)
- ]);
- }
-
- private async postWithRetry(
- path: string,
- body: unknown,
- opts: { retries?: number; baseDelayMs?: number } = {}
- ): Promise {
- const retries = opts.retries ?? 2;
- const baseDelayMs = opts.baseDelayMs ?? 500;
- let attempt = 0;
- while (true) {
- try {
- const response = await this.api.post(path, body);
- return response.data as T;
- } catch (error) {
- if (!OrderServer.isNetworkError(error) || attempt >= retries) throw error;
- await this.waitForOnline();
- await OrderServer.sleep(baseDelayMs * 2 ** attempt);
- attempt += 1;
- }
- }
- }
-
- static getOrderServerUrl(mainnet: boolean) {
- return mainnet ? "https://order.li.fi" : "https://order-dev.li.fi";
- }
-
- static getOrderServerWssUrl(mainnet: boolean) {
- return mainnet ? "wss://order.li.fi" : "wss://order-dev.li.fi";
- }
-
- /**
- * @notice Submits an order to the order server
- * @param request The order submission request
- * @returns The response data from the order server
- */
- async submitOrder(request: SubmitOrderDto) {
- try {
- return await this.postWithRetry("/orders/submit", request, { retries: 2, baseDelayMs: 600 });
- } catch (error) {
- console.error("Error submitting order:", error);
- throw error;
- }
- }
-
- /**
- * @notice Gets latest orders from the order server
- * @param options Optional parameters to filter orders
- * @returns The response data containing the orders
- */
- async getOrders(options?: { user?: `0x${string}`; status?: OrderStatus }) {
- try {
- const response = await this.api.get("/orders", {
- params: { limit: 50, offset: 0, ...options }
- });
- return response.data as GetOrderResponse;
- } catch (error) {
- console.error("Error getting orders:", error);
- throw error;
- }
- }
-
- /**
- * @notice Gets an order by on-chain order id.
- * @param orderId On-chain order id (0x-prefixed hash)
- */
- async getOrderByOnChainOrderId(orderId: `0x${string}`): Promise {
- try {
- const response = await this.api.get("/orders/status/", {
- params: { onChainOrderId: orderId }
- });
- return parseOrderStatusPayload(response.data);
- } catch (error) {
- if (axios.isAxiosError(error) && error.response?.status === 404) {
- throw new Error("Order not found");
- }
- if (error instanceof Error && error.message.startsWith("Order payload invalid")) {
- throw error;
- }
- console.error("Error getting order by id:", error);
- throw new Error("Failed to fetch order");
- }
- }
-
- /**
- * @notice Fetch an intent quote for a set of inputs and outputs.
- * @param options The intent specifications
- * @returns The response data containing the quotes
- */
- async getQuotes(options: GetQuoteOptions): Promise {
- const { user, userChain, inputs, outputs, minValidUntil, exclusiveFor } = options;
-
- const lockType: undefined | { kind: "the-compact" } = undefined;
-
- const rq: {
- user: string;
- intent: {
- intentType: "oif-swap";
- inputs: {
- user: string;
- asset: string;
- amount: string;
- lock: { kind: "the-compact" } | undefined;
- }[];
- outputs: {
- receiver: string;
- asset: string;
- amount: string;
- }[];
- swapType: "exact-input";
- minValidUntil: number | undefined;
- metadata?: {
- exclusiveFor: `0x${string}`[];
- };
- };
- supportedTypes: ["oif-escrow-v0"];
- } = {
- user: getInteropableAddress(user, chainMap[userChain].id),
- intent: {
- intentType: "oif-swap",
- inputs: inputs.map((input) => {
- return {
- user: getInteropableAddress(input.sender, chainMap[userChain].id),
- asset: getInteropableAddress(input.asset, chainMap[userChain].id),
- amount: input.amount.toString(),
- lock: lockType
- };
- }),
- outputs: outputs.map((output) => {
- return {
- receiver: getInteropableAddress(output.receiver, chainMap[output.chain].id),
- asset: getInteropableAddress(output.asset, chainMap[output.chain].id),
- amount: output.amount.toString()
- };
- }),
- swapType: "exact-input",
- minValidUntil
- },
- supportedTypes: ["oif-escrow-v0"]
- };
- if (exclusiveFor && exclusiveFor.length > 0) {
- rq.intent.metadata = { exclusiveFor: exclusiveFor.map(normalizeHexAddress) };
- }
-
- try {
- return await this.postWithRetry("/quote/request", rq, {
- retries: 3,
- baseDelayMs: 700
- });
- } catch (error) {
- console.error("Error fetching quote:", error);
- throw error;
- }
- }
-
- connectOrderServerSocket(newOrderFunction: orderPush) {
- let shouldReconnect = true;
- let backoffMs = 1000;
- const MAX_BACKOFF = 30000;
- let socket: WebSocket;
- let reconnectTimer: ReturnType | undefined;
-
- const connect = () => {
- if (!shouldReconnect) return;
- socket = new WebSocket(this.websocketUrl);
-
- socket.onmessage = function (event) {
- const message = JSON.parse(event.data);
-
- switch (message.event) {
- case "user:vm-order-submit":
- const incomingOrder = message.data as SubmitOrderDto;
- newOrderFunction(incomingOrder);
- break;
- case "ping":
- socket.send(
- JSON.stringify({
- event: "pong"
- })
- );
- break;
- default:
- break;
- }
- };
-
- socket.addEventListener("open", () => {
- console.log("Connected to Catalyst order server");
- backoffMs = 1000; // Reset backoff on successful connection
- });
-
- socket.addEventListener("close", () => {
- console.log("Disconnected from Catalyst order server");
- if (shouldReconnect) {
- console.log(`Reconnecting in ${backoffMs}ms...`);
- if (reconnectTimer) clearTimeout(reconnectTimer);
- reconnectTimer = setTimeout(() => {
- reconnectTimer = undefined;
- connect();
- }, backoffMs);
- backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF);
- }
- });
-
- socket.addEventListener("error", (event) => {
- console.error("WebSocket error:", event);
- });
- };
-
- connect();
-
- return {
- get socket() {
- return socket;
- },
- disconnect: () => {
- shouldReconnect = false;
- if (reconnectTimer) {
- clearTimeout(reconnectTimer);
- reconnectTimer = undefined;
- }
- socket.close();
- }
- };
- }
-
- // -- Translations -- //
-
- /**
- * @notice Fetches all intents from the LI.FI order server and then transmutes them into OrderContainers.
- */
- async getAndParseOrders(): Promise {
- const response = await this.getOrders();
- const parsedOrders = response.data;
- if (parsedOrders) {
- if (Array.isArray(parsedOrders)) {
- // For each order, if a field is string ending in n, convert it to bigint.
- return parsedOrders.map((instance) => {
- instance.order.nonce = BigInt(instance.order.nonce);
- instance.order.originChainId = BigInt(instance.order.originChainId);
- if (instance.order.inputs) {
- instance.order.inputs = instance.order.inputs.map((input) => {
- return [BigInt(input[0]), BigInt(input[1])];
- });
- }
- if (instance.order.outputs) {
- instance.order.outputs = instance.order.outputs.map((output) => {
- return {
- ...output,
- chainId: BigInt(output.chainId),
- amount: BigInt(output.amount)
- };
- });
- }
- const allocatorSignature = instance.allocatorSignature
- ? ({
- type: "ECDSA",
- payload: instance.allocatorSignature
- } as Signature)
- : ({
- type: "None",
- payload: "0x"
- } as NoSignature);
- const sponsorSignature = instance.sponsorSignature
- ? ({
- type: "ECDSA",
- payload: instance.sponsorSignature
- } as Signature)
- : ({
- type: "None",
- payload: "0x"
- } as NoSignature);
- return { ...instance, allocatorSignature, sponsorSignature };
- });
- }
- }
- }
-}
diff --git a/src/lib/libraries/rpcCache.ts b/src/lib/libraries/rpcCache.ts
index 2790e8b..1167031 100644
--- a/src/lib/libraries/rpcCache.ts
+++ b/src/lib/libraries/rpcCache.ts
@@ -1,71 +1,71 @@
type CacheEntry = {
- value: T;
- expiresAt: number;
+ value: T;
+ expiresAt: number;
};
const cache = new Map>();
const inflight = new Map>();
const stats = {
- hits: 0,
- misses: 0,
- inflightJoins: 0
+ hits: 0,
+ misses: 0,
+ inflightJoins: 0
};
export function getRpcCacheStats() {
- return { ...stats };
+ return { ...stats };
}
export function clearRpcCache() {
- cache.clear();
- inflight.clear();
+ cache.clear();
+ inflight.clear();
}
export function invalidateRpcKey(key: string) {
- cache.delete(key);
- inflight.delete(key);
+ cache.delete(key);
+ inflight.delete(key);
}
export function invalidateRpcPrefix(prefix: string) {
- for (const key of cache.keys()) {
- if (key.startsWith(prefix)) cache.delete(key);
- }
- for (const key of inflight.keys()) {
- if (key.startsWith(prefix)) inflight.delete(key);
- }
+ for (const key of cache.keys()) {
+ if (key.startsWith(prefix)) cache.delete(key);
+ }
+ for (const key of inflight.keys()) {
+ if (key.startsWith(prefix)) inflight.delete(key);
+ }
}
export async function getOrFetchRpc(
- key: string,
- fetcher: () => Promise,
- opts: { ttlMs: number; force?: boolean }
+ key: string,
+ fetcher: () => Promise,
+ opts: { ttlMs: number; force?: boolean }
): Promise {
- const { ttlMs, force = false } = opts;
- const now = Date.now();
+ const { ttlMs, force = false } = opts;
+ const now = Date.now();
- if (!force) {
- const cached = cache.get(key) as CacheEntry | undefined;
- if (cached && cached.expiresAt > now) {
- stats.hits += 1;
- return cached.value;
- }
- const pending = inflight.get(key) as Promise | undefined;
- if (pending) {
- stats.inflightJoins += 1;
- return pending;
- }
- }
+ if (!force) {
+ const cached = cache.get(key) as CacheEntry | undefined;
+ if (cached && cached.expiresAt > now) {
+ stats.hits += 1;
+ return cached.value;
+ }
+ const pending = inflight.get(key) as Promise | undefined;
+ if (pending) {
+ stats.inflightJoins += 1;
+ return pending;
+ }
+ }
- stats.misses += 1;
- const request = fetcher()
- .then((value) => {
- cache.set(key, { value, expiresAt: Date.now() + ttlMs });
- return value;
- })
- .finally(() => {
- inflight.delete(key);
- });
+ stats.misses += 1;
+ const request = fetcher()
+ .then((value) => {
+ cache.set(key, { value, expiresAt: Date.now() + ttlMs });
+ return value;
+ })
+ .finally(() => {
+ inflight.delete(key);
+ });
- inflight.set(key, request);
- return request;
+ inflight.set(key, request);
+ return request;
}
diff --git a/src/lib/libraries/solver.ts b/src/lib/libraries/solver.ts
index c3e775a..42817dc 100644
--- a/src/lib/libraries/solver.ts
+++ b/src/lib/libraries/solver.ts
@@ -1,401 +1,389 @@
-import {
- BYTES32_ZERO,
- type chain,
- chainMap,
- clients,
- COIN_FILLER,
- getChainName,
- getOracle,
- type WC
-} from "$lib/config";
+import { BYTES32_ZERO, COIN_FILLER, getChain, getClient, getOracle, type WC } from "$lib/config";
import { hashStruct, maxUint256, parseEventLogs } from "viem";
-import type { MandateOutput, OrderContainer } from "../../types";
-import { addressToBytes32, bytes32ToAddress } from "$lib/utils/convert";
+import type { MandateOutput, OrderContainer } from "@lifi/intent";
+import { addressToBytes32, bytes32ToAddress, StandardSolanaIntent } from "@lifi/intent";
import axios from "axios";
import { POLYMER_ORACLE_ABI } from "$lib/abi/polymeroracle";
import { COIN_FILLER_ABI } from "$lib/abi/outputsettler";
import { ERC20_ABI } from "$lib/abi/erc20";
-import { orderToIntent } from "./intent";
-import { compactTypes } from "$lib/utils/typedMessage";
+import { containerToIntent } from "$lib/utils/intent";
+import { compactTypes } from "@lifi/intent";
import store from "$lib/state.svelte";
+import { finaliseIntent } from "./intentExecution";
/**
* @notice Class for solving intents. Functions called by solvers.
*/
export class Solver {
- private static validationInflight = new Map>();
- private static polymerRequestIndexByLog = new Map();
+ private static validationInflight = new Map>();
+ private static polymerRequestIndexByLog = new Map();
- private static sleep(ms: number) {
- return new Promise((resolve) => setTimeout(resolve, ms));
- }
+ private static sleep(ms: number) {
+ return new Promise((resolve) => setTimeout(resolve, ms));
+ }
- private static async persistReceipt(
- chainId: number | bigint,
- txHash: `0x${string}`,
- receipt: unknown
- ) {
- try {
- await store.saveTransactionReceipt(chainId, txHash, receipt);
- } catch (error) {
- console.warn("saveTransactionReceipt error", { chainId: Number(chainId), txHash, error });
- }
- }
+ private static async persistReceipt(
+ chainId: number | bigint,
+ txHash: `0x${string}`,
+ receipt: unknown
+ ) {
+ try {
+ await store.saveTransactionReceipt(chainId, txHash, receipt);
+ } catch (error) {
+ console.warn("saveTransactionReceipt error", { chainId: Number(chainId), txHash, error });
+ }
+ }
- private static async getReceiptCachedOrRpc(chainId: number | bigint, txHash: `0x${string}`) {
- const cached = store.getTransactionReceipt(chainId, txHash);
- if (
- cached &&
- typeof cached === "object" &&
- Array.isArray((cached as { logs?: unknown[] }).logs) &&
- (cached as { logs?: unknown[] }).logs!.length > 0
- )
- return cached as any;
- const chainName = getChainName(chainId);
- const receipt = await clients[chainName].getTransactionReceipt({ hash: txHash });
- await Solver.persistReceipt(chainId, txHash, receipt);
- return receipt;
- }
+ private static async getReceiptCachedOrRpc(chainId: number | bigint, txHash: `0x${string}`) {
+ const cached = store.getTransactionReceipt(chainId, txHash);
+ if (
+ cached &&
+ typeof cached === "object" &&
+ Array.isArray((cached as { logs?: unknown[] }).logs) &&
+ (cached as { logs?: unknown[] }).logs!.length > 0
+ )
+ return cached;
+ const receipt = await getClient(chainId).getTransactionReceipt({ hash: txHash });
+ await Solver.persistReceipt(chainId, txHash, receipt);
+ return receipt;
+ }
- static fill(
- walletClient: WC,
- args: {
- orderContainer: OrderContainer;
- outputs: MandateOutput[];
- },
- opts: {
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- account: () => `0x${string}`;
- }
- ) {
- return async () => {
- const { preHook, postHook, account } = opts;
- const {
- orderContainer: { order, inputSettler },
- outputs
- } = args;
- const publicClients = clients;
- const orderId = orderToIntent({ order, inputSettler }).orderId();
+ static fill(
+ walletClient: WC,
+ args: {
+ orderContainer: OrderContainer;
+ outputs: MandateOutput[];
+ },
+ opts: {
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ account: () => `0x${string}`;
+ }
+ ) {
+ return async () => {
+ const { preHook, postHook, account } = opts;
+ const {
+ orderContainer: { order, inputSettler },
+ outputs
+ } = args;
+ const orderId = containerToIntent(args.orderContainer).orderId();
- const outputChain = getChainName(outputs[0].chainId);
- // Always attempt chain switch before fill, including native-token fills.
- if (preHook) await preHook(outputChain);
- const connectedChainId = await walletClient.getChainId();
- const expectedChainId = chainMap[outputChain].id;
- if (connectedChainId !== expectedChainId) {
- throw new Error(
- `Wallet is on chain ${connectedChainId}, expected ${expectedChainId} (${outputChain})`
- );
- }
+ const outputChainId = Number(outputs[0].chainId);
+ const outputChain = getChain(outputChainId);
+ // Always attempt chain switch before fill, including native-token fills.
+ if (preHook) await preHook(outputChain.id);
+ const connectedChainId = await walletClient.getChainId();
+ const expectedChainId = outputChain.id;
+ if (connectedChainId !== expectedChainId) {
+ throw new Error(`Wallet is on chain ${connectedChainId}, expected ${expectedChainId}`);
+ }
- let value = 0n;
- for (const output of outputs) {
- if (output.token === BYTES32_ZERO) {
- value += output.amount;
- continue;
- }
- if (output.chainId != outputs[0].chainId) {
- throw new Error("Filling outputs on multiple chains with single fill call not supported");
- }
- if (output.settler != outputs[0].settler) {
- throw new Error("Different settlers on outputs, not supported");
- }
+ let value = 0n;
+ for (const output of outputs) {
+ if (output.token === BYTES32_ZERO) {
+ value += output.amount;
+ continue;
+ }
+ if (output.chainId != outputs[0].chainId) {
+ throw new Error("Filling outputs on multiple chains with single fill call not supported");
+ }
+ if (output.settler != outputs[0].settler) {
+ throw new Error("Different settlers on outputs, not supported");
+ }
- // Check allowance & set allowance if needed
- const assetAddress = bytes32ToAddress(output.token);
- const allowance = await publicClients[outputChain].readContract({
- address: assetAddress,
- abi: ERC20_ABI,
- functionName: "allowance",
- args: [account(), bytes32ToAddress(output.settler)]
- });
- if (BigInt(allowance) < output.amount) {
- const approveTransaction = await walletClient.writeContract({
- chain: chainMap[outputChain],
- account: account(),
- address: assetAddress,
- abi: ERC20_ABI,
- functionName: "approve",
- args: [bytes32ToAddress(output.settler), maxUint256]
- });
- const approveReceipt = await clients[outputChain].waitForTransactionReceipt({
- hash: approveTransaction
- });
- await Solver.persistReceipt(outputs[0].chainId, approveTransaction, approveReceipt);
- }
- }
+ // Check allowance & set allowance if needed
+ const assetAddress = bytes32ToAddress(output.token);
+ const allowance = await getClient(outputChain.id).readContract({
+ address: assetAddress,
+ abi: ERC20_ABI,
+ functionName: "allowance",
+ args: [account(), bytes32ToAddress(output.settler)]
+ });
+ if (BigInt(allowance) < output.amount) {
+ const approveTransaction = await walletClient.writeContract({
+ chain: outputChain,
+ account: account(),
+ address: assetAddress,
+ abi: ERC20_ABI,
+ functionName: "approve",
+ args: [bytes32ToAddress(output.settler), maxUint256]
+ });
+ const approveReceipt = await getClient(outputChain.id).waitForTransactionReceipt({
+ hash: approveTransaction
+ });
+ await Solver.persistReceipt(outputs[0].chainId, approveTransaction, approveReceipt);
+ }
+ }
- const transactionHash = await walletClient.writeContract({
- chain: chainMap[outputChain],
- account: account(),
- address: bytes32ToAddress(outputs[0].settler),
- value,
- abi: COIN_FILLER_ABI,
- functionName: "fillOrderOutputs",
- args: [orderId, outputs, order.fillDeadline, addressToBytes32(account())]
- });
- const fillReceipt = await clients[outputChain].waitForTransactionReceipt({
- hash: transactionHash
- });
- await Solver.persistReceipt(outputs[0].chainId, transactionHash, fillReceipt);
- // orderInputs.validate[index] = transactionHash;
- if (postHook) await postHook();
- return transactionHash;
- };
- }
+ const transactionHash = await walletClient.writeContract({
+ chain: outputChain,
+ account: account(),
+ address: bytes32ToAddress(outputs[0].settler),
+ value,
+ abi: COIN_FILLER_ABI,
+ functionName: "fillOrderOutputs",
+ args: [orderId, outputs, order.fillDeadline, addressToBytes32(account())]
+ });
+ const fillReceipt = await getClient(outputChain.id).waitForTransactionReceipt({
+ hash: transactionHash
+ });
+ await Solver.persistReceipt(outputs[0].chainId, transactionHash, fillReceipt);
+ // orderInputs.validate[index] = transactionHash;
+ if (postHook) await postHook();
+ return transactionHash;
+ };
+ }
- static validate(
- walletClient: WC,
- args: {
- output: MandateOutput;
- orderContainer: OrderContainer;
- fillTransactionHash: string;
- sourceChain: chain;
- mainnet: boolean;
- },
- opts: {
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- account: () => `0x${string}`;
- }
- ) {
- return async () => {
- const { preHook, postHook, account } = opts;
- const {
- output,
- orderContainer: { order },
- fillTransactionHash,
- sourceChain,
- mainnet
- } = args;
- const expectedOutputHash = hashStruct({
- types: compactTypes,
- primaryType: "MandateOutput",
- data: output
- });
- const validationKey = `${sourceChain}:${fillTransactionHash}:${expectedOutputHash}`;
- const existingValidation = Solver.validationInflight.get(validationKey);
- if (existingValidation) return existingValidation;
+ static validate(
+ walletClient: WC,
+ args: {
+ output: MandateOutput;
+ orderContainer: OrderContainer;
+ fillTransactionHash: string;
+ sourceChainId: number | bigint;
+ mainnet: boolean;
+ },
+ opts: {
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ account: () => `0x${string}`;
+ }
+ ) {
+ return async () => {
+ const { preHook, postHook, account } = opts;
+ const {
+ output,
+ orderContainer: { order },
+ fillTransactionHash,
+ sourceChainId,
+ mainnet
+ } = args;
+ const expectedOutputHash = hashStruct({
+ types: compactTypes,
+ primaryType: "MandateOutput",
+ data: output
+ });
+ const validationKey = `${Number(sourceChainId)}:${fillTransactionHash}:${expectedOutputHash}`;
+ const existingValidation = Solver.validationInflight.get(validationKey);
+ if (existingValidation) return existingValidation;
- const validationPromise = (async () => {
- const outputChain = getChainName(output.chainId);
- if (
- !fillTransactionHash ||
- !fillTransactionHash.startsWith("0x") ||
- fillTransactionHash.length !== 66
- ) {
- throw new Error(`Invalid fill transaction hash: ${fillTransactionHash}`);
- }
+ const validationPromise = (async () => {
+ if (
+ !fillTransactionHash ||
+ !fillTransactionHash.startsWith("0x") ||
+ fillTransactionHash.length !== 66
+ ) {
+ throw new Error(`Invalid fill transaction hash: ${fillTransactionHash}`);
+ }
- // Get the output filled event.
- const transactionReceipt = await Solver.getReceiptCachedOrRpc(
- output.chainId,
- fillTransactionHash as `0x${string}`
- );
+ // Get the output filled event.
+ const transactionReceipt = await Solver.getReceiptCachedOrRpc(
+ output.chainId,
+ fillTransactionHash as `0x${string}`
+ );
- const logs = parseEventLogs({
- abi: COIN_FILLER_ABI,
- eventName: "OutputFilled",
- logs: transactionReceipt.logs
- });
- // We need to search through each log until we find one matching our output.
- let logIndex = -1;
- for (const log of logs) {
- const logOutput = log.args.output;
- // TODO: Optimise by comparing the dicts.
- const logOutputHash = hashStruct({
- types: compactTypes,
- primaryType: "MandateOutput",
- data: logOutput
- });
- if (logOutputHash === expectedOutputHash) {
- logIndex = log.logIndex;
- break;
- }
- }
- if (logIndex === -1) throw Error(`Could not find matching log`);
+ const logs = parseEventLogs({
+ abi: COIN_FILLER_ABI,
+ eventName: "OutputFilled",
+ logs: transactionReceipt.logs
+ });
+ // We need to search through each log until we find one matching our output.
+ let logIndex = -1;
+ for (const log of logs) {
+ const logOutput = log.args.output;
+ // TODO: Optimise by comparing the dicts.
+ const logOutputHash = hashStruct({
+ types: compactTypes,
+ primaryType: "MandateOutput",
+ data: logOutput
+ });
+ if (logOutputHash === expectedOutputHash) {
+ logIndex = log.logIndex;
+ break;
+ }
+ }
+ if (logIndex === -1) throw Error(`Could not find matching log`);
- if (order.inputOracle === getOracle("polymer", sourceChain)) {
- let proof: string | undefined;
- const polymerKey = `${Number(output.chainId)}:${Number(transactionReceipt.blockNumber)}:${Number(logIndex)}`;
- let polymerIndex: number | undefined = Solver.polymerRequestIndexByLog.get(polymerKey);
- for (const waitMs of [1000, 2000, 4000, 8000]) {
- const response = await axios.post(
- `/polymer`,
- {
- srcChainId: Number(output.chainId),
- srcBlockNumber: Number(transactionReceipt.blockNumber),
- globalLogIndex: Number(logIndex),
- polymerIndex,
- mainnet: mainnet
- },
- { timeout: 15_000 }
- );
- const dat = response.data as {
- proof: undefined | string;
- polymerIndex: number;
- };
- polymerIndex = dat.polymerIndex;
- if (polymerIndex !== undefined) {
- Solver.polymerRequestIndexByLog.set(polymerKey, polymerIndex);
- }
- if (dat.proof) {
- proof = dat.proof;
- break;
- }
- await Solver.sleep(waitMs);
- }
- if (proof) {
- if (preHook) await preHook(sourceChain);
+ if (order.inputOracle === getOracle("polymer", sourceChainId)) {
+ let proof: string | undefined;
+ const polymerKey = `${Number(output.chainId)}:${Number(transactionReceipt.blockNumber)}:${Number(logIndex)}`;
+ let polymerIndex: number | undefined = Solver.polymerRequestIndexByLog.get(polymerKey);
+ for (const waitMs of [1000, 2000, 4000, 8000]) {
+ const response = await axios.post(
+ `/polymer`,
+ {
+ srcChainId: Number(output.chainId),
+ srcBlockNumber: Number(transactionReceipt.blockNumber),
+ globalLogIndex: Number(logIndex),
+ polymerIndex,
+ mainnet: mainnet
+ },
+ { timeout: 15_000 }
+ );
+ const dat = response.data as {
+ proof: undefined | string;
+ polymerIndex: number;
+ };
+ polymerIndex = dat.polymerIndex;
+ if (polymerIndex !== undefined) {
+ Solver.polymerRequestIndexByLog.set(polymerKey, polymerIndex);
+ }
+ if (dat.proof) {
+ proof = dat.proof;
+ break;
+ }
+ await Solver.sleep(waitMs);
+ }
+ if (proof) {
+ if (preHook) await preHook(Number(sourceChainId));
- const transactionHash = await walletClient.writeContract({
- chain: chainMap[sourceChain],
- account: account(),
- address: order.inputOracle,
- abi: POLYMER_ORACLE_ABI,
- functionName: "receiveMessage",
- args: [`0x${proof.replace("0x", "")}`]
- });
+ const transactionHash = await walletClient.writeContract({
+ chain: getChain(sourceChainId),
+ account: account(),
+ address: order.inputOracle,
+ abi: POLYMER_ORACLE_ABI,
+ functionName: "receiveMessage",
+ args: [`0x${proof.replace("0x", "")}`]
+ });
- const result = await clients[sourceChain].waitForTransactionReceipt({
- hash: transactionHash,
- timeout: 120_000,
- pollingInterval: 2_000
- });
- await Solver.persistReceipt(chainMap[sourceChain].id, transactionHash, result);
- if (postHook) await postHook();
- return result;
- }
- throw new Error(
- `Polymer proof unavailable for output on ${outputChain}. Try again after the fill attestation is indexed.`
- );
- } else if (order.inputOracle === COIN_FILLER) {
- const log = logs.find((log) => log.logIndex === logIndex)!;
- if (preHook) await preHook(sourceChain);
- const transactionHash = await walletClient.writeContract({
- chain: chainMap[sourceChain],
- account: account(),
- address: order.inputOracle,
- abi: COIN_FILLER_ABI,
- functionName: "setAttestation",
- args: [log.args.orderId, log.args.solver, log.args.timestamp, log.args.output]
- });
+ const result = await getClient(sourceChainId).waitForTransactionReceipt({
+ hash: transactionHash,
+ timeout: 120_000,
+ pollingInterval: 2_000
+ });
+ await Solver.persistReceipt(sourceChainId, transactionHash, result);
+ if (postHook) await postHook();
+ return result;
+ }
+ throw new Error(
+ `Polymer proof unavailable for output on ${output.chainId.toString()}. Try again after the fill attestation is indexed.`
+ );
+ } else if (order.inputOracle === COIN_FILLER) {
+ const log = logs.find((log) => log.logIndex === logIndex);
+ if (!log) throw new Error(`Log with index ${logIndex} not found`);
+ if (preHook) await preHook(Number(sourceChainId));
+ const transactionHash = await walletClient.writeContract({
+ chain: getChain(sourceChainId),
+ account: account(),
+ address: order.inputOracle,
+ abi: COIN_FILLER_ABI,
+ functionName: "setAttestation",
+ args: [log.args.orderId, log.args.solver, log.args.timestamp, log.args.output]
+ });
- const result = await clients[sourceChain].waitForTransactionReceipt({
- hash: transactionHash,
- timeout: 120_000,
- pollingInterval: 2_000
- });
- await Solver.persistReceipt(chainMap[sourceChain].id, transactionHash, result);
- if (postHook) await postHook();
- return result;
- }
- throw new Error(
- `Unsupported input oracle ${order.inputOracle} for source chain ${sourceChain}.`
- );
- })();
+ const result = await getClient(sourceChainId).waitForTransactionReceipt({
+ hash: transactionHash,
+ timeout: 120_000,
+ pollingInterval: 2_000
+ });
+ await Solver.persistReceipt(sourceChainId, transactionHash, result);
+ if (postHook) await postHook();
+ return result;
+ }
+ throw new Error(
+ `Unsupported input oracle ${order.inputOracle} for source chain ${Number(sourceChainId)}.`
+ );
+ })();
- Solver.validationInflight.set(validationKey, validationPromise);
- try {
- return await validationPromise;
- } finally {
- Solver.validationInflight.delete(validationKey);
- }
- };
- }
+ Solver.validationInflight.set(validationKey, validationPromise);
+ try {
+ return await validationPromise;
+ } finally {
+ Solver.validationInflight.delete(validationKey);
+ }
+ };
+ }
- static claim(
- walletClient: WC,
- args: {
- orderContainer: OrderContainer;
- fillTransactionHashes: string[];
- sourceChain: chain;
- },
- opts: {
- preHook?: (chain: chain) => Promise;
- postHook?: () => Promise;
- account: () => `0x${string}`;
- }
- ) {
- return async () => {
- const { preHook, postHook, account } = opts;
- const { orderContainer, fillTransactionHashes, sourceChain } = args;
- const { order, inputSettler } = orderContainer;
- const intent = orderToIntent({
- inputSettler,
- order
- });
- if (fillTransactionHashes.length !== order.outputs.length) {
- throw new Error(
- `Fill transaction hash count (${fillTransactionHashes.length}) does not match output count (${order.outputs.length}).`
- );
- }
- for (let i = 0; i < fillTransactionHashes.length; i++) {
- const hash = fillTransactionHashes[i];
- if (!hash || !hash.startsWith("0x") || hash.length !== 66) {
- throw new Error(`Invalid fill tx hash at index ${i}: ${hash}`);
- }
- }
- const transactionReceipts = await Promise.all(
- fillTransactionHashes.map((fth, i) =>
- Solver.getReceiptCachedOrRpc(order.outputs[i].chainId, fth as `0x${string}`)
- )
- );
- const blocks = await Promise.all(
- transactionReceipts.map((r, i) => {
- const outputChain = getChainName(order.outputs[i].chainId);
- return clients[outputChain].getBlock({
- blockHash: r.blockHash
- });
- })
- );
- const fillTimestamps = blocks.map((b) => b.timestamp);
+ static claim(
+ walletClient: WC,
+ args: {
+ orderContainer: OrderContainer;
+ fillTransactionHashes: string[];
+ sourceChainId: number | bigint;
+ },
+ opts: {
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ account: () => `0x${string}`;
+ }
+ ) {
+ return async () => {
+ const { preHook, postHook, account } = opts;
+ const { orderContainer, fillTransactionHashes, sourceChainId } = args;
+ const { order, inputSettler } = orderContainer;
+ const intent = containerToIntent(orderContainer);
+ if (intent instanceof StandardSolanaIntent)
+ throw new Error("Finalise is not supported for Solana input intents.");
+ if (fillTransactionHashes.length !== order.outputs.length) {
+ throw new Error(
+ `Fill transaction hash count (${fillTransactionHashes.length}) does not match output count (${order.outputs.length}).`
+ );
+ }
+ for (let i = 0; i < fillTransactionHashes.length; i++) {
+ const hash = fillTransactionHashes[i];
+ if (!hash || !hash.startsWith("0x") || hash.length !== 66) {
+ throw new Error(`Invalid fill tx hash at index ${i}: ${hash}`);
+ }
+ }
+ const transactionReceipts = await Promise.all(
+ fillTransactionHashes.map((fth, i) =>
+ Solver.getReceiptCachedOrRpc(order.outputs[i].chainId, fth as `0x${string}`)
+ )
+ );
+ const blocks = await Promise.all(
+ transactionReceipts.map((r, i) => {
+ return getClient(order.outputs[i].chainId).getBlock({
+ blockHash: r.blockHash
+ });
+ })
+ );
+ const fillTimestamps = blocks.map((b) => b.timestamp);
- if (preHook) await preHook(sourceChain);
- const expectedChainId = chainMap[sourceChain].id;
- const connectedChainId = await walletClient.getChainId();
- if (connectedChainId !== expectedChainId) {
- throw new Error(
- `Wallet is on chain ${connectedChainId}, expected ${expectedChainId} (${sourceChain}) before finalise`
- );
- }
+ if (preHook) await preHook(Number(sourceChainId));
+ const expectedChainId = Number(sourceChainId);
+ const connectedChainId = await walletClient.getChainId();
+ if (connectedChainId !== expectedChainId) {
+ throw new Error(
+ `Wallet is on chain ${connectedChainId}, expected ${expectedChainId} before finalise`
+ );
+ }
- const solveParams = fillTimestamps.map((fillTimestamp) => {
- return {
- timestamp: Number(fillTimestamp),
- solver: addressToBytes32(account())
- };
- });
+ const solveParams = fillTimestamps.map((fillTimestamp) => {
+ return {
+ timestamp: Number(fillTimestamp),
+ solver: addressToBytes32(account())
+ };
+ });
- const transactionHash = await intent.finalise({
- sourceChain,
- account: account(),
- walletClient,
- solveParams,
- signatures: orderContainer
- });
- if (!transactionHash) {
- throw new Error(
- `Finalise did not return a transaction hash for source chain ${sourceChain}.`
- );
- }
- let result;
- try {
- result = await clients[sourceChain].waitForTransactionReceipt({
- hash: transactionHash,
- timeout: 120_000,
- pollingInterval: 2_000
- });
- } catch (error) {
- throw new Error(
- `Timed out waiting for finalise tx receipt on ${sourceChain} for hash ${transactionHash}.`,
- { cause: error as Error }
- );
- }
- await Solver.persistReceipt(chainMap[sourceChain].id, transactionHash, result);
- if (postHook) await postHook();
- return result;
- };
- }
+ const transactionHash = await finaliseIntent({
+ intent,
+ sourceChainId,
+ account: account(),
+ walletClient,
+ solveParams,
+ signatures: orderContainer
+ });
+ if (!transactionHash) {
+ throw new Error(
+ `Finalise did not return a transaction hash for source chain ${Number(sourceChainId)}.`
+ );
+ }
+ let result;
+ try {
+ result = await getClient(sourceChainId).waitForTransactionReceipt({
+ hash: transactionHash,
+ timeout: 120_000,
+ pollingInterval: 2_000
+ });
+ } catch (error) {
+ throw new Error(
+ `Timed out waiting for finalise tx receipt on ${Number(sourceChainId)} for hash ${transactionHash}.`,
+ { cause: error as Error }
+ );
+ }
+ await Solver.persistReceipt(sourceChainId, transactionHash, result);
+ if (postHook) await postHook();
+ return result;
+ };
+ }
}
diff --git a/src/lib/libraries/token.ts b/src/lib/libraries/token.ts
index 182f461..d000190 100644
--- a/src/lib/libraries/token.ts
+++ b/src/lib/libraries/token.ts
@@ -2,62 +2,62 @@ import { maxUint256 } from "viem";
import { COMPACT_ABI } from "../abi/compact";
import { ERC20_ABI } from "../abi/erc20";
import { ADDRESS_ZERO, clients, COMPACT } from "../config";
-import { ResetPeriod, toId } from "../utils/idLib";
+import { ResetPeriod, toId } from "@lifi/intent";
export async function getBalance(
- user: `0x${string}` | undefined,
- asset: `0x${string}`,
- client: (typeof clients)[keyof typeof clients]
+ user: `0x${string}` | undefined,
+ asset: `0x${string}`,
+ client: (typeof clients)[keyof typeof clients]
) {
- if (!user) return 0n;
- if (asset === ADDRESS_ZERO) {
- return client.getBalance({
- address: user,
- blockTag: "latest"
- });
- } else {
- return client.readContract({
- address: asset,
- abi: ERC20_ABI,
- functionName: "balanceOf",
- args: [user]
- });
- }
+ if (!user) return 0n;
+ if (asset === ADDRESS_ZERO) {
+ return client.getBalance({
+ address: user,
+ blockTag: "latest"
+ });
+ } else {
+ return client.readContract({
+ address: asset,
+ abi: ERC20_ABI,
+ functionName: "balanceOf",
+ args: [user]
+ });
+ }
}
export function getAllowance(contract: `0x${string}`) {
- return async (
- user: `0x${string}` | undefined,
- asset: `0x${string}`,
- client: (typeof clients)[keyof typeof clients]
- ) => {
- if (!user) return 0n;
- if (asset == ADDRESS_ZERO) return maxUint256;
- return client.readContract({
- address: asset,
- abi: ERC20_ABI,
- functionName: "allowance",
- args: [user, contract]
- });
- };
+ return async (
+ user: `0x${string}` | undefined,
+ asset: `0x${string}`,
+ client: (typeof clients)[keyof typeof clients]
+ ) => {
+ if (!user) return 0n;
+ if (asset == ADDRESS_ZERO) return maxUint256;
+ return client.readContract({
+ address: asset,
+ abi: ERC20_ABI,
+ functionName: "allowance",
+ args: [user, contract]
+ });
+ };
}
export async function getCompactBalance(
- user: `0x${string}` | undefined,
- asset: `0x${string}`,
- client: (typeof clients)[keyof typeof clients],
- allocatorId: string
+ user: `0x${string}` | undefined,
+ asset: `0x${string}`,
+ client: (typeof clients)[keyof typeof clients],
+ allocatorId: string
) {
- if (!user) return 0n;
- const assetId = toId(true, ResetPeriod.OneDay, allocatorId, asset);
- try {
- return await client.readContract({
- address: COMPACT,
- abi: COMPACT_ABI,
- functionName: "balanceOf",
- args: [user, assetId]
- });
- } catch {
- return 0n;
- }
+ if (!user) return 0n;
+ const assetId = toId(true, ResetPeriod.OneDay, allocatorId, asset);
+ try {
+ return await client.readContract({
+ address: COMPACT,
+ abi: COMPACT_ABI,
+ functionName: "balanceOf",
+ args: [user, assetId]
+ });
+ } catch {
+ return 0n;
+ }
}
diff --git a/src/lib/migrations.json b/src/lib/migrations.json
index bbd71d7..3699d71 100644
--- a/src/lib/migrations.json
+++ b/src/lib/migrations.json
@@ -1,40 +1,18 @@
[
- {
- "sql": [
- "CREATE TABLE \"intents\" (\n\t\"id\" text PRIMARY KEY NOT NULL,\n\t\"order_id\" text NOT NULL,\n\t\"intent_type\" text NOT NULL,\n\t\"data\" text NOT NULL,\n\t\"created_at\" integer NOT NULL\n);\n"
- ],
- "bps": true,
- "folderMillis": 1770712231202,
- "hash": "3ec46f3cc562c5204f9e841d2ea2086d8994c80253445074b646b07900b30a9f"
- },
- {
- "sql": [
- "CREATE TABLE \"fill_transactions\" (\n\t\"id\" text PRIMARY KEY NOT NULL,\n\t\"output_hash\" text NOT NULL,\n\t\"tx_hash\" text NOT NULL,\n\tCONSTRAINT \"fill_transactions_output_hash_unique\" UNIQUE(\"output_hash\")\n);\n"
- ],
- "bps": true,
- "folderMillis": 1770803119280,
- "hash": "f963c9a03076fc9754b51c2850ad42f5edfdf19fb018a0616db37d935907b165"
- },
- {
- "sql": ["ALTER TABLE \"intents\" ALTER COLUMN \"created_at\" TYPE bigint;\n"],
- "bps": true,
- "folderMillis": 1770809000000,
- "hash": "45484cce461ab6b6ac735465757bebec7d5bf488ed58c4288ebf1fd75d1881f5"
- },
- {
- "sql": [
- "CREATE UNIQUE INDEX IF NOT EXISTS \"intents_order_id_unique\" ON \"intents\" (\"order_id\");\n"
- ],
- "bps": true,
- "folderMillis": 1770810000000,
- "hash": "387946018137748e3a5dd66fca8a1da71ddabc4191a835a3254fad26c6b6d412"
- },
- {
- "sql": [
- "CREATE TABLE \"transaction_receipts\" (\n\t\"id\" text PRIMARY KEY NOT NULL,\n\t\"chain_id\" bigint NOT NULL,\n\t\"tx_hash\" text NOT NULL,\n\t\"receipt\" text NOT NULL,\n\t\"created_at\" bigint NOT NULL\n);\n"
- ],
- "bps": true,
- "folderMillis": 1771060000000,
- "hash": "8f048c5d64c44d6c89c970f44a52e1fdbaf3de8f4052145cfd90f50822ab95f1"
- }
+ {
+ "sql": [
+ "DROP TABLE IF EXISTS \"transaction_receipts\";\n",
+ "\nDROP TABLE IF EXISTS \"tokens\";\n",
+ "\nDROP TABLE IF EXISTS \"intents\";\n",
+ "\nDROP TABLE IF EXISTS \"fill_transactions\";\n",
+ "\nCREATE TABLE \"fill_transactions\" (\n\t\"id\" text PRIMARY KEY NOT NULL,\n\t\"output_hash\" text NOT NULL,\n\t\"tx_hash\" text NOT NULL,\n\tCONSTRAINT \"fill_transactions_output_hash_unique\" UNIQUE(\"output_hash\")\n);\n",
+ "\nCREATE TABLE \"intents\" (\n\t\"id\" text PRIMARY KEY NOT NULL,\n\t\"order_id\" text NOT NULL,\n\t\"intent_type\" text NOT NULL,\n\t\"data\" text NOT NULL,\n\t\"created_at\" bigint NOT NULL,\n\tCONSTRAINT \"intents_order_id_unique\" UNIQUE(\"order_id\")\n);\n",
+ "\nCREATE TABLE \"tokens\" (\n\t\"id\" text PRIMARY KEY NOT NULL,\n\t\"address\" text NOT NULL,\n\t\"name\" text NOT NULL,\n\t\"chain_id\" bigint NOT NULL,\n\t\"decimals\" bigint NOT NULL,\n\t\"is_manual\" boolean DEFAULT false NOT NULL,\n\t\"is_testnet\" boolean DEFAULT false NOT NULL\n);\n",
+ "\nCREATE TABLE \"transaction_receipts\" (\n\t\"id\" text PRIMARY KEY NOT NULL,\n\t\"chain_id\" bigint NOT NULL,\n\t\"tx_hash\" text NOT NULL,\n\t\"receipt\" text NOT NULL,\n\t\"created_at\" bigint NOT NULL\n);\n",
+ "\nCREATE UNIQUE INDEX \"tokens_address_chain_idx\" ON \"tokens\" USING btree (\"address\",\"chain_id\");\n"
+ ],
+ "bps": true,
+ "folderMillis": 1773159031946,
+ "hash": "b9ecf75ed8487a7746169ad49ce1564428a73e69f49e85cd702aaabbb03d72f6"
+ }
]
diff --git a/src/lib/schema.ts b/src/lib/schema.ts
index fee5b44..a6fa802 100644
--- a/src/lib/schema.ts
+++ b/src/lib/schema.ts
@@ -1,25 +1,39 @@
-import { pgTable, text, integer, bigint } from "drizzle-orm/pg-core";
+import { pgTable, text, bigint, boolean, uniqueIndex } from "drizzle-orm/pg-core";
export const intents = pgTable("intents", {
- id: text("id").primaryKey(),
- orderId: text("order_id").notNull().unique(),
- intentType: text("intent_type").notNull(),
- data: text("data").notNull(),
- createdAt: bigint("created_at", { mode: "number" }).notNull()
+ id: text("id").primaryKey(),
+ orderId: text("order_id").notNull().unique(),
+ intentType: text("intent_type").notNull(),
+ data: text("data").notNull(),
+ createdAt: bigint("created_at", { mode: "number" }).notNull()
});
export const fillTransactions = pgTable("fill_transactions", {
- id: text("id").primaryKey(),
- outputHash: text("output_hash").notNull().unique(),
- txHash: text("tx_hash").notNull()
+ id: text("id").primaryKey(),
+ outputHash: text("output_hash").notNull().unique(),
+ txHash: text("tx_hash").notNull()
});
export const transactionReceipts = pgTable("transaction_receipts", {
- id: text("id").primaryKey(),
- chainId: bigint("chain_id", { mode: "number" }).notNull(),
- txHash: text("tx_hash").notNull(),
- receipt: text("receipt").notNull(),
- createdAt: bigint("created_at", { mode: "number" }).notNull()
+ id: text("id").primaryKey(),
+ chainId: bigint("chain_id", { mode: "number" }).notNull(),
+ txHash: text("tx_hash").notNull(),
+ receipt: text("receipt").notNull(),
+ createdAt: bigint("created_at", { mode: "number" }).notNull()
});
-export const schema = { intents, fillTransactions, transactionReceipts };
+export const tokens = pgTable(
+ "tokens",
+ {
+ id: text("id").primaryKey(),
+ address: text("address").notNull(),
+ name: text("name").notNull(),
+ chainId: bigint("chain_id", { mode: "number" }).notNull(),
+ decimals: bigint("decimals", { mode: "number" }).notNull(),
+ isManual: boolean("is_manual").notNull().default(false),
+ isTestnet: boolean("is_testnet").notNull().default(false)
+ },
+ (table) => [uniqueIndex("tokens_address_chain_idx").on(table.address, table.chainId)]
+);
+
+export const schema = { intents, fillTransactions, transactionReceipts, tokens };
diff --git a/src/lib/screens/ConnectWallet.svelte b/src/lib/screens/ConnectWallet.svelte
index 1279c99..7461fea 100644
--- a/src/lib/screens/ConnectWallet.svelte
+++ b/src/lib/screens/ConnectWallet.svelte
@@ -1,26 +1,49 @@
-
- {connecting ? "Waiting for wallet..." : "Connect Wallet"}
-
+
+ {#each connectors as connector (connector.id)}
+
connectWallet(connector.id)}
+ >
+ {#if connectingId === connector.id}
+ Connecting {connector.name}...
+ {:else}
+ Connect {connector.name}
+ {/if}
+
+ {/each}
+
+ {#if !walletConnectProjectId}
+
+ WalletConnect is disabled (missing `PUBLIC_WALLET_CONNECT_PROJECT_ID`).
+
+ {/if}
+ {#if errorMessage}
+
{errorMessage}
+ {/if}
+
diff --git a/src/lib/screens/FillIntent.svelte b/src/lib/screens/FillIntent.svelte
index 44484bc..11907e9 100644
--- a/src/lib/screens/FillIntent.svelte
+++ b/src/lib/screens/FillIntent.svelte
@@ -1,219 +1,271 @@
-
- {#each sortOutputsByChain(orderContainer) as chainIdAndOutputs}
-
-
- {#snippet action()}
- {@const chainStatuses = chainIdAndOutputs[1].map(
- (output) => fillStatuses[outputKey(output)]
- )}
- {#if chainStatuses.some((status) => status === undefined)}
-
- Fill
-
- {:else}
- v == BYTES32_ZERO) ? "default" : "muted"}
- buttonFunction={chainStatuses.every((v) => v == BYTES32_ZERO)
- ? fillWrapper(
- chainIdAndOutputs[1],
- Solver.fill(
- store.walletClient,
- {
- orderContainer,
- outputs: chainIdAndOutputs[1]
- },
- {
- preHook,
- postHook: postHookScroll,
- account
- }
- )
- )
- : async () => {}}
- >
- {#snippet name()}
- Fill
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {/if}
- {/snippet}
- {#snippet chips()}
- {#each chainIdAndOutputs[1] as output}
- {@const filled = fillStatuses[outputKey(output)]}
-
-
-
- {/each}
-
+
+
+ {#each orderContainer.order.outputs as output}
+ {@const key = outputKey(output)}
+ {@const currentHash = store.fillTransactions[key]}
+
+
+
{
+ const value = (event.currentTarget as HTMLInputElement).value;
+ manualFillTxInputs[key] = value;
+ manualFillTxSaved[key] = false;
+ manualFillTxErrors[key] = "";
+ }}
+ />
+
saveManualFillTransaction(output)}
+ >
+ {manualFillTxSaving[key] ? "Saving..." : "Save Tx"}
+
+ {#if manualFillTxErrors[key]}
+
{manualFillTxErrors[key]}
+ {:else if manualFillTxSaved[key]}
+
Saved
+ {/if}
+
+ {/each}
+
+ {#each sortOutputsByChain(orderContainer) as chainIdAndOutputs}
+
+
+ {#snippet action()}
+ {@const chainStatuses = chainIdAndOutputs[1].map(
+ (output) => fillStatuses[outputKey(output)]
+ )}
+ {#if chainStatuses.some((status) => status === undefined)}
+
+ Fill
+
+ {:else}
+ v == BYTES32_ZERO) ? "default" : "muted"}
+ buttonFunction={chainStatuses.every((v) => v == BYTES32_ZERO)
+ ? fillWrapper(
+ chainIdAndOutputs[1],
+ Solver.fill(
+ store.walletClient,
+ {
+ orderContainer,
+ outputs: chainIdAndOutputs[1]
+ },
+ {
+ preHook,
+ postHook: postHookScroll,
+ account
+ }
+ )
+ )
+ : async () => {}}
+ >
+ {#snippet name()}
+ Fill
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {/if}
+ {/snippet}
+ {#snippet chips()}
+ {#each chainIdAndOutputs[1] as output}
+ {@const filled = fillStatuses[outputKey(output)]}
+
+
+ {/each}
+
diff --git a/src/lib/screens/Finalise.svelte b/src/lib/screens/Finalise.svelte
index 1a0f522..87a5f5d 100644
--- a/src/lib/screens/Finalise.svelte
+++ b/src/lib/screens/Finalise.svelte
@@ -1,280 +1,284 @@
-
- {#if allFinalised}
-
- {#each confettiPieces as piece, i}
-
- {/each}
-
- {/if}
- {#if allFinalised}
-
-
All inputs finalised
-
Intent fully solved.
-
- {/if}
- {#each inputChains as inputChain}
-
-
- {#snippet action()}
- {@const isClaimedStatus = claimedByChain[inputChain.toString()]}
- {#if isClaimedStatus === undefined}
-
- Finalise
-
- {:else if isClaimedStatus}
-
- Finalised
-
- {:else}
-
- store.fillTransactions[
- hashStruct({
- data: output,
- types: compactTypes,
- primaryType: "MandateOutput"
- })
- ] as string
- )
- },
- {
- account,
- preHook,
- postHook: postHookRefreshValidate
- }
- )}
- >
- {#snippet name()}
- Claim
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {/if}
- {/snippet}
- {#snippet chips()}
- {#if "originChainId" in orderContainer.order}
- {#each orderContainer.order.inputs as input}
-
-
- {/each}
-
+ {#if allFinalised}
+
+ {#each confettiPieces as piece, i}
+
+ {/each}
+
+ {/if}
+ {#if allFinalised}
+
+
All inputs finalised
+
Intent fully solved.
+
+ {/if}
+ {#each inputChains as inputChain}
+
+
+ {#snippet action()}
+ {@const isClaimedStatus = claimedByChain[inputChain.toString()]}
+ {#if isClaimedStatus === undefined}
+
+ Finalise
+
+ {:else if isClaimedStatus}
+
+ Finalised
+
+ {:else}
+ {@const fillTransactionHashes = fillTransactionHashesFor(orderContainer)}
+ {@const canClaim = fillTransactionHashes.every((hash) => isValidFillTxHash(hash))}
+ {#if !canClaim}
+
+ Await fills
+
+ {:else}
+
+ {#snippet name()}
+ Claim
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {/if}
+ {/if}
+ {/snippet}
+ {#snippet chips()}
+ {#each getInputsForChain(orderContainer, inputChain) as input}
+
+
+ {/each}
+
diff --git a/src/lib/screens/IntentDescription.svelte b/src/lib/screens/IntentDescription.svelte
index 0c463f5..106fb04 100644
--- a/src/lib/screens/IntentDescription.svelte
+++ b/src/lib/screens/IntentDescription.svelte
@@ -1,33 +1,33 @@
-
Intent Description
-
- To fill an intent, you may need to execute up to 4 transactions. This intent requires 3.
-
-
-
-
-
- The intent has been filled.
-
-
-
-
- The intent does not need to be submitted.
-
-
-
-
- The fill proof has not been proven.
-
-
-
-
- The intent has not been finalised.
-
-
-
+
Intent Description
+
+ To fill an intent, you may need to execute up to 4 transactions. This intent requires 3.
+
+
+
+
+
+ The intent has been filled.
+
+
+
+
+ The intent does not need to be submitted.
+
+
+
+
+ The fill proof has not been proven.
+
+
+
+
+ The intent has not been finalised.
+
+
+
-
-
- {importState === "loading" ? "Importing..." : "Import"}
-
-
- {#if importMessage}
-
- {importMessage}
-
- {/if}
-
-
- {#each activeRows as row (row.orderId)}
-
- {
- selectedOrder = row.orderContainer;
- await tick();
- scroll(3)();
- }}
- >
-
- handleDelete(row.orderId as `0x${string}`)}
- disabled={deletingOrderId === row.orderId}
- data-testid={`intent-delete-${row.orderId}`}
- >
- {deletingOrderId === row.orderId ? "..." : "Delete"}
-
-
- {/each}
-
-
-
- {#each expiredRows as row (row.orderId)}
-
-
{
- expandedExpiredOrderId =
- expandedExpiredOrderId === row.orderId ? undefined : row.orderId;
- }}
- >
- {#if expandedExpiredOrderId === row.orderId}
-
-
- {row.chainScope} • {row.inputCount} in → {row.outputCount} out • {row.orderIdShort}
-
-
{formatRelativeDeadline(row.secondsToDeadline)}
-
- {#if expandedExpiredOrderId === row.orderId}
-
handleDelete(row.orderId as `0x${string}`)}
- disabled={deletingOrderId === row.orderId}
- data-testid={`intent-delete-${row.orderId}`}
- >
- {deletingOrderId === row.orderId ? "..." : "Delete"}
-
- {/if}
-
- {/each}
-
+
+
+ {importState === "loading" ? "Importing..." : "Import"}
+
+
+ {#if importMessage}
+
+ {importMessage}
+
+ {/if}
+
+
+ {#each activeRows as row (row.orderId)}
+
+ {
+ selectedOrder = row.orderContainer;
+ await tick();
+ scroll(3)();
+ }}
+ >
+
+ handleDelete(row.orderId as `0x${string}`)}
+ disabled={deletingOrderId === row.orderId}
+ data-testid={`intent-delete-${row.orderId}`}
+ >
+ {deletingOrderId === row.orderId ? "..." : "Delete"}
+
+
+ {/each}
+
+
+
+ {#each expiredRows as row (row.orderId)}
+
+
{
+ expandedExpiredOrderId =
+ expandedExpiredOrderId === row.orderId ? undefined : row.orderId;
+ }}
+ >
+ {#if expandedExpiredOrderId === row.orderId}
+
+
+ {row.chainScope} • {row.inputCount} in → {row.outputCount} out • {row.orderIdShort}
+
+
{formatRelativeDeadline(row.secondsToDeadline)}
+
+ {#if expandedExpiredOrderId === row.orderId}
+
handleDelete(row.orderId as `0x${string}`)}
+ disabled={deletingOrderId === row.orderId}
+ data-testid={`intent-delete-${row.orderId}`}
+ >
+ {deletingOrderId === row.orderId ? "..." : "Delete"}
+
+ {/if}
+
+ {/each}
+
diff --git a/src/lib/screens/IssueIntent.svelte b/src/lib/screens/IssueIntent.svelte
index 1eee3da..d038bb1 100644
--- a/src/lib/screens/IssueIntent.svelte
+++ b/src/lib/screens/IssueIntent.svelte
@@ -1,351 +1,409 @@
- {#if inputTokenSelectorActive}
-
-
- {#snippet headerRight()}
-
-
- {/snippet}
-
-
-
You Pay
- {#each abstractInputs as input, i (input.name)}
-
(inputTokenSelectorActive = true)}
- >
-
-
-
{formatTokenAmount(input.amount, input.decimals)}
-
{input.name.toUpperCase()}
-
-
- {#each input.chains as chainName, chainIndex (chainName)}
- {chainName}{chainIndex < input.chains.length - 1 ? ", " : ""}
- {/each}
-
-
- {/each}
- {#if numInputChains > 1}
-
Multichain
- {/if}
- {#if sameChain}
-
Same chain
- {/if}
-
-
-
-
You Receive
- {#each store.outputTokens as outputToken, i (`${outputToken.token.chain}-${outputToken.token.address}-${i}`)}
-
(outputTokenSelectorActive = true)}
- >
-
-
-
{formatTokenAmount(outputToken.amount, outputToken.token.decimals)}
-
- {outputToken.token.name.toUpperCase()}
-
-
-
- {outputToken.token.chain}
-
-
- {/each}
-
-
+
+
+ {#snippet headerRight()}
+
+
+ {/snippet}
+
+
+
You Pay
+ {#each abstractInputs as input, i (input.name)}
+
(inputTokenSelectorActive = true)}
+ >
+
+
+
{formatTokenAmount(input.amount, input.decimals)}
+
{input.name.toUpperCase()}
+
+
+ {#each input.chains as chainName, chainIndex (chainName)}
+ {chainName}{chainIndex < input.chains.length - 1 ? ", " : ""}
+ {/each}
+
+
+ {/each}
+ {#if numInputChains > 1}
+
Multichain
+ {/if}
+ {#if sameChain}
+
Same chain
+ {/if}
+
+
+
+
You Receive
+ {#each store.outputTokens as outputToken, i (`${outputToken.token.chainId}-${outputToken.token.address}-${i}`)}
+
(outputTokenSelectorActive = true)}
+ >
+
+
+
{formatTokenAmount(outputToken.amount, outputToken.token.decimals)}
+
+ {outputToken.token.name.toUpperCase()}
+
+
+
+ {getChainName(outputToken.token.chainId)}
+
+
+ {/each}
+
+
-
-
-
- Verifier
- {#if sameChain}
-
- Settler
-
- {:else}
-
- Polymer
- Wormhole
-
- {/if}
-
-
- Exclusive
-
-
-
-
+
+
+
+ Recipient
+ 0 && !resolveRecipient(store.recipient)
+ ? "error"
+ : "default"}
+ bind:value={store.recipient}
+ />
+
+
+ Verifier
+ {#if sameChain}
+
+ Settler
+
+ {:else}
+
+ Polymer
+ Wormhole
+
+ {/if}
+
+
+ Exclusive
+
+
+
+
-
- {#if !allowanceCheck}
-
- {#snippet name()}
- Set allowance
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {:else}
-
- {#if !balanceCheckWallet}
-
- Low Balance
-
- {:else if store.intentType === "escrow"}
-
- {#snippet name()}
- Execute Open
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {/if}
- {#if store.intentType === "compact" && store.allocatorId !== POLYMER_ALLOCATOR}
- {#if !balanceCheckCompact}
-
- Low Compact Balance
-
- {:else}
-
- {#snippet name()}
- Sign Order
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {/if}
- {/if}
-
- {/if}
-
- {#if numInputChains > 1 && store.intentType !== "compact"}
-
- You'll need to open the order on {numInputChains} chains. Be prepared and do not interrupt the
- process.
-
- {/if}
-
+
+ {#if !allowanceCheck}
+
+ {#snippet name()}
+ Set allowance
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {:else}
+
+ {#if !balanceCheckWallet}
+
+ Low Balance
+
+ {:else if store.intentType === "escrow"}
+
+ {#snippet name()}
+ Execute Open
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {/if}
+ {#if store.intentType === "compact" && store.allocatorId !== POLYMER_ALLOCATOR}
+ {#if !balanceCheckCompact}
+
+ Low Compact Balance
+
+ {:else}
+
+ {#snippet name()}
+ Sign Order
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {/if}
+ {/if}
+
+ {/if}
+
+ {#if numInputChains > 1 && store.intentType !== "compact"}
+
+ You'll need to open the order on {numInputChains} chains. Be prepared and do not interrupt the
+ process.
+
+ {/if}
+
diff --git a/src/lib/screens/ManageDeposit.svelte b/src/lib/screens/ManageDeposit.svelte
index 283a72c..d639ab4 100644
--- a/src/lib/screens/ManageDeposit.svelte
+++ b/src/lib/screens/ManageDeposit.svelte
@@ -1,190 +1,292 @@
-
-
-
-
Network
- (store.mainnet = v === "mainnet")}
- />
-
-
-
-
-
Input Type
- (store.intentType = v as "compact" | "escrow")}
- />
-
-
- {#if store.intentType === "compact"}
-
-
-
-
Allocator
- (store.allocatorId = v as typeof store.allocatorId)}
- />
-
-
-
- Deposit
- Withdraw
-
- of
- {#if (manageAssetAction === "withdraw" ? store.compactBalances : store.balances)[token.chain]}
-
- {#each coinList(store.mainnet) as tkn, i}
- {printToken(tkn)}
- {/each}
-
-
-
- {#if manageAssetAction === "withdraw"}
-
- {#snippet name()}
- Withdraw
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {:else if allowance < inputAmount}
-
- {#snippet name()}
- Set allowance
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {:else}
-
- {#snippet name()}
- Execute deposit
- {/snippet}
- {#snippet awaiting()}
- Waiting for transaction...
- {/snippet}
-
- {/if}
-
-
- {:else}
-
-
- The Escrow Input Settler does not have any asset management. Skip to the next step to
- select which assets to use. In the future, this place will be updated to show your pending
- intents.
-
-
- {/if}
-
+
+
+
+
Network
+ (store.mainnet = v === "mainnet")}
+ />
+
+
+
Intent API
+ (store.useProductionApi = v === "auto" ? null : v === "production")}
+ />
+
+
+
+
+
Input Type
+ (store.intentType = v as "compact" | "escrow")}
+ />
+
+
+ {#if store.intentType === "compact"}
+
+
+
+
Allocator
+ (store.allocatorId = v as typeof store.allocatorId)}
+ />
+
+
+
+ Deposit
+ Withdraw
+
+ of
+ {#if (manageAssetAction === "withdraw" ? store.compactBalances : store.balances)[token.chainId]}
+
+ {#each store.availableTokens as tkn, i}
+ {printToken(tkn)}
+ {/each}
+
+
+
+ {#if manageAssetAction === "withdraw"}
+
+ {#snippet name()}
+ Withdraw
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {:else if allowance < inputAmount}
+
+ {#snippet name()}
+ Set allowance
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {:else}
+
+ {#snippet name()}
+ Execute deposit
+ {/snippet}
+ {#snippet awaiting()}
+ Waiting for transaction...
+ {/snippet}
+
+ {/if}
+
+
+ {/if}
+
+
+
+
Add Token
+
+
+ {#each chainList(store.mainnet) as chainName}
+ {chainName}
+ {/each}
+
+ {#if addTokenError}
+
{addTokenError}
+ {/if}
+
{
+ addTokenError = "";
+ if (!/^0x[0-9a-fA-F]{40}$/.test(newTokenAddress)) {
+ addTokenError = "Invalid address";
+ return;
+ }
+ try {
+ const client = getClient(newTokenChainId);
+ const addr = newTokenAddress as `0x${string}`;
+ const decimals = await client.readContract({
+ address: addr,
+ abi: erc20Abi,
+ functionName: "decimals"
+ });
+ const symbol = await client.readContract({
+ address: addr,
+ abi: erc20Abi,
+ functionName: "symbol"
+ });
+ await store.addCustomToken({
+ address: addr,
+ name: symbol.toLowerCase(),
+ chainId: newTokenChainId,
+ decimals: Number(decimals)
+ });
+ newTokenAddress = "";
+ } catch (e) {
+ addTokenError = e instanceof Error ? e.message : "Failed to fetch token";
+ }
+ }}
+ >
+ {#snippet name()}
+ Add
+ {/snippet}
+ {#snippet awaiting()}
+ Fetching...
+ {/snippet}
+
+
+
+ {#each store.availableTokens as tkn}
+ {@const tokenKey = `${tkn.chainId}:${tkn.address.toLowerCase()}`}
+ {@const isManual = store.manualTokenKeys.has(tokenKey)}
+
+ {tkn.name.toUpperCase()}
+ {printToken(tkn)}
+ {tkn.address.slice(0, 8)}…
+ {#if isManual}
+ store.removeCustomToken(tkn.address, tkn.chainId)}>×
+ {/if}
+
+ {/each}
+
+
+
diff --git a/src/lib/screens/ReceiveMessage.svelte b/src/lib/screens/ReceiveMessage.svelte
index 211dfc5..3d2d430 100644
--- a/src/lib/screens/ReceiveMessage.svelte
+++ b/src/lib/screens/ReceiveMessage.svelte
@@ -1,242 +1,227 @@
-
- {#each orderToIntent(orderContainer).inputChains() as inputChain}
-
-
- {#snippet action()}
- Validate outputs
- {/snippet}
- {#snippet chips()}
- {#each orderContainer.order.outputs as output}
- {@const status = validationStatuses[validationKey(inputChain, output)]}
- {#if status === undefined}
- {}
- : Solver.validate(
- store.walletClient,
- {
- output,
- orderContainer,
- fillTransactionHash:
- store.fillTransactions[
- hashStruct({
- data: output,
- types: compactTypes,
- primaryType: "MandateOutput"
- })
- ],
- sourceChain: getChainName(inputChain),
- mainnet: store.mainnet
- },
- {
- preHook,
- postHook: postHookRefreshValidate,
- account
- }
- )}
- >
- {#snippet name()}
- {formatTokenAmount(
- output.amount,
- getCoin({ address: output.token, chain: getChainName(output.chainId) })
- .decimals
- )}
-
- {getCoin({
- address: output.token,
- chain: getChainName(output.chainId)
- }).name.toUpperCase()}
- {/snippet}
- {#snippet awaiting()}
- Validating...
- {/snippet}
-
- {/if}
- {/each}
- {/snippet}
-
-
- {/each}
-
+ {#each containerToIntent(orderContainer).inputChains() as inputChain}
+
+
+ {#snippet action()}
+ Validate outputs
+ {/snippet}
+ {#snippet chips()}
+ {#each orderContainer.order.outputs as output}
+ {@const status = validationStatuses[validationKey(inputChain, output)]}
+ {#if status === undefined}
+ {}
+ : Solver.validate(
+ store.walletClient,
+ {
+ output,
+ orderContainer,
+ fillTransactionHash: store.fillTransactions[outputKey(output)],
+ sourceChainId: Number(inputChain),
+ mainnet: store.mainnet
+ },
+ {
+ preHook,
+ postHook: postHookRefreshValidate,
+ account
+ }
+ )}
+ >
+ {#snippet name()}
+ {formatTokenAmount(
+ output.amount,
+ getCoin({ address: output.token, chainId: output.chainId }).decimals
+ )}
+
+ {getCoin({
+ address: output.token,
+ chainId: output.chainId
+ }).name.toUpperCase()}
+ {/snippet}
+ {#snippet awaiting()}
+ Validating...
+ {/snippet}
+
+ {/if}
+ {/each}
+ {/snippet}
+
+
+ {/each}
+
diff --git a/src/lib/state.svelte.ts b/src/lib/state.svelte.ts
index 59b0ded..ff64a49 100644
--- a/src/lib/state.svelte.ts
+++ b/src/lib/state.svelte.ts
@@ -1,416 +1,577 @@
-import type { WalletState } from "@web3-onboard/core";
-import type { OrderContainer } from "../types";
+import type { OrderContainer } from "@lifi/intent";
+import type { GetTransactionReceiptReturnType } from "viem";
+import type { AppTokenContext } from "./appTypes";
+
+type OrderContainerWithMeta = OrderContainer & { id?: string; intentType?: string };
import {
- ALWAYS_OK_ALLOCATOR,
- chainMap,
- clients,
- coinList,
- COMPACT,
- INPUT_SETTLER_COMPACT_LIFI,
- INPUT_SETTLER_ESCROW_LIFI,
- MULTICHAIN_INPUT_SETTLER_COMPACT,
- MULTICHAIN_INPUT_SETTLER_ESCROW,
- type availableAllocators,
- type chain,
- type Token,
- type Verifier
+ ALWAYS_OK_ALLOCATOR,
+ clientsById,
+ coinList,
+ COMPACT,
+ INPUT_SETTLER_COMPACT_LIFI,
+ INPUT_SETTLER_ESCROW_LIFI,
+ MULTICHAIN_INPUT_SETTLER_COMPACT,
+ MULTICHAIN_INPUT_SETTLER_ESCROW,
+ isChainIdTestnet,
+ type availableAllocators,
+ type Token,
+ type Verifier,
+ type WC
} from "./config";
import { getAllowance, getBalance, getCompactBalance } from "./libraries/token";
-import onboard from "./utils/web3-onboard";
-import { createWalletClient, custom } from "viem";
import { browser } from "$app/environment";
import { initDb, db } from "./db";
import {
- intents,
- fillTransactions as fillTransactionsTable,
- transactionReceipts as transactionReceiptsTable
+ intents,
+ fillTransactions as fillTransactionsTable,
+ transactionReceipts as transactionReceiptsTable,
+ tokens as tokensTable
} from "./schema";
-import { and, eq } from "drizzle-orm";
-import { orderToIntent } from "./libraries/intent";
+import { and, eq, ne, notInArray } from "drizzle-orm";
+import { containerToIntent } from "./utils/intent";
import { getOrFetchRpc, invalidateRpcPrefix } from "./libraries/rpcCache";
-
-export type TokenContext = {
- token: Token;
- amount: bigint;
-};
+import {
+ getCurrentConnection,
+ getCurrentWalletClient,
+ reconnectWallet,
+ type WalletConnection,
+ watchWalletConnection
+} from "./utils/wagmi";
+import { switchWalletChain } from "./utils/walletClientRuntime";
+
+function generateUUID(): string {
+ return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+ const r = (Math.random() * 16) | 0;
+ const v = c === "x" ? r : (r & 0x3) | 0x8;
+ return v.toString(16);
+ });
+}
class Store {
- mainnet = $state(true);
- orders = $state([]);
-
- async loadOrdersFromDb() {
- if (!browser) return;
- if (!db) await initDb();
- if (!db) return;
- const rows = await db!.select().from(intents);
- this.orders = rows.map((r: any) => JSON.parse(r.data) as OrderContainer);
- }
-
- async saveOrderToDb(order: OrderContainer) {
- if (!browser) return;
- if (!db) await initDb();
- const orderId = orderToIntent(order).orderId();
- const now = Math.floor(Date.now() / 1000);
- const id =
- (order as any).id ?? (typeof crypto !== "undefined" ? crypto.randomUUID() : String(now));
- const intentType = (order as any).intentType ?? "escrow";
- const data = JSON.stringify(order);
- if (db) {
- try {
- try {
- await db
- .insert(intents)
- .values({
- id,
- orderId,
- intentType,
- data,
- createdAt: now
- })
- .onConflictDoUpdate({
- target: intents.orderId,
- set: { intentType, data }
- });
- } catch (_error) {
- const existing = await db.select().from(intents).where(eq(intents.orderId, orderId));
- if (existing.length > 0) {
- await db.update(intents).set({ intentType, data }).where(eq(intents.orderId, orderId));
- } else {
- await db.insert(intents).values({
- id,
- orderId,
- intentType,
- data,
- createdAt: now
- });
- }
- }
- } catch (error) {
- console.warn("saveOrderToDb db write failed", { orderId, error });
- }
- }
- const idx = this.orders.findIndex((o) => orderToIntent(o).orderId() === orderId);
- if (idx >= 0) this.orders[idx] = order;
- else this.orders.push(order);
- }
-
- async deleteOrderFromDb(orderId: string) {
- if (!browser) return;
- if (!db) await initDb();
- if (!db) return;
- await db!.delete(intents).where(eq(intents.orderId, orderId));
- await this.loadOrdersFromDb();
- }
-
- async loadFillTransactionsFromDb() {
- if (!browser) return;
- if (!db) await initDb();
- if (!db) return;
- const rows = await db!.select().from(fillTransactionsTable);
- const loaded: { [outputId: string]: `0x${string}` } = {};
- for (const row of rows) loaded[row.outputHash] = row.txHash as `0x${string}`;
- this.fillTransactions = loaded;
- }
-
- async saveFillTransaction(outputHash: string, txHash: `0x${string}`) {
- if (!browser) return;
- if (!db) await initDb();
- if (!db) return;
- const existing = await db!
- .select()
- .from(fillTransactionsTable)
- .where(eq(fillTransactionsTable.outputHash, outputHash));
- if (existing.length > 0) {
- await db!
- .update(fillTransactionsTable)
- .set({ txHash })
- .where(eq(fillTransactionsTable.outputHash, outputHash));
- } else {
- await db!.insert(fillTransactionsTable).values({
- id: typeof crypto !== "undefined" ? crypto.randomUUID() : String(Date.now()),
- outputHash,
- txHash
- });
- }
- }
-
- async loadTransactionReceiptsFromDb() {
- if (!browser) return;
- if (!db) await initDb();
- if (!db) return;
- const rows = await db!.select().from(transactionReceiptsTable);
- const loaded: Record = {};
- for (const row of rows) {
- loaded[`${row.chainId}:${row.txHash}`] = row.receipt;
- }
- this.transactionReceipts = loaded;
- }
-
- async saveTransactionReceipt(chainId: number | bigint, txHash: `0x${string}`, receipt: unknown) {
- if (!browser) return;
- if (!db) await initDb();
- if (!db) return;
- const chainIdNumber = Number(chainId);
- const serializedReceipt = JSON.stringify(receipt, (_key, value) =>
- typeof value === "bigint" ? value.toString() : value
- );
- const existing = await db!
- .select()
- .from(transactionReceiptsTable)
- .where(
- and(
- eq(transactionReceiptsTable.chainId, chainIdNumber),
- eq(transactionReceiptsTable.txHash, txHash)
- )
- );
- if (existing.length > 0) {
- await db!
- .update(transactionReceiptsTable)
- .set({ receipt: serializedReceipt })
- .where(
- and(
- eq(transactionReceiptsTable.chainId, chainIdNumber),
- eq(transactionReceiptsTable.txHash, txHash)
- )
- );
- } else {
- await db!.insert(transactionReceiptsTable).values({
- id: typeof crypto !== "undefined" ? crypto.randomUUID() : String(Date.now()),
- chainId: chainIdNumber,
- txHash,
- receipt: serializedReceipt,
- createdAt: Math.floor(Date.now() / 1000)
- });
- }
- this.transactionReceipts[`${chainIdNumber}:${txHash}`] = serializedReceipt;
- }
-
- getTransactionReceipt(chainId: number | bigint, txHash: `0x${string}`) {
- const serialized = this.transactionReceipts[`${Number(chainId)}:${txHash}`];
- if (!serialized) return undefined;
- try {
- return JSON.parse(serialized) as unknown;
- } catch (error) {
- console.warn("parse cached transaction receipt failed", {
- chainId: Number(chainId),
- txHash,
- error
- });
- return undefined;
- }
- }
-
- wallets = onboard.state.select("wallets");
- activeWallet = $state<{ wallet?: WalletState }>({});
- connectedAccount = $derived(this.activeWallet.wallet?.accounts?.[0]);
- walletClient = $derived(
- this.activeWallet?.wallet?.provider
- ? createWalletClient({ transport: custom(this.activeWallet.wallet.provider) })
- : undefined
- )!;
-
- inputTokens = $state([]);
- outputTokens = $state([]);
- fillTransactions = $state<{ [outputId: string]: `0x${string}` }>({});
- transactionReceipts = $state>({});
-
- refreshEpoch = $state(0);
- rpcRefreshMs = 45_000;
- _rpcRefreshHandle?: ReturnType;
-
- balances = $derived.by(() => {
- this.refreshEpoch;
- const account = this.connectedAccount?.address;
- return this.mapOverCoinsCached({
- bucket: "balance",
- ttlMs: 30_000,
- isMainnet: this.mainnet,
- scopeKey: account ?? "none",
- fetcher: (asset, client) => getBalance(account, asset, client)
- });
- });
-
- allowances = $derived.by(() => {
- this.refreshEpoch;
- const account = this.connectedAccount?.address;
- const spender =
- this.inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
- this.inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT
- ? COMPACT
- : this.inputSettler;
- return this.mapOverCoinsCached({
- bucket: "allowance",
- ttlMs: 60_000,
- isMainnet: this.mainnet,
- scopeKey: `${account ?? "none"}:${spender}`,
- fetcher: (asset, client) => getAllowance(spender)(account, asset, client)
- });
- });
-
- compactBalances = $derived.by(() => {
- this.refreshEpoch;
- const account = this.connectedAccount?.address;
- const allocatorId = this.allocatorId;
- return this.mapOverCoinsCached({
- bucket: "compact",
- ttlMs: 60_000,
- isMainnet: this.mainnet,
- scopeKey: `${account ?? "none"}:${allocatorId}`,
- fetcher: (asset, client) => getCompactBalance(account, asset, client, allocatorId)
- });
- });
-
- multichain = $derived([...new Set(this.inputTokens.map((i) => i.token.chain))].length > 1);
-
- inputSettler = $derived.by(() => {
- if (this.intentType === "escrow" && !this.multichain) return INPUT_SETTLER_ESCROW_LIFI;
- if (this.intentType === "escrow" && this.multichain) return MULTICHAIN_INPUT_SETTLER_ESCROW;
- if (this.intentType === "compact" && !this.multichain) return INPUT_SETTLER_COMPACT_LIFI;
- if (this.intentType === "compact" && this.multichain) return MULTICHAIN_INPUT_SETTLER_COMPACT;
- return INPUT_SETTLER_ESCROW_LIFI;
- });
- intentType = $state<"escrow" | "compact">("escrow");
- allocatorId = $state(ALWAYS_OK_ALLOCATOR);
- verifier = $state("polymer");
- exclusiveFor: string = $state("");
- useExclusiveForQuoteRequest = $state(false);
-
- invalidateWalletReadCache(scope: "all" | "balance" | "allowance" | "compact" = "all") {
- if (scope === "all" || scope === "balance") invalidateRpcPrefix("balance:");
- if (scope === "all" || scope === "allowance") invalidateRpcPrefix("allowance:");
- if (scope === "all" || scope === "compact") invalidateRpcPrefix("compact:");
- }
-
- refreshWalletReads(opts?: {
- force?: boolean;
- scope?: "all" | "balance" | "allowance" | "compact";
- }) {
- const force = opts?.force ?? false;
- const scope = opts?.scope ?? "all";
- if (force) this.invalidateWalletReadCache(scope);
- this.refreshEpoch += 1;
- }
-
- refreshTokenBalance(token: Token, force = true) {
- if (force) {
- invalidateRpcPrefix(
- `balance:${this.mainnet ? "mainnet" : "testnet"}:${token.chain}:${token.address}:`
- );
- }
- this.refreshEpoch += 1;
- }
-
- refreshTokenAllowance(token: Token, force = true) {
- if (force) {
- invalidateRpcPrefix(
- `allowance:${this.mainnet ? "mainnet" : "testnet"}:${token.chain}:${token.address}:`
- );
- }
- this.refreshEpoch += 1;
- }
-
- refreshCompactBalance(token: Token, force = true) {
- if (force) {
- invalidateRpcPrefix(
- `compact:${this.mainnet ? "mainnet" : "testnet"}:${token.chain}:${token.address}:`
- );
- }
- this.refreshEpoch += 1;
- }
-
- forceUpdate = () => {
- this.refreshWalletReads({ force: true, scope: "all" });
- };
-
- syncIntervalMs = 5000;
- _syncHandle?: ReturnType;
-
- startSync(intervalMs?: number) {
- this.stopSync();
- this._syncHandle = setInterval(() => {
- this.loadOrdersFromDb().catch((e) => console.warn("sync error", e));
- }, intervalMs ?? this.syncIntervalMs);
- }
-
- stopSync() {
- if (this._syncHandle) {
- clearInterval(this._syncHandle);
- this._syncHandle = undefined;
- }
- }
-
- startRpcRefreshLoop(intervalMs?: number) {
- if (!browser) return;
- this.stopRpcRefreshLoop();
- this._rpcRefreshHandle = setInterval(() => {
- this.refreshWalletReads();
- }, intervalMs ?? this.rpcRefreshMs);
- }
-
- stopRpcRefreshLoop() {
- if (this._rpcRefreshHandle) {
- clearInterval(this._rpcRefreshHandle);
- this._rpcRefreshHandle = undefined;
- }
- }
-
- async setWalletToCorrectChain(chain: chain) {
- try {
- return await this.walletClient?.switchChain({ id: chainMap[chain].id });
- } catch (error) {
- console.warn(
- `Wallet does not support switchChain or failed to switch chain: ${chainMap[chain].id}`,
- error
- );
- return undefined;
- }
- }
-
- mapOverCoinsCached(opts: {
- bucket: "balance" | "allowance" | "compact";
- ttlMs: number;
- isMainnet: boolean;
- scopeKey: string;
- fetcher: (asset: `0x${string}`, client: (typeof clients)[keyof typeof clients]) => Promise;
- }) {
- const { bucket, ttlMs, isMainnet, scopeKey, fetcher } = opts;
- const resolved: Record>> = {} as any;
- for (const token of coinList(isMainnet)) {
- if (!resolved[token.chain as chain]) resolved[token.chain] = {};
- const key = `${bucket}:${isMainnet ? "mainnet" : "testnet"}:${token.chain}:${token.address}:${scopeKey}`;
- resolved[token.chain][token.address] = getOrFetchRpc(
- key,
- () => fetcher(token.address, clients[token.chain]),
- { ttlMs }
- );
- }
- return resolved;
- }
-
- dbReady: Promise | undefined;
-
- constructor() {
- this.inputTokens = [{ token: coinList(this.mainnet)[0], amount: 1000000n }];
- this.outputTokens = [{ token: coinList(this.mainnet)[1], amount: 1000000n }];
-
- this.wallets.subscribe((v) => {
- this.activeWallet.wallet = v?.[0];
- });
-
- this.startRpcRefreshLoop();
-
- this.dbReady = browser
- ? Promise.all([
- this.loadOrdersFromDb().catch((e) => console.warn("loadOrdersFromDb error", e)),
- this.loadFillTransactionsFromDb().catch((e) =>
- console.warn("loadFillTransactionsFromDb error", e)
- ),
- this.loadTransactionReceiptsFromDb().catch((e) =>
- console.warn("loadTransactionReceiptsFromDb error", e)
- )
- ]).then(() => {})
- : Promise.resolve();
- }
+ mainnet = $state(true);
+ useProductionApi = $state(null);
+ orders = $state([]);
+
+ async loadOrdersFromDb() {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ const rows = await db!.select().from(intents);
+ this.orders = rows.map((r) => JSON.parse(r.data) as OrderContainer);
+ }
+
+ async saveOrderToDb(order: OrderContainerWithMeta) {
+ if (!browser) return;
+ if (!db) await initDb();
+ const orderId = containerToIntent(order).orderId();
+ const now = Math.floor(Date.now() / 1000);
+ const id = order.id ?? generateUUID();
+ const intentType = order.intentType ?? "escrow";
+ const data = JSON.stringify(order);
+ if (db) {
+ try {
+ try {
+ await db
+ .insert(intents)
+ .values({
+ id,
+ orderId,
+ intentType,
+ data,
+ createdAt: now
+ })
+ .onConflictDoUpdate({
+ target: intents.orderId,
+ set: { intentType, data }
+ });
+ } catch (_error) {
+ const existing = await db.select().from(intents).where(eq(intents.orderId, orderId));
+ if (existing.length > 0) {
+ await db.update(intents).set({ intentType, data }).where(eq(intents.orderId, orderId));
+ } else {
+ await db.insert(intents).values({
+ id,
+ orderId,
+ intentType,
+ data,
+ createdAt: now
+ });
+ }
+ }
+ } catch (error) {
+ console.warn("saveOrderToDb db write failed", { orderId, error });
+ }
+ }
+ const idx = this.orders.findIndex((o) => containerToIntent(o).orderId() === orderId);
+ if (idx >= 0) this.orders[idx] = order;
+ else this.orders.push(order);
+ }
+
+ async deleteOrderFromDb(orderId: string) {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ await db!.delete(intents).where(eq(intents.orderId, orderId));
+ await this.loadOrdersFromDb();
+ }
+
+ async loadFillTransactionsFromDb() {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ const rows = await db!.select().from(fillTransactionsTable);
+ const loaded: { [outputId: string]: `0x${string}` } = {};
+ for (const row of rows) loaded[row.outputHash] = row.txHash as `0x${string}`;
+ this.fillTransactions = loaded;
+ }
+
+ async saveFillTransaction(outputHash: string, txHash: `0x${string}`) {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ const existing = await db!
+ .select()
+ .from(fillTransactionsTable)
+ .where(eq(fillTransactionsTable.outputHash, outputHash));
+ if (existing.length > 0) {
+ await db!
+ .update(fillTransactionsTable)
+ .set({ txHash })
+ .where(eq(fillTransactionsTable.outputHash, outputHash));
+ } else {
+ await db!.insert(fillTransactionsTable).values({
+ id: generateUUID(),
+ outputHash,
+ txHash
+ });
+ }
+ }
+
+ async loadTransactionReceiptsFromDb() {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ const rows = await db!.select().from(transactionReceiptsTable);
+ const loaded: Record = {};
+ for (const row of rows) {
+ loaded[`${row.chainId}:${row.txHash}`] = row.receipt;
+ }
+ this.transactionReceipts = loaded;
+ }
+
+ async saveTransactionReceipt(chainId: number | bigint, txHash: `0x${string}`, receipt: unknown) {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ const chainIdNumber = Number(chainId);
+ const serializedReceipt = JSON.stringify(receipt, (_key, value) =>
+ typeof value === "bigint" ? value.toString() : value
+ );
+ const existing = await db!
+ .select()
+ .from(transactionReceiptsTable)
+ .where(
+ and(
+ eq(transactionReceiptsTable.chainId, chainIdNumber),
+ eq(transactionReceiptsTable.txHash, txHash)
+ )
+ );
+ if (existing.length > 0) {
+ await db!
+ .update(transactionReceiptsTable)
+ .set({ receipt: serializedReceipt })
+ .where(
+ and(
+ eq(transactionReceiptsTable.chainId, chainIdNumber),
+ eq(transactionReceiptsTable.txHash, txHash)
+ )
+ );
+ } else {
+ await db!.insert(transactionReceiptsTable).values({
+ id: typeof crypto !== "undefined" ? crypto.randomUUID() : String(Date.now()),
+ chainId: chainIdNumber,
+ txHash,
+ receipt: serializedReceipt,
+ createdAt: Math.floor(Date.now() / 1000)
+ });
+ }
+ this.transactionReceipts[`${chainIdNumber}:${txHash}`] = serializedReceipt;
+ }
+
+ getTransactionReceipt(chainId: number | bigint, txHash: `0x${string}`) {
+ const serialized = this.transactionReceipts[`${Number(chainId)}:${txHash}`];
+ if (!serialized) return undefined;
+ try {
+ return JSON.parse(serialized) as GetTransactionReceiptReturnType;
+ } catch (error) {
+ console.warn("parse cached transaction receipt failed", {
+ chainId: Number(chainId),
+ txHash,
+ error
+ });
+ return undefined;
+ }
+ }
+
+ walletConnection = $state(getCurrentConnection());
+ connectedAccount = $derived(
+ this.walletConnection.status === "connected"
+ ? { address: this.walletConnection.address }
+ : undefined
+ );
+ walletClient = $state(undefined as unknown as WC);
+ _unwatchWalletConnection?: () => void;
+
+ availableTokens = $state([...(coinList(true) as readonly Token[])]);
+ manualTokenKeys = $state>(new Set());
+ inputTokens = $state([]);
+ outputTokens = $state([]);
+ fillTransactions = $state<{ [outputId: string]: `0x${string}` }>({});
+ transactionReceipts = $state>({});
+
+ refreshEpoch = $state(0);
+ rpcRefreshMs = 45_000;
+ _rpcRefreshHandle?: ReturnType;
+
+ balances = $derived.by(() => {
+ this.refreshEpoch;
+ const account = this.connectedAccount?.address;
+ return this.mapOverCoinsCached({
+ bucket: "balance",
+ ttlMs: 30_000,
+ isMainnet: this.mainnet,
+ scopeKey: account ?? "none",
+ fetcher: (asset, client) => getBalance(account, asset, client)
+ });
+ });
+
+ allowances = $derived.by(() => {
+ this.refreshEpoch;
+ const account = this.connectedAccount?.address;
+ const spender =
+ this.inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
+ this.inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT
+ ? COMPACT
+ : this.inputSettler;
+ return this.mapOverCoinsCached({
+ bucket: "allowance",
+ ttlMs: 60_000,
+ isMainnet: this.mainnet,
+ scopeKey: `${account ?? "none"}:${spender}`,
+ fetcher: (asset, client) => getAllowance(spender)(account, asset, client)
+ });
+ });
+
+ compactBalances = $derived.by(() => {
+ this.refreshEpoch;
+ const account = this.connectedAccount?.address;
+ const allocatorId = this.allocatorId;
+ return this.mapOverCoinsCached({
+ bucket: "compact",
+ ttlMs: 60_000,
+ isMainnet: this.mainnet,
+ scopeKey: `${account ?? "none"}:${allocatorId}`,
+ fetcher: (asset, client) => getCompactBalance(account, asset, client, allocatorId)
+ });
+ });
+
+ multichain = $derived([...new Set(this.inputTokens.map((i) => i.token.chainId))].length > 1);
+
+ inputSettler = $derived.by(() => {
+ if (this.intentType === "escrow" && !this.multichain) return INPUT_SETTLER_ESCROW_LIFI;
+ if (this.intentType === "escrow" && this.multichain) return MULTICHAIN_INPUT_SETTLER_ESCROW;
+ if (this.intentType === "compact" && !this.multichain) return INPUT_SETTLER_COMPACT_LIFI;
+ if (this.intentType === "compact" && this.multichain) return MULTICHAIN_INPUT_SETTLER_COMPACT;
+ return INPUT_SETTLER_ESCROW_LIFI;
+ });
+ intentType = $state<"escrow" | "compact">("escrow");
+ allocatorId = $state(ALWAYS_OK_ALLOCATOR);
+ verifier = $state("polymer");
+ exclusiveFor: string = $state("");
+ recipient: string = $state("");
+ useExclusiveForQuoteRequest = $state(false);
+
+ invalidateWalletReadCache(scope: "all" | "balance" | "allowance" | "compact" = "all") {
+ if (scope === "all" || scope === "balance") invalidateRpcPrefix("balance:");
+ if (scope === "all" || scope === "allowance") invalidateRpcPrefix("allowance:");
+ if (scope === "all" || scope === "compact") invalidateRpcPrefix("compact:");
+ }
+
+ refreshWalletReads(opts?: {
+ force?: boolean;
+ scope?: "all" | "balance" | "allowance" | "compact";
+ }) {
+ const force = opts?.force ?? false;
+ const scope = opts?.scope ?? "all";
+ if (force) this.invalidateWalletReadCache(scope);
+ this.refreshEpoch += 1;
+ }
+
+ refreshTokenBalance(token: Token, force = true) {
+ if (force) {
+ invalidateRpcPrefix(
+ `balance:${this.mainnet ? "mainnet" : "testnet"}:${token.chainId}:${token.address}:`
+ );
+ }
+ this.refreshEpoch += 1;
+ }
+
+ refreshTokenAllowance(token: Token, force = true) {
+ if (force) {
+ invalidateRpcPrefix(
+ `allowance:${this.mainnet ? "mainnet" : "testnet"}:${token.chainId}:${token.address}:`
+ );
+ }
+ this.refreshEpoch += 1;
+ }
+
+ refreshCompactBalance(token: Token, force = true) {
+ if (force) {
+ invalidateRpcPrefix(
+ `compact:${this.mainnet ? "mainnet" : "testnet"}:${token.chainId}:${token.address}:`
+ );
+ }
+ this.refreshEpoch += 1;
+ }
+
+ forceUpdate = () => {
+ this.refreshWalletReads({ force: true, scope: "all" });
+ };
+
+ syncIntervalMs = 5000;
+ _syncHandle?: ReturnType;
+
+ startSync(intervalMs?: number) {
+ this.stopSync();
+ this._syncHandle = setInterval(() => {
+ this.loadOrdersFromDb().catch((e) => console.warn("sync error", e));
+ }, intervalMs ?? this.syncIntervalMs);
+ }
+
+ stopSync() {
+ if (this._syncHandle) {
+ clearInterval(this._syncHandle);
+ this._syncHandle = undefined;
+ }
+ }
+
+ startRpcRefreshLoop(intervalMs?: number) {
+ if (!browser) return;
+ this.stopRpcRefreshLoop();
+ this._rpcRefreshHandle = setInterval(() => {
+ this.refreshWalletReads();
+ }, intervalMs ?? this.rpcRefreshMs);
+ }
+
+ stopRpcRefreshLoop() {
+ if (this._rpcRefreshHandle) {
+ clearInterval(this._rpcRefreshHandle);
+ this._rpcRefreshHandle = undefined;
+ }
+ }
+
+ private async loadTokensFromDb(mainnet: boolean) {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ const rows = await db!.select().from(tokensTable).where(eq(tokensTable.isTestnet, !mainnet));
+ this.availableTokens = rows.map((r) => ({
+ address: r.address as `0x${string}`,
+ name: r.name,
+ chainId: r.chainId,
+ decimals: r.decimals
+ }));
+ this.manualTokenKeys = new Set(
+ rows.filter((r) => r.isManual).map((r) => `${r.chainId}:${r.address.toLowerCase()}`)
+ );
+ }
+
+ async syncConfiguredTokens() {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+
+ const mainnetTokens = [...(coinList(true) as readonly Token[])];
+ const testnetTokens = [...(coinList(false) as readonly Token[])];
+ const allConfigured = [
+ ...mainnetTokens.map((t) => ({ ...t, isTestnet: false })),
+ ...testnetTokens.map((t) => ({ ...t, isTestnet: true }))
+ ];
+
+ // Upsert all configured tokens
+ for (const t of allConfigured) {
+ const id = `${t.chainId}:${t.address.toLowerCase()}`;
+ try {
+ await db!
+ .insert(tokensTable)
+ .values({
+ id,
+ address: t.address,
+ name: t.name,
+ chainId: t.chainId,
+ decimals: t.decimals,
+ isManual: false,
+ isTestnet: t.isTestnet
+ })
+ .onConflictDoUpdate({
+ target: tokensTable.id,
+ set: { name: t.name, decimals: t.decimals, isTestnet: t.isTestnet, isManual: false }
+ });
+ } catch (_e) {
+ // ignore individual upsert errors
+ }
+ }
+
+ // Delete stale non-manual tokens not in current configured lists
+ const configuredIds = allConfigured.map((t) => `${t.chainId}:${t.address.toLowerCase()}`);
+ try {
+ await db!
+ .delete(tokensTable)
+ .where(and(eq(tokensTable.isManual, false), notInArray(tokensTable.id, configuredIds)));
+ } catch (_e) {
+ // ignore
+ }
+
+ await this.loadTokensFromDb(this.mainnet);
+ }
+
+ async addCustomToken(token: Token) {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ const isTestnet = isChainIdTestnet(token.chainId);
+ const id = `${token.chainId}:${token.address.toLowerCase()}`;
+ try {
+ await db!
+ .insert(tokensTable)
+ .values({
+ id,
+ address: token.address,
+ name: token.name,
+ chainId: token.chainId,
+ decimals: token.decimals,
+ isManual: true,
+ isTestnet
+ })
+ .onConflictDoUpdate({
+ target: tokensTable.id,
+ set: { name: token.name, decimals: token.decimals, isManual: true }
+ });
+ } catch (_e) {
+ // fallback update
+ await db!
+ .update(tokensTable)
+ .set({ name: token.name, decimals: token.decimals, isManual: true })
+ .where(eq(tokensTable.id, id));
+ }
+ await this.loadTokensFromDb(this.mainnet);
+ }
+
+ async removeCustomToken(address: string, chainId: number) {
+ if (!browser) return;
+ if (!db) await initDb();
+ if (!db) return;
+ await db!
+ .delete(tokensTable)
+ .where(
+ and(
+ eq(tokensTable.address, address),
+ eq(tokensTable.chainId, chainId),
+ eq(tokensTable.isManual, true)
+ )
+ );
+ await this.loadTokensFromDb(this.mainnet);
+ }
+
+ async syncTokensForNetwork(mainnet: boolean) {
+ await this.loadTokensFromDb(mainnet);
+ }
+
+ async syncWalletClient() {
+ if (this.walletConnection.status !== "connected") {
+ this.walletClient = undefined as unknown as WC;
+ return;
+ }
+ try {
+ this.walletClient = (await getCurrentWalletClient()) as unknown as WC;
+ } catch (error) {
+ console.warn("getCurrentWalletClient failed", error);
+ this.walletClient = undefined as unknown as WC;
+ }
+ }
+
+ async setWalletToCorrectChain(chainId: number | bigint) {
+ try {
+ return await switchWalletChain(this.walletClient, Number(chainId));
+ } catch (error) {
+ console.warn(
+ `Wallet does not support switchChain or failed to switch chain: ${Number(chainId)}`,
+ error
+ );
+ return undefined;
+ }
+ }
+
+ mapOverCoinsCached(opts: {
+ bucket: "balance" | "allowance" | "compact";
+ ttlMs: number;
+ isMainnet: boolean;
+ scopeKey: string;
+ fetcher: (
+ asset: `0x${string}`,
+ client: (typeof clientsById)[keyof typeof clientsById]
+ ) => Promise;
+ }) {
+ const { bucket, ttlMs, isMainnet, scopeKey, fetcher } = opts;
+ const resolved: Record>> = {};
+ for (const token of this.availableTokens) {
+ if (!resolved[token.chainId]) resolved[token.chainId] = {};
+ const key = `${bucket}:${isMainnet ? "mainnet" : "testnet"}:${token.chainId}:${token.address}:${scopeKey}`;
+ resolved[token.chainId][token.address] = getOrFetchRpc(
+ key,
+ () => fetcher(token.address, clientsById[token.chainId]),
+ { ttlMs }
+ );
+ }
+ return resolved;
+ }
+
+ dbReady: Promise | undefined;
+
+ constructor() {
+ this.availableTokens = [...(coinList(this.mainnet) as readonly Token[])];
+ this.inputTokens = [{ token: this.availableTokens[0], amount: 1000000n }];
+ this.outputTokens = [{ token: this.availableTokens[1], amount: 1000000n }];
+
+ if (browser) {
+ reconnectWallet()
+ .catch((error) => console.warn("reconnectWallet failed", error))
+ .finally(() => {
+ this.walletConnection = getCurrentConnection();
+ this.syncWalletClient().catch((error) => console.warn("syncWalletClient failed", error));
+ });
+
+ this._unwatchWalletConnection = watchWalletConnection((connection) => {
+ this.walletConnection = connection;
+ this.syncWalletClient().catch((error) => console.warn("syncWalletClient failed", error));
+ });
+ }
+
+ this.startRpcRefreshLoop();
+
+ this.dbReady = browser
+ ? Promise.all([
+ this.loadOrdersFromDb().catch((e) => console.warn("loadOrdersFromDb error", e)),
+ this.loadFillTransactionsFromDb().catch((e) =>
+ console.warn("loadFillTransactionsFromDb error", e)
+ ),
+ this.loadTransactionReceiptsFromDb().catch((e) =>
+ console.warn("loadTransactionReceiptsFromDb error", e)
+ ),
+ this.syncConfiguredTokens().catch((e) => console.warn("syncConfiguredTokens error", e))
+ ]).then(() => {})
+ : Promise.resolve();
+ }
}
export const store = new Store();
diff --git a/src/lib/utils/convert.ts b/src/lib/utils/convert.ts
deleted file mode 100644
index ee97ecc..0000000
--- a/src/lib/utils/convert.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-// --- Type conversion helpers --- //
-
-import { checksumAddress } from "viem";
-
-export function toBigIntWithDecimals(value: number, decimals: number): bigint {
- // Convert number to string in full precision
- const [intPart, decPart = ""] = value.toString().split(".");
-
- // Take up to `decimals` digits of the decimal part
- const truncatedDec = decPart.slice(0, decimals);
-
- // Pad the decimal part to ensure we have exactly `decimals` digits
- const paddedDec = truncatedDec.padEnd(decimals, "0");
-
- // Remove leading zeros from intPart just in case
- const normalizedInt = intPart.replace(/^(-?)0+(?=\d)/, "$1");
- // Combine parts
- const combined = (normalizedInt + paddedDec).replace(".", "");
-
- return BigInt(combined);
-}
-
-export function addressToBytes32(address: `0x${string}`): `0x${string}` {
- if (address.length !== 42 && address.length !== 40) {
- throw new Error(`Invalid address length: ${address.length}`);
- }
- return `0x${address.replace("0x", "").padStart(64, "0")}`;
-}
-
-export function bytes32ToAddress(bytes: `0x${string}`): `0x${string}` {
- if (bytes.length != 66 && bytes.length != 64) {
- throw new Error(`Invalid bytes length: ${bytes.length}`);
- }
- return `0x${bytes.replace("0x", "").slice(24, 64)}`;
-}
-
-export function idToToken(id: `0x${string}` | bigint): `0x${string}` {
- if (typeof id === "string" && id.indexOf("0x") != 0) {
- id = BigInt(id);
- }
- if (typeof id === "bigint") {
- // Convert bigint to hex string and pad it to 64 characters.
- id = `0x${id.toString(16).padStart(64, "0")}`;
- }
- // Remove the first 12 bytes (24 hex characters) and keep the last 20 bytes (40 hex characters).
- return checksumAddress(bytes32ToAddress(id));
-}
-
-export function trunc(value: `0x${string}`, length: number = 6): `0x${string}...${string}` {
- return `0x${value.replace("0x", "").slice(0, length)}...${value
- .replace("0x", "")
- .slice(-length)}`;
-}
diff --git a/src/lib/utils/idLib.ts b/src/lib/utils/idLib.ts
deleted file mode 100644
index 3f1010e..0000000
--- a/src/lib/utils/idLib.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import { getAddress, hexToBigInt } from "viem";
-
-// source: https://github.com/Uniswap/CompactX/blob/main/src/utils/lockId.ts#L17
-
-export enum ResetPeriod {
- OneSecond = 0,
- FifteenSeconds,
- OneMinute,
- TenMinutes,
- OneHourAndFiveMinutes,
- OneDay,
- SevenDaysAndOneHour,
- ThirtyDays
-}
-
-/**
- * Converts lock parameters to a unique ID.
- * The ID consists of:
- * - Bit 255: scope (0 for multichain, 1 for single chain)
- * - Bits 252-254: reset period
- * - Bits 160-251: allocator ID (92 bits)
- * - Bits 0-159: token address (20 bytes = 160 bits)
- *
- * @param inputChains Whether the lock is multichain (maps to scope)
- * @param resetPeriod Reset period (0-7)
- * @param allocatorId Allocator ID as string
- * @param token Token address as hex string
- * @returns The derived resource lock ID as a BigInt
- */
-export function toId(
- inputChains: boolean,
- resetPeriod: number,
- allocatorId: string,
- token: string
-): bigint {
- // Validate inputs
- if (resetPeriod < 0 || resetPeriod > 7) {
- throw new Error("Reset period must be between 0 and 7");
- }
- // Validate token is a valid address and normalize it
- const normalizedToken = getAddress(token);
-
- // Convert inputChains to scope (inverse relationship)
- const scope = inputChains ? 0n : 1n;
-
- // Convert allocatorId from decimal string to BigInt
- const allocatorBigInt = BigInt(allocatorId);
- if (allocatorBigInt > (1n << 92n) - 1n) {
- throw new Error("AllocatorId must fit in 92 bits");
- }
-
- // Convert token address to BigInt using viem
- const tokenBigInt = hexToBigInt(normalizedToken);
-
- // Perform bitwise operations
- const scopeBits = scope << 255n;
- const resetPeriodBits = BigInt(resetPeriod) << 252n;
- const allocatorBits = allocatorBigInt << 160n;
-
- // Combine all bits using bitwise OR
- const id = scopeBits | resetPeriodBits | allocatorBits | tokenBigInt;
-
- return id;
-}
diff --git a/src/lib/utils/intent.ts b/src/lib/utils/intent.ts
new file mode 100644
index 0000000..8d2f266
--- /dev/null
+++ b/src/lib/utils/intent.ts
@@ -0,0 +1,29 @@
+import {
+ orderToIntent,
+ SOLANA_MAINNET_CHAIN_ID,
+ SOLANA_TESTNET_CHAIN_ID,
+ SOLANA_DEVNET_CHAIN_ID,
+ StandardEVMIntent,
+ StandardSolanaIntent,
+ MultichainOrderIntent
+} from "@lifi/intent";
+import type { OrderContainer } from "@lifi/intent";
+
+const SOLANA_CHAIN_IDS = new Set([
+ SOLANA_MAINNET_CHAIN_ID,
+ SOLANA_TESTNET_CHAIN_ID,
+ SOLANA_DEVNET_CHAIN_ID
+]);
+
+export function containerToIntent(
+ container: OrderContainer
+): StandardEVMIntent | StandardSolanaIntent | MultichainOrderIntent {
+ const { inputSettler, order } = container;
+ if (!("originChainId" in order)) {
+ return orderToIntent({ namespace: "eip155", inputSettler, order });
+ }
+ if (SOLANA_CHAIN_IDS.has(order.originChainId)) {
+ return orderToIntent({ namespace: "solana", inputSettler, order });
+ }
+ return orderToIntent({ namespace: "eip155", inputSettler, order });
+}
diff --git a/src/lib/utils/interopableAddresses.ts b/src/lib/utils/interopableAddresses.ts
deleted file mode 100644
index 0ff6e4b..0000000
--- a/src/lib/utils/interopableAddresses.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-function padEven(s: string, minimal = 2, pad: string = "0") {
- return s.padStart(((Math.max(s.length + 1, minimal) / 2) | 0) * 2, pad);
-}
-
-export function toHex(
- num: number | bigint,
- bytes: number = 1,
- prefix?: T
-): `${T}${string}` {
- const p = (prefix ?? "") as T;
- return `${p}${padEven(num.toString(16), bytes * 2)}` as `${T}${string}`;
-}
-
-type Version = "0001";
-type ChainType = "0000";
-type ChainReferenceLength = string;
-type ChainReference = string;
-type Address = string;
-
-export type InteropableAddress =
- `0x${Version}${ChainType}${ChainReferenceLength}${ChainReference}${Address}`;
-
-export const getInteropableAddress = (
- address: `0x${string}`,
- chainId: number | bigint
-): InteropableAddress => {
- const version = "0001";
- const chainType = "0000";
-
- const chainReference = padEven(chainId.toString(16));
- const chainReferenceLength = toHex(chainReference.length / 2);
-
- return `0x${version}${chainType}${chainReferenceLength}${chainReference}${toHex(
- address.replace("0x", "").length / 2
- )}${address.replace("0x", "")}`;
-};
diff --git a/src/lib/utils/orderLib.ts b/src/lib/utils/orderLib.ts
deleted file mode 100644
index 21b387d..0000000
--- a/src/lib/utils/orderLib.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-import { encodeAbiParameters, encodePacked, keccak256, parseAbiParameters } from "viem";
-import type { MandateOutput, MultichainOrder, OrderContainer, StandardOrder } from "../../types";
-import {
- BYTES32_ZERO,
- type chain,
- chainMap,
- COIN_FILLER,
- INPUT_SETTLER_COMPACT_LIFI,
- MULTICHAIN_INPUT_SETTLER_COMPACT,
- POLYMER_ORACLE,
- WORMHOLE_ORACLE
-} from "../config";
-import { addressToBytes32 } from "./convert";
-
-export type ValidationResult = {
- passed: boolean;
- reason: string;
-};
-
-export const VALIDATION_PASS_REASON = "Validation pass" as const;
-
-export const VALIDATION_ERRORS = {
- FILL_DEADLINE_AFTER_EXPIRES: "fillDeadline > expires",
- UNKNOWN_ORIGIN_CHAIN: "input chain",
- INPUT_ORACLE_NOT_ALLOWED: "inputOracle",
- NO_INPUTS: "inputs",
- INVALID_INPUT_TUPLE: "inputs",
- INPUT_AMOUNT_NON_POSITIVE: "input amount",
- NO_OUTPUTS: "outputs",
- UNKNOWN_OUTPUT_CHAIN: "output chain",
- OUTPUT_AMOUNT_NON_POSITIVE: "output amount",
- OUTPUT_ORACLE_ZERO: "output oracle",
- OUTPUT_ORACLE_NOT_ALLOWED: "output oracle",
- OUTPUT_SETTLER_ZERO: "output settler",
- OUTPUT_SETTLER_NOT_ALLOWED: "output settler",
- OUTPUT_TOKEN_ZERO: "output token",
- OUTPUT_RECIPIENT_ZERO: "output recipient"
-} as const;
-
-export function getOutputHash(output: MandateOutput) {
- return keccak256(
- encodePacked(
- [
- "bytes32",
- "bytes32",
- "uint256",
- "bytes32",
- "uint256",
- "bytes32",
- "uint16",
- "bytes",
- "uint16",
- "bytes"
- ],
- [
- output.oracle,
- output.settler,
- output.chainId,
- output.token,
- output.amount,
- output.recipient,
- output.callbackData.replace("0x", "").length / 2,
- output.callbackData,
- output.context.replace("0x", "").length / 2,
- output.context
- ]
- )
- );
-}
-
-export function encodeMandateOutput(
- solver: `0x${string}`,
- orderId: `0x${string}`,
- timestamp: number,
- output: MandateOutput
-) {
- return encodePacked(
- [
- "bytes32",
- "bytes32",
- "uint32",
- "bytes32",
- "uint256",
- "bytes32",
- "uint16",
- "bytes",
- "uint16",
- "bytes"
- ],
- [
- solver,
- orderId,
- timestamp,
- output.token,
- output.amount,
- output.recipient,
- output.callbackData.replace("0x", "").length / 2,
- output.callbackData,
- output.context.replace("0x", "").length / 2,
- output.context
- ]
- );
-}
-
-function findChainById(chainId: bigint): chain | undefined {
- const numericChainId = Number(chainId);
- if (!Number.isInteger(numericChainId) || numericChainId <= 0) return undefined;
- return Object.entries(chainMap).find(([, value]) => value.id === numericChainId)?.[0] as
- | chain
- | undefined;
-}
-
-function normalize(value: string) {
- return value.toLowerCase();
-}
-
-function isZeroBytes32(value: string) {
- return normalize(value) === normalize(BYTES32_ZERO);
-}
-
-function getAllowedInputOracles(inputChain: chain, sameChainFill: boolean): string[] {
- const allowed: string[] = [];
- const polymer = POLYMER_ORACLE[inputChain as keyof typeof POLYMER_ORACLE];
- if (polymer) allowed.push(polymer);
- const wormhole = WORMHOLE_ORACLE[inputChain as keyof typeof WORMHOLE_ORACLE];
- if (wormhole && normalize(wormhole) !== "0x0000000000000000000000000000000000000000") {
- allowed.push(wormhole);
- }
- if (sameChainFill) allowed.push(COIN_FILLER);
- return allowed.map(normalize);
-}
-
-function getAllowedOutputOracles(outputChain: chain): string[] {
- const allowed: string[] = [addressToBytes32(COIN_FILLER)];
- const polymer = POLYMER_ORACLE[outputChain as keyof typeof POLYMER_ORACLE];
- if (polymer) allowed.push(addressToBytes32(polymer));
- const wormhole = WORMHOLE_ORACLE[outputChain as keyof typeof WORMHOLE_ORACLE];
- if (wormhole && normalize(wormhole) !== "0x0000000000000000000000000000000000000000") {
- allowed.push(addressToBytes32(wormhole));
- }
- return allowed.map(normalize);
-}
-
-function getAllowedOutputSettlers(): string[] {
- return [addressToBytes32(COIN_FILLER)].map(normalize);
-}
-
-function pass(): ValidationResult {
- return { passed: true, reason: VALIDATION_PASS_REASON };
-}
-
-function fail(reason: string): ValidationResult {
- return { passed: false, reason };
-}
-
-/// https://docs.li.fi/lifi-intents/for-solvers/orderflow#order-validation
-export function validateOrderWithReason(order: StandardOrder): ValidationResult {
- // 1-2. temporal consistency only
- if (order.fillDeadline > order.expires)
- return fail(VALIDATION_ERRORS.FILL_DEADLINE_AFTER_EXPIRES);
-
- // 3. validation layer
- const inputChain = findChainById(order.originChainId);
- if (!inputChain) return fail(VALIDATION_ERRORS.UNKNOWN_ORIGIN_CHAIN);
- const sameChainFill = order.outputs.every((output) => output.chainId === order.originChainId);
- const allowedInputOracles = getAllowedInputOracles(inputChain, sameChainFill);
- if (!allowedInputOracles.includes(normalize(order.inputOracle))) {
- return fail(VALIDATION_ERRORS.INPUT_ORACLE_NOT_ALLOWED);
- }
-
- // 4. inputs
- if (!Array.isArray(order.inputs) || order.inputs.length === 0)
- return fail(VALIDATION_ERRORS.NO_INPUTS);
- for (const input of order.inputs) {
- if (!Array.isArray(input) || input.length !== 2)
- return fail(VALIDATION_ERRORS.INVALID_INPUT_TUPLE);
- const [, amount] = input;
- if (amount <= 0n) return fail(VALIDATION_ERRORS.INPUT_AMOUNT_NON_POSITIVE);
- }
-
- // 5. lock ID semantics are not validated yet.
- // TODO: validate lock IDs for escrow/compact compatibility and token mapping.
- // 6. reset period semantics are not validated yet.
- // TODO: decode and validate reset period constraints from lock IDs.
- // 7. allocator ID policy is not validated yet.
- // TODO: enforce allocator policy rules for active environments.
- // 8. claim/signature verification is not validated here.
- // TODO: validate sponsor/allocator signatures when required.
-
- // 9. outputs
- if (!Array.isArray(order.outputs) || order.outputs.length === 0)
- return fail(VALIDATION_ERRORS.NO_OUTPUTS);
- for (const output of order.outputs) {
- const outputChain = findChainById(output.chainId);
- if (!outputChain) return fail(VALIDATION_ERRORS.UNKNOWN_OUTPUT_CHAIN);
- if (output.amount < 0n) return fail(VALIDATION_ERRORS.OUTPUT_AMOUNT_NON_POSITIVE);
- if (isZeroBytes32(output.oracle)) return fail(VALIDATION_ERRORS.OUTPUT_ORACLE_ZERO);
- const allowedOutputOracles = getAllowedOutputOracles(outputChain);
- if (!allowedOutputOracles.includes(normalize(output.oracle))) {
- return fail(VALIDATION_ERRORS.OUTPUT_ORACLE_NOT_ALLOWED);
- }
- if (isZeroBytes32(output.settler)) return fail(VALIDATION_ERRORS.OUTPUT_SETTLER_ZERO);
- const allowedOutputSettlers = getAllowedOutputSettlers();
- if (!allowedOutputSettlers.includes(normalize(output.settler))) {
- return fail(VALIDATION_ERRORS.OUTPUT_SETTLER_NOT_ALLOWED);
- }
- if (isZeroBytes32(output.token)) return fail(VALIDATION_ERRORS.OUTPUT_TOKEN_ZERO);
- if (isZeroBytes32(output.recipient)) return fail(VALIDATION_ERRORS.OUTPUT_RECIPIENT_ZERO);
- }
-
- // 11. allocatorData is not validated yet.
- // TODO: parse and validate allocatorData.
- // 12. nonce freshness/replay checks require chain state.
- // TODO: validate nonce freshness against chain state.
- return pass();
-}
-
-export function validateOrder(order: StandardOrder): boolean {
- return validateOrderWithReason(order).passed;
-}
-
-export function validateOrderContainerWithReason(orderContainer: OrderContainer): ValidationResult {
- const compactSettlers = [INPUT_SETTLER_COMPACT_LIFI, MULTICHAIN_INPUT_SETTLER_COMPACT].map(
- normalize
- );
- if (compactSettlers.includes(normalize(orderContainer.inputSettler))) {
- // TODO: implement compact validation from LI.FI orderflow docs.
- return pass();
- }
-
- if ("originChainId" in orderContainer.order) return validateOrderWithReason(orderContainer.order);
-
- return pass();
-}
-
-export function validateOrderContainer(orderContainer: OrderContainer): boolean {
- return validateOrderContainerWithReason(orderContainer).passed;
-}
diff --git a/src/lib/utils/typedMessage.ts b/src/lib/utils/typedMessage.ts
deleted file mode 100644
index d1f1ea0..0000000
--- a/src/lib/utils/typedMessage.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { keccak256, toHex } from "viem";
-
-const BatchCompact = [
- { name: "arbiter", type: "address" },
- { name: "sponsor", type: "address" },
- { name: "nonce", type: "uint256" },
- { name: "expires", type: "uint256" },
- { name: "commitments", type: "Lock[]" },
- { name: "mandate", type: "Mandate" }
-] as const;
-
-const MultichainCompact = [
- { name: "sponsor", type: "address" },
- { name: "nonce", type: "uint256" },
- { name: "expires", type: "uint256" },
- { name: "elements", type: "Element[]" }
-] as const;
-
-const Lock = [
- { name: "lockTag", type: "bytes12" },
- { name: "token", type: "address" },
- { name: "amount", type: "uint256" }
-] as const;
-
-const Element = [
- { name: "arbiter", type: "address" },
- { name: "chainId", type: "uint256" },
- { name: "commitments", type: "Lock[]" },
- { name: "mandate", type: "Mandate" }
-] as const;
-
-const Mandate = [
- { name: "fillDeadline", type: "uint32" },
- { name: "inputOracle", type: "address" },
- { name: "outputs", type: "MandateOutput[]" }
-] as const;
-
-export const MandateOutput = [
- { name: "oracle", type: "bytes32" },
- { name: "settler", type: "bytes32" },
- { name: "chainId", type: "uint256" },
- { name: "token", type: "bytes32" },
- { name: "amount", type: "uint256" },
- { name: "recipient", type: "bytes32" },
- { name: "callbackData", type: "bytes" },
- { name: "context", type: "bytes" }
-] as const;
-
-// The named list of all type definitions
-export const compactTypes = {
- BatchCompact,
- Lock,
- Mandate,
- MandateOutput,
- Element,
- MultichainCompact
-} as const;
-
-const compact_type =
- "BatchCompact(address arbiter,address sponsor,uint256 nonce,uint256 expires,Lock[] commitments,Mandate mandate)Lock(bytes12 lockTag,address token,uint256 amount)Mandate(uint32 fillDeadline,address inputOracle,MandateOutput[] outputs)MandateOutput(bytes32 oracle,bytes32 settler,uint256 chainId,bytes32 token,uint256 amount,bytes32 recipient,bytes callbackData,bytes context)" as const;
-export const compact_type_hash = keccak256(toHex(compact_type));
-const compact_type_hash_contract =
- "0x5f094e58b077a941d99d3449bd1be66fd3bc9d23ab9e4c06a8713cabc3e3b634";
-if (compact_type_hash != compact_type_hash_contract) {
- throw Error(
- `Computed typehash ${compact_type_hash} does not match expected ${compact_type_hash_contract}`
- );
-}
-
-const multichain_compact_type =
- "MultichainCompact(address sponsor,uint256 nonce,uint256 expires,Element[] elements)Element(address arbiter,uint256 chainId,Lock[] commitments,Mandate mandate)Lock(bytes12 lockTag,address token,uint256 amount)Mandate(uint32 fillDeadline,address inputOracle,MandateOutput[] outputs)MandateOutput(bytes32 oracle,bytes32 settler,uint256 chainId,bytes32 token,uint256 amount,bytes32 recipient,bytes callbackData,bytes context)" as const;
-export const multichain_compact_type_hash = keccak256(toHex(multichain_compact_type));
-const multichain_compact_type_hash_contract =
- "0x6bc0624272798c7a3ff97563d8a009ea96cffd8ea74a971b2946ca790fc50319";
-if (multichain_compact_type_hash != multichain_compact_type_hash_contract) {
- throw Error(
- `Computed multichain typehash ${multichain_compact_type_hash} does not match expected ${multichain_compact_type_hash_contract}`
- );
-}
diff --git a/src/lib/utils/wagmi.ts b/src/lib/utils/wagmi.ts
new file mode 100644
index 0000000..0b665cc
--- /dev/null
+++ b/src/lib/utils/wagmi.ts
@@ -0,0 +1,103 @@
+import { browser } from "$app/environment";
+import { env } from "$env/dynamic/public";
+import {
+ connect,
+ createConfig,
+ disconnect,
+ getConnection,
+ getConnectors,
+ http,
+ reconnect,
+ watchConnection
+} from "@wagmi/core";
+import { injected, metaMask, walletConnect } from "@wagmi/connectors";
+import { createWalletClient, custom, type Chain, type EIP1193Provider } from "viem";
+import { chainMap } from "../config";
+
+const APP_METADATA = {
+ name: "Open Intents Framework Demo",
+ description: "A demo website showcasing using the Open Intents Framework. Built by LIFI.",
+ url: "https://lintent.org",
+ icons: ["https://lintent.org/favicon.ico"]
+};
+
+export const walletConnectProjectId = env.PUBLIC_WALLET_CONNECT_PROJECT_ID?.trim();
+
+export function resolveConnectorIds(projectId?: string) {
+ return ["injected", ...(projectId ? ["walletConnect"] : []), "metaMask"];
+}
+
+const wagmiChains = Object.values(chainMap) as Chain[];
+
+const connectors = [
+ injected(),
+ ...(walletConnectProjectId
+ ? [
+ walletConnect({
+ projectId: walletConnectProjectId,
+ showQrModal: true,
+ metadata: APP_METADATA
+ })
+ ]
+ : []),
+ metaMask({ dappMetadata: APP_METADATA })
+];
+
+const transports = Object.fromEntries(wagmiChains.map((chain) => [chain.id, http()]));
+
+export const wagmiConfig = createConfig({
+ ssr: true,
+ chains: wagmiChains as [Chain, ...Chain[]],
+ connectors,
+ transports: transports as Record>
+});
+
+export type WalletConnection = ReturnType;
+
+export function listWalletConnectors() {
+ return getConnectors(wagmiConfig).map((connector) => ({
+ id: connector.id,
+ name: connector.name
+ }));
+}
+
+export async function connectWith(connectorId: string) {
+ const connector = getConnectors(wagmiConfig).find((candidate) => candidate.id === connectorId);
+ if (!connector) throw new Error(`Connector not found: ${connectorId}`);
+ return connect(wagmiConfig, { connector });
+}
+
+export async function reconnectWallet() {
+ return reconnect(wagmiConfig);
+}
+
+export async function disconnectWallet() {
+ const connection = getConnection(wagmiConfig);
+ if (connection.status !== "connected") return;
+ return disconnect(wagmiConfig, { connector: connection.connector });
+}
+
+export function getCurrentConnection() {
+ return getConnection(wagmiConfig);
+}
+
+export async function getCurrentProvider() {
+ const connection = getConnection(wagmiConfig);
+ if (connection.status !== "connected") return undefined;
+ return (await connection.connector.getProvider()) as EIP1193Provider;
+}
+
+export async function getCurrentWalletClient() {
+ const provider = await getCurrentProvider();
+ if (!provider) return undefined;
+ return createWalletClient({ transport: custom(provider) });
+}
+
+export function watchWalletConnection(onChange: (connection: WalletConnection) => void) {
+ if (!browser) return () => {};
+ return watchConnection(wagmiConfig, {
+ onChange(connection) {
+ onChange(connection);
+ }
+ });
+}
diff --git a/src/lib/utils/walletClient.ts b/src/lib/utils/walletClient.ts
new file mode 100644
index 0000000..34ed3ea
--- /dev/null
+++ b/src/lib/utils/walletClient.ts
@@ -0,0 +1,69 @@
+import type { EIP1193Provider } from "viem";
+import { toHex } from "viem";
+import type { WC } from "$lib/config";
+
+export type SwitchableWalletClient = WC & {
+ switchChain?: (args: { id: number }) => Promise;
+};
+
+export type SwitchWalletChainOptions = {
+ provider?: EIP1193Provider;
+};
+
+export type SwitchWalletChain = (
+ walletClient: WC | undefined,
+ chainId: number,
+ options?: SwitchWalletChainOptions
+) => Promise;
+
+export type SwitchWalletChainDeps = {
+ getCurrentProvider: () => Promise;
+};
+
+async function resolveWalletProvider(
+ walletClient: WC | undefined,
+ deps: SwitchWalletChainDeps,
+ provider?: EIP1193Provider
+): Promise {
+ if (provider?.request) return provider;
+
+ const walletClientWithTransport = walletClient as
+ | (WC & { transport?: { value?: EIP1193Provider } })
+ | undefined;
+ const transportProvider = walletClientWithTransport?.transport?.value;
+ if (transportProvider?.request) return transportProvider;
+
+ try {
+ return await deps.getCurrentProvider();
+ } catch {
+ return undefined;
+ }
+}
+
+export function createSwitchWalletChain(deps: SwitchWalletChainDeps): SwitchWalletChain {
+ return async (
+ walletClient: WC | undefined,
+ chainId: number,
+ options?: SwitchWalletChainOptions
+ ) => {
+ if (!walletClient) return;
+
+ const switchableClient = walletClient as SwitchableWalletClient;
+ if (typeof switchableClient.switchChain === "function") {
+ await switchableClient.switchChain({ id: chainId });
+ return;
+ }
+
+ const provider = await resolveWalletProvider(walletClient, deps, options?.provider);
+ if (!provider?.request) {
+ throw new Error(
+ `Wallet client does not support switchChain and no provider is available for chain ${chainId}.`
+ );
+ }
+
+ await provider.request({
+ method: "wallet_switchEthereumChain",
+ params: [{ chainId: toHex(chainId) }]
+ });
+ };
+}
diff --git a/src/lib/utils/walletClientRuntime.ts b/src/lib/utils/walletClientRuntime.ts
new file mode 100644
index 0000000..4bc4b05
--- /dev/null
+++ b/src/lib/utils/walletClientRuntime.ts
@@ -0,0 +1,4 @@
+import { createSwitchWalletChain } from "./walletClient";
+import { getCurrentProvider } from "./wagmi";
+
+export const switchWalletChain = createSwitchWalletChain({ getCurrentProvider });
diff --git a/src/lib/utils/web3-onboard.ts b/src/lib/utils/web3-onboard.ts
deleted file mode 100644
index 5ca6309..0000000
--- a/src/lib/utils/web3-onboard.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import Onboard from "@web3-onboard/core";
-import type { OnboardAPI } from "@web3-onboard/core";
-import injectedWalletsModule from "@web3-onboard/injected-wallets";
-import zealWalletModule from "@web3-onboard/zeal";
-import coinbaseWalletModule from "@web3-onboard/coinbase";
-import walletConnectModule from "@web3-onboard/walletconnect";
-import { env } from "$env/dynamic/public";
-import { chainMap } from "../config";
-
-const injected = injectedWalletsModule();
-const zealWalletSdk = zealWalletModule();
-const coinbaseWalletSdk = coinbaseWalletModule();
-const walletConnectProjectId = env.PUBLIC_WALLET_CONNECT_PROJECT_ID;
-const walletConnect = walletConnectProjectId
- ? walletConnectModule({
- projectId: walletConnectProjectId,
- dappUrl: "lintent.org"
- })
- : undefined;
-
-const wallets = [
- injected,
- zealWalletSdk,
- coinbaseWalletSdk,
- ...(walletConnect ? [walletConnect] : [])
-];
-
-const getChains = () => {
- return Object.values(chainMap).map((v) => {
- return {
- id: v.id,
- token: v.nativeCurrency.symbol,
- label: v.name,
- rpcUrl: v.rpcUrls.default.http[0]
- };
- });
-};
-
-const appMetadata = {
- name: "Open Intents Framework Demo",
- icon: "
-
- Intents with Open Intents Framework
-
-
-
-
-
-
-
-
-
-
- Preview by LI.FI
-
+
+ Resource lock intents using OIF
+
+
+
+
+
+
+
+
+
+
+ Preview by LI.FI
+
- {#if !(!store.connectedAccount || !store.walletClient)}
-
-
- →
-
-
-
- ←
-
- {/if}
-
- {#if !store.connectedAccount || !store.walletClient}
-
-
-
-
{
- if (step.targetIndex === undefined) return;
- goToScreen(step.targetIndex);
- }}
- />
-
-
-
-
+ {#if !(!store.connectedAccount || !store.walletClient)}
+
+
+ →
+
+
+
+ ←
+
+ {/if}
+
+ {#if !store.connectedAccount || !store.walletClient}
+
+
+
+
{
+ if (step.targetIndex === undefined) return;
+ goToScreen(step.targetIndex);
+ }}
+ />
+
+
diff --git a/src/routes/allocator/+server.ts b/src/routes/allocator/+server.ts
index 91c3966..f3d7e3c 100644
--- a/src/routes/allocator/+server.ts
+++ b/src/routes/allocator/+server.ts
@@ -1,83 +1,106 @@
import { json } from "@sveltejs/kit";
import axios from "axios";
import type { RequestHandler } from "./$types";
-import { type StandardOrder } from "../../types";
+import { type StandardOrder } from "@lifi/intent";
import {
- PRIVATE_POLYMER_MAINNET_ZONE_API_KEY,
- PRIVATE_POLYMER_TESTNET_ZONE_API_KEY
+ PRIVATE_POLYMER_MAINNET_ZONE_API_KEY,
+ PRIVATE_POLYMER_TESTNET_ZONE_API_KEY
} from "$env/static/private";
function getPolymerKey(mainnet: boolean) {
- return mainnet ? PRIVATE_POLYMER_MAINNET_ZONE_API_KEY : PRIVATE_POLYMER_TESTNET_ZONE_API_KEY;
+ return mainnet ? PRIVATE_POLYMER_MAINNET_ZONE_API_KEY : PRIVATE_POLYMER_TESTNET_ZONE_API_KEY;
+}
+
+function isHexString(value: unknown): value is `0x${string}` {
+ return typeof value === "string" && /^0x[0-9a-fA-F]+$/.test(value);
+}
+
+function isPositiveInteger(value: unknown): value is number {
+ return typeof value === "number" && Number.isInteger(value) && value > 0;
}
export const POST: RequestHandler = async ({ request }) => {
- const {
- order,
- claimHash,
- blockNumber,
- chainId,
- mainnet
- }: {
- order: StandardOrder;
- claimHash: `0x${string}`;
- blockNumber: number;
- chainId: number;
- mainnet?: boolean;
- } = await request.json();
- console.log({ order, claimHash, blockNumber, chainId });
+ let body: unknown;
+ try {
+ body = await request.json();
+ } catch {
+ return json({ error: "Invalid JSON body" }, { status: 400 });
+ }
+
+ const { order, claimHash, blockNumber, chainId, mainnet } = body as {
+ order: StandardOrder;
+ claimHash: `0x${string}`;
+ blockNumber: number;
+ chainId: number;
+ mainnet?: boolean;
+ };
- const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
+ if (!order || typeof order !== "object") {
+ return json({ error: "Missing or invalid 'order'" }, { status: 400 });
+ }
+ if (!isHexString(claimHash)) {
+ return json({ error: "Missing or invalid 'claimHash'" }, { status: 400 });
+ }
+ if (!isPositiveInteger(blockNumber)) {
+ return json({ error: "Missing or invalid 'blockNumber'" }, { status: 400 });
+ }
+ if (!isPositiveInteger(chainId)) {
+ return json({ error: "Missing or invalid 'chainId'" }, { status: 400 });
+ }
- const requestAllocation = await axios.post(
- "https://allocator.devnet.polymer.zone/",
- {
- jsonrpc: "2.0",
- id: 1,
- method: "allocator_attestCommit",
- params: [
- {
- chainId,
- blockNumber,
- claimHash,
- order
- }
- ]
- },
- {
- headers: {
- Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
- "Content-Type": "application/json",
- Accept: "application/json"
- }
- }
- );
+ try {
+ const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
- const dat: {
- jsonrpc: "2.0";
- id: 1;
- result: {
- chainId: number;
- blockNumber: number;
- logIndex: number;
- order: StandardOrder;
- commitSignature: `0x${string}`;
- allocatorSignature: `0x${string}`;
- allocatorAddress: `0x${string}`;
- claimHash: `0x${string}`;
- sponsor: `0x${string}`;
- tokenBalances: {
- tokenId: `0x${string}`;
- balance: `0x${string}`;
- }[];
- };
- } = requestAllocation.data;
+ const requestAllocation = await axios.post(
+ "https://allocator.devnet.polymer.zone/",
+ {
+ jsonrpc: "2.0",
+ id: 1,
+ method: "allocator_attestCommit",
+ params: [
+ {
+ chainId,
+ blockNumber,
+ claimHash,
+ order
+ }
+ ]
+ },
+ {
+ headers: {
+ Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
+ "Content-Type": "application/json",
+ Accept: "application/json"
+ }
+ }
+ );
- console.log(dat);
+ const dat: {
+ jsonrpc: "2.0";
+ id: 1;
+ result: {
+ chainId: number;
+ blockNumber: number;
+ logIndex: number;
+ order: StandardOrder;
+ commitSignature: `0x${string}`;
+ allocatorSignature: `0x${string}`;
+ allocatorAddress: `0x${string}`;
+ claimHash: `0x${string}`;
+ sponsor: `0x${string}`;
+ tokenBalances: {
+ tokenId: `0x${string}`;
+ balance: `0x${string}`;
+ }[];
+ };
+ } = requestAllocation.data;
- // create a JSON Response using a header we received
- return json({
- allocatorSignature: dat.result.allocatorSignature,
- allocatorAddress: dat.result.allocatorAddress
- });
+ return json({
+ allocatorSignature: dat.result.allocatorSignature,
+ allocatorAddress: dat.result.allocatorAddress
+ });
+ } catch (error) {
+ console.error("allocator_attestCommit failed", { chainId });
+ return json({ error: "Allocator request failed" }, { status: 502 });
+ }
};
diff --git a/src/routes/health/+server.ts b/src/routes/health/+server.ts
index 94f864c..cfd89c7 100644
--- a/src/routes/health/+server.ts
+++ b/src/routes/health/+server.ts
@@ -1,5 +1,5 @@
import type { RequestHandler } from "./$types";
export const GET: RequestHandler = async ({}) => {
- return new Response(JSON.stringify({ status: "ok", timestamp: Date.now() }));
+ return new Response(JSON.stringify({ status: "ok", timestamp: Date.now() }));
};
diff --git a/src/routes/polymer/+server.ts b/src/routes/polymer/+server.ts
index c19da15..b525184 100644
--- a/src/routes/polymer/+server.ts
+++ b/src/routes/polymer/+server.ts
@@ -2,109 +2,139 @@ import { json } from "@sveltejs/kit";
import axios from "axios";
import type { RequestHandler } from "./$types";
import {
- PRIVATE_POLYMER_MAINNET_ZONE_API_KEY,
- PRIVATE_POLYMER_TESTNET_ZONE_API_KEY
+ PRIVATE_POLYMER_MAINNET_ZONE_API_KEY,
+ PRIVATE_POLYMER_TESTNET_ZONE_API_KEY
} from "$env/static/private";
import { toByteArray } from "base64-js";
function getPolymerUrl(mainnet: boolean) {
- return mainnet
- ? ("https://api.polymer.zone/v1/" as const)
- : ("https://api.testnet.polymer.zone/v1/" as const);
+ return mainnet
+ ? ("https://api.polymer.zone/v1/" as const)
+ : ("https://api.testnet.polymer.zone/v1/" as const);
}
function getPolymerKey(mainnet: boolean) {
- return mainnet ? PRIVATE_POLYMER_MAINNET_ZONE_API_KEY : PRIVATE_POLYMER_TESTNET_ZONE_API_KEY;
+ return mainnet ? PRIVATE_POLYMER_MAINNET_ZONE_API_KEY : PRIVATE_POLYMER_TESTNET_ZONE_API_KEY;
+}
+
+function isPositiveInteger(value: unknown): value is number {
+ return typeof value === "number" && Number.isInteger(value) && value > 0;
}
export const POST: RequestHandler = async ({ request }) => {
- const { srcChainId, srcBlockNumber, globalLogIndex, polymerIndex, mainnet } =
- await request.json();
- console.log({ srcChainId, srcBlockNumber, globalLogIndex, polymerIndex, mainnet });
+ let body: unknown;
+ try {
+ body = await request.json();
+ } catch {
+ return json({ error: "Invalid JSON body" }, { status: 400 });
+ }
+
+ const { srcChainId, srcBlockNumber, globalLogIndex, polymerIndex, mainnet } = body as {
+ srcChainId: number;
+ srcBlockNumber: number;
+ globalLogIndex: number;
+ polymerIndex?: number;
+ mainnet?: boolean;
+ };
+
+ if (!isPositiveInteger(srcChainId)) {
+ return json({ error: "Missing or invalid 'srcChainId'" }, { status: 400 });
+ }
+ if (!isPositiveInteger(srcBlockNumber)) {
+ return json({ error: "Missing or invalid 'srcBlockNumber'" }, { status: 400 });
+ }
+ if (
+ typeof globalLogIndex !== "number" ||
+ !Number.isInteger(globalLogIndex) ||
+ globalLogIndex < 0
+ ) {
+ return json({ error: "Missing or invalid 'globalLogIndex'" }, { status: 400 });
+ }
+
+ try {
+ const POLYMER_URL = getPolymerUrl(mainnet ?? true);
+ const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
- const POLYMER_URL = getPolymerUrl(mainnet ?? true);
- const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
+ let polymerRequestIndex = polymerIndex;
+ if (!polymerRequestIndex) {
+ const requestProof = await axios.post(
+ POLYMER_URL,
+ {
+ jsonrpc: "2.0",
+ id: 1,
+ method: "polymer_requestProof",
+ params: [
+ {
+ srcChainId,
+ srcBlockNumber,
+ globalLogIndex
+ }
+ ]
+ },
+ {
+ headers: {
+ Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
+ "Content-Type": "application/json",
+ Accept: "application/json"
+ }
+ }
+ );
+ polymerRequestIndex = requestProof.data.result;
+ }
+ const requestProofData = await axios.post(
+ POLYMER_URL,
+ {
+ jsonrpc: "2.0",
+ id: 1,
+ method: "polymer_queryProof",
+ params: [polymerRequestIndex]
+ },
+ {
+ headers: {
+ Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
+ "Content-Type": "application/json",
+ Accept: "application/json"
+ }
+ }
+ );
+ const dat: {
+ jsonrpc: "2.0";
+ id: 1;
+ result: {
+ jobID: number;
+ createdAt: number;
+ updatedAt: number;
+ } & (
+ | {
+ status: "error";
+ failureReason: string;
+ }
+ | {
+ status: "complete";
+ proof: "string";
+ }
+ | {
+ status: "initialized";
+ }
+ );
+ } = requestProofData.data;
- let polymerRequestIndex = polymerIndex;
- if (!polymerRequestIndex) {
- const requestProof = await axios.post(
- POLYMER_URL,
- {
- jsonrpc: "2.0",
- id: 1,
- method: "polymer_requestProof",
- params: [
- {
- srcChainId,
- srcBlockNumber,
- globalLogIndex
- }
- ]
- },
- {
- headers: {
- Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
- "Content-Type": "application/json",
- Accept: "application/json"
- }
- }
- );
- polymerRequestIndex = requestProof.data.result;
- console.log({ requestProof: requestProof.data });
- }
- const requestProofData = await axios.post(
- POLYMER_URL,
- {
- jsonrpc: "2.0",
- id: 1,
- method: "polymer_queryProof",
- params: [polymerRequestIndex]
- },
- {
- headers: {
- Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
- "Content-Type": "application/json",
- Accept: "application/json"
- }
- }
- );
- const dat: {
- jsonrpc: "2.0";
- id: 1;
- result: {
- jobID: number;
- createdAt: number;
- updatedAt: number;
- } & (
- | {
- status: "error";
- failureReason: string;
- }
- | {
- status: "complete";
- proof: "string";
- }
- | {
- status: "initialized";
- }
- );
- } = requestProofData.data;
+ let proof: string | undefined;
+ if (dat.result.status === "complete") {
+ proof = dat.result.proof;
+ const proofBytes = toByteArray(proof);
+ proof = Array.from(proofBytes)
+ .map((byte) => byte.toString(16).padStart(2, "0"))
+ .join("");
+ }
- let proof: string | undefined;
- // decode proof from base64 to hex
- if (dat.result.status === "complete") {
- proof = dat.result.proof;
- const proofBytes = toByteArray(proof);
- proof = Array.from(proofBytes)
- .map((byte) => byte.toString(16).padStart(2, "0"))
- .join("");
- } else {
- console.log(dat);
- }
- // create a JSON Response
- return json({
- proof,
- polymerIndex: polymerRequestIndex,
- status: dat.result.status
- });
+ return json({
+ proof,
+ polymerIndex: polymerRequestIndex,
+ status: dat.result.status
+ });
+ } catch (error) {
+ console.error("polymer proof request failed", { srcChainId });
+ return json({ error: "Polymer proof request failed" }, { status: 502 });
+ }
};
diff --git a/src/routes/polymer/health/+server.ts b/src/routes/polymer/health/+server.ts
index d62f822..4318d13 100644
--- a/src/routes/polymer/health/+server.ts
+++ b/src/routes/polymer/health/+server.ts
@@ -2,64 +2,90 @@ import { json } from "@sveltejs/kit";
import axios from "axios";
import type { RequestHandler } from "./$types";
import {
- PRIVATE_POLYMER_MAINNET_ZONE_API_KEY,
- PRIVATE_POLYMER_TESTNET_ZONE_API_KEY
+ PRIVATE_POLYMER_MAINNET_ZONE_API_KEY,
+ PRIVATE_POLYMER_TESTNET_ZONE_API_KEY
} from "$env/static/private";
function getPolymerUrl(mainnet: boolean) {
- return mainnet
- ? ("https://api.polymer.zone/v1/" as const)
- : ("https://api.testnet.polymer.zone/v1/" as const);
+ return mainnet
+ ? ("https://api.polymer.zone/v1/" as const)
+ : ("https://api.testnet.polymer.zone/v1/" as const);
}
function getPolymerKey(mainnet: boolean) {
- return mainnet ? PRIVATE_POLYMER_MAINNET_ZONE_API_KEY : PRIVATE_POLYMER_TESTNET_ZONE_API_KEY;
+ return mainnet ? PRIVATE_POLYMER_MAINNET_ZONE_API_KEY : PRIVATE_POLYMER_TESTNET_ZONE_API_KEY;
}
+const MAX_CHAIN_IDS = 20;
+
export const POST: RequestHandler = async ({ request }) => {
- const { chainIds, mainnet }: { chainIds?: number[]; mainnet?: boolean } = await request.json();
+ let body: unknown;
+ try {
+ body = await request.json();
+ } catch {
+ return json({ error: "Invalid JSON body" }, { status: 400 });
+ }
+
+ const { chainIds, mainnet } = body as { chainIds?: number[]; mainnet?: boolean };
+
+ if (chainIds !== undefined) {
+ if (!Array.isArray(chainIds) || chainIds.length > MAX_CHAIN_IDS) {
+ return json(
+ { error: `'chainIds' must be an array with at most ${MAX_CHAIN_IDS} elements` },
+ { status: 400 }
+ );
+ }
+ if (!chainIds.every((id) => typeof id === "number" && Number.isInteger(id) && id > 0)) {
+ return json({ error: "'chainIds' must contain only positive integers" }, { status: 400 });
+ }
+ }
- const POLYMER_URL = getPolymerUrl(mainnet ?? true);
- const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
+ try {
+ const POLYMER_URL = getPolymerUrl(mainnet ?? true);
+ const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
- const requestProofData = await axios.post(
- POLYMER_URL,
- {
- jsonrpc: "2.0",
- id: 1,
- method: "info_health",
- params: [{ chain_ids: chainIds ?? [] }]
- },
- {
- headers: {
- Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
- "Content-Type": "application/json",
- Accept: "application/json"
- }
- }
- );
+ const requestProofData = await axios.post(
+ POLYMER_URL,
+ {
+ jsonrpc: "2.0",
+ id: 1,
+ method: "info_health",
+ params: [{ chain_ids: chainIds ?? [] }]
+ },
+ {
+ headers: {
+ Authorization: `Bearer ${PRIVATE_POLYMER_ZONE_API_KEY}`,
+ "Content-Type": "application/json",
+ Accept: "application/json"
+ }
+ }
+ );
- const dat:
- | ({
- jsonrpc: "2.0";
- id: 1;
- } & {
- result: {
- status: {
- [chainId: string]: "healthy" | "unhealthy";
- };
- };
- })
- | { error: { code: -32000; message: `unsupported chain ID(s): [${string}]` } } =
- requestProofData.data;
+ const dat:
+ | ({
+ jsonrpc: "2.0";
+ id: 1;
+ } & {
+ result: {
+ status: {
+ [chainId: string]: "healthy" | "unhealthy";
+ };
+ };
+ })
+ | { error: { code: -32000; message: `unsupported chain ID(s): [${string}]` } } =
+ requestProofData.data;
- const failed = "error" in dat;
- const status = !failed ? dat.result.status : [];
- const error = failed ? dat.error : {};
+ const failed = "error" in dat;
+ const status = !failed ? dat.result.status : [];
+ const error = failed ? dat.error : {};
- return json({
- failed,
- status,
- error
- });
+ return json({
+ failed,
+ status,
+ error
+ });
+ } catch (error) {
+ console.error("polymer health check failed");
+ return json({ error: "Polymer health check failed" }, { status: 502 });
+ }
};
diff --git a/src/types/index.ts b/src/types/index.ts
deleted file mode 100644
index bf774de..0000000
--- a/src/types/index.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-export type Quote = {
- fromAsset: string;
- toAsset: string;
- fromPrice: string;
- toPrice: string;
- intermediary: string;
- discount?: string;
-};
-
-export type MandateOutput = {
- oracle: `0x${string}`;
- settler: `0x${string}`;
- chainId: bigint;
- token: `0x${string}`;
- amount: bigint;
- recipient: `0x${string}`;
- callbackData: `0x${string}`;
- context: `0x${string}`;
-};
-
-export type CompactMandate = {
- fillDeadline: number;
- inputOracle: `0x${string}`;
- outputs: MandateOutput[];
-};
-
-export type Lock = {
- lockTag: `0x${string}`;
- token: `0x${string}`;
- amount: bigint;
-};
-
-export type BatchCompact = {
- arbiter: `0x${string}`; // The account tasked with verifying and submitting the claim.
- sponsor: `0x${string}`; // The account to source the tokens from.
- nonce: bigint; // A parameter to enforce replay protection, scoped to allocator.
- expires: bigint; // The time at which the claim expires.
- commitments: Lock[]; // The allocated token IDs and amounts.
- mandate: CompactMandate;
-};
-
-export type Element = {
- arbiter: `0x${string}`;
- chainId: bigint;
- commitments: Lock[];
- mandate: CompactMandate;
-};
-export type MultichainCompact = {
- sponsor: `0x${string}`; // The account tasked with verifying and submitting the claim.
- nonce: bigint; // A parameter to enforce replay protection, scoped to allocator.
- expires: bigint; // The time at which the claim expires.
- elements: Element[];
- mandate: CompactMandate;
-};
-
-export type StandardOrder = {
- user: `0x${string}`;
- nonce: bigint;
- originChainId: bigint;
- expires: number;
- fillDeadline: number;
- inputOracle: `0x${string}`;
- inputs: [bigint, bigint][];
- outputs: MandateOutput[];
-};
-
-export type MultichainOrderComponent = {
- user: `0x${string}`;
- nonce: bigint;
- chainIdField: bigint;
- chainIndex: bigint;
- expires: number;
- fillDeadline: number;
- inputOracle: `0x${string}`;
- inputs: [bigint, bigint][];
- outputs: MandateOutput[];
- additionalChains: `0x${string}`[];
-};
-
-export type MultichainOrder = {
- user: `0x${string}`;
- nonce: bigint;
- expires: number;
- fillDeadline: number;
- inputOracle: `0x${string}`;
- outputs: MandateOutput[];
- inputs: { chainId: bigint; inputs: [bigint, bigint][] }[];
-};
-
-export type NoSignature = {
- type: "None";
- payload: "0x";
-};
-
-export type Signature = {
- type: "ECDSA" | "ERC-1271";
- payload: `0x${string}`;
-};
-
-export type OrderContainer = {
- inputSettler: `0x${string}`;
- order: StandardOrder | MultichainOrder;
- sponsorSignature: Signature | NoSignature;
- allocatorSignature: Signature | NoSignature;
-};
diff --git a/svelte.config.js b/svelte.config.js
index 9343c0b..a2cfc22 100644
--- a/svelte.config.js
+++ b/svelte.config.js
@@ -3,16 +3,16 @@ import { vitePreprocess } from "@sveltejs/vite-plugin-svelte";
/** @type {import('@sveltejs/kit').Config} */
const config = {
- // Consult https://svelte.dev/docs/kit/integrations
- // for more information about preprocessors
- preprocess: vitePreprocess(),
+ // Consult https://svelte.dev/docs/kit/integrations
+ // for more information about preprocessors
+ preprocess: vitePreprocess(),
- kit: {
- // adapter-auto only supports some environments, see https://svelte.dev/docs/kit/adapter-auto for a list.
- // If your environment is not supported, or you settled on a specific environment, switch out the adapter.
- // See https://svelte.dev/docs/kit/adapters for more information about adapters.
- adapter: adapter()
- }
+ kit: {
+ // adapter-auto only supports some environments, see https://svelte.dev/docs/kit/adapter-auto for a list.
+ // If your environment is not supported, or you settled on a specific environment, switch out the adapter.
+ // See https://svelte.dev/docs/kit/adapters for more information about adapters.
+ adapter: adapter()
+ }
};
export default config;
diff --git a/tests/db.test.ts b/tests/db.test.ts
index 4e452e0..7801b80 100644
--- a/tests/db.test.ts
+++ b/tests/db.test.ts
@@ -5,50 +5,50 @@ import migrations from "../src/lib/migrations.json";
import { intents } from "../src/lib/schema";
async function createTestDb() {
- const pglite = new PGlite({ fs: new MemoryFS("testdb") });
- const db = drizzle(pglite);
+ const pglite = new PGlite({ fs: new MemoryFS("testdb") });
+ const db = drizzle(pglite);
- // dialect and session will appear to not exist...but they do on the pglite drizzle instance
- // @ts-ignore
- await db.dialect.migrate(migrations, db.session, {
- migrationsTable: "drizzle_migrations"
- });
+ // dialect and session will appear to not exist...but they do on the pglite drizzle instance
+ // @ts-ignore
+ await db.dialect.migrate(migrations, db.session, {
+ migrationsTable: "drizzle_migrations"
+ });
- return { db, pglite };
+ return { db, pglite };
}
describe("pglite migrations", () => {
- it("applies migrations and supports upserts", async () => {
- const { db, pglite } = await createTestDb();
- try {
- const now = Date.now();
- await db.insert(intents).values({
- id: "1",
- orderId: "order-1",
- intentType: "escrow",
- data: "{}",
- createdAt: now
- });
+ it("applies migrations and supports upserts", async () => {
+ const { db, pglite } = await createTestDb();
+ try {
+ const now = Date.now();
+ await db.insert(intents).values({
+ id: "1",
+ orderId: "order-1",
+ intentType: "escrow",
+ data: "{}",
+ createdAt: now
+ });
- await db
- .insert(intents)
- .values({
- id: "2",
- orderId: "order-1",
- intentType: "escrow",
- data: '{"v":2}',
- createdAt: now
- })
- .onConflictDoUpdate({
- target: intents.orderId,
- set: { data: '{"v":2}' }
- });
+ await db
+ .insert(intents)
+ .values({
+ id: "2",
+ orderId: "order-1",
+ intentType: "escrow",
+ data: '{"v":2}',
+ createdAt: now
+ })
+ .onConflictDoUpdate({
+ target: intents.orderId,
+ set: { data: '{"v":2}' }
+ });
- const rows = await db.select().from(intents);
- expect(rows).toHaveLength(1);
- expect(rows[0].data).toBe('{"v":2}');
- } finally {
- await pglite.close();
- }
- });
+ const rows = await db.select().from(intents);
+ expect(rows).toHaveLength(1);
+ expect(rows[0].data).toBe('{"v":2}');
+ } finally {
+ await pglite.close();
+ }
+ });
});
diff --git a/tests/e2e/escrow-standard-blackbox.spec.ts b/tests/e2e/escrow-standard-blackbox.spec.ts
new file mode 100644
index 0000000..80cbc04
--- /dev/null
+++ b/tests/e2e/escrow-standard-blackbox.spec.ts
@@ -0,0 +1,296 @@
+import { expect, test, type Page } from "@playwright/test";
+import {
+ connectInjectedWallet,
+ e2eWalletAddress,
+ hasE2EPrivateKey,
+ installInjectedWalletProvider
+} from "./helpers/bootstrap";
+
+const REQUIRED_INPUT_USDC_HUMAN = "0.0001";
+const REQUIRED_INPUT_USDC_RAW = "100";
+const TEST_TIMEOUT_MS = 2 * 60_000;
+const UI_TIMEOUT_MS = 30_000;
+const TX_TIMEOUT_MS = 45_000;
+const PROVE_ATTEMPT_TIMEOUT_MS = 20_000;
+const ORDER_STATUS_CLAIMED = 2;
+type FlowStepName = "Asset" | "Issue" | "Fetch" | "Fill" | "Prove" | "Claim";
+type FlowStepStatus = "Now" | "Done" | "Next" | "Locked";
+type FlowState = Record;
+
+test.skip(!hasE2EPrivateKey, "Skipping private-key E2E tests: E2E_PRIVATE_KEY is not defined.");
+
+test.setTimeout(TEST_TIMEOUT_MS);
+
+async function expectRightRailState(page: Page, state: FlowState) {
+ const entries = Object.entries(state) as Array<[FlowStepName, FlowStepStatus]>;
+ for (const [step, status] of entries) {
+ await expect(page.getByRole("button", { name: `${step} (${status})` })).toBeVisible({
+ timeout: UI_TIMEOUT_MS
+ });
+ }
+}
+
+async function lockVerticalScrollAtTop(page: Page) {
+ await page.addInitScript(() => {
+ const enforceTop = () => {
+ if (window.scrollY > 0) window.scrollTo(0, 0);
+ };
+ window.addEventListener("scroll", enforceTop, { passive: true });
+ window.addEventListener("load", enforceTop);
+ });
+}
+
+test("black-box escrow flow shows expected UI state transitions", async ({ page }) => {
+ const issuerAddress = e2eWalletAddress();
+ let sawRequiredInputAmount = false;
+ const getReceiptCount = async () =>
+ await page.evaluate(async () => {
+ const { default: store } = await import("/src/lib/state.svelte.ts");
+ return Object.keys(store.transactionReceipts).length;
+ });
+
+ await lockVerticalScrollAtTop(page);
+
+ await page.route("**/quote/request", async (route) => {
+ const body = route.request().postDataJSON() as
+ | {
+ intent?: {
+ inputs?: Array<{ amount?: string }>;
+ };
+ }
+ | undefined;
+ const totalInputRaw = (body?.intent?.inputs ?? []).reduce((sum, input) => {
+ try {
+ return sum + BigInt(input.amount ?? "0");
+ } catch {
+ return sum;
+ }
+ }, 0n);
+ if (totalInputRaw.toString() === REQUIRED_INPUT_USDC_RAW) {
+ sawRequiredInputAmount = true;
+ }
+
+ await route.fulfill({
+ status: 200,
+ contentType: "application/json",
+ body: JSON.stringify({
+ quotes: [
+ {
+ order: null,
+ eta: null,
+ validUntil: Date.now() + 60_000,
+ quoteId: null,
+ metadata: { exclusiveFor: issuerAddress },
+ preview: {
+ inputs: [],
+ outputs: [
+ {
+ receiver: "0x0000000000000000000000000000000000000000",
+ asset: "0x0000000000000000000000000000000000000000",
+ amount: REQUIRED_INPUT_USDC_RAW
+ }
+ ]
+ },
+ provider: null,
+ partialFill: false,
+ failureHandling: "refund-automatic"
+ }
+ ]
+ })
+ });
+ });
+
+ await installInjectedWalletProvider(page);
+ await page.goto("/");
+ await connectInjectedWallet(page);
+
+ await expect(page.getByRole("heading", { name: "Assets Management" })).toBeVisible();
+ await expectRightRailState(page, {
+ Asset: "Now",
+ Issue: "Next",
+ Fetch: "Next",
+ Fill: "Locked",
+ Prove: "Locked",
+ Claim: "Locked"
+ });
+
+ await page.getByTestId("network-mainnet").click();
+ await page.getByTestId("intent-type-escrow").click();
+
+ await page.getByRole("button", { name: "→" }).first().click();
+ await expect(page.getByRole("heading", { name: "Intent Issuance" })).toBeVisible();
+ await expectRightRailState(page, {
+ Asset: "Done",
+ Issue: "Now",
+ Fetch: "Next",
+ Fill: "Locked",
+ Prove: "Locked",
+ Claim: "Locked"
+ });
+
+ await page.getByTestId("open-input-modal-0").click();
+ const inputModal = page.getByTestId("input-token-modal");
+ await expect(inputModal).toBeVisible({ timeout: UI_TIMEOUT_MS });
+ await inputModal.locator("select#tokenSelector").selectOption("usdc");
+
+ const baseRow = inputModal.getByTestId("input-token-row-base");
+ await baseRow.locator('input[type="checkbox"]').check();
+ await baseRow.locator('input[type="number"]').fill(REQUIRED_INPUT_USDC_HUMAN);
+ await page.getByTestId("input-token-modal-save").click();
+ await expect(inputModal).toBeHidden({ timeout: UI_TIMEOUT_MS });
+
+ const exclusiveInput = page.getByPlaceholder("0x... (optional)");
+ await exclusiveInput.fill(issuerAddress);
+ await page.getByLabel("Lock Exclusive").check();
+ await expect(exclusiveInput).toHaveValue(issuerAddress);
+
+ await page.getByTestId("quote-button").click();
+ await expect(page.getByTestId("quote-button")).toBeVisible();
+ await expect.poll(() => sawRequiredInputAmount).toBe(true);
+
+ if (
+ await page
+ .getByRole("button", { name: "Set allowance" })
+ .isVisible()
+ .catch(() => false)
+ ) {
+ await page.getByRole("button", { name: "Set allowance" }).click();
+ }
+
+ const executeOpenButton = page.getByRole("button", { name: "Execute Open" });
+ await expect(executeOpenButton).toBeVisible({ timeout: TX_TIMEOUT_MS });
+ await executeOpenButton.click();
+
+ await expect(page.getByRole("heading", { name: "Select Intent To Solve" })).toBeVisible({
+ timeout: TX_TIMEOUT_MS
+ });
+ await expectRightRailState(page, {
+ Asset: "Done",
+ Issue: "Done",
+ Fetch: "Now",
+ Fill: "Locked",
+ Prove: "Locked",
+ Claim: "Locked"
+ });
+
+ const activeIntentRow = page.getByRole("button", { name: /SingleChain/i }).first();
+ await expect(activeIntentRow).toBeVisible({ timeout: UI_TIMEOUT_MS });
+ await expect(page.getByRole("button", { name: /IN 0\.0001 USDC on base/i }).first()).toBeVisible({
+ timeout: UI_TIMEOUT_MS
+ });
+ await activeIntentRow.click();
+ const currentOrder = await page.evaluate(async () => {
+ const { default: store } = await import("/src/lib/state.svelte.ts");
+ const { buildBaseIntentRow } = await import("/src/lib/libraries/intentList.ts");
+ const latest = store.orders.at(-1);
+ if (!latest) return null;
+ const baseRow = buildBaseIntentRow(latest);
+
+ const order = latest.order as
+ | { originChainId?: bigint }
+ | { inputs?: Array<{ chainId: bigint }> };
+ const inputChainId =
+ "originChainId" in order && typeof order.originChainId === "bigint"
+ ? order.originChainId.toString()
+ : (order.inputs?.[0]?.chainId?.toString() ?? "");
+
+ return {
+ orderId: baseRow.orderId,
+ inputSettler: latest.inputSettler,
+ inputChainId
+ };
+ });
+ expect(currentOrder).not.toBeNull();
+
+ await expect(page.getByRole("heading", { name: "Fill Intent" })).toBeVisible({
+ timeout: UI_TIMEOUT_MS
+ });
+ await expectRightRailState(page, {
+ Asset: "Done",
+ Issue: "Done",
+ Fetch: "Done",
+ Fill: "Now",
+ Prove: "Locked",
+ Claim: "Locked"
+ });
+
+ const fillButton = page.getByRole("button", { name: /^Fill$/ }).first();
+ await expect(fillButton).toBeEnabled({ timeout: UI_TIMEOUT_MS });
+ await fillButton.click();
+
+ await expect(page.getByRole("heading", { name: "Submit Proof of Fill" })).toBeVisible({
+ timeout: TX_TIMEOUT_MS
+ });
+ await expectRightRailState(page, {
+ Asset: "Done",
+ Issue: "Done",
+ Fetch: "Done",
+ Fill: "Done",
+ Prove: "Now",
+ Claim: "Locked"
+ });
+
+ const proveButton = page.getByRole("button", { name: /^\d+(\.\d+)?\s+USDC$/ }).first();
+ let reachedFinalise = false;
+ for (let attempt = 0; attempt < 4; attempt++) {
+ await expect(proveButton).toBeVisible({ timeout: UI_TIMEOUT_MS });
+ await expect(proveButton).toBeEnabled({ timeout: UI_TIMEOUT_MS });
+ await proveButton.click();
+ try {
+ await expect(page.getByRole("heading", { name: "Finalise Intent" })).toBeVisible({
+ timeout: PROVE_ATTEMPT_TIMEOUT_MS
+ });
+ reachedFinalise = true;
+ break;
+ } catch {
+ await page.waitForTimeout(3_000);
+ }
+ }
+ expect(reachedFinalise).toBe(true);
+
+ await expectRightRailState(page, {
+ Asset: "Done",
+ Issue: "Done",
+ Fetch: "Done",
+ Fill: "Done",
+ Prove: "Done",
+ Claim: "Now"
+ });
+
+ const claimButton = page.getByRole("button", { name: "Claim" }).first();
+ await expect(claimButton).toBeEnabled({ timeout: UI_TIMEOUT_MS });
+ const receiptsBeforeClaim = await getReceiptCount();
+ await claimButton.click();
+
+ await expect
+ .poll(async () => await getReceiptCount(), { timeout: TX_TIMEOUT_MS })
+ .toBeGreaterThan(receiptsBeforeClaim);
+
+ await expect
+ .poll(
+ async () =>
+ await page.evaluate(async (orderMeta) => {
+ const { getClient } = await import("/src/lib/config.ts");
+ const { SETTLER_ESCROW_ABI } = await import("/src/lib/abi/escrow.ts");
+ if (!orderMeta) return -1;
+ const status = await getClient(orderMeta.inputChainId).readContract({
+ address: orderMeta.inputSettler as `0x${string}`,
+ abi: SETTLER_ESCROW_ABI,
+ functionName: "orderStatus",
+ args: [orderMeta.orderId as `0x${string}`]
+ });
+ return Number(status);
+ }, currentOrder),
+ { timeout: TX_TIMEOUT_MS }
+ )
+ .toBe(ORDER_STATUS_CLAIMED);
+
+ await expectRightRailState(page, {
+ Asset: "Done",
+ Issue: "Done",
+ Fetch: "Done",
+ Fill: "Done",
+ Prove: "Done",
+ Claim: "Now"
+ });
+});
diff --git a/tests/e2e/escrow-standard-live.spec.ts b/tests/e2e/escrow-standard-live.spec.ts
new file mode 100644
index 0000000..cf444a2
--- /dev/null
+++ b/tests/e2e/escrow-standard-live.spec.ts
@@ -0,0 +1,280 @@
+import { expect, test, type Page } from "@playwright/test";
+import {
+ connectInjectedWallet,
+ e2eWalletAddress,
+ hasE2EPrivateKey,
+ installInjectedWalletProvider
+} from "./helpers/bootstrap";
+
+const REQUIRED_INPUT_USDC_RAW = "100";
+const TEST_TIMEOUT_MS = 2 * 60_000;
+const UI_TIMEOUT_MS = 30_000;
+const TX_TIMEOUT_MS = 45_000;
+const ORDER_STATUS_CLAIMED = 2;
+const PROVE_ATTEMPT_TIMEOUT_MS = 20_000;
+
+test.skip(!hasE2EPrivateKey, "Skipping private-key E2E tests: E2E_PRIVATE_KEY is not defined.");
+
+test.setTimeout(TEST_TIMEOUT_MS);
+
+async function resolveIssuanceActionState(page: Page): Promise<"execute-open" | "low-balance"> {
+ const executeOpenButton = page.getByRole("button", { name: "Execute Open" });
+ const lowBalanceButton = page.getByRole("button", { name: "Low Balance" });
+ const started = Date.now();
+
+ while (Date.now() - started < TX_TIMEOUT_MS) {
+ if (await lowBalanceButton.isVisible().catch(() => false)) return "low-balance";
+ if (await executeOpenButton.isVisible().catch(() => false)) return "execute-open";
+ await page.waitForTimeout(200);
+ }
+
+ throw new Error("Timed out waiting for issuance action state (Execute Open or Low Balance).");
+}
+
+test("executes full standard escrow flow from base to arbitrum with raw input 100", async ({
+ page
+}) => {
+ const issuerAddress = e2eWalletAddress();
+ let sawExpectedQuotePayload = false;
+ let sawExclusiveForIssuer = false;
+ const getReceiptCount = async () =>
+ await page.evaluate(async () => {
+ const { default: store } = await import("/src/lib/state.svelte.ts");
+ return Object.keys(store.transactionReceipts).length;
+ });
+
+ await page.route("**/quote/request", async (route) => {
+ const body = route.request().postDataJSON() as
+ | {
+ intent?: {
+ metadata?: { exclusiveFor?: string[] | string };
+ inputs?: Array<{ amount?: string }>;
+ outputs?: Array<{ amount?: string }>;
+ };
+ }
+ | undefined;
+
+ const firstInputAmount = body?.intent?.inputs?.[0]?.amount;
+ const firstOutputAmount = body?.intent?.outputs?.[0]?.amount;
+ if (firstInputAmount === REQUIRED_INPUT_USDC_RAW && firstOutputAmount === "0") {
+ sawExpectedQuotePayload = true;
+ }
+ const exclusiveForRaw = body?.intent?.metadata?.exclusiveFor;
+ const exclusiveFor =
+ Array.isArray(exclusiveForRaw) && exclusiveForRaw.length > 0
+ ? exclusiveForRaw[0]
+ : (exclusiveForRaw ?? "");
+ if (exclusiveFor.toLowerCase() === issuerAddress.toLowerCase()) {
+ sawExclusiveForIssuer = true;
+ }
+
+ await route.fulfill({
+ status: 200,
+ contentType: "application/json",
+ body: JSON.stringify({
+ quotes: [
+ {
+ order: null,
+ eta: null,
+ validUntil: Date.now() + 60_000,
+ quoteId: null,
+ metadata: { exclusiveFor: issuerAddress },
+ preview: {
+ inputs: [],
+ outputs: [
+ {
+ receiver: "0x0000000000000000000000000000000000000000",
+ asset: "0x0000000000000000000000000000000000000000",
+ amount: REQUIRED_INPUT_USDC_RAW
+ }
+ ]
+ },
+ provider: null,
+ partialFill: false,
+ failureHandling: "refund-automatic"
+ }
+ ]
+ })
+ });
+ });
+
+ await installInjectedWalletProvider(page);
+ await page.goto("/");
+ await connectInjectedWallet(page);
+
+ await expect(page.getByRole("heading", { name: "Assets Management" })).toBeVisible();
+ await page.getByTestId("network-mainnet").click();
+ await page.getByTestId("intent-type-escrow").click();
+
+ // Keep the flow deterministic by fixing tiny standard-order assets directly in state.
+ await page.evaluate(
+ async ({ amount, issuer }) => {
+ const { default: store } = await import("/src/lib/state.svelte.ts");
+ const { coinList, chainMap } = await import("/src/lib/config");
+ const coins = coinList(true);
+ const baseUsdc = coins.find(
+ (token) => token.chainId === chainMap.base.id && token.name === "usdc"
+ );
+ const arbitrumUsdc = coins.find(
+ (token) => token.chainId === chainMap.arbitrum.id && token.name === "usdc"
+ );
+ if (!baseUsdc || !arbitrumUsdc) {
+ throw new Error("Could not resolve base/arbitrum USDC from coin list.");
+ }
+
+ store.mainnet = true;
+ store.intentType = "escrow";
+ store.orders = [];
+ store.inputTokens = [{ token: baseUsdc, amount: BigInt(amount) }];
+ store.outputTokens = [{ token: arbitrumUsdc, amount: BigInt(amount) }];
+ store.exclusiveFor = issuer;
+ store.useExclusiveForQuoteRequest = true;
+ },
+ { amount: REQUIRED_INPUT_USDC_RAW, issuer: issuerAddress }
+ );
+
+ await page.getByRole("button", { name: "→" }).first().click();
+ await expect(page.getByRole("heading", { name: "Intent Issuance" })).toBeVisible();
+
+ await page.getByTestId("quote-button").click();
+ await expect.poll(() => sawExpectedQuotePayload).toBe(true);
+ await expect.poll(() => sawExclusiveForIssuer).toBe(true);
+
+ if (
+ await page
+ .getByRole("button", { name: "Set allowance" })
+ .isVisible()
+ .catch(() => false)
+ ) {
+ await page.getByRole("button", { name: "Set allowance" }).click();
+ }
+
+ const actionState = await resolveIssuanceActionState(page);
+ if (actionState === "low-balance") {
+ test.skip(true, "Skipping live flow: wallet has insufficient Base USDC for Execute Open.");
+ }
+
+ await page.getByRole("button", { name: "Execute Open" }).click();
+ await expect(page.getByRole("heading", { name: "Select Intent To Solve" })).toBeVisible({
+ timeout: TX_TIMEOUT_MS
+ });
+
+ const activeIntentRow = page.getByRole("button", { name: /SingleChain/i }).first();
+ await expect(activeIntentRow).toBeVisible({ timeout: TX_TIMEOUT_MS });
+ await activeIntentRow.click();
+
+ const currentOrder = await page.evaluate(async () => {
+ const { default: store } = await import("/src/lib/state.svelte.ts");
+ const { buildBaseIntentRow } = await import("/src/lib/libraries/intentList.ts");
+ const latest = store.orders.at(-1);
+ if (!latest) return null;
+ const baseRow = buildBaseIntentRow(latest);
+
+ const order = latest.order as
+ | { originChainId?: bigint }
+ | { inputs?: Array<{ chainId: bigint }> };
+ const inputChainId =
+ "originChainId" in order && typeof order.originChainId === "bigint"
+ ? order.originChainId.toString()
+ : (order.inputs?.[0]?.chainId?.toString() ?? "");
+
+ return {
+ orderId: baseRow.orderId,
+ inputSettler: latest.inputSettler,
+ inputChainId
+ };
+ });
+ expect(currentOrder).not.toBeNull();
+ const observedInputRaw = await page.evaluate(async () => {
+ const { default: store } = await import("/src/lib/state.svelte.ts");
+ const latest = store.orders.at(-1) as
+ | { order?: { inputs?: Array<[bigint, bigint]> } }
+ | undefined;
+ const inputs = latest?.order?.inputs;
+ if (!inputs || inputs.length === 0) return null;
+ const sum = inputs.reduce((acc, input) => acc + input[1], 0n);
+ return sum.toString();
+ });
+ // Exact raw input is asserted at quote request time; here we assert the selected order still has input.
+ expect(observedInputRaw).not.toBeNull();
+ expect(BigInt(observedInputRaw as string)).toBeGreaterThan(0n);
+
+ await expect(page.getByRole("heading", { name: "Fill Intent" })).toBeVisible({
+ timeout: UI_TIMEOUT_MS
+ });
+ await expect(page.getByText(/^arbitrum$/i).last()).toBeVisible();
+
+ const fillButton = page.getByRole("button", { name: /^Fill$/ }).first();
+ await expect(fillButton).toBeEnabled({ timeout: UI_TIMEOUT_MS });
+ const receiptsBeforeFill = await getReceiptCount();
+ await fillButton.click();
+
+ await expect
+ .poll(async () => await getReceiptCount(), { timeout: TX_TIMEOUT_MS })
+ .toBeGreaterThan(receiptsBeforeFill);
+
+ await expect(page.getByRole("heading", { name: "Submit Proof of Fill" })).toBeVisible({
+ timeout: TX_TIMEOUT_MS
+ });
+
+ const proveButton = page.getByRole("button", { name: /^\d+(\.\d+)?\s+USDC$/ }).first();
+ let validated = false;
+ for (let attempt = 0; attempt < 4; attempt++) {
+ await expect(proveButton).toBeVisible({ timeout: UI_TIMEOUT_MS });
+ await expect(proveButton).toBeEnabled({ timeout: UI_TIMEOUT_MS });
+ await proveButton.click();
+ try {
+ await expect
+ .poll(
+ async () =>
+ await page.evaluate(async () => {
+ const { default: store } = await import("/src/lib/state.svelte.ts");
+ const { getOrderProgressChecks } = await import("/src/lib/libraries/flowProgress.ts");
+ const latest = store.orders.at(-1);
+ if (!latest) return false;
+ const checks = await getOrderProgressChecks(latest, store.fillTransactions);
+ return checks.allValidated;
+ }),
+ { timeout: PROVE_ATTEMPT_TIMEOUT_MS, intervals: [1_000, 2_000, 4_000] }
+ )
+ .toBe(true);
+ validated = true;
+ break;
+ } catch {
+ await page.waitForTimeout(3_000);
+ }
+ }
+ expect(validated).toBe(true);
+
+ await expect(page.getByRole("heading", { name: "Finalise Intent" })).toBeVisible({
+ timeout: TX_TIMEOUT_MS
+ });
+
+ const claimButton = page.getByRole("button", { name: "Claim" }).first();
+ await expect(claimButton).toBeEnabled({ timeout: UI_TIMEOUT_MS });
+ const receiptsBeforeClaim = await getReceiptCount();
+ await claimButton.click();
+
+ await expect
+ .poll(async () => await getReceiptCount(), { timeout: TX_TIMEOUT_MS })
+ .toBeGreaterThan(receiptsBeforeClaim);
+
+ await expect
+ .poll(
+ async () =>
+ await page.evaluate(async (orderMeta) => {
+ const { getClient } = await import("/src/lib/config.ts");
+ const { SETTLER_ESCROW_ABI } = await import("/src/lib/abi/escrow.ts");
+ if (!orderMeta) return -1;
+ const status = await getClient(orderMeta.inputChainId).readContract({
+ address: orderMeta.inputSettler as `0x${string}`,
+ abi: SETTLER_ESCROW_ABI,
+ functionName: "orderStatus",
+ args: [orderMeta.orderId as `0x${string}`]
+ });
+ return Number(status);
+ }, currentOrder),
+ { timeout: TX_TIMEOUT_MS }
+ )
+ .toBe(ORDER_STATUS_CLAIMED);
+});
diff --git a/tests/e2e/helpers/bootstrap.ts b/tests/e2e/helpers/bootstrap.ts
index 798e97c..21456d2 100644
--- a/tests/e2e/helpers/bootstrap.ts
+++ b/tests/e2e/helpers/bootstrap.ts
@@ -1,13 +1,261 @@
import type { Page } from "@playwright/test";
+import process from "node:process";
+import { config as loadDotenv } from "dotenv";
+import type { Hex } from "viem";
+import { createPublicClient, createWalletClient, http, toHex } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { arbitrum, base } from "viem/chains";
+
+type ProviderPayload = {
+ method: string;
+ params?: unknown[];
+};
+
+function ensureEnvLoaded() {
+ const envFilePath = process.env.E2E_ENV_FILE?.trim() || ".env";
+ loadDotenv({ path: envFilePath, quiet: true });
+}
+
+ensureEnvLoaded();
+
+function getE2EEnv(name: string) {
+ return process.env[name]?.trim();
+}
+
+export const hasE2EPrivateKey = Boolean(getE2EEnv("E2E_PRIVATE_KEY"));
+
+const BASE_CHAIN_ID = base.id;
+const ARBITRUM_CHAIN_ID = arbitrum.id;
+const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const;
+const ERC20_BALANCE_OF_ABI = [
+ {
+ type: "function",
+ name: "balanceOf",
+ stateMutability: "view",
+ inputs: [{ name: "owner", type: "address" }],
+ outputs: [{ name: "", type: "uint256" }]
+ }
+] as const;
+const baseRpcUrl = getE2EEnv("E2E_BASE_RPC_URL") || "https://base-rpc.publicnode.com";
+const arbitrumRpcUrl = getE2EEnv("E2E_ARBITRUM_RPC_URL") || "https://arbitrum-rpc.publicnode.com";
+
+let accountCache: ReturnType | undefined;
+let walletClientByChainCache: Record> | undefined;
+let basePublicClientCache: ReturnType | undefined;
+
+function rpcUrlForChain(chainId: number): string {
+ if (chainId === BASE_CHAIN_ID) return baseRpcUrl;
+ if (chainId === ARBITRUM_CHAIN_ID) return arbitrumRpcUrl;
+ throw new Error(`Unsupported chain for E2E wallet provider: ${chainId}`);
+}
+
+function getWalletContext() {
+ const configuredPrivateKey = getE2EEnv("E2E_PRIVATE_KEY") as Hex | undefined;
+ if (!configuredPrivateKey) {
+ throw new Error("E2E_PRIVATE_KEY is required for E2E wallet injection.");
+ }
+
+ const account = (accountCache ??= privateKeyToAccount(configuredPrivateKey));
+ const walletClientByChain =
+ walletClientByChainCache ??
+ (walletClientByChainCache = {
+ [BASE_CHAIN_ID]: createWalletClient({
+ account,
+ chain: base,
+ transport: http(baseRpcUrl)
+ }),
+ [ARBITRUM_CHAIN_ID]: createWalletClient({
+ account,
+ chain: arbitrum,
+ transport: http(arbitrumRpcUrl)
+ })
+ });
+ return { account, walletClientByChain };
+}
+
+function activeWalletClient() {
+ const { walletClientByChain } = getWalletContext();
+ const walletClient = walletClientByChain[currentChainId];
+ if (!walletClient) {
+ throw new Error(`No wallet client configured for active chain ${currentChainId}.`);
+ }
+ return walletClient;
+}
+
+let currentChainId = Number(process.env.E2E_CHAIN_ID ?? BASE_CHAIN_ID);
+if (!Number.isFinite(currentChainId)) {
+ currentChainId = BASE_CHAIN_ID;
+}
+
+async function rpcRequest(method: string, params: unknown[] = []) {
+ const response = await fetch(rpcUrlForChain(currentChainId), {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ jsonrpc: "2.0",
+ id: Date.now(),
+ method,
+ params
+ })
+ });
+ const payload = (await response.json()) as { result?: unknown; error?: { message?: string } };
+ if (payload.error) {
+ throw new Error(payload.error.message ?? `RPC error for method ${method}`);
+ }
+ return payload.result;
+}
+
+function asBigInt(value: unknown): bigint | undefined {
+ if (typeof value !== "string" || value.length === 0) return undefined;
+ return BigInt(value);
+}
+
+async function handleProviderRequest(payload: ProviderPayload) {
+ const { account } = getWalletContext();
+ const { method, params = [] } = payload;
+
+ if (method === "eth_chainId") return toHex(currentChainId);
+ if (method === "eth_accounts" || method === "eth_requestAccounts") return [account.address];
+ if (method === "wallet_switchEthereumChain") {
+ const nextChainHex = (params[0] as { chainId?: string } | undefined)?.chainId;
+ if (!nextChainHex) throw new Error("wallet_switchEthereumChain missing chainId");
+ currentChainId = Number(BigInt(nextChainHex));
+ return null;
+ }
+
+ if (method === "eth_sendTransaction") {
+ const walletClient = activeWalletClient();
+ const tx = (params[0] as Record | undefined) ?? {};
+ return await walletClient.sendTransaction({
+ account,
+ to: tx.to as Hex | undefined,
+ data: tx.data as Hex | undefined,
+ value: asBigInt(tx.value),
+ gas: asBigInt(tx.gas),
+ maxFeePerGas: asBigInt(tx.maxFeePerGas),
+ maxPriorityFeePerGas: asBigInt(tx.maxPriorityFeePerGas)
+ });
+ }
+
+ if (method === "eth_signTypedData_v4" || method === "eth_signTypedData") {
+ const rawTypedData = params[1];
+ const typedData =
+ typeof rawTypedData === "string"
+ ? (JSON.parse(rawTypedData) as Record)
+ : ((rawTypedData ?? {}) as Record);
+ const types = { ...(typedData.types as Record) };
+ delete (types as Record).EIP712Domain;
+ return account.signTypedData({
+ domain: (typedData.domain as Record) ?? {},
+ types: types as Record,
+ primaryType: typedData.primaryType as string,
+ message: (typedData.message as Record) ?? {}
+ } as never);
+ }
+
+ if (method === "personal_sign") {
+ const message = params[0];
+ if (typeof message === "string" && message.startsWith("0x")) {
+ return account.signMessage({ message: { raw: message as Hex } });
+ }
+ return account.signMessage({ message: String(message ?? "") });
+ }
+
+ return rpcRequest(method, params);
+}
+
+export async function installInjectedWalletProvider(page: Page) {
+ getWalletContext();
+
+ await page.exposeFunction("__lintentE2EProviderRequest", (payload: ProviderPayload) => {
+ return handleProviderRequest(payload);
+ });
+
+ await page.addInitScript(() => {
+ type E2EWindow = Window &
+ typeof globalThis & {
+ __lintentE2EProviderRequest: (payload: {
+ method: string;
+ params?: unknown[];
+ }) => Promise;
+ __LINTENT_E2E_PROVIDER__?: unknown;
+ ethereum?: unknown;
+ };
+ const e2eWindow = window as E2EWindow;
+
+ const listeners = new Map void>>();
+ const emit = (event: string, value: unknown) => {
+ const set = listeners.get(event);
+ if (!set) return;
+ for (const listener of set) listener(value);
+ };
+
+ const provider = {
+ isMetaMask: false,
+ request: async ({ method, params }: { method: string; params?: unknown[] }) => {
+ const result = await e2eWindow.__lintentE2EProviderRequest({
+ method,
+ params: params ?? []
+ });
+
+ if (method === "eth_requestAccounts") emit("accountsChanged", result);
+ if (method === "wallet_switchEthereumChain") {
+ const nextChain = (params?.[0] as { chainId?: string } | undefined)?.chainId;
+ if (nextChain) emit("chainChanged", nextChain);
+ }
+
+ return result;
+ },
+ enable: async () => {
+ return await provider.request({ method: "eth_requestAccounts", params: [] });
+ },
+ on: (event: string, callback: (value: unknown) => void) => {
+ const set = listeners.get(event) ?? new Set<(value: unknown) => void>();
+ set.add(callback);
+ listeners.set(event, set);
+ },
+ removeListener: (event: string, callback: (value: unknown) => void) => {
+ listeners.get(event)?.delete(callback);
+ },
+ off: (event: string, callback: (value: unknown) => void) => {
+ listeners.get(event)?.delete(callback);
+ }
+ };
+
+ e2eWindow.__LINTENT_E2E_PROVIDER__ = provider;
+ e2eWindow.ethereum = provider;
+ });
+}
+
+export async function connectInjectedWallet(page: Page) {
+ await page.getByRole("button", { name: "Connect Injected" }).click();
+}
+
+export function e2eWalletAddress() {
+ const { account } = getWalletContext();
+ return account.address;
+}
+
+export async function hasBaseUsdcBalance(minimumRawAmount: bigint) {
+ const { account } = getWalletContext();
+ const basePublicClient =
+ basePublicClientCache ??
+ (basePublicClientCache = createPublicClient({
+ chain: base,
+ transport: http(baseRpcUrl)
+ }));
+
+ const balance = await basePublicClient.readContract({
+ address: BASE_USDC,
+ abi: ERC20_BALANCE_OF_ABI,
+ functionName: "balanceOf",
+ args: [account.address]
+ });
+ return balance >= minimumRawAmount;
+}
export async function bootstrapConnectedWallet(page: Page) {
- await page.evaluate(async () => {
- const { default: store } = await import("/src/lib/state.svelte.ts");
- (store as any).activeWallet.wallet = {
- accounts: [{ address: "0x1111111111111111111111111111111111111111" }],
- provider: {
- request: async () => null
- }
- };
- });
+ await installInjectedWalletProvider(page);
+ await page.goto("/");
+ await connectInjectedWallet(page);
}
diff --git a/tests/e2e/issuance.spec.ts b/tests/e2e/issuance.spec.ts
deleted file mode 100644
index 2afc8b7..0000000
--- a/tests/e2e/issuance.spec.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { expect, test } from "@playwright/test";
-import { mockQuoteResponse } from "../fixtures/mockQuote";
-import { bootstrapConnectedWallet } from "./helpers/bootstrap";
-
-test.beforeEach(async ({ page }) => {
- await page.route("**/quote/request", async (route) => {
- await route.fulfill({
- status: 200,
- contentType: "application/json",
- body: JSON.stringify(mockQuoteResponse)
- });
- });
- await page.route("**/orders/status/*", async (route) => {
- const now = Math.floor(Date.now() / 1000);
- await route.fulfill({
- status: 200,
- contentType: "application/json",
- body: JSON.stringify({
- data: {
- order: {
- user: "0x1111111111111111111111111111111111111111",
- nonce: "123",
- originChainId: "8453",
- expires: now + 3600,
- fillDeadline: now + 1800,
- inputOracle: "0x0000000000000000000000000000000000000001",
- inputs: [["1", "1000000"]],
- outputs: [
- {
- oracle: "0x0000000000000000000000000000000000000000000000000000000000000001",
- settler: "0x0000000000000000000000000000000000000000000000000000000000000001",
- chainId: "42161",
- token: "0x0000000000000000000000000000000000000000000000000000000000000001",
- amount: "1000000",
- recipient: "0x0000000000000000000000000000000000000000000000000000000000000001",
- callbackData: "0x",
- context: "0x"
- }
- ]
- },
- inputSettler: "0x000025c3226C00B2Cdc200005a1600509f4e00C0",
- sponsorSignature: null,
- allocatorSignature: null
- }
- })
- });
- });
-
- await page.goto("/");
- await bootstrapConnectedWallet(page);
-});
-
-test("asset management controls remain interactive", async ({ page }) => {
- await expect(page.getByRole("heading", { name: "Assets Management" })).toBeVisible();
-
- await page.getByTestId("network-mainnet").click();
- await page.getByTestId("network-testnet").click();
- await page.getByTestId("intent-type-compact").click();
- await page.getByTestId("intent-type-escrow").click();
- await page.getByTestId("intent-type-compact").click();
-
- await expect(page.getByTestId("allocator-116450367070547927622991121")).toBeVisible();
- await page.getByTestId("allocator-116450367070547927622991121").click();
-});
-
-test("input/output modals open and save in issuance screen", async ({ page }) => {
- await page.getByRole("button", { name: "→" }).click();
- await expect(page.getByRole("heading", { name: "Intent Issuance" })).toBeVisible();
-
- await page.getByTestId("open-input-modal-0").click();
- await expect(page.getByTestId("input-token-modal")).toBeVisible();
- await page.getByTestId("input-token-modal-save").click();
- await expect(page.getByTestId("input-token-modal")).toBeHidden();
-
- await page.getByTestId("open-output-modal-0").click();
- await expect(page.getByTestId("output-token-modal")).toBeVisible();
- await page.getByTestId("output-token-add").click();
- await page.getByTestId("output-token-modal-save").click();
- await expect(page.getByTestId("output-token-modal")).toBeHidden();
-
- await page.getByTestId("quote-button").click();
- await expect(page.getByTestId("quote-button")).toBeVisible();
-});
-
-test("imports order by order id into intent list", async ({ page }) => {
- await page.getByRole("button", { name: "→" }).click();
- await page.getByRole("button", { name: "→" }).click();
- await expect(page.getByRole("heading", { name: "Select Intent To Solve" })).toBeVisible();
-
- await page
- .getByTestId("intent-import-order-id")
- .fill("0x1111111111111111111111111111111111111111111111111111111111111111");
- await page.getByTestId("intent-import-order-submit").click();
-
- await expect(page.getByTestId("intent-import-order-id")).toHaveValue("");
-});
diff --git a/tests/fixtures/mockQuote.ts b/tests/fixtures/mockQuote.ts
index 458da7a..9852a66 100644
--- a/tests/fixtures/mockQuote.ts
+++ b/tests/fixtures/mockQuote.ts
@@ -1,24 +1,24 @@
export const mockQuoteResponse = {
- quotes: [
- {
- order: null,
- eta: null,
- validUntil: Date.now() + 30_000,
- quoteId: null,
- metadata: { exclusiveFor: "0x0000000000000000000000000000000000000000" },
- preview: {
- inputs: [],
- outputs: [
- {
- receiver: "0x0000000000000000000000000000000000000000",
- asset: "0x0000000000000000000000000000000000000000",
- amount: "1000000"
- }
- ]
- },
- provider: null,
- partialFill: false,
- failureHandling: "refund-automatic"
- }
- ]
+ quotes: [
+ {
+ order: null,
+ eta: null,
+ validUntil: Date.now() + 30_000,
+ quoteId: null,
+ metadata: { exclusiveFor: "0x0000000000000000000000000000000000000000" },
+ preview: {
+ inputs: [],
+ outputs: [
+ {
+ receiver: "0x0000000000000000000000000000000000000000",
+ asset: "0x0000000000000000000000000000000000000000",
+ amount: "1000000"
+ }
+ ]
+ },
+ provider: null,
+ partialFill: false,
+ failureHandling: "refund-automatic"
+ }
+ ]
};
diff --git a/tests/fixtures/orderFixtures.ts b/tests/fixtures/orderFixtures.ts
new file mode 100644
index 0000000..ab3a7b5
--- /dev/null
+++ b/tests/fixtures/orderFixtures.ts
@@ -0,0 +1,61 @@
+import type { MandateOutput, MultichainOrder, StandardOrder } from "@lifi/intent";
+import { COIN_FILLER, addressToBytes32 } from "@lifi/intent";
+
+export const CHAIN_ID_ETHEREUM = 1n;
+export const CHAIN_ID_ARBITRUM = 42161n;
+export const CHAIN_ID_BASE = 8453n;
+
+export const TEST_POLYMER_ORACLE: `0x${string}` = "0x0000003E06000007A224AeE90052fA6bb46d43C9";
+
+export const TEST_USER: `0x${string}` = "0x1111111111111111111111111111111111111111";
+export const TEST_NOW_SECONDS = 1_700_000_000;
+
+export const b32 = (nibble: string): `0x${string}` => `0x${nibble.repeat(64)}`;
+
+export function makeMandateOutput(
+ chainId = CHAIN_ID_ARBITRUM,
+ amount = 1n,
+ overrides: Partial = {}
+): MandateOutput {
+ return {
+ oracle: addressToBytes32(COIN_FILLER),
+ settler: addressToBytes32(COIN_FILLER),
+ chainId,
+ token: b32("3"),
+ amount,
+ recipient: b32("4"),
+ callbackData: "0x",
+ context: "0x",
+ ...overrides
+ };
+}
+
+export function makeStandardOrder(overrides: Partial = {}): StandardOrder {
+ return {
+ user: TEST_USER,
+ nonce: 1n,
+ originChainId: CHAIN_ID_ETHEREUM,
+ expires: TEST_NOW_SECONDS + 1000,
+ fillDeadline: TEST_NOW_SECONDS + 900,
+ inputOracle: TEST_POLYMER_ORACLE,
+ inputs: [[1n, 1n]],
+ outputs: [makeMandateOutput(CHAIN_ID_ARBITRUM)],
+ ...overrides
+ };
+}
+
+export function makeMultichainOrder(overrides: Partial = {}): MultichainOrder {
+ return {
+ user: TEST_USER,
+ nonce: 2n,
+ expires: TEST_NOW_SECONDS + 1000,
+ fillDeadline: TEST_NOW_SECONDS + 900,
+ inputOracle: TEST_POLYMER_ORACLE,
+ outputs: [makeMandateOutput(CHAIN_ID_BASE, 2n)],
+ inputs: [
+ { chainId: CHAIN_ID_ETHEREUM, inputs: [[1n, 1n]] },
+ { chainId: CHAIN_ID_ARBITRUM, inputs: [[2n, 2n]] }
+ ],
+ ...overrides
+ };
+}
diff --git a/tests/unit/assetSelection.test.ts b/tests/unit/assetSelection.test.ts
index 0fee6c5..0371b8e 100644
--- a/tests/unit/assetSelection.test.ts
+++ b/tests/unit/assetSelection.test.ts
@@ -2,25 +2,25 @@ import { describe, expect, it } from "bun:test";
import { AssetSelection } from "../../src/lib/libraries/assetSelection";
describe("AssetSelection", () => {
- it("picks largest-first values to satisfy goal", () => {
- const selector = new AssetSelection({
- goal: 7n,
- values: [4n, 4n, 3n]
- }).largest();
+ it("picks largest-first values to satisfy goal", () => {
+ const selector = new AssetSelection({
+ goal: 7n,
+ values: [4n, 4n, 3n]
+ }).largest();
- expect(selector.asValues()).toEqual([4n, 3n, 0n]);
- });
+ expect(selector.asValues()).toEqual([4n, 3n, 0n]);
+ });
- it("picks smallest-first values to satisfy goal", () => {
- const selector = new AssetSelection({
- goal: 7n,
- values: [4n, 4n, 3n]
- }).smallest();
+ it("picks smallest-first values to satisfy goal", () => {
+ const selector = new AssetSelection({
+ goal: 7n,
+ values: [4n, 4n, 3n]
+ }).smallest();
- expect(selector.asValues()).toEqual([4n, 0n, 3n]);
- });
+ expect(selector.asValues()).toEqual([4n, 0n, 3n]);
+ });
- it("throws when goal is infeasible", () => {
- expect(() => new AssetSelection({ goal: 10n, values: [2n, 3n] })).toThrow();
- });
+ it("throws when goal is infeasible", () => {
+ expect(() => new AssetSelection({ goal: 10n, values: [2n, 3n] })).toThrow();
+ });
});
diff --git a/tests/unit/intentList.test.ts b/tests/unit/intentList.test.ts
index b2a231a..9c42300 100644
--- a/tests/unit/intentList.test.ts
+++ b/tests/unit/intentList.test.ts
@@ -1,71 +1,107 @@
import { describe, expect, it } from "bun:test";
import {
- EXPIRING_THRESHOLD_SECONDS,
- formatRelativeDeadline,
- formatRemaining,
- withTiming,
- type BaseIntentRow
+ buildBaseIntentRow,
+ EXPIRING_THRESHOLD_SECONDS,
+ formatRelativeDeadline,
+ formatRemaining,
+ withTiming,
+ type BaseIntentRow
} from "../../src/lib/libraries/intentList";
const baseRow: BaseIntentRow = {
- orderContainer: {
- inputSettler: "0x000025c3226C00B2Cdc200005a1600509f4e00C0",
- order: {
- user: "0x1111111111111111111111111111111111111111",
- nonce: 1n,
- originChainId: 8453n,
- expires: Math.floor(Date.now() / 1000) + 3600,
- fillDeadline: Math.floor(Date.now() / 1000) + 3600,
- inputOracle: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
- inputs: [[1n, 1n]],
- outputs: [
- {
- oracle: "0x0000000000000000000000000000000000000000000000000000000000000001",
- settler: "0x0000000000000000000000000000000000000000000000000000000000000002",
- chainId: 42161n,
- token: "0x0000000000000000000000000000000000000000000000000000000000000003",
- amount: 1n,
- recipient: "0x0000000000000000000000000000000000000004",
- callbackData: "0x",
- context: "0x00"
- }
- ]
- },
- sponsorSignature: { type: "None", payload: "0x" },
- allocatorSignature: { type: "None", payload: "0x" }
- },
- orderId: "0xabc",
- orderIdShort: "0xabc",
- userShort: "0x1111...1111",
- fillDeadline: Math.floor(Date.now() / 1000) + 3600,
- inputCount: 1,
- outputCount: 1,
- chainScope: "singlechain",
- chainScopeBadge: "SingleChain",
- inputChips: [],
- inputOverflow: 0,
- outputChips: [],
- outputOverflow: 0,
- validationPassed: true,
- validationReason: "Validation pass"
+ orderContainer: {
+ inputSettler: "0x000025c3226C00B2Cdc200005a1600509f4e00C0",
+ order: {
+ user: "0x1111111111111111111111111111111111111111",
+ nonce: 1n,
+ originChainId: 8453n,
+ expires: Math.floor(Date.now() / 1000) + 3600,
+ fillDeadline: Math.floor(Date.now() / 1000) + 3600,
+ inputOracle: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ inputs: [[1n, 1n]],
+ outputs: [
+ {
+ oracle: "0x0000000000000000000000000000000000000000000000000000000000000001",
+ settler: "0x0000000000000000000000000000000000000000000000000000000000000002",
+ chainId: 42161n,
+ token: "0x0000000000000000000000000000000000000000000000000000000000000003",
+ amount: 1n,
+ recipient: "0x0000000000000000000000000000000000000004",
+ callbackData: "0x",
+ context: "0x00"
+ }
+ ]
+ },
+ sponsorSignature: { type: "None", payload: "0x" },
+ allocatorSignature: { type: "None", payload: "0x" }
+ },
+ orderId: "0xabc",
+ orderIdShort: "0xabc",
+ userShort: "0x1111...1111",
+ fillDeadline: Math.floor(Date.now() / 1000) + 3600,
+ inputCount: 1,
+ outputCount: 1,
+ chainScope: "singlechain",
+ chainScopeBadge: "SingleChain",
+ inputChips: [],
+ inputOverflow: 0,
+ outputChips: [],
+ outputOverflow: 0,
+ validationPassed: true,
+ validationReason: "Validation pass"
};
describe("intentList timing and formatting", () => {
- it("marks expired rows", () => {
- const row = withTiming(baseRow, baseRow.fillDeadline + 1);
- expect(row.status).toBe("expired");
- });
+ it("marks expired rows", () => {
+ const row = withTiming(baseRow, baseRow.fillDeadline + 1);
+ expect(row.status).toBe("expired");
+ });
- it("marks expiring rows", () => {
- const now = baseRow.fillDeadline - EXPIRING_THRESHOLD_SECONDS + 1;
- const row = withTiming(baseRow, now);
- expect(row.status).toBe("expiring");
- });
+ it("marks expiring rows", () => {
+ const now = baseRow.fillDeadline - EXPIRING_THRESHOLD_SECONDS + 1;
+ const row = withTiming(baseRow, now);
+ expect(row.status).toBe("expiring");
+ });
- it("formats remaining/relative deadline values", () => {
- expect(formatRemaining(59)).toBe("59s");
- expect(formatRemaining(180)).toBe("3m");
- expect(formatRelativeDeadline(30)).toBe("in 30s");
- expect(formatRelativeDeadline(-30)).toBe("30s ago");
- });
+ it("formats remaining/relative deadline values", () => {
+ expect(formatRemaining(59)).toBe("59s");
+ expect(formatRemaining(180)).toBe("3m");
+ expect(formatRelativeDeadline(30)).toBe("in 30s");
+ expect(formatRelativeDeadline(-30)).toBe("30s ago");
+ });
+
+ it("builds rows for unknown chains without throwing", () => {
+ const unknownChainId = 999999999n;
+ const row = buildBaseIntentRow({
+ inputSettler: "0x000025c3226C00B2Cdc200005a1600509f4e00C0",
+ order: {
+ user: "0x1111111111111111111111111111111111111111",
+ nonce: 1n,
+ originChainId: unknownChainId,
+ expires: Math.floor(Date.now() / 1000) + 3600,
+ fillDeadline: Math.floor(Date.now() / 1000) + 3600,
+ inputOracle: "0x0000000000eC36B683C2E6AC89e9A75989C22a2e",
+ inputs: [[1n, 1n]],
+ outputs: [
+ {
+ oracle: "0x0000000000000000000000000000000000000000000000000000000000000001",
+ settler: "0x0000000000000000000000000000000000000000000000000000000000000002",
+ chainId: unknownChainId,
+ token: "0x0000000000000000000000000000000000000000000000000000000000000003",
+ amount: 1n,
+ recipient: "0x0000000000000000000000000000000000000000000000000000000000000004",
+ callbackData: "0x",
+ context: "0x00"
+ }
+ ]
+ },
+ sponsorSignature: { type: "None", payload: "0x" },
+ allocatorSignature: { type: "None", payload: "0x" }
+ });
+
+ expect(row.inputChips[0].text).toContain("chain-999999999");
+ expect(row.outputChips[0].text).toContain("chain-999999999");
+ expect(row.inputChips[0].text).toContain("...");
+ expect(row.outputChips[0].text).toContain("...");
+ });
});
diff --git a/tests/unit/orderLib.test.ts b/tests/unit/orderLib.test.ts
deleted file mode 100644
index bcbb65d..0000000
--- a/tests/unit/orderLib.test.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
- COIN_FILLER,
- INPUT_SETTLER_COMPACT_LIFI,
- POLYMER_ORACLE,
- chainMap
-} from "../../src/lib/config";
-import {
- getOutputHash,
- validateOrder,
- validateOrderContainer,
- validateOrderWithReason,
- VALIDATION_ERRORS
-} from "../../src/lib/utils/orderLib";
-import { addressToBytes32 } from "../../src/lib/utils/convert";
-import type { MandateOutput, OrderContainer, StandardOrder } from "../../src/types";
-
-const b32 = (byte: string) => `0x${byte.repeat(64)}` as `0x${string}`;
-
-const output: MandateOutput = {
- oracle: addressToBytes32(COIN_FILLER),
- settler: addressToBytes32(COIN_FILLER),
- chainId: BigInt(chainMap.arbitrum.id),
- token: b32("3"),
- amount: 1n,
- recipient: b32("4"),
- callbackData: "0x",
- context: "0x00"
-};
-
-function makeOrder(overrides: Partial = {}): StandardOrder {
- return {
- user: "0x1111111111111111111111111111111111111111",
- nonce: 1n,
- originChainId: BigInt(chainMap.ethereum.id),
- expires: Math.floor(Date.now() / 1000) + 1000,
- fillDeadline: Math.floor(Date.now() / 1000) + 1000,
- inputOracle: POLYMER_ORACLE.ethereum,
- inputs: [[1n, 1n]],
- outputs: [output],
- ...overrides
- };
-}
-
-describe("orderLib", () => {
- it("produces stable output hashes", () => {
- const h1 = getOutputHash(output);
- const h2 = getOutputHash(output);
- expect(h1).toBe(h2);
- });
-
- it("changes hash when output amount changes", () => {
- const h1 = getOutputHash(output);
- const h2 = getOutputHash({ ...output, amount: output.amount + 1n });
- expect(h1).not.toBe(h2);
- });
-
- it("rejects orders where fillDeadline is later than expires", () => {
- const invalidTiming = makeOrder({
- expires: Math.floor(Date.now() / 1000) + 1000,
- fillDeadline: Math.floor(Date.now() / 1000) + 1001
- });
- const result = validateOrderWithReason(invalidTiming);
- expect(result.passed).toBe(false);
- expect(result.reason).toBe(VALIDATION_ERRORS.FILL_DEADLINE_AFTER_EXPIRES);
- });
-
- it("accepts orders with multiple outputs", () => {
- const multiOutput = makeOrder({ outputs: [output, { ...output, amount: 2n }] });
- expect(validateOrder(multiOutput)).toBe(true);
- });
-
- it("rejects orders with unknown source oracle", () => {
- const invalidOracle = makeOrder({
- inputOracle: "0x0000000000000000000000000000000000000001"
- });
- const result = validateOrderWithReason(invalidOracle);
- expect(result.passed).toBe(false);
- expect(result.reason).toBe(VALIDATION_ERRORS.INPUT_ORACLE_NOT_ALLOWED);
- });
-
- it("accepts same-chain intents with COIN_FILLER as inputOracle", () => {
- const sameChainCoinFiller = makeOrder({
- inputOracle: COIN_FILLER,
- outputs: [{ ...output, chainId: BigInt(chainMap.ethereum.id) }]
- });
- expect(validateOrder(sameChainCoinFiller)).toBe(true);
- });
-
- it("rejects orders with empty inputs", () => {
- const emptyInputs = makeOrder({ inputs: [] });
- const result = validateOrderWithReason(emptyInputs);
- expect(result.passed).toBe(false);
- expect(result.reason).toBe(VALIDATION_ERRORS.NO_INPUTS);
- });
-
- it("accepts orders with zero output amount", () => {
- const zeroOutputAmount = makeOrder({
- outputs: [{ ...output, amount: 0n }]
- });
- expect(validateOrder(zeroOutputAmount)).toBe(true);
- });
-
- it("rejects orders with negative output amount", () => {
- const negativeOutputAmount = makeOrder({
- outputs: [{ ...output, amount: -1n }]
- });
- const result = validateOrderWithReason(negativeOutputAmount);
- expect(result.passed).toBe(false);
- expect(result.reason).toBe(VALIDATION_ERRORS.OUTPUT_AMOUNT_NON_POSITIVE);
- });
-
- it("rejects orders with unknown output chain", () => {
- const badOutputChain = makeOrder({
- outputs: [{ ...output, chainId: 999999999n }]
- });
- const result = validateOrderWithReason(badOutputChain);
- expect(result.passed).toBe(false);
- expect(result.reason).toBe(VALIDATION_ERRORS.UNKNOWN_OUTPUT_CHAIN);
- });
-
- it("rejects orders with non-whitelisted output oracle", () => {
- const badOutputOracle = makeOrder({
- outputs: [{ ...output, oracle: b32("a") }]
- });
- const result = validateOrderWithReason(badOutputOracle);
- expect(result.passed).toBe(false);
- expect(result.reason).toBe(VALIDATION_ERRORS.OUTPUT_ORACLE_NOT_ALLOWED);
- });
-
- it("rejects orders with non-whitelisted output settler", () => {
- const badOutputSettler = makeOrder({
- outputs: [{ ...output, settler: b32("b") }]
- });
- const result = validateOrderWithReason(badOutputSettler);
- expect(result.passed).toBe(false);
- expect(result.reason).toBe(VALIDATION_ERRORS.OUTPUT_SETTLER_NOT_ALLOWED);
- });
-
- it("treats compact intents as valid in container validator (TODO path)", () => {
- const compactContainer: OrderContainer = {
- inputSettler: INPUT_SETTLER_COMPACT_LIFI,
- order: makeOrder({
- inputOracle: "0x0000000000000000000000000000000000000001"
- }),
- sponsorSignature: { type: "None", payload: "0x" },
- allocatorSignature: { type: "None", payload: "0x" }
- };
- expect(validateOrderContainer(compactContainer)).toBe(true);
- });
-});
diff --git a/tests/unit/orderServer.test.ts b/tests/unit/orderServer.test.ts
deleted file mode 100644
index 738080a..0000000
--- a/tests/unit/orderServer.test.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { parseOrderStatusPayload } from "../../src/lib/libraries/orderServer";
-
-const BYTES32_ONE = "0x0000000000000000000000000000000000000000000000000000000000000001" as const;
-
-describe("parseOrderStatusPayload", () => {
- it("parses a status payload into an OrderContainer", () => {
- const payload = {
- data: {
- order: {
- user: "0x1111111111111111111111111111111111111111",
- nonce: "123",
- originChainId: "8453",
- expires: Math.floor(Date.now() / 1000) + 3600,
- fillDeadline: Math.floor(Date.now() / 1000) + 1800,
- inputOracle: "0x0000000000000000000000000000000000000001",
- inputs: [["1", "1000000"]],
- outputs: [
- {
- oracle: BYTES32_ONE,
- settler: BYTES32_ONE,
- chainId: "42161",
- token: BYTES32_ONE,
- amount: "1000000",
- recipient: BYTES32_ONE,
- callbackData: "0x",
- context: "0x"
- }
- ]
- },
- inputSettler: "0x000025c3226C00B2Cdc200005a1600509f4e00C0",
- sponsorSignature: null,
- allocatorSignature: "0x1234"
- }
- };
-
- const parsed = parseOrderStatusPayload(payload);
-
- expect(parsed.inputSettler).toBe("0x000025c3226C00B2Cdc200005a1600509f4e00C0");
- expect(parsed.order.nonce).toBe(123n);
- expect("originChainId" in parsed.order && parsed.order.originChainId).toBe(8453n);
- expect(parsed.sponsorSignature).toEqual({ type: "None", payload: "0x" });
- expect(parsed.allocatorSignature).toEqual({ type: "ECDSA", payload: "0x1234" });
- });
-
- it("throws for invalid payload", () => {
- expect(() => parseOrderStatusPayload({ data: {} })).toThrow();
- });
-});
diff --git a/tests/unit/orderValidationDeps.test.ts b/tests/unit/orderValidationDeps.test.ts
new file mode 100644
index 0000000..6eaf3cc
--- /dev/null
+++ b/tests/unit/orderValidationDeps.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "bun:test";
+import {
+ COIN_FILLER,
+ VALIDATION_ERRORS,
+ addressToBytes32,
+ validateOrderWithReason
+} from "@lifi/intent";
+import { makeMandateOutput, makeStandardOrder } from "../fixtures/orderFixtures";
+import { orderValidationDeps } from "../../src/lib/libraries/coreDeps";
+
+describe("orderValidationDeps unknown-chain handling", () => {
+ it("rejects unsupported origin chains even when same-chain fill uses COIN_FILLER", () => {
+ const unknownChainId = 999999999n;
+ const result = validateOrderWithReason({
+ order: makeStandardOrder({
+ originChainId: unknownChainId,
+ inputOracle: COIN_FILLER,
+ outputs: [
+ makeMandateOutput(unknownChainId, 1n, {
+ oracle: addressToBytes32(COIN_FILLER),
+ settler: addressToBytes32(COIN_FILLER),
+ context: "0x00"
+ })
+ ]
+ }),
+ deps: orderValidationDeps
+ });
+
+ expect(result.passed).toBe(false);
+ expect(result.reason).toBe(VALIDATION_ERRORS.UNKNOWN_ORIGIN_CHAIN);
+ });
+
+ it("rejects unsupported output chains instead of treating them as COIN_FILLER-only", () => {
+ const unknownChainId = 999999999n;
+ const result = validateOrderWithReason({
+ order: makeStandardOrder({
+ outputs: [
+ makeMandateOutput(unknownChainId, 1n, {
+ oracle: addressToBytes32(COIN_FILLER),
+ settler: addressToBytes32(COIN_FILLER),
+ context: "0x00"
+ })
+ ]
+ }),
+ deps: orderValidationDeps
+ });
+
+ expect(result.passed).toBe(false);
+ expect(result.reason).toBe(VALIDATION_ERRORS.UNKNOWN_OUTPUT_CHAIN);
+ });
+});
diff --git a/tests/unit/recipientField.test.ts b/tests/unit/recipientField.test.ts
new file mode 100644
index 0000000..73d3edd
--- /dev/null
+++ b/tests/unit/recipientField.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from "bun:test";
+import { isAddress } from "viem";
+
+// Mirrors the resolveRecipient helper in IssueIntent.svelte
+const resolveRecipient = (value: string): `0x${string}` | undefined =>
+ isAddress(value, { strict: false }) ? (value as `0x${string}`) : undefined;
+
+describe("resolveRecipient", () => {
+ it("returns the address for a valid checksummed EVM address", () => {
+ const addr = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+ expect(resolveRecipient(addr)).toBe(addr);
+ });
+
+ it("returns the address for a valid lowercase EVM address (strict: false)", () => {
+ const addr = "0xd8da6bf26964af9d7eed9e03e53415d37aa96045";
+ expect(resolveRecipient(addr)).toBe(addr);
+ });
+
+ it("returns undefined for an empty string", () => {
+ expect(resolveRecipient("")).toBeUndefined();
+ });
+
+ it("returns undefined for a partial address", () => {
+ expect(resolveRecipient("0x1234")).toBeUndefined();
+ });
+
+ it("returns undefined for arbitrary non-address text", () => {
+ expect(resolveRecipient("alice.eth")).toBeUndefined();
+ });
+
+ it("returns undefined for a hex string that is too long", () => {
+ expect(resolveRecipient("0x" + "a".repeat(42))).toBeUndefined();
+ });
+});
+
+describe("outputRecipient in AppCreateIntentOptions", () => {
+ it("is undefined when recipient field is empty", () => {
+ const recipient = "";
+ const outputRecipient = resolveRecipient(recipient);
+ expect(outputRecipient).toBeUndefined();
+ });
+
+ it("is set when a valid address is provided", () => {
+ const recipient = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
+ const outputRecipient = resolveRecipient(recipient);
+ expect(outputRecipient).toBe(recipient);
+ });
+
+ it("is undefined for an invalid address, so wallet default is used", () => {
+ const recipient = "not-an-address";
+ const outputRecipient = resolveRecipient(recipient);
+ expect(outputRecipient).toBeUndefined();
+ });
+});
diff --git a/tests/unit/walletClientSwitch.test.ts b/tests/unit/walletClientSwitch.test.ts
new file mode 100644
index 0000000..c853a04
--- /dev/null
+++ b/tests/unit/walletClientSwitch.test.ts
@@ -0,0 +1,57 @@
+import { describe, expect, it, mock } from "bun:test";
+import type { EIP1193Provider } from "viem";
+import { createSwitchWalletChain } from "../../src/lib/utils/walletClient";
+
+describe("switchWalletChain", () => {
+ it("uses walletClient.switchChain when available", async () => {
+ const getCurrentProvider = mock(async () => undefined);
+ const switchWalletChain = createSwitchWalletChain({ getCurrentProvider });
+ const switchChain = mock(async () => undefined);
+ const walletClient = { switchChain } as unknown as Parameters[0];
+ await switchWalletChain(walletClient, 8453);
+ expect(switchChain).toHaveBeenCalledWith({ id: 8453 });
+ expect(getCurrentProvider).not.toHaveBeenCalled();
+ });
+
+ it("falls back to provider wallet_switchEthereumChain", async () => {
+ const getCurrentProvider = mock(async () => undefined);
+ const switchWalletChain = createSwitchWalletChain({ getCurrentProvider });
+ const request = mock(async () => null);
+ const walletClient = {} as unknown as Parameters[0];
+ const provider = { request } as unknown as NonNullable<
+ Parameters[2]
+ >["provider"];
+ await switchWalletChain(walletClient, 8453, { provider });
+ expect(request).toHaveBeenCalledWith({
+ method: "wallet_switchEthereumChain",
+ params: [{ chainId: "0x2105" }]
+ });
+ expect(getCurrentProvider).not.toHaveBeenCalled();
+ });
+
+ it("falls back to injected getCurrentProvider when no provider is passed", async () => {
+ const request = mock(async () => null);
+ const provider = { request } as unknown as EIP1193Provider;
+ const getCurrentProvider = mock(async () => provider);
+ const switchWalletChain = createSwitchWalletChain({ getCurrentProvider });
+ const walletClient = {} as unknown as Parameters[0];
+
+ await switchWalletChain(walletClient, 8453);
+
+ expect(getCurrentProvider).toHaveBeenCalledTimes(1);
+ expect(request).toHaveBeenCalledWith({
+ method: "wallet_switchEthereumChain",
+ params: [{ chainId: "0x2105" }]
+ });
+ });
+
+ it("throws when no provider can be resolved", async () => {
+ const getCurrentProvider = mock(async () => undefined);
+ const switchWalletChain = createSwitchWalletChain({ getCurrentProvider });
+ const walletClient = {} as unknown as Parameters[0];
+
+ await expect(switchWalletChain(walletClient, 8453)).rejects.toThrow(
+ "Wallet client does not support switchChain and no provider is available for chain 8453."
+ );
+ });
+});
diff --git a/tsconfig.json b/tsconfig.json
index f7ccfe4..8e0bd6d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,22 +1,22 @@
{
- "extends": "./.svelte-kit/tsconfig.json",
- "compilerOptions": {
- "allowJs": true,
- "checkJs": true,
- "esModuleInterop": true,
- "forceConsistentCasingInFileNames": true,
- "resolveJsonModule": true,
- "skipLibCheck": true,
- "sourceMap": true,
- "strict": true,
- "module": "ESNext",
- "moduleResolution": "bundler",
- "target": "ESNext"
- },
- "exclude": ["tests/e2e", "playwright.config.ts"]
- // Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
- // except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
- //
- // If you want to overwrite includes/excludes, make sure to copy over the relevant includes/excludes
- // from the referenced tsconfig.json - TypeScript does not merge them in
+ "extends": "./.svelte-kit/tsconfig.json",
+ "compilerOptions": {
+ "allowJs": true,
+ "checkJs": true,
+ "esModuleInterop": true,
+ "forceConsistentCasingInFileNames": true,
+ "resolveJsonModule": true,
+ "skipLibCheck": true,
+ "sourceMap": true,
+ "strict": true,
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "target": "ESNext"
+ },
+ "exclude": ["tests/e2e", "playwright.config.ts"]
+ // Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
+ // except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
+ //
+ // If you want to overwrite includes/excludes, make sure to copy over the relevant includes/excludes
+ // from the referenced tsconfig.json - TypeScript does not merge them in
}
diff --git a/vite.config.ts b/vite.config.ts
index 83ecf56..f12ffff 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -3,8 +3,8 @@ import { sveltekit } from "@sveltejs/kit/vite";
import { defineConfig } from "vite";
export default defineConfig({
- plugins: [tailwindcss(), sveltekit()],
- optimizeDeps: {
- exclude: ["@electric-sql/pglite"]
- }
+ plugins: [tailwindcss(), sveltekit()],
+ optimizeDeps: {
+ exclude: ["@electric-sql/pglite"]
+ }
});
diff --git a/wrangler.toml b/wrangler.toml
index 73bbe8e..d00003a 100644
--- a/wrangler.toml
+++ b/wrangler.toml
@@ -1,6 +1,6 @@
name = "lintent-worker"
main = ".svelte-kit/cloudflare/_worker.js"
-compatibility_date = "2024-03-06"
+compatibility_date = "2026-03-06"
compatibility_flags = ["nodejs_compat"]
# account_id is NOT set here — passed via CLOUDFLARE_ACCOUNT_ID in CI