- {#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 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.
-
+
+ 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.
+
-
+
-
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.
-
+
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.
+
-
+
-
Why Resource Locks?
-
- Resource Locks improve asset availability guarantees in cross-chain contexts and asynchronous
- environments, offering several key advantages:
-
+
Why Resource Locks?
+
+ Resource Locks improve asset availability guarantees in cross-chain contexts and asynchronous
+ environments, offering several key advantages:
+
-
- 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.
-
+
+ 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 .
-
+
+ Learn more about
+ Resource Locks .
+
-
+
-
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:
-
+
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 .
-
+
+ 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 .
+
-
+
-
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.
-
+
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 9034160..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..af421a3 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 d9bb9b0..7495ebc 100644
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -1,79 +1,81 @@
import { createPublicClient, createWalletClient, custom, 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
} from "viem/chains";
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: Partial
> = {
- [ethereum.id]: "0x0000000000000000000000000000000000000000",
- [arbitrum.id]: "0x0000000000000000000000000000000000000000",
- [base.id]: "0x0000000000000000000000000000000000000000"
+ [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",
- // testnet
- [sepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
- [baseSepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
- [arbitrumSepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
- [optimismSepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00"
+ [ethereum.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [arbitrum.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [base.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [megaeth.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [katana.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [polygon.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ [bsc.id]: "0x0000003E06000007A224AeE90052fA6bb46d43C9",
+ // testnet
+ [sepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
+ [baseSepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
+ [arbitrumSepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00",
+ [optimismSepolia.id]: "0x00d5b500ECa100F7cdeDC800eC631Aca00BaAC00"
};
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
+ ethereum,
+ base,
+ arbitrum,
+ optimism,
+ sepolia,
+ arbitrumSepolia,
+ optimismSepolia,
+ baseSepolia,
+ katana,
+ megaeth,
+ bsc,
+ polygon
} as const;
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"] as ChainName[];
- } else return ["sepolia", "optimismSepolia", "baseSepolia", "arbitrumSepolia"] as ChainName[];
+ if (mainnet == true) {
+ return ["ethereum", "base", "arbitrum", "megaeth", "katana", "polygon", "bsc"] as ChainName[];
+ } else return ["sepolia", "optimismSepolia", "baseSepolia", "arbitrumSepolia"] as ChainName[];
};
export const chainIdList = (mainnet: boolean) => {
- return chainList(mainnet).map((name) => chainMap[name].id);
+ return chainList(mainnet).map((name) => chainMap[name].id);
};
const chainEntries = chains.map((name) => [chainMap[name].id, chainMap[name]] as const);
@@ -82,406 +84,426 @@ const chainNameEntries = chains.map((name) => [chainMap[name].id, name] as const
export type balanceQuery = Record>>;
export type Token = {
- address: `0x${string}`;
- name: string;
- chainId: number;
- decimals: number;
+ address: `0x${string}`;
+ name: string;
+ chainId: number;
+ decimals: number;
};
export const coinList = (mainnet: boolean) => {
- 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: `0x4200000000000000000000000000000000000006`,
- name: "weth",
- chainId: base.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
- }
- ] 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
+ }
+ ] as const;
};
export function printToken(token: Token) {
- return `${token.name.toUpperCase()}, ${getChainName(token.chainId)}`;
+ 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) {
- 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;
+ 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
+ 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
} as const;
export type Verifier = "wormhole" | "polymer";
export function getCoin(
- args:
- | { name: string; chainId: number | bigint | string; address?: undefined }
- | {
- address: `0x${string}`;
- chainId: number | bigint | string;
- 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 } = 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}`);
+ 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;
+ 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;
+ 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) {
- const normalized = normalizeChainId(chainId);
- const name = chainNameById[normalized];
- if (!name) throw new Error(`Chain is not known: ${normalized}`);
- return name;
+ 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;
+ const normalized = normalizeChainId(chainId);
+ if (verifier === "polymer") return POLYMER_ORACLE[normalized];
+ if (verifier === "wormhole") return WORMHOLE_ORACLE[normalized];
+ return undefined;
}
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;
+ 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 normalized = normalizeChainId(chainId);
- const client = clientsById[normalized];
- if (!client) throw new Error(`Could not find client for chainId ${normalized}`);
- return client;
+ 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([
- 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))])
- }),
- // 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))])
+ }),
+ // 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))
+ ])
+ })
} as const;
export const chainById = Object.fromEntries(chainEntries) as Record<
- number,
- (typeof chainMap)[keyof typeof chainMap]
+ 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]])
+ 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 c59d862..594f0d4 100644
--- a/src/lib/libraries/compactLib.ts
+++ b/src/lib/libraries/compactLib.ts
@@ -8,150 +8,150 @@ import { ERC20_ABI } from "$lib/abi/erc20";
import type { AppTokenContext } from "$lib/appTypes";
export class CompactLib {
- 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.
+ 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: 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;
- };
- }
+ 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?: (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);
+ 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.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;
- };
- }
+ 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?: (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]
- });
+ 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
index e2e75bb..947449d 100644
--- a/src/lib/libraries/coreDeps.ts
+++ b/src/lib/libraries/coreDeps.ts
@@ -1,54 +1,54 @@
import {
- COIN_FILLER,
- INPUT_SETTLER_COMPACT_LIFI,
- MULTICHAIN_INPUT_SETTLER_COMPACT,
- POLYMER_ORACLE,
- WORMHOLE_ORACLE
+ 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";
+ 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;
- }
+ 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];
- }
+ 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 510e33f..c4e59a3 100644
--- a/src/lib/libraries/flowProgress.ts
+++ b/src/lib/libraries/flowProgress.ts
@@ -1,11 +1,11 @@
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";
@@ -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({
- 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 }
- );
+ 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 = 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;
}
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 = 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
+ };
+ }
}
diff --git a/src/lib/libraries/intentExecution.ts b/src/lib/libraries/intentExecution.ts
index 1c95197..c09e07f 100644
--- a/src/lib/libraries/intentExecution.ts
+++ b/src/lib/libraries/intentExecution.ts
@@ -5,13 +5,13 @@ 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
+ 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";
@@ -22,172 +22,172 @@ import type { TypedDataSigner } from "@lifi/intent";
import { switchWalletChain } from "$lib/utils/walletClientRuntime";
function combineSignatures(signatures: {
- sponsorSignature: Signature | NoSignature;
- allocatorSignature: Signature | NoSignature;
+ sponsorSignature: Signature | NoSignature;
+ allocatorSignature: Signature | NoSignature;
}) {
- const { sponsorSignature, allocatorSignature } = signatures;
- return encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
- sponsorSignature.payload ?? "0x",
- allocatorSignature.payload
- ]);
+ const { sponsorSignature, allocatorSignature } = signatures;
+ return encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
+ sponsorSignature.payload ?? "0x",
+ allocatorSignature.payload
+ ]);
}
export function signIntentCompact(
- intent: StandardOrderIntent | MultichainOrderIntent,
- account: `0x${string}`,
- walletClient: WC
+ intent: StandardOrderIntent | MultichainOrderIntent,
+ account: `0x${string}`,
+ walletClient: WC
): Promise<`0x${string}`> {
- const signer = walletClient as unknown as TypedDataSigner;
- if (intent instanceof StandardOrderIntent) {
- 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()
- );
+ const signer = walletClient as unknown as TypedDataSigner;
+ if (intent instanceof StandardOrderIntent) {
+ 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: StandardOrderIntent,
- account: `0x${string}`,
- walletClient: WC
+ intent: StandardOrderIntent,
+ 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]]]
- });
+ 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: StandardOrderIntent | MultichainOrderIntent,
- account: `0x${string}`,
- walletClient: WC
+ intent: StandardOrderIntent | MultichainOrderIntent,
+ account: `0x${string}`,
+ walletClient: WC
): Promise<`0x${string}`[]> {
- if (intent instanceof StandardOrderIntent) {
- 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]
- })
- ];
- }
+ if (intent instanceof StandardOrderIntent) {
+ 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;
+ 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: StandardOrderIntent | MultichainOrderIntent;
- sourceChainId: number | bigint;
- account: `0x${string}`;
- walletClient: WC;
- solveParams: { timestamp: number; solver: `0x${string}` }[];
- signatures: {
- sponsorSignature: Signature | NoSignature;
- allocatorSignature: Signature | NoSignature;
- };
+ intent: StandardOrderIntent | 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);
+ const { intent, sourceChainId, account, walletClient, solveParams, signatures } = options;
+ const actionChain = getChain(sourceChainId);
- if (intent instanceof StandardOrderIntent) {
- 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}`);
- }
+ if (intent instanceof StandardOrderIntent) {
+ 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}.`);
- }
+ 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}`);
- }
+ 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}.`);
+ 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 5b1b7a1..5e9ccf2 100644
--- a/src/lib/libraries/intentFactory.ts
+++ b/src/lib/libraries/intentFactory.ts
@@ -1,20 +1,20 @@
import {
- getChain,
- getClient,
- INPUT_SETTLER_COMPACT_LIFI,
- INPUT_SETTLER_ESCROW_LIFI,
- MULTICHAIN_INPUT_SETTLER_ESCROW,
- 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 {
- CreateIntentOptions,
- TokenContext,
- MultichainOrder,
- NoSignature,
- OrderContainer,
- Signature,
- StandardOrder
+ CreateIntentOptions,
+ TokenContext,
+ MultichainOrder,
+ NoSignature,
+ OrderContainer,
+ Signature,
+ StandardOrder
} from "@lifi/intent";
import type { AppCreateIntentOptions, AppTokenContext } from "$lib/appTypes";
import { ERC20_ABI } from "$lib/abi/erc20";
@@ -24,245 +24,287 @@ import { store } from "$lib/state.svelte";
import { depositAndRegisterCompact, openEscrowIntent, signIntentCompact } from "./intentExecution";
import { intentDeps } from "./coreDeps";
+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;
+ (intent as any).expiry = SAME_CHAIN_DURATION_SECONDS;
+ (intent as any).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 as any).context = newContext;
+ }
+ }
+}
+
function toCoreTokenContext(input: AppTokenContext): TokenContext {
- return {
- token: {
- address: input.token.address,
- name: input.token.name,
- chainId: BigInt(input.token.chainId),
- decimals: input.token.decimals
- },
- amount: input.amount
- };
+ return {
+ token: {
+ address: input.token.address,
+ name: input.token.name,
+ chainId: BigInt(input.token.chainId),
+ decimals: input.token.decimals
+ },
+ 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,
- 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,
- lock: {
- type: "escrow"
- }
- };
+ 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,
+ 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,
+ lock: {
+ type: "escrow"
+ }
+ };
}
/**
* @notice Factory class for creating and managing intents. Functions called by integrators.
*/
export class IntentFactory {
- mainnet: boolean;
- intentApi: IntentApi;
-
- walletClient: WC;
-
- preHook?: (chainId: number) => Promise;
- postHook?: () => Promise;
-
- orders: OrderContainer[] = [];
-
- constructor(options: {
- mainnet: boolean;
- walletClient: WC;
- preHook?: (chainId: number) => Promise;
- postHook?: () => Promise;
- ordersPointer?: OrderContainer[];
- }) {
- const { mainnet, walletClient, preHook, postHook, ordersPointer } = options;
- this.mainnet = mainnet;
- this.intentApi = new IntentApi(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: AppCreateIntentOptions) {
- return async () => {
- const { account, inputTokens } = opts;
- const inputChain = inputTokens[0].token.chainId;
- if (this.preHook) await this.preHook(inputChain);
- const intent = new Intent(toCoreCreateIntentOptions(opts), intentDeps).order();
-
- const sponsorSignature = await signIntentCompact(intent, account(), this.walletClient);
-
- console.log({
- order: intent.asOrder(),
- sponsorSignature
- });
-
- 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 intent = new Intent(toCoreCreateIntentOptions(opts), intentDeps).singlechain();
-
- 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.
- 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 intent = new Intent(toCoreCreateIntentOptions(opts), intentDeps).order();
-
- 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();
-
- 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;
+ walletClient: WC;
+ preHook?: (chainId: number) => Promise;
+ postHook?: () => Promise;
+ ordersPointer?: OrderContainer[];
+ }) {
+ const { mainnet, walletClient, preHook, postHook, ordersPointer } = options;
+ this.mainnet = mainnet;
+ this.intentApi = new IntentApi(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: 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();
+ applyExclusivityOverride(intent, opts.exclusiveFor, sameChain);
+
+ const sponsorSignature = await signIntentCompact(intent, account(), this.walletClient);
+
+ console.log({
+ order: intent.asOrder(),
+ sponsorSignature
+ });
+
+ 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();
+ 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.
+ 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();
+ 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();
+
+ this.saveOrder({
+ order: intent.asOrder(),
+ inputSettler: store.inputSettler
+ });
+
+ return transactionHashes;
+ };
+ }
}
export function escrowApprove(
- walletClient: WC,
- opts: {
- preHook?: (chainId: number) => Promise;
- postHook?: () => Promise;
- inputTokens: AppTokenContext[];
- 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.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();
- };
+ 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 4689d51..d0c3d54 100644
--- a/src/lib/libraries/intentList.ts
+++ b/src/lib/libraries/intentList.ts
@@ -1,11 +1,11 @@
import {
- formatTokenAmount,
- getChainName,
- getCoin,
- 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 "@lifi/intent";
import { bytes32ToAddress, idToToken } from "@lifi/intent";
@@ -14,264 +14,264 @@ 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): string | undefined {
- try {
- return getChainName(chainId);
- } catch {
- return 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 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}`;
+ 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 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}`;
+ 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,
- 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
- };
+ 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,
+ 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/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 674ce29..961b7dd 100644
--- a/src/lib/libraries/solver.ts
+++ b/src/lib/libraries/solver.ts
@@ -15,375 +15,375 @@ 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 receipt = await getClient(chainId).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 as any;
+ 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?: (chainId: number) => Promise;
- postHook?: () => Promise;
- account: () => `0x${string}`;
- }
- ) {
- return async () => {
- const { preHook, postHook, account } = opts;
- const {
- orderContainer: { order, inputSettler },
- outputs
- } = args;
- 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 = orderToIntent({ order, inputSettler }).orderId();
- 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}`);
- }
+ 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 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);
- }
- }
+ // 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: 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;
- };
- }
+ 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;
- 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;
+ 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 () => {
- 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", 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));
+ 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: getChain(sourceChainId),
- 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 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 (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 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 (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 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)}.`
- );
- })();
+ 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[];
- 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 = 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) => {
- return getClient(order.outputs[i].chainId).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 = 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) => {
+ return getClient(order.outputs[i].chainId).getBlock({
+ blockHash: r.blockHash
+ });
+ })
+ );
+ const fillTimestamps = blocks.map((b) => b.timestamp);
- 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`
- );
- }
+ 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 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;
- };
- }
+ 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 b4ae255..d000190 100644
--- a/src/lib/libraries/token.ts
+++ b/src/lib/libraries/token.ts
@@ -5,59 +5,59 @@ import { ADDRESS_ZERO, clients, COMPACT } from "../config";
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 9423261..a6fa802 100644
--- a/src/lib/schema.ts
+++ b/src/lib/schema.ts
@@ -1,25 +1,39 @@
-import { pgTable, text, 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 e08b7e5..7461fea 100644
--- a/src/lib/screens/ConnectWallet.svelte
+++ b/src/lib/screens/ConnectWallet.svelte
@@ -1,49 +1,49 @@
-
- {#each connectors as connector (connector.id)}
-
connectWallet(connector.id)}
- >
- {#if connectingId === connector.id}
- Connecting {connector.name}...
- {:else}
- Connect {connector.name}
- {/if}
-
- {/each}
+
+ {#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}
-
+ {#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 2147aa1..018d95a 100644
--- a/src/lib/screens/FillIntent.svelte
+++ b/src/lib/screens/FillIntent.svelte
@@ -1,211 +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 5dcf169..e3ec236 100644
--- a/src/lib/screens/Finalise.svelte
+++ b/src/lib/screens/Finalise.svelte
@@ -1,284 +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}
- {@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}
-
+ {#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 167d326..105c6a1 100644
--- a/src/lib/screens/IssueIntent.svelte
+++ b/src/lib/screens/IssueIntent.svelte
@@ -1,383 +1,398 @@
- {#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.chainId}-${outputToken.token.address}-${i}`)}
-
(outputTokenSelectorActive = true)}
- >
-
-
-
{formatTokenAmount(outputToken.amount, outputToken.token.decimals)}
-
- {outputToken.token.name.toUpperCase()}
-
-
-
- {getChainName(outputToken.token.chainId)}
-
-
- {/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
-
-
-
-
+
+
+
+ Verifier
+ {#if sameChain}
+
+ Settler
+
+ {:else}
+
+ Polymer
+ Wormhole
+
+ {/if}
+
+
+ Exclusive
+
+
+
+
-
- {#if !true}
-
- Input must be exactly raw 100 USDC
-
- {:else 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 !true}
+
+ Input must be exactly raw 100 USDC
+
+ {:else 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 ea1a1c2..1e59847 100644
--- a/src/lib/screens/ManageDeposit.svelte
+++ b/src/lib/screens/ManageDeposit.svelte
@@ -1,189 +1,272 @@
-
-
-
-
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.chainId]}
-
- {#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")}
+ />
+
+
+
+
+
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 a721f0f..c867b68 100644
--- a/src/lib/screens/ReceiveMessage.svelte
+++ b/src/lib/screens/ReceiveMessage.svelte
@@ -1,240 +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"
- })
- ],
- 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}
-
+ {#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[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 145bc99..fa84279 100644
--- a/src/lib/state.svelte.ts
+++ b/src/lib/state.svelte.ts
@@ -1,442 +1,572 @@
import type { OrderContainer } from "@lifi/intent";
import type { AppTokenContext } from "./appTypes";
import {
- ALWAYS_OK_ALLOCATOR,
- clientsById,
- coinList,
- COMPACT,
- INPUT_SETTLER_COMPACT_LIFI,
- INPUT_SETTLER_ESCROW_LIFI,
- MULTICHAIN_INPUT_SETTLER_COMPACT,
- MULTICHAIN_INPUT_SETTLER_ESCROW,
- type availableAllocators,
- type Token,
- type Verifier,
- type WC
+ 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 { 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 { and, eq, ne, notInArray } from "drizzle-orm";
import { orderToIntent } from "@lifi/intent";
import { getOrFetchRpc, invalidateRpcPrefix } from "./libraries/rpcCache";
import {
- getCurrentConnection,
- getCurrentWalletClient,
- reconnectWallet,
- type WalletConnection,
- watchWalletConnection
+ 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;
- }
- }
-
- walletConnection = $state(getCurrentConnection());
- connectedAccount = $derived(
- this.walletConnection.status === "connected"
- ? { address: this.walletConnection.address }
- : undefined
- );
- walletClient = $state(undefined as unknown as WC);
- _unwatchWalletConnection?: () => void;
-
- 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("");
- 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;
- }
- }
-
- 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 coinList(isMainnet)) {
- 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.inputTokens = [{ token: coinList(this.mainnet)[0], amount: 1000000n }];
- this.outputTokens = [{ token: coinList(this.mainnet)[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)
- )
- ]).then(() => {})
- : Promise.resolve();
- }
+ 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 ?? generateUUID();
+ 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: 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 unknown;
+ } 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("");
+ 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/wagmi.ts b/src/lib/utils/wagmi.ts
index a02bb41..0b665cc 100644
--- a/src/lib/utils/wagmi.ts
+++ b/src/lib/utils/wagmi.ts
@@ -1,103 +1,103 @@
import { browser } from "$app/environment";
import { env } from "$env/dynamic/public";
import {
- connect,
- createConfig,
- disconnect,
- getConnection,
- getConnectors,
- http,
- reconnect,
- watchConnection
+ 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"]
+ 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"];
+ 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 })
+ 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>
+ 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
- }));
+ 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 });
+ 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);
+ return reconnect(wagmiConfig);
}
export async function disconnectWallet() {
- const connection = getConnection(wagmiConfig);
- if (connection.status !== "connected") return;
- return disconnect(wagmiConfig, { connector: connection.connector });
+ const connection = getConnection(wagmiConfig);
+ if (connection.status !== "connected") return;
+ return disconnect(wagmiConfig, { connector: connection.connector });
}
export function getCurrentConnection() {
- return getConnection(wagmiConfig);
+ return getConnection(wagmiConfig);
}
export async function getCurrentProvider() {
- const connection = getConnection(wagmiConfig);
- if (connection.status !== "connected") return undefined;
- return (await connection.connector.getProvider()) as EIP1193Provider;
+ 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) });
+ 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);
- }
- });
+ if (!browser) return () => {};
+ return watchConnection(wagmiConfig, {
+ onChange(connection) {
+ onChange(connection);
+ }
+ });
}
diff --git a/src/lib/utils/walletClient.ts b/src/lib/utils/walletClient.ts
index b040963..34ed3ea 100644
--- a/src/lib/utils/walletClient.ts
+++ b/src/lib/utils/walletClient.ts
@@ -3,67 +3,67 @@ import { toHex } from "viem";
import type { WC } from "$lib/config";
export type SwitchableWalletClient = WC & {
- switchChain?: (args: { id: number }) => Promise;
+ switchChain?: (args: { id: number }) => Promise;
};
export type SwitchWalletChainOptions = {
- provider?: EIP1193Provider;
+ provider?: EIP1193Provider;
};
export type SwitchWalletChain = (
- walletClient: WC | undefined,
- chainId: number,
- options?: SwitchWalletChainOptions
+ walletClient: WC | undefined,
+ chainId: number,
+ options?: SwitchWalletChainOptions
) => Promise;
export type SwitchWalletChainDeps = {
- getCurrentProvider: () => Promise;
+ getCurrentProvider: () => Promise;
};
async function resolveWalletProvider(
- walletClient: WC | undefined,
- deps: SwitchWalletChainDeps,
- provider?: EIP1193Provider
+ walletClient: WC | undefined,
+ deps: SwitchWalletChainDeps,
+ provider?: EIP1193Provider
): Promise {
- if (provider?.request) return provider;
+ if (provider?.request) return provider;
- const walletClientWithTransport = walletClient as
- | (WC & { transport?: { value?: EIP1193Provider } })
- | undefined;
- const transportProvider = walletClientWithTransport?.transport?.value;
- if (transportProvider?.request) return transportProvider;
+ 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;
- }
+ 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;
+ 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 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}.`
- );
- }
+ 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) }]
- });
- };
+ await provider.request({
+ method: "wallet_switchEthereumChain",
+ params: [{ chainId: toHex(chainId) }]
+ });
+ };
}
diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte
index 2458f08..801be90 100644
--- a/src/routes/+layout.svelte
+++ b/src/routes/+layout.svelte
@@ -1,7 +1,7 @@
{@render children()}
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 2b98745..3b6bdc1 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -1,253 +1,258 @@
-
- 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);
- }}
- />
-
-
+ 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);
+ }}
+ />
+
+
diff --git a/src/routes/allocator/+server.ts b/src/routes/allocator/+server.ts
index 4f03cea..5a747a6 100644
--- a/src/routes/allocator/+server.ts
+++ b/src/routes/allocator/+server.ts
@@ -3,81 +3,81 @@ import axios from "axios";
import type { RequestHandler } 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;
}
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 });
+ 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 });
- const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
+ const PRIVATE_POLYMER_ZONE_API_KEY = getPolymerKey(mainnet ?? true);
- 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"
- }
- }
- );
+ 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"
+ }
+ }
+ );
- 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 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;
- console.log(dat);
+ console.log(dat);
- // create a JSON Response using a header we received
- return json({
- allocatorSignature: dat.result.allocatorSignature,
- allocatorAddress: dat.result.allocatorAddress
- });
+ // create a JSON Response using a header we received
+ return json({
+ allocatorSignature: dat.result.allocatorSignature,
+ allocatorAddress: dat.result.allocatorAddress
+ });
};
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..98d8df4 100644
--- a/src/routes/polymer/+server.ts
+++ b/src/routes/polymer/+server.ts
@@ -2,109 +2,109 @@ 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;
}
export const POST: RequestHandler = async ({ request }) => {
- const { srcChainId, srcBlockNumber, globalLogIndex, polymerIndex, mainnet } =
- await request.json();
- console.log({ srcChainId, srcBlockNumber, globalLogIndex, polymerIndex, mainnet });
+ const { srcChainId, srcBlockNumber, globalLogIndex, polymerIndex, mainnet } =
+ await request.json();
+ console.log({ srcChainId, srcBlockNumber, globalLogIndex, polymerIndex, mainnet });
- 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;
- 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 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;
- // 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
- });
+ 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
+ });
};
diff --git a/src/routes/polymer/health/+server.ts b/src/routes/polymer/health/+server.ts
index d62f822..e6071ca 100644
--- a/src/routes/polymer/health/+server.ts
+++ b/src/routes/polymer/health/+server.ts
@@ -2,64 +2,64 @@ 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;
}
export const POST: RequestHandler = async ({ request }) => {
- const { chainIds, mainnet }: { chainIds?: number[]; mainnet?: boolean } = await request.json();
+ const { chainIds, mainnet }: { chainIds?: number[]; mainnet?: boolean } = await request.json();
- 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);
- 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
+ });
};
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
index a8247fd..80cbc04 100644
--- a/tests/e2e/escrow-standard-blackbox.spec.ts
+++ b/tests/e2e/escrow-standard-blackbox.spec.ts
@@ -1,9 +1,9 @@
import { expect, test, type Page } from "@playwright/test";
import {
- connectInjectedWallet,
- e2eWalletAddress,
- hasE2EPrivateKey,
- installInjectedWalletProvider
+ connectInjectedWallet,
+ e2eWalletAddress,
+ hasE2EPrivateKey,
+ installInjectedWalletProvider
} from "./helpers/bootstrap";
const REQUIRED_INPUT_USDC_HUMAN = "0.0001";
@@ -22,275 +22,275 @@ test.skip(!hasE2EPrivateKey, "Skipping private-key E2E tests: E2E_PRIVATE_KEY is
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
- });
- }
+ 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);
- });
+ 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"
- });
+ 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
index 6e24696..cf444a2 100644
--- a/tests/e2e/escrow-standard-live.spec.ts
+++ b/tests/e2e/escrow-standard-live.spec.ts
@@ -1,9 +1,9 @@
import { expect, test, type Page } from "@playwright/test";
import {
- connectInjectedWallet,
- e2eWalletAddress,
- hasE2EPrivateKey,
- installInjectedWalletProvider
+ connectInjectedWallet,
+ e2eWalletAddress,
+ hasE2EPrivateKey,
+ installInjectedWalletProvider
} from "./helpers/bootstrap";
const REQUIRED_INPUT_USDC_RAW = "100";
@@ -18,263 +18,263 @@ test.skip(!hasE2EPrivateKey, "Skipping private-key E2E tests: E2E_PRIVATE_KEY is
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();
+ 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);
- }
+ 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).");
+ 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
+ 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);
+ 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 367b7a4..21456d2 100644
--- a/tests/e2e/helpers/bootstrap.ts
+++ b/tests/e2e/helpers/bootstrap.ts
@@ -7,19 +7,19 @@ import { privateKeyToAccount } from "viem/accounts";
import { arbitrum, base } from "viem/chains";
type ProviderPayload = {
- method: string;
- params?: unknown[];
+ method: string;
+ params?: unknown[];
};
function ensureEnvLoaded() {
- const envFilePath = process.env.E2E_ENV_FILE?.trim() || ".env";
- loadDotenv({ path: envFilePath, quiet: true });
+ const envFilePath = process.env.E2E_ENV_FILE?.trim() || ".env";
+ loadDotenv({ path: envFilePath, quiet: true });
}
ensureEnvLoaded();
function getE2EEnv(name: string) {
- return process.env[name]?.trim();
+ return process.env[name]?.trim();
}
export const hasE2EPrivateKey = Boolean(getE2EEnv("E2E_PRIVATE_KEY"));
@@ -28,13 +28,13 @@ 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" }]
- }
+ {
+ 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";
@@ -44,218 +44,218 @@ let walletClientByChainCache: Record | 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}`);
+ 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 };
+ 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;
+ 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;
+ 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;
+ 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);
+ 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);
+ 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;
- });
+ 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();
+ await page.getByRole("button", { name: "Connect Injected" }).click();
}
export function e2eWalletAddress() {
- const { account } = getWalletContext();
- return account.address;
+ 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;
+ 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 installInjectedWalletProvider(page);
- await page.goto("/");
- await connectInjectedWallet(page);
+ await installInjectedWalletProvider(page);
+ await page.goto("/");
+ await connectInjectedWallet(page);
}
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
index 7128865..ab3a7b5 100644
--- a/tests/fixtures/orderFixtures.ts
+++ b/tests/fixtures/orderFixtures.ts
@@ -13,49 +13,49 @@ 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 = {}
+ 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
- };
+ 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
- };
+ 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
- };
+ 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 af30ae3..9c42300 100644
--- a/tests/unit/intentList.test.ts
+++ b/tests/unit/intentList.test.ts
@@ -1,107 +1,107 @@
import { describe, expect, it } from "bun:test";
import {
- buildBaseIntentRow,
- 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" }
- });
+ 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("...");
- });
+ 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/orderValidationDeps.test.ts b/tests/unit/orderValidationDeps.test.ts
index 8514908..6eaf3cc 100644
--- a/tests/unit/orderValidationDeps.test.ts
+++ b/tests/unit/orderValidationDeps.test.ts
@@ -1,51 +1,51 @@
import { describe, expect, it } from "bun:test";
import {
- COIN_FILLER,
- VALIDATION_ERRORS,
- addressToBytes32,
- validateOrderWithReason
+ 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
- });
+ 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);
- });
+ 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
- });
+ 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);
- });
+ expect(result.passed).toBe(false);
+ expect(result.reason).toBe(VALIDATION_ERRORS.UNKNOWN_OUTPUT_CHAIN);
+ });
});
diff --git a/tests/unit/walletClientSwitch.test.ts b/tests/unit/walletClientSwitch.test.ts
index c86b686..c853a04 100644
--- a/tests/unit/walletClientSwitch.test.ts
+++ b/tests/unit/walletClientSwitch.test.ts
@@ -3,55 +3,55 @@ 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("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 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];
+ 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);
+ await switchWalletChain(walletClient, 8453);
- expect(getCurrentProvider).toHaveBeenCalledTimes(1);
- expect(request).toHaveBeenCalledWith({
- method: "wallet_switchEthereumChain",
- params: [{ chainId: "0x2105" }]
- });
- });
+ 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];
+ 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."
- );
- });
+ 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.jsonc b/wrangler.jsonc
deleted file mode 100644
index e787b50..0000000
--- a/wrangler.jsonc
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "name": "intent",
- "main": ".svelte-kit/cloudflare/_worker.js",
- "compatibility_date": "2025-01-01",
- "assets": {
- "binding": "ASSETS",
- "directory": ".svelte-kit/cloudflare"
- }
-}
diff --git a/wrangler.toml b/wrangler.toml
new file mode 100644
index 0000000..d00003a
--- /dev/null
+++ b/wrangler.toml
@@ -0,0 +1,32 @@
+name = "lintent-worker"
+main = ".svelte-kit/cloudflare/_worker.js"
+compatibility_date = "2026-03-06"
+compatibility_flags = ["nodejs_compat"]
+
+# account_id is NOT set here — passed via CLOUDFLARE_ACCOUNT_ID in CI
+
+[assets]
+binding = "ASSETS"
+directory = ".svelte-kit/cloudflare"
+
+[build]
+command = "bun run build"
+
+[env.production]
+name = "lintent-worker"
+vars = { ENVIRONMENT = "production" }
+
+[observability]
+enabled = true
+head_sampling_rate = 1
+
+[observability.logs]
+enabled = true
+invocation_logs = true
+
+[tags]
+lifi = "true"
+lintent = "true"
+
+[placement]
+mode = "smart"