diff --git a/README.md b/README.md
index 5e430d2..8dac886 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,7 @@ This project uses SvelteKit and `npm`. It is configured for a deployment to Clou
 ### Development
 
 To start development:
+
 1. Copy `.env.example` to `.env`.
 2. Then fill in the `env` variables by creating a [WalletConnect](https://walletconnect.com) project
 3. Also create an [account](https://accounts.polymerlabs.org/) with Polymer to generation [Polymer](https://polymerlabs.org) API keys.
diff --git a/_typos.toml b/_typos.toml
new file mode 100644
index 0000000..70c933b
--- /dev/null
+++ b/_typos.toml
@@ -0,0 +1,3 @@
+[default.extend-words]
+oif = "oif"
+OIF = "OIF"
\ No newline at end of file
diff --git a/src/lib/abi/escrow.ts b/src/lib/abi/escrow.ts
index a35f7bf..61a0992 100644
--- a/src/lib/abi/escrow.ts
+++ b/src/lib/abi/escrow.ts
@@ -1,13 +1,7 @@
 export const SETTLER_ESCROW_ABI = [
 	{
 		type: "constructor",
-		inputs: [
-			{
-				name: "initialOwner",
-				type: "address",
-				internalType: "address"
-			}
-		],
+		inputs: [],
 		stateMutability: "nonpayable"
 	},
 	{
@@ -23,33 +17,6 @@ export const SETTLER_ESCROW_ABI = [
 		],
 		stateMutability: "view"
 	},
-	{
-		type: "function",
-		name: "applyGovernanceFee",
-		inputs: [],
-		outputs: [],
-		stateMutability: "nonpayable"
-	},
-	{
-		type: "function",
-		name: "cancelOwnershipHandover",
-		inputs: [],
-		outputs: [],
-		stateMutability: "payable"
-	},
-	{
-		type: "function",
-		name: "completeOwnershipHandover",
-		inputs: [
-			{
-				name: "pendingOwner",
-				type: "address",
-				internalType: "address"
-			}
-		],
-		outputs: [],
-		stateMutability: "payable"
-	},
 	{
 		type: "function",
 		name: "eip712Domain",
@@ -346,45 +313,6 @@ export const SETTLER_ESCROW_ABI = [
 		outputs: [],
 		stateMutability: "nonpayable"
 	},
-	{
-		type: "function",
-		name: "governanceFee",
-		inputs: [],
-		outputs: [
-			{
-				name: "",
-				type: "uint64",
-				internalType: "uint64"
-			}
-		],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "nextGovernanceFee",
-		inputs: [],
-		outputs: [
-			{
-				name: "",
-				type: "uint64",
-				internalType: "uint64"
-			}
-		],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "nextGovernanceFeeTime",
-		inputs: [],
-		outputs: [
-			{
-				name: "",
-				type: "uint64",
-				internalType: "uint64"
-			}
-		],
-		stateMutability: "view"
-	},
 	{
 		type: "function",
 		name: "open",
@@ -828,38 +756,6 @@ export const SETTLER_ESCROW_ABI = [
 		],
 		stateMutability: "view"
 	},
-	{
-		type: "function",
-		name: "owner",
-		inputs: [],
-		outputs: [
-			{
-				name: "result",
-				type: "address",
-				internalType: "address"
-			}
-		],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "ownershipHandoverExpiresAt",
-		inputs: [
-			{
-				name: "pendingOwner",
-				type: "address",
-				internalType: "address"
-			}
-		],
-		outputs: [
-			{
-				name: "result",
-				type: "uint256",
-				internalType: "uint256"
-			}
-		],
-		stateMutability: "view"
-	},
 	{
 		type: "function",
 		name: "purchaseOrder",
@@ -1135,46 +1031,6 @@ export const SETTLER_ESCROW_ABI = [
 		outputs: [],
 		stateMutability: "nonpayable"
 	},
-	{
-		type: "function",
-		name: "renounceOwnership",
-		inputs: [],
-		outputs: [],
-		stateMutability: "payable"
-	},
-	{
-		type: "function",
-		name: "requestOwnershipHandover",
-		inputs: [],
-		outputs: [],
-		stateMutability: "payable"
-	},
-	{
-		type: "function",
-		name: "setGovernanceFee",
-		inputs: [
-			{
-				name: "_nextGovernanceFee",
-				type: "uint64",
-				internalType: "uint64"
-			}
-		],
-		outputs: [],
-		stateMutability: "nonpayable"
-	},
-	{
-		type: "function",
-		name: "transferOwnership",
-		inputs: [
-			{
-				name: "newOwner",
-				type: "address",
-				internalType: "address"
-			}
-		],
-		outputs: [],
-		stateMutability: "payable"
-	},
 	{
 		type: "event",
 		name: "EIP712DomainChanged",
@@ -1206,44 +1062,6 @@ export const SETTLER_ESCROW_ABI = [
 		],
 		anonymous: false
 	},
-	{
-		type: "event",
-		name: "GovernanceFeeChanged",
-		inputs: [
-			{
-				name: "oldGovernanceFee",
-				type: "uint64",
-				indexed: false,
-				internalType: "uint64"
-			},
-			{
-				name: "newGovernanceFee",
-				type: "uint64",
-				indexed: false,
-				internalType: "uint64"
-			}
-		],
-		anonymous: false
-	},
-	{
-		type: "event",
-		name: "NextGovernanceFee",
-		inputs: [
-			{
-				name: "nextGovernanceFee",
-				type: "uint64",
-				indexed: false,
-				internalType: "uint64"
-			},
-			{
-				name: "nextGovernanceFeeTime",
-				type: "uint64",
-				indexed: false,
-				internalType: "uint64"
-			}
-		],
-		anonymous: false
-	},
 	{
 		type: "event",
 		name: "Open",
@@ -1347,19 +1165,6 @@ export const SETTLER_ESCROW_ABI = [
 		],
 		anonymous: false
 	},
-	{
-		type: "event",
-		name: "Open",
-		inputs: [
-			{
-				name: "orderId",
-				type: "bytes32",
-				indexed: true,
-				internalType: "bytes32"
-			}
-		],
-		anonymous: false
-	},
 	{
 		type: "event",
 		name: "OrderPurchased",
@@ -1385,51 +1190,6 @@ export const SETTLER_ESCROW_ABI = [
 		],
 		anonymous: false
 	},
-	{
-		type: "event",
-		name: "OwnershipHandoverCanceled",
-		inputs: [
-			{
-				name: "pendingOwner",
-				type: "address",
-				indexed: true,
-				internalType: "address"
-			}
-		],
-		anonymous: false
-	},
-	{
-		type: "event",
-		name: "OwnershipHandoverRequested",
-		inputs: [
-			{
-				name: "pendingOwner",
-				type: "address",
-				indexed: true,
-				internalType: "address"
-			}
-		],
-		anonymous: false
-	},
-	{
-		type: "event",
-		name: "OwnershipTransferred",
-		inputs: [
-			{
-				name: "oldOwner",
-				type: "address",
-				indexed: true,
-				internalType: "address"
-			},
-			{
-				name: "newOwner",
-				type: "address",
-				indexed: true,
-				internalType: "address"
-			}
-		],
-		anonymous: false
-	},
 	{
 		type: "event",
 		name: "Refunded",
@@ -1443,11 +1203,6 @@ export const SETTLER_ESCROW_ABI = [
 		],
 		anonymous: false
 	},
-	{
-		type: "error",
-		name: "AlreadyInitialized",
-		inputs: []
-	},
 	{
 		type: "error",
 		name: "AlreadyPurchased",
@@ -1491,15 +1246,15 @@ export const SETTLER_ESCROW_ABI = [
 	},
 	{
 		type: "error",
-		name: "FilledTooLate",
+		name: "FillDeadlineAfterExpiry",
 		inputs: [
 			{
-				name: "expected",
+				name: "fillDeadline",
 				type: "uint32",
 				internalType: "uint32"
 			},
 			{
-				name: "actual",
+				name: "expires",
 				type: "uint32",
 				internalType: "uint32"
 			}
@@ -1545,21 +1300,11 @@ export const SETTLER_ESCROW_ABI = [
 		name: "InvalidTimestampLength",
 		inputs: []
 	},
-	{
-		type: "error",
-		name: "NewOwnerIsZeroAddress",
-		inputs: []
-	},
 	{
 		type: "error",
 		name: "NoDestination",
 		inputs: []
 	},
-	{
-		type: "error",
-		name: "NoHandoverRequest",
-		inputs: []
-	},
 	{
 		type: "error",
 		name: "NotOrderOwner",
@@ -1636,8 +1381,14 @@ export const SETTLER_ESCROW_ABI = [
 	},
 	{
 		type: "error",
-		name: "Unauthorized",
-		inputs: []
+		name: "UnexpectedCaller",
+		inputs: [
+			{
+				name: "expectedCaller",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		]
 	},
 	{
 		type: "error",
diff --git a/src/lib/abi/multichain_compact.ts b/src/lib/abi/multichain_compact.ts
new file mode 100644
index 0000000..a4f7ef8
--- /dev/null
+++ b/src/lib/abi/multichain_compact.ts
@@ -0,0 +1,624 @@
+export const MULTICHAIN_SETTLER_COMPACT_ABI = [
+	{
+		type: "constructor",
+		inputs: [
+			{
+				name: "compact",
+				type: "address",
+				internalType: "address"
+			}
+		],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "COMPACT",
+		inputs: [],
+		outputs: [
+			{
+				name: "",
+				type: "address",
+				internalType: "contract TheCompact"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "DOMAIN_SEPARATOR",
+		inputs: [],
+		outputs: [
+			{
+				name: "",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "eip712Domain",
+		inputs: [],
+		outputs: [
+			{
+				name: "fields",
+				type: "bytes1",
+				internalType: "bytes1"
+			},
+			{
+				name: "name",
+				type: "string",
+				internalType: "string"
+			},
+			{
+				name: "version",
+				type: "string",
+				internalType: "string"
+			},
+			{
+				name: "chainId",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "verifyingContract",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "salt",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "extensions",
+				type: "uint256[]",
+				internalType: "uint256[]"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "finalise",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			},
+			{
+				name: "signatures",
+				type: "bytes",
+				internalType: "bytes"
+			},
+			{
+				name: "solveParams",
+				type: "tuple[]",
+				internalType: "struct InputSettlerBase.SolveParams[]",
+				components: [
+					{
+						name: "timestamp",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "solver",
+						type: "bytes32",
+						internalType: "bytes32"
+					}
+				]
+			},
+			{
+				name: "destination",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "call",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		],
+		outputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "finaliseWithSignature",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			},
+			{
+				name: "signatures",
+				type: "bytes",
+				internalType: "bytes"
+			},
+			{
+				name: "solveParams",
+				type: "tuple[]",
+				internalType: "struct InputSettlerBase.SolveParams[]",
+				components: [
+					{
+						name: "timestamp",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "solver",
+						type: "bytes32",
+						internalType: "bytes32"
+					}
+				]
+			},
+			{
+				name: "destination",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "call",
+				type: "bytes",
+				internalType: "bytes"
+			},
+			{
+				name: "orderOwnerSignature",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		],
+		outputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "orderIdentifier",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			}
+		],
+		outputs: [
+			{
+				name: "",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "event",
+		name: "EIP712DomainChanged",
+		inputs: [],
+		anonymous: false
+	},
+	{
+		type: "event",
+		name: "Finalised",
+		inputs: [
+			{
+				name: "orderId",
+				type: "bytes32",
+				indexed: true,
+				internalType: "bytes32"
+			},
+			{
+				name: "solver",
+				type: "bytes32",
+				indexed: false,
+				internalType: "bytes32"
+			},
+			{
+				name: "destination",
+				type: "bytes32",
+				indexed: false,
+				internalType: "bytes32"
+			}
+		],
+		anonymous: false
+	},
+	{
+		type: "error",
+		name: "CallOutOfRange",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "ContextOutOfRange",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "FillDeadlineAfterExpiry",
+		inputs: [
+			{
+				name: "fillDeadline",
+				type: "uint32",
+				internalType: "uint32"
+			},
+			{
+				name: "expires",
+				type: "uint32",
+				internalType: "uint32"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "FilledTooLate",
+		inputs: [
+			{
+				name: "expected",
+				type: "uint32",
+				internalType: "uint32"
+			},
+			{
+				name: "actual",
+				type: "uint32",
+				internalType: "uint32"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "InvalidShortString",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidSigner",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidTimestampLength",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NoDestination",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "StringTooLong",
+		inputs: [
+			{
+				name: "str",
+				type: "string",
+				internalType: "string"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "TimestampNotPassed",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "TimestampPassed",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "UnexpectedCaller",
+		inputs: [
+			{
+				name: "expectedCaller",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "UserCannotBeSettler",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "WrongChain",
+		inputs: [
+			{
+				name: "expected",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "actual",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		]
+	}
+] as const;
diff --git a/src/lib/abi/multichain_escrow.ts b/src/lib/abi/multichain_escrow.ts
new file mode 100644
index 0000000..892b962
--- /dev/null
+++ b/src/lib/abi/multichain_escrow.ts
@@ -0,0 +1,1051 @@
+export const MULTICHAIN_SETTLER_ESCROW_ABI = [
+	{
+		type: "constructor",
+		inputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "DOMAIN_SEPARATOR",
+		inputs: [],
+		outputs: [
+			{
+				name: "",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "eip712Domain",
+		inputs: [],
+		outputs: [
+			{
+				name: "fields",
+				type: "bytes1",
+				internalType: "bytes1"
+			},
+			{
+				name: "name",
+				type: "string",
+				internalType: "string"
+			},
+			{
+				name: "version",
+				type: "string",
+				internalType: "string"
+			},
+			{
+				name: "chainId",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "verifyingContract",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "salt",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "extensions",
+				type: "uint256[]",
+				internalType: "uint256[]"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "finalise",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			},
+			{
+				name: "solveParams",
+				type: "tuple[]",
+				internalType: "struct InputSettlerBase.SolveParams[]",
+				components: [
+					{
+						name: "timestamp",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "solver",
+						type: "bytes32",
+						internalType: "bytes32"
+					}
+				]
+			},
+			{
+				name: "destination",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "call",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		],
+		outputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "finaliseWithSignature",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			},
+			{
+				name: "solveParams",
+				type: "tuple[]",
+				internalType: "struct InputSettlerBase.SolveParams[]",
+				components: [
+					{
+						name: "timestamp",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "solver",
+						type: "bytes32",
+						internalType: "bytes32"
+					}
+				]
+			},
+			{
+				name: "destination",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "call",
+				type: "bytes",
+				internalType: "bytes"
+			},
+			{
+				name: "orderOwnerSignature",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		],
+		outputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "open",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			}
+		],
+		outputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "openFor",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			},
+			{
+				name: "sponsor",
+				type: "address",
+				internalType: "address"
+			},
+			{
+				name: "signature",
+				type: "bytes",
+				internalType: "bytes"
+			}
+		],
+		outputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "orderIdentifier",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			}
+		],
+		outputs: [
+			{
+				name: "",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "orderStatus",
+		inputs: [
+			{
+				name: "orderId",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		],
+		outputs: [
+			{
+				name: "",
+				type: "uint8",
+				internalType: "enum InputSettlerMultichainEscrow.OrderStatus"
+			}
+		],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "refund",
+		inputs: [
+			{
+				name: "order",
+				type: "tuple",
+				internalType: "struct MultichainOrderComponent",
+				components: [
+					{
+						name: "user",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "nonce",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIdField",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "chainIndex",
+						type: "uint256",
+						internalType: "uint256"
+					},
+					{
+						name: "expires",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "fillDeadline",
+						type: "uint32",
+						internalType: "uint32"
+					},
+					{
+						name: "inputOracle",
+						type: "address",
+						internalType: "address"
+					},
+					{
+						name: "inputs",
+						type: "uint256[2][]",
+						internalType: "uint256[2][]"
+					},
+					{
+						name: "outputs",
+						type: "tuple[]",
+						internalType: "struct MandateOutput[]",
+						components: [
+							{
+								name: "oracle",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "settler",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "chainId",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "token",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "amount",
+								type: "uint256",
+								internalType: "uint256"
+							},
+							{
+								name: "recipient",
+								type: "bytes32",
+								internalType: "bytes32"
+							},
+							{
+								name: "callbackData",
+								type: "bytes",
+								internalType: "bytes"
+							},
+							{
+								name: "context",
+								type: "bytes",
+								internalType: "bytes"
+							}
+						]
+					},
+					{
+						name: "additionalChains",
+						type: "bytes32[]",
+						internalType: "bytes32[]"
+					}
+				]
+			}
+		],
+		outputs: [],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "event",
+		name: "EIP712DomainChanged",
+		inputs: [],
+		anonymous: false
+	},
+	{
+		type: "event",
+		name: "Finalised",
+		inputs: [
+			{
+				name: "orderId",
+				type: "bytes32",
+				indexed: true,
+				internalType: "bytes32"
+			},
+			{
+				name: "solver",
+				type: "bytes32",
+				indexed: false,
+				internalType: "bytes32"
+			},
+			{
+				name: "destination",
+				type: "bytes32",
+				indexed: false,
+				internalType: "bytes32"
+			}
+		],
+		anonymous: false
+	},
+	{
+		type: "event",
+		name: "Open",
+		inputs: [
+			{
+				name: "orderId",
+				type: "bytes32",
+				indexed: true,
+				internalType: "bytes32"
+			},
+			{
+				name: "order",
+				type: "bytes",
+				indexed: false,
+				internalType: "bytes"
+			}
+		],
+		anonymous: false
+	},
+	{
+		type: "event",
+		name: "Refunded",
+		inputs: [
+			{
+				name: "orderId",
+				type: "bytes32",
+				indexed: true,
+				internalType: "bytes32"
+			}
+		],
+		anonymous: false
+	},
+	{
+		type: "error",
+		name: "CallOutOfRange",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "ChainIndexOutOfRange",
+		inputs: [
+			{
+				name: "chainIndex",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "numSegments",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "CodeSize0",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "ContextOutOfRange",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "FillDeadlineAfterExpiry",
+		inputs: [
+			{
+				name: "fillDeadline",
+				type: "uint32",
+				internalType: "uint32"
+			},
+			{
+				name: "expires",
+				type: "uint32",
+				internalType: "uint32"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "FilledTooLate",
+		inputs: [
+			{
+				name: "expected",
+				type: "uint32",
+				internalType: "uint32"
+			},
+			{
+				name: "actual",
+				type: "uint32",
+				internalType: "uint32"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "HasDirtyBits",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidOrderStatus",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidShortString",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidSigner",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "InvalidTimestampLength",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "NoDestination",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "OrderIdMismatch",
+		inputs: [
+			{
+				name: "provided",
+				type: "bytes32",
+				internalType: "bytes32"
+			},
+			{
+				name: "computed",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "ReentrancyDetected",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "SafeERC20FailedOperation",
+		inputs: [
+			{
+				name: "token",
+				type: "address",
+				internalType: "address"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "SignatureAndInputsNotEqual",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "SignatureNotSupported",
+		inputs: [
+			{
+				name: "",
+				type: "bytes1",
+				internalType: "bytes1"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "StringTooLong",
+		inputs: [
+			{
+				name: "str",
+				type: "string",
+				internalType: "string"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "TimestampNotPassed",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "TimestampPassed",
+		inputs: []
+	},
+	{
+		type: "error",
+		name: "UnexpectedCaller",
+		inputs: [
+			{
+				name: "expectedCaller",
+				type: "bytes32",
+				internalType: "bytes32"
+			}
+		]
+	},
+	{
+		type: "error",
+		name: "WrongChain",
+		inputs: [
+			{
+				name: "expected",
+				type: "uint256",
+				internalType: "uint256"
+			},
+			{
+				name: "actual",
+				type: "uint256",
+				internalType: "uint256"
+			}
+		]
+	}
+] as const;
diff --git a/src/lib/abi/outputsettler.ts b/src/lib/abi/outputsettler.ts
index 9321129..ac4a130 100644
--- a/src/lib/abi/outputsettler.ts
+++ b/src/lib/abi/outputsettler.ts
@@ -496,17 +496,6 @@ export const COIN_FILLER_ABI = [
 		name: "ContextOutOfRange",
 		inputs: []
 	},
-	{
-		type: "error",
-		name: "ExclusiveTo",
-		inputs: [
-			{
-				name: "solver",
-				type: "bytes32",
-				internalType: "bytes32"
-			}
-		]
-	},
 	{
 		type: "error",
 		name: "FailedCall",
@@ -554,11 +543,6 @@ export const COIN_FILLER_ABI = [
 			}
 		]
 	},
-	{
-		type: "error",
-		name: "InvalidContextDataLength",
-		inputs: []
-	},
 	{
 		type: "error",
 		name: "NotDivisible",
@@ -575,11 +559,6 @@ export const COIN_FILLER_ABI = [
 			}
 		]
 	},
-	{
-		type: "error",
-		name: "NotImplemented",
-		inputs: []
-	},
 	{
 		type: "error",
 		name: "NotProven",
@@ -648,10 +627,5 @@ export const COIN_FILLER_ABI = [
 				internalType: "bytes32"
 			}
 		]
-	},
-	{
-		type: "error",
-		name: "ZeroValue",
-		inputs: []
 	}
 ] as const;
diff --git a/src/lib/components/BalanceField.svelte b/src/lib/components/BalanceField.svelte
index 3f02899..bde44f0 100644
--- a/src/lib/components/BalanceField.svelte
+++ b/src/lib/components/BalanceField.svelte
@@ -13,21 +13,21 @@
 {#await value}
 	<input
 		type="text"
-		class="w-20 rounded border border-gray-800 bg-gray-50 px-2 py-1"
+		class="w-20 cursor-not-allowed rounded border border-gray-700 bg-gray-50 px-2 py-1 text-gray-600"
 		disabled
 		value="..."
 	/>
 {:then value}
 	<input
 		type="text"
-		class="w-20 rounded border border-gray-800 bg-gray-50 px-2 py-1"
+		class="w-20 cursor-not-allowed rounded border border-gray-700 bg-gray-50 px-2 py-1 text-gray-600"
 		disabled
 		value={Number(value) / 10 ** decimals}
 	/>
 {:catch error}
 	<input
 		type="text"
-		class="w-20 rounded border border-gray-800 bg-gray-50 px-2 py-1"
+		class="w-20 cursor-not-allowed rounded border border-gray-700 bg-gray-50 px-2 py-1 text-gray-600"
 		disabled
 		value="err"
 	/>
diff --git a/src/lib/components/GetQuote.svelte b/src/lib/components/GetQuote.svelte
index 35c7509..f8f0fda 100644
--- a/src/lib/components/GetQuote.svelte
+++ b/src/lib/components/GetQuote.svelte
@@ -1,22 +1,18 @@
 <script lang="ts">
-	import type { Token } from "$lib/config";
 	import { OrderServer } from "$lib/libraries/orderServer";
+	import type { TokenContext } from "$lib/state.svelte";
 	import { interval } from "rxjs";
 
 	let {
 		exclusiveFor = $bindable(),
-		inputAmounts,
-		outputAmount = $bindable(),
 		inputTokens,
-		outputToken,
+		outputTokens = $bindable(),
 		account,
 		mainnet
 	}: {
 		exclusiveFor: string;
-		inputAmounts: bigint[];
-		outputAmount: bigint;
-		inputTokens: Token[];
-		outputToken: Token;
+		inputTokens: TokenContext[];
+		outputTokens: TokenContext[];
 		account: () => `0x${string}`;
 		mainnet: boolean;
 	} = $props();
@@ -24,37 +20,42 @@
 	const orderServer = $derived(new OrderServer(mainnet));
 
 	async function getQuoteAndSet() {
-		const response = await orderServer.getQuotes({
-			user: account(),
-			userChain: inputTokens[0].chain,
-			inputs: inputTokens.map((input, i) => {
-				return {
-					sender: account(),
-					asset: input.address,
-					chain: input.chain,
-					amount: inputAmounts[i]
-				};
-			}),
-			outputs: [
-				{
-					receiver: account(),
-					asset: outputToken.address,
-					chain: outputToken.chain,
-					amount: 0n
-				}
-			]
-		});
-		if (response?.quotes?.length ?? 0) {
-			const quote = response.quotes[0];
-			quoteExpires = quote.validUntil ?? new Date().getTime() + 30 * 1000;
-			if (quoteExpires < new Date().getTime()) quoteExpires = new Date().getTime() + 30 * 1000;
-			quoteDuration = quoteExpires - new Date().getTime();
-			outputAmount = BigInt(quote.preview.outputs[0].amount);
-			exclusiveFor = quote.metadata.exclusiveFor ?? "";
-			updater();
-		} else {
-			quoteExpires = 0;
-			exclusiveFor = "";
+		try {
+			const response = await orderServer.getQuotes({
+				user: account(),
+				userChain: inputTokens[0].token.chain,
+				inputs: inputTokens.map(({ token, amount }) => {
+					return {
+						sender: account(),
+						asset: token.address,
+						chain: token.chain,
+						amount: amount
+					};
+				}),
+				outputs: outputTokens.map(({ token }) => {
+					return {
+						receiver: account(),
+						asset: token.address,
+						chain: token.chain,
+						amount: 0n
+					};
+				})
+			});
+			if (response?.quotes?.length ?? 0) {
+				const quote = response.quotes[0];
+				quoteExpires = quote.validUntil ?? new Date().getTime() + 30 * 1000;
+				if (quoteExpires < new Date().getTime()) quoteExpires = new Date().getTime() + 30 * 1000;
+				quoteDuration = quoteExpires - new Date().getTime();
+				outputTokens[0].amount = BigInt(quote.preview.outputs[0].amount);
+				exclusiveFor = quote.metadata.exclusiveFor ?? "";
+				updater();
+			} else {
+				quoteExpires = 0;
+				exclusiveFor = "";
+			}
+		} catch (e) {
+			console.log("Could not fetch a quote", e);
+			return;
 		}
 	}
 
@@ -99,9 +100,9 @@
 	let quoteRequest: Promise<void> = $state(Promise.resolve());
 </script>
 
-<div class="relative my-1 flex items-center justify-center align-middle">
+<div class="relative my-1 flex w-full items-center justify-center text-center align-middle">
 	{#await quoteRequest}
-		<div class="relative h-7 animate-pulse rounded border px-2 font-bold">Fetch Quote</div>
+		<div class="relative h-7 w-full animate-pulse rounded border px-2 font-bold">Fetch Quote</div>
 	{:then _}
 		<!-- Button gradually shows how long until it is expired by fill background -->
 		{#if quoteExpires !== 0}
diff --git a/src/lib/components/InputTokenModal.svelte b/src/lib/components/InputTokenModal.svelte
new file mode 100644
index 0000000..e94a117
--- /dev/null
+++ b/src/lib/components/InputTokenModal.svelte
@@ -0,0 +1,199 @@
+<script lang="ts">
+	import BalanceField from "$lib/components/BalanceField.svelte";
+	import { chainMap, coinList, INPUT_SETTLER_COMPACT_LIFI, type Token } from "$lib/config";
+	import { AssetSelection } from "$lib/libraries/assetSelection";
+	import store, { type TokenContext } from "$lib/state.svelte";
+	import { toBigIntWithDecimals } from "$lib/utils/convert";
+	import { type InteropableAddress, getInteropableAddress } from "$lib/utils/interopableAddresses";
+
+	const v = (num: number | null) => (num ? num : 0);
+
+	let {
+		active = $bindable(),
+		currentInputTokens = $bindable()
+	}: {
+		active: boolean;
+		currentInputTokens: TokenContext[];
+	} = $props();
+
+	let inputs = $state<{ [index: InteropableAddress]: number | null }>(
+		Object.fromEntries(
+			(currentInputTokens ?? []).map(({ token, amount }) => [
+				getInteropableAddress(token.address, chainMap[token.chain].id),
+				Number(amount) / 10 ** token.decimals
+			])
+		)
+	);
+	// svelte-ignore state_referenced_locally
+	let computerValue = $state<number | null>(Object.values(inputs).reduce((a, b) => v(a) + v(b), 0));
+
+	type SortOrder = "largest" | "smallest";
+	let sortOrder = $state<SortOrder>("largest");
+
+	function getTokenFor(address: InteropableAddress): Token | undefined {
+		for (const token of tokenSet) {
+			const iaddr = getInteropableAddress(token.address, chainMap[token.chain].id);
+			if (iaddr === address) return token;
+		}
+	}
+
+	function save() {
+		// Go over every single non-0 instance in the array:
+		const inputKeys = Object.keys(inputs) as InteropableAddress[];
+		const inputTokens: TokenContext[] = [];
+		for (const key of inputKeys) {
+			// Check that key is a number
+			const inputValue = v(inputs[key]);
+			// The token would be:
+			const token = getTokenFor(key);
+			// If we can't find the token, then it is most likely because the user changed their token.
+			if (!token) continue;
+
+			if (inputValue === 0) continue;
+			inputTokens.push({ token, amount: toBigIntWithDecimals(inputValue, token.decimals) });
+		}
+		if (inputTokens.length === 0) {
+			inputTokens.push({ token: tokenSet[0], amount: 0n });
+		}
+		currentInputTokens = inputTokens;
+
+		active = false;
+	}
+
+	const uniqueTokens = $derived([...new Set(coinList(store.mainnet).map((v) => v.name))]);
+
+	// svelte-ignore state_referenced_locally
+	let selectedTokenName = $state<string>(currentInputTokens[0].token.name);
+	const tokenSet = $derived(
+		coinList(store.mainnet).filter((v) => v.name.toLowerCase() === selectedTokenName.toLowerCase())
+	);
+
+	let circuitBreaker = false;
+	$effect(() => {
+		selectedTokenName;
+		if (circuitBreaker || currentInputTokens[0].token.name !== selectedTokenName) {
+			circuitBreaker = true;
+			inputs = Object.fromEntries(
+				tokenSet.map((token) => [getInteropableAddress(token.address, chainMap[token.chain].id), 0])
+			);
+		}
+	});
+
+	async function computeInputs(total: number, order: SortOrder) {
+		const tokens = tokenSet;
+		const balancePromises = tokenSet.map(
+			(tkn) =>
+				(store.intentType === "compact" ? store.compactBalances : store.balances)[tkn.chain][
+					tkn.address
+				]
+		);
+		const balances = await Promise.all(balancePromises);
+
+		const goal = toBigIntWithDecimals(total, tokens[0].decimals);
+		const solution =
+			AssetSelection.Sum(balances) < goal
+				? balances
+				: order === "largest"
+					? new AssetSelection({ goal, values: balances }).largest().asValues()
+					: new AssetSelection({ goal, values: balances }).smallest().asValues();
+
+		for (let i = 0; i < tokens.length; ++i) {
+			const token = tokenSet[i];
+			const iaddr = getInteropableAddress(token.address, chainMap[token.chain].id);
+			inputs[iaddr] = Number(solution[i]) / 10 ** token.decimals;
+		}
+
+		return Number(AssetSelection.Sum(solution)) / 10 ** tokens[0].decimals;
+	}
+
+	// svelte-ignore state_referenced_locally
+	let lastComputed = $state<number | null>(computerValue);
+	// svelte-ignore state_referenced_locally
+	let lastSortOrder = $state<SortOrder>(sortOrder);
+
+	// Only trigger computeInputs when the user actually changes `computerValue` or `sortOrder`.
+	$effect(() => {
+		if (computerValue === lastComputed && lastSortOrder === sortOrder) return;
+		lastSortOrder = sortOrder;
+		const requested = v(computerValue);
+		computeInputs(requested, sortOrder).then(() => {
+			// computeInputs updates `inputs`; the inputs-effect below will set
+			// `computerValue` and `lastComputed` so we don't set them here.
+		});
+	});
+
+	// Canonical source of truth: derive `computerValue` from `inputs`.
+	$effect(() => {
+		const sum = Object.values(inputs).reduce((a, b) => v(a) + v(b), 0) as number;
+		lastComputed = sum;
+		computerValue = sum;
+	});
+</script>
+
+<div
+	class="absolute top-30 left-1/2 z-20 mx-auto h-2/3 w-11/12 -translate-x-1/2 transform border border-gray-200 bg-gray-50"
+>
+	<!-- svelte-ignore a11y_consider_explicit_label -->
+	<button
+		class="absolute top-0 right-0 h-5 w-5 cursor-pointer bg-blue-100 text-center"
+		onclick={() => {
+			active = false;
+		}}
+	>
+		<div class="absolute top-1.5 right-2.5 h-2 w-[1px] rotate-45 bg-black font-bold"></div>
+		<div class="absolute top-1.5 right-2.5 h-2 w-[1px] -rotate-45 bg-black font-bold"></div>
+	</button>
+	<div class="flex h-full w-full flex-col items-center justify-center space-y-3 align-middle">
+		<h3 class="-mt-2 text-center text-xl font-medium">Select Input</h3>
+		<div class="flex flex-row">
+			<select id="orderSelector" class="mr-0.5" bind:value={sortOrder}>
+				<option value="largest">↑</option>
+				<option value="smallest">↓</option>
+			</select>
+			<input
+				type="number"
+				class="w-20 rounded rounded-r-none border border-r-0 border-gray-400 px-2 py-1"
+				bind:value={computerValue}
+			/>
+			<select
+				id="tokenSelector"
+				class="rounded rounded-l-none border border-gray-400 px-2 py-1"
+				bind:value={selectedTokenName}
+			>
+				{#each uniqueTokens as token}
+					<option value={token}>{token.toUpperCase()}</option>
+				{/each}
+			</select>
+		</div>
+		<div class="flex flex-row space-x-2">
+			<div class="flex flex-col space-y-2 text-right">
+				{#each tokenSet as tkn}
+					<span class="h-8">{tkn.chain}</span>
+				{/each}
+			</div>
+			<div class="flex flex-col space-y-2">
+				{#each tokenSet as tkn}
+					<div class="flex flex-row space-x-2">
+						<input
+							type="number"
+							class="w-20 rounded border px-2 py-1"
+							defaultValue="0"
+							bind:value={inputs[getInteropableAddress(tkn.address, chainMap[tkn.chain].id)]}
+						/>
+						<span class="mt-0.5">of</span>
+						<BalanceField
+							value={(store.intentType === "compact" ? store.compactBalances : store.balances)[
+								tkn.chain
+							][tkn.address]}
+							decimals={tkn.decimals}
+						/>
+					</div>
+				{/each}
+			</div>
+		</div>
+		<button
+			class="bg-gray h-8 rounded border px-4 text-xl font-bold text-gray-600 hover:text-blue-600"
+			onclick={save}>Save</button
+		>
+	</div>
+</div>
diff --git a/src/lib/components/Introduction.svelte b/src/lib/components/Introduction.svelte
index f9f3582..ea22fea 100644
--- a/src/lib/components/Introduction.svelte
+++ b/src/lib/components/Introduction.svelte
@@ -4,11 +4,21 @@
 		<a
 			class="font-bold text-blue-700 hover:text-blue-500"
 			href="https://github.com/openintentsframework/oif-contracts">Open Intents Framework</a
-		>. It is work in progress and currently support a seamless resource lock flow using
+		>. It currently support a seamless resource lock flow using
 		<a
 			class="font-bold text-blue-700 hover:text-blue-500"
 			href="https://github.com/Uniswap/the-compact/tree/v1">The Compact</a
-		> and a traditional escrow flow.
+		> and a traditional escrow flow, along with a work in progress multichain flow.
+	</p>
+
+	<br />
+
+	<h3 class="font-semibold">Multichain</h3>
+	<p>
+		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 <i>any to any</i> intent.
+		Multichain intents are currently work in progress and will break in the future. If you are using
+		this interface for testing, ensure the <b>multichain</b> flag is not shown.
 	</p>
 
 	<br />
@@ -57,4 +67,16 @@
 			>Open Intents Framework</a
 		>.
 	</p>
+
+	<br />
+
+	<h3 class="font-semibold">Same Chain</h3>
+	<p>
+		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 <a
+			href="https://github.com/catalystsystem/catalyst-intent/blob/997649a2e2474d4c3e59afc631c6afd45a9040dc/test/integration/InputSettler7683LIFI.samechain.t.sol#L169-L174"
+			>explore a demo</a
+		> of how to collect inputs before delivering outputs.
+	</p>
 </div>
diff --git a/src/lib/components/OutputTokenModal.svelte b/src/lib/components/OutputTokenModal.svelte
new file mode 100644
index 0000000..f053ad7
--- /dev/null
+++ b/src/lib/components/OutputTokenModal.svelte
@@ -0,0 +1,131 @@
+<script lang="ts">
+	import BalanceField from "$lib/components/BalanceField.svelte";
+	import { chainList, type chain, chains, coinList, type Token } from "$lib/config";
+	import store, { type TokenContext } from "$lib/state.svelte";
+	import { toBigIntWithDecimals } from "$lib/utils/convert";
+
+	let {
+		active = $bindable(),
+		currentOutputTokens = $bindable()
+	}: {
+		active: boolean;
+		currentOutputTokens: TokenContext[];
+	} = $props();
+
+	const outputs = $state<{ chain: chain; name: string; amount: number }[]>(
+		currentOutputTokens.map(({ token, amount }) => {
+			return {
+				chain: token.chain,
+				name: token.name,
+				amount: Number(amount) / 10 ** token.decimals
+			};
+		})
+	);
+
+	function getTokensForChain(chain: chain) {
+		const coins = coinList(store.mainnet);
+		console.log(chain);
+		return coins.filter((v) => v.chain == chain);
+	}
+
+	function save() {
+		const coins = coinList(store.mainnet);
+		const nextOutputTokens = [];
+		for (const output of outputs) {
+			const { name, chain, amount } = output;
+			const token = coins.find((v) => v.name == name && v.chain == chain);
+			// Check if we found token.
+			if (!token) {
+				console.log(`Could not find ${name} on ${chain}`);
+				continue;
+			}
+			nextOutputTokens.push({
+				token,
+				amount: toBigIntWithDecimals(amount, token.decimals)
+			});
+		}
+
+		currentOutputTokens = nextOutputTokens;
+		active = false;
+	}
+
+	function add() {
+		if (outputs.length == 3) return;
+		outputs.push({
+			chain: outputs[outputs.length - 1].chain,
+			name: "usdc",
+			amount: 0
+		});
+	}
+
+	function remove() {
+		if (outputs.length == 1) return;
+		outputs.pop();
+	}
+</script>
+
+<div
+	class="absolute top-30 left-1/2 z-20 mx-auto h-2/3 w-11/12 -translate-x-1/2 transform border border-gray-200 bg-gray-50"
+>
+	<!-- svelte-ignore a11y_consider_explicit_label -->
+	<button
+		class="absolute top-0 right-0 h-5 w-5 cursor-pointer bg-blue-100 text-center"
+		onclick={() => {
+			active = false;
+		}}
+	>
+		<div class="absolute top-1.5 right-2.5 h-2 w-[1px] rotate-45 bg-black font-bold"></div>
+		<div class="absolute top-1.5 right-2.5 h-2 w-[1px] -rotate-45 bg-black font-bold"></div>
+	</button>
+	<div class="flex h-full w-full flex-col items-center justify-center space-y-3 align-middle">
+		<h3 class="-mt-2 text-center text-xl font-medium">Select Output</h3>
+		<div class="flex flex-row space-x-2">
+			<div class="flex flex-col space-y-2">
+				{#each outputs as output}
+					<div class="flex flex-row space-x-2">
+						<input
+							type="number"
+							class="w-20 rounded border px-2 py-1"
+							defaultValue="0"
+							bind:value={output.amount}
+						/>
+						<select
+							class="rounded rounded-l-none border border-gray-400 px-2 py-1"
+							bind:value={output.chain}
+						>
+							{#each Object.values(chainList(store.mainnet)) as chain}
+								<option value={chain}>{chain}</option>
+							{/each}
+						</select>
+						<select
+							class="rounded rounded-l-none border border-gray-400 px-2 py-1"
+							bind:value={output.name}
+						>
+							{#each getTokensForChain(output.chain) as token}
+								<option value={token.name}>{token.name.toUpperCase()}</option>
+							{/each}
+						</select>
+					</div>
+				{/each}
+			</div>
+		</div>
+		<div class="flex w-full flex-row justify-evenly">
+			<button
+				class="w-8 cursor-pointer rounded bg-red-100 font-medium hover:bg-red-200"
+				onclick={remove}
+			>
+				-
+			</button>
+			<button
+				class="bg-gray h-8 rounded border px-4 text-xl font-bold text-gray-600 hover:text-blue-600"
+				onclick={save}>Save</button
+			>
+			<button
+				class="w-8 cursor-pointer rounded bg-green-100 font-medium hover:bg-green-200"
+				onclick={add}
+			>
+				+
+			</button>
+		</div>
+	</div>
+</div>
diff --git a/src/lib/config.ts b/src/lib/config.ts
index fd38387..3efc4ad 100644
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -15,7 +15,11 @@ export const BYTES32_ZERO =
 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 ALWAYS_OK_ALLOCATOR = "301267367668059890006832136" as const;
+export const MULTICHAIN_INPUT_SETTLER_ESCROW =
+	"0xb912b4c38ab54b94D45Ac001484dEBcbb519Bc2B" as const;
+export const MULTICHAIN_INPUT_SETTLER_COMPACT =
+	"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 = {
@@ -43,13 +47,18 @@ export const chainMap = {
 	ethereum,
 	base,
 	arbitrum,
-	arbitrumSepolia,
 	sepolia,
+	arbitrumSepolia,
 	optimismSepolia,
 	baseSepolia
 } as const;
 export const chains = Object.keys(chainMap) as (keyof typeof chainMap)[];
 export type chain = (typeof chains)[number];
+export const chainList = (mainnet: boolean) => {
+	if (mainnet == true) {
+		return ["ethereum", "base", "arbitrum"];
+	} else return ["sepolia", "optimismSepolia", "baseSepolia", "arbitrumSepolia"];
+};
 
 export type balanceQuery = Record<chain, Record<`0x${string}`, Promise<bigint>>>;
 
@@ -199,8 +208,8 @@ export function printToken(token: Token) {
 	return `${token.name.toUpperCase()}, ${token.chain}`;
 }
 
-export function formatTokenAmount(amount: bigint, token: Token, decimals = 4) {
-	const formattedAmount = Number(amount) / 10 ** token.decimals;
+export function formatTokenAmount(amount: bigint, tokenDecimals: number, decimals = 4) {
+	const formattedAmount = Number(amount) / 10 ** tokenDecimals;
 	return formattedAmount.toFixed(decimals);
 }
 
diff --git a/src/lib/libraries/assetSelection.ts b/src/lib/libraries/assetSelection.ts
new file mode 100644
index 0000000..810ea4b
--- /dev/null
+++ b/src/lib/libraries/assetSelection.ts
@@ -0,0 +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<T>(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 3383da1..be1786f 100644
--- a/src/lib/libraries/compactLib.ts
+++ b/src/lib/libraries/compactLib.ts
@@ -13,6 +13,7 @@ import {
 import { COMPACT_ABI } from "$lib/abi/compact";
 import { addressToBytes32 } from "$lib/utils/convert";
 import { ERC20_ABI } from "$lib/abi/erc20";
+import type { TokenContext } from "$lib/state.svelte";
 
 export class CompactLib {
 	static compactDeposit(
@@ -20,16 +21,16 @@ export class CompactLib {
 		opts: {
 			preHook?: (chain: chain) => Promise<any>;
 			postHook?: () => Promise<any>;
-			inputToken: Token;
+			inputToken: TokenContext;
 			account: () => `0x${string}`;
-			inputAmount: bigint;
 			allocatorId: string;
 		}
 	) {
 		return async () => {
-			const { preHook, postHook, inputToken, account, allocatorId, inputAmount } = opts;
+			const { preHook, postHook, inputToken, account, allocatorId } = opts;
+			const { token, amount } = inputToken;
 			const publicClients = clients;
-			if (preHook) await preHook(inputToken.chain);
+			if (preHook) await preHook(token.chain);
 			const lockTag: `0x${string}` = `0x${toHex(
 				toId(true, ResetPeriod.OneDay, allocatorId, ADDRESS_ZERO),
 				{
@@ -41,27 +42,27 @@ export class CompactLib {
 			const recipient = ADDRESS_ZERO; // This means sender.
 
 			let transactionHash: `0x${string}`;
-			if (inputToken.address === ADDRESS_ZERO) {
+			if (token.address === ADDRESS_ZERO) {
 				transactionHash = await walletClient.writeContract({
-					chain: chainMap[inputToken.chain],
+					chain: chainMap[token.chain],
 					account: account(),
 					address: COMPACT,
 					abi: COMPACT_ABI,
 					functionName: "depositNative",
-					value: inputAmount,
+					value: amount,
 					args: [lockTag, recipient]
 				});
 			} else {
 				transactionHash = await walletClient.writeContract({
-					chain: chainMap[inputToken.chain],
+					chain: chainMap[token.chain],
 					account: account(),
 					address: COMPACT,
 					abi: COMPACT_ABI,
 					functionName: "depositERC20",
-					args: [inputToken.address, lockTag, inputAmount, recipient]
+					args: [token.address, lockTag, amount, recipient]
 				});
 			}
-			await publicClients[inputToken.chain].waitForTransactionReceipt({
+			await publicClients[token.chain].waitForTransactionReceipt({
 				hash: await transactionHash
 			});
 			if (postHook) await postHook();
@@ -74,16 +75,16 @@ export class CompactLib {
 		opts: {
 			preHook?: (chain: chain) => Promise<any>;
 			postHook?: () => Promise<any>;
-			inputToken: Token;
+			inputToken: TokenContext;
 			account: () => `0x${string}`;
-			inputAmount: bigint;
 			allocatorId: string;
 		}
 	) {
 		return async () => {
-			const { preHook, postHook, inputToken, account, allocatorId, inputAmount } = opts;
+			const { preHook, postHook, inputToken, account, allocatorId } = opts;
+			const { token, amount } = inputToken;
 			const publicClients = clients;
-			const assetId = toId(true, ResetPeriod.OneDay, allocatorId, inputToken.address);
+			const assetId = toId(true, ResetPeriod.OneDay, allocatorId, token.address);
 
 			const allocatedTransferStruct: {
 				allocatorData: `0x${string}`;
@@ -102,21 +103,21 @@ export class CompactLib {
 				recipients: [
 					{
 						claimant: BigInt(addressToBytes32(account())),
-						amount: inputAmount
+						amount: amount
 					}
 				]
 			};
 
-			if (preHook) await preHook(inputToken.chain);
+			if (preHook) await preHook(token.chain);
 			const transactionHash = walletClient.writeContract({
-				chain: chainMap[inputToken.chain],
+				chain: chainMap[token.chain],
 				account: account(),
 				address: COMPACT,
 				abi: COMPACT_ABI,
 				functionName: "allocatedTransfer",
 				args: [allocatedTransferStruct]
 			});
-			await publicClients[inputToken.chain].waitForTransactionReceipt({
+			await publicClients[token.chain].waitForTransactionReceipt({
 				hash: await transactionHash
 			});
 			if (postHook) await postHook();
@@ -129,15 +130,14 @@ export class CompactLib {
 		opts: {
 			preHook?: (chain: chain) => Promise<any>;
 			postHook?: () => Promise<any>;
-			inputTokens: Token[];
-			inputAmounts: bigint[];
+			inputTokens: TokenContext[];
 			account: () => `0x${string}`;
 		}
 	) {
 		return async () => {
-			const { preHook, postHook, inputTokens, inputAmounts, account } = opts;
+			const { preHook, postHook, inputTokens, account } = opts;
 			for (let i = 0; i < inputTokens.length; ++i) {
-				const inputToken = inputTokens[i];
+				const { token: inputToken, amount } = inputTokens[i];
 				if (preHook) await preHook(inputToken.chain);
 				const publicClient = clients[inputToken.chain];
 				// Check if we have sufficient allowance already.
@@ -147,7 +147,7 @@ export class CompactLib {
 					functionName: "allowance",
 					args: [account(), COMPACT]
 				});
-				if (currentAllowance >= inputAmounts[i]) continue;
+				if (currentAllowance >= amount) continue;
 				const transactionHash = walletClient.writeContract({
 					chain: chainMap[inputToken.chain],
 					account: account(),
diff --git a/src/lib/libraries/intent.ts b/src/lib/libraries/intent.ts
index 894226e..487b4b5 100644
--- a/src/lib/libraries/intent.ts
+++ b/src/lib/libraries/intent.ts
@@ -1,15 +1,29 @@
-import { encodePacked, hashStruct, toHex } from "viem";
-import type { BatchCompact, CompactMandate, MandateOutput, StandardOrder } from "../../types";
+import { encodeAbiParameters, encodePacked, hashStruct, keccak256, parseAbiParameters } from "viem";
+import type {
+	BatchCompact,
+	CompactMandate,
+	Element,
+	MandateOutput,
+	MultichainCompact,
+	MultichainOrder,
+	MultichainOrderComponent,
+	NoSignature,
+	Signature,
+	StandardOrder
+} from "../../types";
 import { COMPACT_ABI } from "../abi/compact";
 import {
 	chainMap,
+	clients,
 	COIN_FILLER,
 	COMPACT,
+	getChainName,
 	getOracle,
 	INPUT_SETTLER_COMPACT_LIFI,
 	INPUT_SETTLER_ESCROW_LIFI,
+	MULTICHAIN_INPUT_SETTLER_COMPACT,
+	MULTICHAIN_INPUT_SETTLER_ESCROW,
 	type chain,
-	type Token,
 	type Verifier,
 	type WC
 } from "../config";
@@ -17,19 +31,48 @@ import { ResetPeriod, toId } from "../utils/idLib";
 import { compact_type_hash, compactTypes } from "../utils/typedMessage";
 import { addressToBytes32 } from "../utils/convert";
 import { SETTLER_ESCROW_ABI } from "../abi/escrow";
+import type { TokenContext } from "$lib/state.svelte";
+import { MULTICHAIN_SETTLER_ESCROW_ABI } from "$lib/abi/multichain_escrow";
+import { SETTLER_COMPACT_ABI } from "$lib/abi/settlercompact";
+import { toHex } from "$lib/utils/interopableAddresses";
+import { MULTICHAIN_SETTLER_COMPACT_ABI } from "$lib/abi/multichain_compact";
 
-export type CreateIntentOptions = {
-	exclusiveFor: string;
+type Lock = {
+	lockTag: `0x${string}`;
+	token: `0x${string}`;
+	amount: bigint;
+};
+
+export type EscrowLock = {
+	type: "escrow";
+};
+
+export type CompactLock = {
+	type: "compact";
+	resetPeriod: ResetPeriod;
 	allocatorId: string;
-	inputTokens: Token[];
-	outputToken: Token;
-	inputAmounts: bigint[];
-	outputAmount: bigint;
+};
+
+export type CreateIntentOptionsEscrow = {
+	exclusiveFor: string;
+	inputTokens: TokenContext[];
+	outputTokens: TokenContext[];
 	verifier: Verifier;
 	account: () => `0x${string}`;
-	inputSettler: typeof INPUT_SETTLER_COMPACT_LIFI | typeof INPUT_SETTLER_ESCROW_LIFI;
+	lock: EscrowLock;
 };
 
+export type CreateIntentOptionsCompact = {
+	exclusiveFor: string;
+	inputTokens: TokenContext[];
+	outputTokens: TokenContext[];
+	verifier: Verifier;
+	account: () => `0x${string}`;
+	lock: CompactLock;
+};
+
+export type CreateIntentOptions = CreateIntentOptionsEscrow | CreateIntentOptionsCompact;
+
 function findChain(chainId: bigint) {
 	for (const [name, data] of Object.entries(chainMap)) {
 		if (BigInt(data.id) === chainId) {
@@ -39,96 +82,255 @@ function findChain(chainId: bigint) {
 	return undefined;
 }
 
+function selectAllBut<T>(arr: T[], index: number): T[] {
+	return [...arr.slice(0, index), ...arr.slice(index + 1, arr.length)];
+}
+
+function encodeOutputs(outputs: MandateOutput[]) {
+	return encodeAbiParameters(
+		parseAbiParameters(
+			"(bytes32 oracle, bytes32 settler, uint256 chainId, bytes32 token, uint256 amount, bytes32 recipient, bytes callbackData, bytes context)[]"
+		),
+		[outputs]
+	);
+}
+
+const ONE_MINUTE = 60;
+const ONE_HOUR = 60 * ONE_MINUTE;
+const ONE_DAY = 24 * ONE_HOUR;
+
 /**
  * @notice Class representing a Li.Fi Intent. Contains intent abstractions and helpers.
  */
 export class Intent {
-	private order: StandardOrder;
+	private lock: EscrowLock | CompactLock;
 
-	constructor(opts: CreateIntentOptions) {
-		const { order } = Intent.create(opts);
-		this.order = order;
+	// User facing order options
+	private user: () => `0x${string}`;
+	private inputs: TokenContext[];
+	private outputs: TokenContext[];
+	private verifier: Verifier;
+
+	private exclusiveFor: `0x${string}`;
+
+	private _nonce?: bigint;
+
+	private expiry = ONE_DAY;
+	private fillDeadline = 2 * ONE_HOUR;
+
+	constructor(opts: CreateIntentOptionsEscrow | CreateIntentOptionsCompact) {
+		this.lock = opts.lock;
+
+		this.user = opts.account;
+		this.inputs = opts.inputTokens;
+		this.outputs = opts.outputTokens;
+		this.verifier = opts.verifier;
+
+		this.exclusiveFor = opts.exclusiveFor as `0x${string}`;
 	}
 
-	static create(opts: CreateIntentOptions) {
-		const {
-			exclusiveFor,
-			allocatorId,
-			inputTokens,
-			outputToken,
-			inputAmounts,
-			outputAmount,
-			verifier,
-			account,
-			inputSettler
-		} = opts;
+	numInputChains() {
+		const tokenChains = this.inputs.map(({ token }) => token.chain);
+		return [...new Set(tokenChains)].length;
+	}
+
+	isMultichain() {
+		return this.numInputChains() > 1;
+	}
+
+	isSameChain() {
+		// Multichain intents cannot be same chain. Normal "Output oracle" will be used.
+		if (this.isMultichain()) return false;
 
+		// Only 1 input chain is used.
+		const inputChain = this.inputs[0].token.chain;
+		const outputChains = this.outputs.map((o) => o.token.chain);
+		const numOutputChains = [...new Set(outputChains)].length;
+		if (numOutputChains > 1) return false;
+		// Only 1 output chain is used.
+		const outputChain = this.outputs[0].token.chain;
+		return inputChain === outputChain;
+	}
+
+	nonce() {
+		if (this._nonce) return this._nonce;
+		this._nonce = BigInt(Math.floor(Math.random() * 2 ** 32));
+		return this._nonce;
+	}
+
+	inputSettler(multichain: boolean) {
+		if (this.lock.type === "compact" && multichain === false) return INPUT_SETTLER_COMPACT_LIFI;
+		if (this.lock.type === "compact" && multichain === true)
+			return MULTICHAIN_INPUT_SETTLER_COMPACT;
+		if (this.lock.type === "escrow" && multichain === false) return INPUT_SETTLER_ESCROW_LIFI;
+		if (this.lock.type === "escrow" && multichain === true) return MULTICHAIN_INPUT_SETTLER_ESCROW;
+
+		throw new Error(`Not supported | multichain: ${multichain}, type: ${this.lock.type}`);
+	}
+
+	encodeOutputs(currentTime: number) {
 		// Check if exclusiveFor has right formatting:
-		if (exclusiveFor) {
+		if (this.exclusiveFor) {
 			// Length should be 42.
-			const formattedCorrectly = exclusiveFor.length === 42 && exclusiveFor.slice(0, 2) === "0x";
+			const formattedCorrectly =
+				this.exclusiveFor.length === 42 && this.exclusiveFor.slice(0, 2) === "0x";
 			if (!formattedCorrectly)
-				throw new Error(`ExclusiveFor not formatted correctly ${exclusiveFor}`);
-		}
-
-		const inputChain = inputTokens[0].chain;
-		const inputs: [bigint, bigint][] = [];
-		for (let i = 0; i < inputTokens.length; ++i) {
-			// If Compact input, then generate the tokenId otherwise cast into uint256.
-			const inputTokenId =
-				inputSettler == INPUT_SETTLER_COMPACT_LIFI
-					? toId(true, ResetPeriod.OneDay, allocatorId, inputTokens[i].address)
-					: BigInt(inputTokens[i].address);
-			inputs.push([inputTokenId, inputAmounts[i]]);
+				throw new Error(`ExclusiveFor not formatted correctly ${this.exclusiveFor}`);
 		}
 
-		const outputSettler = COIN_FILLER;
-		const outputOracle = getOracle(verifier, outputToken.chain)!;
-		const inputOracle = getOracle(verifier, inputChain)!;
-
 		// Get the current epoch timestamp:
-		const currentTime = Math.floor(Date.now() / 1000);
+		currentTime;
 		const ONE_MINUTE = 60;
 
 		let context: `0x${string}` = "0x";
-		if (exclusiveFor) {
-			const paddedExclusiveFor: `0x${string}` = `0x${exclusiveFor.replace("0x", "").padStart(64, "0")}`;
+		if (this.exclusiveFor) {
+			const paddedExclusiveFor: `0x${string}` = `0x${this.exclusiveFor.replace("0x", "").padStart(64, "0")}`;
 			context = encodePacked(
 				["bytes1", "bytes32", "uint32"],
 				["0xe0", paddedExclusiveFor, currentTime + ONE_MINUTE]
 			);
 		}
 
-		// Make Outputs
-		const output: MandateOutput = {
-			oracle: addressToBytes32(outputOracle),
-			settler: addressToBytes32(outputSettler),
-			chainId: BigInt(chainMap[outputToken.chain].id),
-			token: addressToBytes32(outputToken.address),
-			amount: outputAmount,
-			recipient: addressToBytes32(account()),
-			callbackData: "0x",
-			context
-		};
-		const outputs = [output];
+		const outputSettler = COIN_FILLER;
+		const sameChain = this.isSameChain();
+
+		return this.outputs.map(({ token, amount }) => {
+			const outputOracle = sameChain
+				? addressToBytes32(outputSettler)
+				: addressToBytes32(getOracle(this.verifier, token.chain)!);
+			return {
+				oracle: outputOracle,
+				settler: addressToBytes32(outputSettler),
+				chainId: BigInt(chainMap[token.chain].id),
+				token: addressToBytes32(token.address),
+				amount: amount,
+				recipient: addressToBytes32(this.user()),
+				callbackData: "0x",
+				context
+			};
+		}) as MandateOutput[];
+	}
+
+	singlechain() {
+		if (this.isMultichain())
+			throw new Error(`Not supported as single chain with ${this.numInputChains()} chains`);
+
+		const inputChain = this.inputs[0].token.chain;
+
+		const inputs: [bigint, bigint][] = this.inputs.map(({ token, amount }) => [
+			this.lock.type === "compact"
+				? toId(true, this.lock.resetPeriod, this.lock.allocatorId, token.address)
+				: BigInt(token.address),
+			amount
+		]);
+
+		const currentTime = Math.floor(Date.now() / 1000);
+
+		const inputOracle = this.isSameChain() ? COIN_FILLER : getOracle(this.verifier, inputChain)!;
 
-		// Make order
 		const order: StandardOrder = {
-			user: account(),
-			nonce: BigInt(Math.floor(Math.random() * 2 ** 32)), // Random nonce
+			user: this.user(),
+			nonce: this.nonce(),
 			originChainId: BigInt(chainMap[inputChain].id),
-			fillDeadline: currentTime + ONE_MINUTE * 120,
-			expires: currentTime + ONE_MINUTE * 120,
+			fillDeadline: currentTime + this.fillDeadline,
+			expires: currentTime + this.expiry,
 			inputOracle: inputOracle,
 			inputs: inputs,
-			outputs: outputs
+			outputs: this.encodeOutputs(currentTime)
 		};
 
-		return { order };
+		return new StandardOrderIntent(this.inputSettler(false), order);
+	}
+
+	multichain() {
+		const currentTime = Math.floor(Date.now() / 1000);
+
+		// TODO: Fix before release. The input oracle is not the same on every chain.
+		const inputOracle = getOracle(this.verifier, this.inputs[0].token.chain)!;
+
+		// Get all unique chains and then get all inputs for each chain.
+		const inputs: { chainId: bigint; inputs: [bigint, bigint][] }[] = [
+			...new Set(this.inputs.map(({ token }) => token.chain))
+		].map((chain) => {
+			const chainInputs = this.inputs.filter(({ token }) => token.chain === chain);
+
+			return {
+				chainId: BigInt(chainMap[chain].id),
+				inputs: chainInputs.map(({ token, amount }) => [
+					this.lock.type === "compact"
+						? toId(true, this.lock.resetPeriod, this.lock.allocatorId, token.address)
+						: BigInt(token.address),
+					amount
+				])
+			};
+		});
+
+		const order: MultichainOrder = {
+			user: this.user(),
+			nonce: this.nonce(),
+			fillDeadline: currentTime + this.fillDeadline,
+			expires: currentTime + this.expiry,
+			inputOracle: inputOracle,
+			outputs: this.encodeOutputs(currentTime),
+			inputs: inputs
+		};
+
+		return new MultichainOrderIntent(this.inputSettler(true), order, this.lock);
+	}
+
+	order() {
+		if (this.isMultichain()) return this.multichain();
+		return this.singlechain();
+	}
+}
+
+/// @notice Helper function that allows you to provide an order and it will correctly generate the appropriate order.
+export function orderToIntent(options: {
+	inputSettler: `0x${string}`;
+	order: StandardOrder;
+	lock?: { type: string };
+}): StandardOrderIntent;
+export function orderToIntent(options: {
+	inputSettler: `0x${string}`;
+	order: MultichainOrder;
+	lock?: { type: string };
+}): MultichainOrderIntent;
+export function orderToIntent(options: {
+	inputSettler: `0x${string}`;
+	order: StandardOrder | MultichainOrder;
+	lock?: { type: string };
+}): StandardOrderIntent | MultichainOrderIntent;
+export function orderToIntent(options: {
+	inputSettler: `0x${string}`;
+	order: StandardOrder | MultichainOrder;
+	lock?: { type: string };
+}): StandardOrderIntent | MultichainOrderIntent {
+	const { inputSettler, order, lock } = options;
+	// Use presence of originChainId to discriminate StandardOrder vs MultichainOrder
+	if ("originChainId" in order) {
+		return new StandardOrderIntent(inputSettler, order as StandardOrder);
+	}
+	return new MultichainOrderIntent(inputSettler, order as MultichainOrder, lock);
+}
+
+export class StandardOrderIntent {
+	inputSettler: `0x${string}`;
+	order: StandardOrder;
+
+	constructor(inputSetter: `0x${string}`, order: StandardOrder) {
+		this.inputSettler = inputSetter;
+		this.order = order;
 	}
 
 	// -- Order Representations -- //
 
+	/**
+	 * @notice Returns for logging
+	 */
+	asOrder(): StandardOrder {
+		return this.order;
+	}
+
 	/**
 	 * @notice Returns the order as a StandardOrder.
 	 * @returns Order as StandardOrder
@@ -149,12 +351,8 @@ export class Intent {
 			outputs: order.outputs
 		};
 		const commitments = order.inputs.map(([tokenId, amount]) => {
-			const lockTag: `0x${string}` = `0x${toHex(tokenId)
-				.replace("0x", "")
-				.slice(0, 12 * 2)}`;
-			const token: `0x${string}` = `0x${toHex(tokenId)
-				.replace("0x", "")
-				.slice(12 * 2, 32 * 2)}`;
+			const lockTag: `0x${string}` = `0x${toHex(tokenId, 32).slice(0, 12 * 2)}`;
+			const token: `0x${string}` = `0x${toHex(tokenId, 32).slice(12 * 2, 32 * 2)}`;
 			return {
 				lockTag,
 				token,
@@ -165,12 +363,45 @@ export class Intent {
 			arbiter: INPUT_SETTLER_COMPACT_LIFI,
 			sponsor: order.user,
 			nonce: order.nonce,
-			expires: order.expires,
+			expires: BigInt(order.expires),
 			commitments,
 			mandate
 		};
 	}
 
+	inputChains(): bigint[] {
+		return [this.order.originChainId];
+	}
+
+	orderId(): `0x${string}` {
+		return keccak256(
+			encodePacked(
+				[
+					"uint256",
+					"address",
+					"address",
+					"uint256",
+					"uint32",
+					"uint32",
+					"address",
+					"bytes32",
+					"bytes"
+				],
+				[
+					this.order.originChainId,
+					this.inputSettler,
+					this.order.user,
+					this.order.nonce,
+					this.order.expires,
+					this.order.fillDeadline,
+					this.order.inputOracle,
+					keccak256(encodePacked(["uint256[2][]"], [this.order.inputs])),
+					encodeOutputs(this.order.outputs)
+				]
+			)
+		);
+	}
+
 	// -- Escrow Helpers -- //
 
 	/**
@@ -179,18 +410,21 @@ export class Intent {
 	 * @param walletClient Wallet client for sending the call to.
 	 * @returns transactionHash for the on-chain call.
 	 */
-	openEscrow(account: `0x${string}`, walletClient: WC): Promise<`0x${string}`> {
+	async openEscrow(account: `0x${string}`, walletClient: WC): Promise<[`0x${string}`]> {
 		const chain = findChain(this.order.originChainId);
+		walletClient.switchChain({ id: Number(this.order.originChainId) });
 		if (!chain)
 			throw new Error("Chain not found for chainId " + this.order.originChainId.toString());
-		return walletClient.writeContract({
-			chain,
-			account,
-			address: INPUT_SETTLER_ESCROW_LIFI,
-			abi: SETTLER_ESCROW_ABI,
-			functionName: "open",
-			args: [this.order]
-		});
+		return [
+			await walletClient.writeContract({
+				chain,
+				account,
+				address: INPUT_SETTLER_ESCROW_LIFI,
+				abi: SETTLER_ESCROW_ABI,
+				functionName: "open",
+				args: [this.order]
+			})
+		];
 	}
 
 	// -- Compact Helpers -- //
@@ -233,4 +467,450 @@ export class Intent {
 			args: [this.order.inputs, [[this.compactClaimHash(), compact_type_hash]]]
 		});
 	}
+
+	async finalise(options: {
+		sourceChain: chain;
+		account: `0x${string}`;
+		walletClient: WC;
+		solveParams: { timestamp: number; solver: `0x${string}` }[];
+		signatures: {
+			sponsorSignature: Signature | NoSignature;
+			allocatorSignature: Signature | NoSignature;
+		};
+	}) {
+		const { sourceChain, account, walletClient, solveParams, signatures } = options;
+		const actionChain = chainMap[sourceChain];
+		if (actionChain.id !== Number(this.order.originChainId))
+			throw new Error(
+				`Origin chain id and action ID does not match: ${this.order.originChainId}, ${actionChain.id}`
+			);
+
+		if (this.inputSettler.toLowerCase() === INPUT_SETTLER_ESCROW_LIFI.toLowerCase()) {
+			return await walletClient.writeContract({
+				chain: actionChain,
+				account: account,
+				address: this.inputSettler,
+				abi: SETTLER_ESCROW_ABI,
+				functionName: "finalise",
+				args: [this.order, solveParams, addressToBytes32(account), "0x"]
+			});
+		} else if (this.inputSettler.toLowerCase() === INPUT_SETTLER_COMPACT_LIFI.toLowerCase()) {
+			// Check whether or not we have a signature.
+			const { sponsorSignature, allocatorSignature } = signatures;
+			console.log({
+				sponsorSignature,
+				allocatorSignature
+			});
+			const combinedSignatures = encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
+				sponsorSignature.payload ?? "0x",
+				allocatorSignature.payload
+			]);
+			return await walletClient.writeContract({
+				chain: actionChain,
+				account: account,
+				address: this.inputSettler,
+				abi: SETTLER_COMPACT_ABI,
+				functionName: "finalise",
+				args: [this.order, combinedSignatures, solveParams, addressToBytes32(account), "0x"]
+			});
+		} else {
+			throw new Error(`Could not detect settler type ${this.inputSettler}`);
+		}
+	}
+}
+
+export class MultichainOrderIntent {
+	lock?: { type: string } | EscrowLock | CompactLock;
+
+	// Notice that this has to be the same address on every chain.
+	inputSettler: `0x${string}`;
+	order: MultichainOrder;
+
+	constructor(inputSetter: `0x${string}`, order: MultichainOrder, lock?: { type: string }) {
+		this.inputSettler = inputSetter;
+		this.order = order;
+
+		const isCompact =
+			this.inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
+			this.inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT;
+
+		this.lock = lock ?? { type: isCompact ? "compact" : "escrow" };
+	}
+
+	selfTest() {
+		this.asOrder();
+		this.inputChains();
+		this.asComponents();
+
+		this.orderId();
+	}
+
+	/**
+	 * @notice Returns for logging
+	 */
+	asOrder(): MultichainOrder {
+		return this.order;
+	}
+
+	inputChains(): bigint[] {
+		return [...new Set(this.order.inputs.map((i) => i.chainId))];
+	}
+
+	orderId(): `0x${string}` {
+		// We need a random order components.
+		const components = this.asComponents();
+		const computedOrderIds = components.map((c) =>
+			this.lock?.type === "escrow"
+				? MultichainOrderIntent.escrowOrderId(this.inputSettler, c.orderComponent, c.chainId)
+				: MultichainOrderIntent.compactOrderid(this.inputSettler, c.orderComponent, c.chainId)
+		);
+
+		const orderId = computedOrderIds[0];
+		computedOrderIds.map((v) => {
+			if (v !== orderId) throw new Error(`Order ids are not equal ${computedOrderIds}`);
+		});
+		if (this.lock?.type === "compact") {
+			const multichainCompactHash = hashStruct({
+				data: this.asMultichainBatchCompact(),
+				types: compactTypes,
+				primaryType: "MultichainCompact"
+			});
+			if (multichainCompactHash !== orderId)
+				throw new Error(
+					`MultichainCompact does not match orderId, ${multichainCompactHash} ${orderId}`
+				);
+		}
+		return orderId;
+	}
+
+	async orderIdCheck() {
+		const components = this.asComponents();
+		const computedOrderId = this.orderId();
+		const onChainOrderIds = await Promise.all(
+			components.map(async (component) => {
+				const onChainId = await clients[getChainName(component.chainId)].readContract({
+					address: this.inputSettler,
+					abi: MULTICHAIN_SETTLER_COMPACT_ABI,
+					functionName: "orderIdentifier",
+					args: [component.orderComponent]
+				});
+				return onChainId;
+			})
+		);
+		console.log({ computedOrderId, onChainOrderIds });
+	}
+
+	static escrowOrderId(
+		inputSettler: `0x${string}`,
+		orderComponent: MultichainOrderComponent,
+		_: bigint
+	) {
+		return keccak256(
+			encodePacked(
+				["address", "address", "uint256", "uint32", "uint32", "address", "bytes32", "bytes"],
+				[
+					inputSettler,
+					orderComponent.user,
+					orderComponent.nonce,
+					orderComponent.expires,
+					orderComponent.fillDeadline,
+					orderComponent.inputOracle,
+					MultichainOrderIntent.constructInputHash(
+						orderComponent.chainIdField,
+						orderComponent.chainIndex,
+						orderComponent.inputs,
+						orderComponent.additionalChains
+					),
+					encodeOutputs(orderComponent.outputs)
+				]
+			)
+		);
+	}
+
+	static compactOrderid(
+		inputSettler: `0x${string}`,
+		orderComponent: MultichainOrderComponent,
+		chainId: bigint
+	) {
+		const MULTICHAIN_COMPACT_TYPEHASH_WITH_WITNESS = keccak256(
+			encodePacked(
+				["string"],
+				[
+					"MultichainCompact(address sponsor,uint256 nonce,uint256 expires,Element[] elements)Element(address arbiter,uint256 chainId,Lock[] commitments,Mandate mandate)Lock(bytes12 lockTag,address token,uint256 amount)Mandate(uint32 fillDeadline,address inputOracle,MandateOutput[] outputs)MandateOutput(bytes32 oracle,bytes32 settler,uint256 chainId,bytes32 token,uint256 amount,bytes32 recipient,bytes callbackData,bytes context)"
+				]
+			)
+		);
+		const { fillDeadline, inputOracle, outputs, inputs } = orderComponent;
+		const mandate: CompactMandate = {
+			fillDeadline,
+			inputOracle,
+			outputs
+		};
+		const element: Element = {
+			arbiter: inputSettler,
+			chainId: chainId,
+			commitments: MultichainOrderIntent.inputsToLocks(inputs),
+			mandate
+		};
+
+		const elementHash = hashStruct({
+			types: compactTypes,
+			primaryType: "Element",
+			data: element
+		});
+
+		const elementHashes = [
+			...orderComponent.additionalChains.slice(0, Number(orderComponent.chainIndex)),
+			elementHash,
+			...orderComponent.additionalChains.slice(Number(orderComponent.chainIndex))
+		];
+
+		return keccak256(
+			encodeAbiParameters(
+				parseAbiParameters(["bytes32", "address", "uint256", "uint256", "bytes32"]),
+				[
+					MULTICHAIN_COMPACT_TYPEHASH_WITH_WITNESS,
+					orderComponent.user,
+					orderComponent.nonce,
+					BigInt(orderComponent.expires),
+					keccak256(encodePacked(["bytes32[]"], [elementHashes]))
+				]
+			)
+		);
+	}
+
+	static hashInputs(chainId: bigint, inputs: [bigint, bigint][]) {
+		return keccak256(encodePacked(["uint256", "uint256[2][]"], [chainId, inputs]));
+	}
+
+	static constructInputHash(
+		inputsChainId: bigint,
+		chainIndex: bigint,
+		inputs: [bigint, bigint][],
+		additionalChains: `0x${string}`[]
+	) {
+		const inputHash = MultichainOrderIntent.hashInputs(inputsChainId, inputs);
+		const numSegments = additionalChains.length + 1;
+		if (numSegments <= chainIndex)
+			throw new Error(`ChainIndexOutOfRange(${chainIndex},${numSegments})`);
+		const claimStructure: `0x${string}`[] = [];
+		for (let i = 0; i < numSegments; ++i) {
+			const additionalChainsIndex = i > chainIndex ? i - 1 : i;
+			const inputHashElement =
+				chainIndex == BigInt(i) ? inputHash : additionalChains[additionalChainsIndex];
+			claimStructure[i] = inputHashElement;
+		}
+		return keccak256(encodePacked(["bytes32[]"], [claimStructure]));
+	}
+
+	static inputsToLocks(inputs: [bigint, bigint][]): Lock[] {
+		return inputs.map((input) => {
+			const bytes32 = toHex(input[0], 32);
+			return {
+				lockTag: `0x${bytes32.slice(0, 12 * 2)}`,
+				token: `0x${bytes32.slice(12 * 2, 32 * 2)}`,
+				amount: input[1]
+			};
+		});
+	}
+
+	secondariesEcsrow(): { chainIdField: bigint; additionalChains: `0x${string}`[] }[] {
+		const inputsHash: `0x${string}`[] = this.order.inputs.map((input) =>
+			keccak256(encodePacked(["uint256", "uint256[2][]"], [input.chainId, input.inputs]))
+		);
+		return this.order.inputs.map((v, i) => {
+			return {
+				chainIdField: v.chainId,
+				additionalChains: selectAllBut(inputsHash, i)
+			};
+		});
+	}
+
+	asCompactElements() {
+		const { fillDeadline, inputOracle, outputs, inputs } = this.order;
+		const mandate: CompactMandate = {
+			fillDeadline,
+			inputOracle,
+			outputs
+		};
+		return inputs.map((inputs) => {
+			const element: Element = {
+				arbiter: this.inputSettler,
+				chainId: inputs.chainId,
+				commitments: MultichainOrderIntent.inputsToLocks(inputs.inputs),
+				mandate
+			};
+			return element;
+		});
+	}
+
+	secondariesCompact(): { chainIdField: bigint; additionalChains: `0x${string}`[] }[] {
+		const { inputs } = this.order;
+		const elements = this.asCompactElements().map((element) => {
+			const hash = hashStruct({
+				types: compactTypes,
+				primaryType: "Element",
+				data: element
+			});
+			return hash;
+		});
+		return inputs.map((_, i) => {
+			return {
+				chainIdField: inputs[0].chainId,
+				additionalChains: selectAllBut(elements, i)
+			};
+		});
+	}
+
+	asComponents(): { chainId: bigint; orderComponent: MultichainOrderComponent }[] {
+		const { inputs, user, nonce, expires, fillDeadline, inputOracle, outputs } = this.order;
+		if (!this.lock) throw new Error(`No lock provided, cannot compute secondaries.`);
+		const secondaries =
+			this.lock.type == "escrow" ? this.secondariesEcsrow() : this.secondariesCompact();
+		const components: { chainId: bigint; orderComponent: MultichainOrderComponent }[] = [];
+		for (let i = 0; i < inputs.length; ++i) {
+			const { chainIdField, additionalChains } = secondaries[i];
+
+			const orderComponent: MultichainOrderComponent = {
+				user: user,
+				nonce: nonce,
+				chainIdField: chainIdField,
+				chainIndex: BigInt(i),
+				expires: expires,
+				fillDeadline: fillDeadline,
+				inputOracle: inputOracle,
+				inputs: inputs[i].inputs,
+				outputs: outputs,
+				additionalChains: additionalChains
+			};
+			components.push({ chainId: inputs[i].chainId, orderComponent });
+		}
+		return components;
+	}
+
+	// -- Compact Helpers -- //
+
+	asMultichainBatchCompact(): MultichainCompact {
+		const { order } = this;
+		const mandate: CompactMandate = {
+			fillDeadline: order.fillDeadline,
+			inputOracle: order.inputOracle,
+			outputs: order.outputs
+		};
+		const result = {
+			sponsor: order.user,
+			nonce: order.nonce,
+			expires: BigInt(order.expires),
+			elements: this.asCompactElements(),
+			mandate
+		};
+		return result;
+	}
+
+	compactClaimHash(): `0x${string}` {
+		const claimHash = hashStruct({
+			data: this.asMultichainBatchCompact(),
+			types: compactTypes,
+			primaryType: "MultichainCompact"
+		});
+		return claimHash;
+	}
+
+	signCompact(account: `0x${string}`, walletClient: WC): Promise<`0x${string}`> {
+		this.selfTest();
+		const chainId = this.order.inputs[0].chainId;
+		return walletClient.signTypedData({
+			account,
+			domain: {
+				name: "The Compact",
+				version: "1",
+				chainId,
+				verifyingContract: COMPACT
+			} as const,
+			types: compactTypes,
+			primaryType: "MultichainCompact",
+			message: this.asMultichainBatchCompact()
+		});
+	}
+
+	// This code is depreciated and needs to be updated.
+	async openEscrow(account: `0x${string}`, walletClient: WC) {
+		this.selfTest();
+		const components = this.asComponents();
+		const results: `0x${string}`[] = [];
+		for (const { chainId, orderComponent } of components) {
+			const chain = findChain(chainId)!;
+			walletClient.switchChain({ id: chain.id });
+			results.push(
+				await walletClient.writeContract({
+					chain,
+					account,
+					address: this.inputSettler,
+					abi: MULTICHAIN_SETTLER_ESCROW_ABI,
+					functionName: "open",
+					args: [orderComponent]
+				})
+			);
+			console.log(results);
+		}
+		return results;
+	}
+
+	async finalise(options: {
+		sourceChain: chain;
+		account: `0x${string}`;
+		walletClient: WC;
+		solveParams: { timestamp: number; solver: `0x${string}` }[];
+		signatures: {
+			sponsorSignature: Signature | NoSignature;
+			allocatorSignature: Signature | NoSignature;
+		};
+	}) {
+		this.asMultichainBatchCompact();
+		const { sourceChain, account, walletClient, solveParams, signatures } = options;
+		const actionChain = chainMap[sourceChain];
+		if (actionChain.id in this.inputChains().map((v) => Number(v)))
+			throw new Error(
+				`Input chains and action ID does not match: ${this.inputChains()}, ${actionChain.id}`
+			);
+		// Get all components for our chain.
+		const components = this.asComponents().filter((c) => c.chainId === BigInt(actionChain.id));
+
+		for (const { orderComponent, chainId } of components) {
+			if (this.inputSettler.toLowerCase() === MULTICHAIN_INPUT_SETTLER_ESCROW.toLowerCase()) {
+				return await walletClient.writeContract({
+					chain: actionChain,
+					account: account,
+					address: this.inputSettler,
+					abi: MULTICHAIN_SETTLER_ESCROW_ABI,
+					functionName: "finalise",
+					args: [orderComponent, solveParams, addressToBytes32(account), "0x"]
+				});
+			} else if (
+				this.inputSettler.toLowerCase() === MULTICHAIN_INPUT_SETTLER_COMPACT.toLowerCase()
+			) {
+				const { sponsorSignature, allocatorSignature } = signatures;
+				console.log({
+					orderComponent,
+					sponsorSignature,
+					allocatorSignature
+				});
+
+				const combinedSignatures = encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
+					sponsorSignature.payload ?? "0x",
+					allocatorSignature.payload
+				]);
+				return await walletClient.writeContract({
+					chain: actionChain,
+					account: account,
+					address: this.inputSettler,
+					abi: MULTICHAIN_SETTLER_COMPACT_ABI,
+					functionName: "finalise",
+					args: [orderComponent, combinedSignatures, solveParams, addressToBytes32(account), "0x"]
+				});
+			} else {
+				throw new Error(`Could not detect settler type ${this.inputSettler}`);
+			}
+		}
+	}
 }
diff --git a/src/lib/libraries/intentFactory.ts b/src/lib/libraries/intentFactory.ts
index f23fa8d..9a9ed71 100644
--- a/src/lib/libraries/intentFactory.ts
+++ b/src/lib/libraries/intentFactory.ts
@@ -4,15 +4,23 @@ import {
 	clients,
 	INPUT_SETTLER_COMPACT_LIFI,
 	INPUT_SETTLER_ESCROW_LIFI,
+	MULTICHAIN_INPUT_SETTLER_ESCROW,
 	type Token,
 	type WC
 } from "$lib/config";
 import { maxUint256 } from "viem";
-import type { NoSignature, OrderContainer, Signature, StandardOrder } from "../../types";
+import type {
+	MultichainOrder,
+	NoSignature,
+	OrderContainer,
+	Signature,
+	StandardOrder
+} from "../../types";
 import { ERC20_ABI } from "$lib/abi/erc20";
 import { Intent } from "$lib/libraries/intent";
 import { OrderServer } from "$lib/libraries/orderServer";
 import type { CreateIntentOptions } from "$lib/libraries/intent";
+import { store, type TokenContext } from "$lib/state.svelte";
 
 /**
  * @notice Factory class for creating and managing intents. Functions called by integrators.
@@ -47,8 +55,8 @@ export class IntentFactory {
 	}
 
 	private saveOrder(options: {
-		order: StandardOrder;
-		inputSettler: typeof INPUT_SETTLER_COMPACT_LIFI | typeof INPUT_SETTLER_ESCROW_LIFI;
+		order: StandardOrder | MultichainOrder;
+		inputSettler: `0x${string}`;
 		sponsorSignature?: Signature | NoSignature;
 		allocatorSignature?: Signature | NoSignature;
 	}) {
@@ -71,26 +79,34 @@ export class IntentFactory {
 	compact(opts: CreateIntentOptions) {
 		return async () => {
 			const { account, inputTokens } = opts;
-			const inputChain = inputTokens[0].chain;
+			const inputChain = inputTokens[0].token.chain;
 			if (this.preHook) await this.preHook(inputChain);
-			const intent = new Intent(opts);
+			const intent = new Intent(opts).order();
 
 			const sponsorSignature = await intent.signCompact(account(), this.walletClient);
 
 			console.log({
-				order: intent.asStandardOrder(),
-				batchCompact: intent.asBatchCompact(),
+				order: intent.asOrder(),
 				sponsorSignature
 			});
 
-			const signedOrder = await this.orderServer.submitOrder({
-				orderType: "CatalystCompactOrder",
-				order: intent.asStandardOrder(),
-				inputSettler: INPUT_SETTLER_COMPACT_LIFI,
-				sponsorSignature,
-				allocatorSignature: "0x"
+			this.saveOrder({
+				order: intent.asOrder(),
+				inputSettler: intent.inputSettler,
+				sponsorSignature: {
+					type: "ECDSA",
+					payload: sponsorSignature
+				}
 			});
-			console.log("signedOrder", signedOrder);
+
+			// const signedOrder = await this.orderServer.submitOrder({
+			// 	orderType: "CatalystCompactOrder",
+			// 	order: intent.asStandardOrder(),
+			// 	inputSettler: INPUT_SETTLER_COMPACT_LIFI,
+			// 	sponsorSignature,
+			// 	allocatorSignature: "0x"
+			// });
+			// console.log("signedOrder", signedOrder);
 
 			if (this.postHook) await this.postHook();
 		};
@@ -100,13 +116,13 @@ export class IntentFactory {
 		return async () => {
 			const { inputTokens, account } = opts;
 			const publicClients = clients;
-			const intent = new Intent(opts);
+			const intent = new Intent(opts).singlechain();
 
-			if (this.preHook) await this.preHook(inputTokens[0].chain);
+			if (this.preHook) await this.preHook(inputTokens[0].token.chain);
 
 			let transactionHash = await intent.depositAndRegisterCompact(account(), this.walletClient);
 
-			const recepit = await publicClients[inputTokens[0].chain].waitForTransactionReceipt({
+			const receipt = await publicClients[inputTokens[0].token.chain].waitForTransactionReceipt({
 				hash: transactionHash
 			});
 
@@ -135,26 +151,29 @@ export class IntentFactory {
 	openIntent(opts: CreateIntentOptions) {
 		return async () => {
 			const { inputTokens, account } = opts;
-			const intent = new Intent(opts);
+			const intent = new Intent(opts).order();
 
-			const inputChain = inputTokens[0].chain;
+			const inputChain = inputTokens[0].token.chain;
 			if (this.preHook) await this.preHook(inputChain);
 
 			// Execute the open.
-			const transactionHash = await intent.openEscrow(account(), this.walletClient);
+			const transactionHashes = await intent.openEscrow(account(), this.walletClient);
+			console.log({ tsh: transactionHashes });
 
-			await clients[inputChain].waitForTransactionReceipt({
-				hash: transactionHash
-			});
+			// for (const hash of transactionHashes) {
+			// 	await clients[inputChain].waitForTransactionReceipt({
+			// 		hash: await hash
+			// 	});
+			// }
 
 			if (this.postHook) await this.postHook();
 
 			this.saveOrder({
-				order: intent.asStandardOrder(),
-				inputSettler: INPUT_SETTLER_ESCROW_LIFI
+				order: intent.asOrder(),
+				inputSettler: store.inputSettler
 			});
 
-			return transactionHash;
+			return transactionHashes;
 		};
 	}
 }
@@ -164,31 +183,32 @@ export function escrowApprove(
 	opts: {
 		preHook?: (chain: chain) => Promise<any>;
 		postHook?: () => Promise<any>;
-		inputTokens: Token[];
-		inputAmounts: bigint[];
+		inputTokens: TokenContext[];
 		account: () => `0x${string}`;
 	}
 ) {
 	return async () => {
-		const { preHook, postHook, inputTokens, inputAmounts, account } = opts;
+		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 inputToken = inputTokens[i];
-			if (preHook) await preHook(inputToken.chain);
-			const publicClient = clients[inputToken.chain];
+			const { token, amount } = inputTokens[i];
+			if (preHook) await preHook(token.chain);
+			const publicClient = clients[token.chain];
 			const currentAllowance = await publicClient.readContract({
-				address: inputToken.address,
+				address: token.address,
 				abi: ERC20_ABI,
 				functionName: "allowance",
-				args: [account(), INPUT_SETTLER_ESCROW_LIFI]
+				args: [account(), settler]
 			});
-			if (currentAllowance >= inputAmounts[i]) continue;
+			if (currentAllowance >= amount) continue;
 			const transactionHash = walletClient.writeContract({
-				chain: chainMap[inputToken.chain],
+				chain: chainMap[token.chain],
 				account: account(),
-				address: inputToken.address,
+				address: token.address,
 				abi: ERC20_ABI,
 				functionName: "approve",
-				args: [INPUT_SETTLER_ESCROW_LIFI, maxUint256]
+				args: [settler, maxUint256]
 			});
 
 			await publicClient.waitForTransactionReceipt({
diff --git a/src/lib/libraries/solver.ts b/src/lib/libraries/solver.ts
index b423a0f..0f2b944 100644
--- a/src/lib/libraries/solver.ts
+++ b/src/lib/libraries/solver.ts
@@ -3,13 +3,20 @@ import {
 	type chain,
 	chainMap,
 	clients,
+	COIN_FILLER,
 	getChainName,
 	getOracle,
 	INPUT_SETTLER_COMPACT_LIFI,
 	INPUT_SETTLER_ESCROW_LIFI,
 	type WC
 } from "$lib/config";
-import { encodeAbiParameters, maxUint256, parseAbiParameters } from "viem";
+import {
+	encodeAbiParameters,
+	hashStruct,
+	maxUint256,
+	parseAbiParameters,
+	parseEventLogs
+} from "viem";
 import type { MandateOutput, OrderContainer } from "../../types";
 import { addressToBytes32, bytes32ToAddress } from "$lib/utils/convert";
 import axios from "axios";
@@ -17,8 +24,9 @@ import { POLYMER_ORACLE_ABI } from "$lib/abi/polymeroracle";
 import { SETTLER_COMPACT_ABI } from "$lib/abi/settlercompact";
 import { COIN_FILLER_ABI } from "$lib/abi/outputsettler";
 import { ERC20_ABI } from "$lib/abi/erc20";
-import { getOrderId } from "$lib/utils/orderLib";
 import { SETTLER_ESCROW_ABI } from "$lib/abi/escrow";
+import { orderToIntent } from "./intent";
+import { compactTypes } from "$lib/utils/typedMessage";
 
 /**
  * @notice Class for solving intents. Functions called by solvers.
@@ -43,18 +51,15 @@ export class Solver {
 				outputs
 			} = args;
 			const publicClients = clients;
-			const orderId = getOrderId({ order, inputSettler });
-			//Check that only 1 output exists.
-			if (outputs.length !== 1) {
-				throw new Error("Order must have exactly one output");
-			}
+			const orderId = orderToIntent({ order, inputSettler }).orderId();
 
 			const outputChain = getChainName(outputs[0].chainId);
 			console.log({ outputChain });
+			let value = 0n;
 			for (const output of outputs) {
 				if (output.token === BYTES32_ZERO) {
-					// The destination asset cannot be ETH.
-					throw new Error("Output token cannot be ETH");
+					value += output.amount;
+					continue;
 				}
 				if (output.chainId != outputs[0].chainId) {
 					throw new Error("Filling outputs on multiple chains with single fill call not supported");
@@ -91,6 +96,7 @@ export class Solver {
 				chain: chainMap[outputChain],
 				account: account(),
 				address: bytes32ToAddress(outputs[0].settler),
+				value,
 				abi: COIN_FILLER_ABI,
 				functionName: "fillOrderOutputs",
 				args: [orderId, outputs, order.fillDeadline, addressToBytes32(account())]
@@ -98,7 +104,7 @@ export class Solver {
 			await clients[outputChain].waitForTransactionReceipt({
 				hash: transactionHash
 			});
-			// orderInputs.validate[index] = transcationHash;
+			// orderInputs.validate[index] = transactionHash;
 			if (postHook) await postHook();
 			return transactionHash;
 		};
@@ -106,7 +112,13 @@ export class Solver {
 
 	static validate(
 		walletClient: WC,
-		args: { orderContainer: OrderContainer; fillTransactionHash: string; mainnet: boolean },
+		args: {
+			output: MandateOutput;
+			orderContainer: OrderContainer;
+			fillTransactionHash: string;
+			sourceChain: chain;
+			mainnet: boolean;
+		},
 		opts: {
 			preHook?: (chain: chain) => Promise<any>;
 			postHook?: () => Promise<any>;
@@ -116,34 +128,55 @@ export class Solver {
 		return async () => {
 			const { preHook, postHook, account } = opts;
 			const {
-				orderContainer: { order },
+				output,
+				orderContainer: { order, inputSettler },
 				fillTransactionHash,
+				sourceChain,
 				mainnet
 			} = args;
-			const sourceChain = getChainName(order.originChainId);
 			const outputChain = getChainName(order.outputs[0].chainId);
-			if (order.outputs.length !== 1) {
-				throw new Error("Order must have exactly one output");
-			}
-			// The destination asset cannot be ETH.
-			const output = order.outputs[0];
 
-			if (order.inputOracle === getOracle("polymer", sourceChain)) {
-				const transactionReceipt = await clients[outputChain].getTransactionReceipt({
-					hash: fillTransactionHash as `0x${string}`
-				});
+			// Get the output filled event.
+			const transactionReceipt = await clients[outputChain].getTransactionReceipt({
+				hash: fillTransactionHash as `0x${string}`
+			});
 
-				const numlogs = transactionReceipt.logs.length;
-				if (numlogs !== 2) throw Error(`Unexpected Logs count ${numlogs}`);
-				const fillLog = transactionReceipt.logs[1]; // The first log is transfer, next is fill.
+			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.
+			console.log("logs", logs);
+			let logIndex = -1;
+			const expectedOutputHash = hashStruct({
+				types: compactTypes,
+				primaryType: "MandateOutput",
+				data: output
+			});
+			for (const log of logs) {
+				const logOutput = log.args.output;
+				// TODO: Optimise by comparing the dicts.
+				const logOutputHash = hashStruct({
+					types: compactTypes,
+					primaryType: "MandateOutput",
+					data: logOutput
+				});
+				if (logOutputHash === expectedOutputHash) {
+					logIndex = log.logIndex;
+					break;
+				}
+			}
+			if (logIndex === -1) throw Error(`Could not find matching log`);
 
+			if (order.inputOracle === getOracle("polymer", sourceChain)) {
 				let proof: string | undefined;
 				let polymerIndex: number | undefined;
 				for (let i = 0; i < 5; ++i) {
 					const response = await axios.post(`/polymer`, {
 						srcChainId: Number(order.outputs[0].chainId),
 						srcBlockNumber: Number(transactionReceipt.blockNumber),
-						globalLogIndex: Number(fillLog.logIndex),
+						globalLogIndex: Number(logIndex),
 						polymerIndex,
 						mainnet: mainnet
 					});
@@ -160,11 +193,11 @@ export class Solver {
 					// Wait while backing off before requesting again.
 					await new Promise((r) => setTimeout(r, i * 2 + 1000));
 				}
-				console.log({ proof });
+				console.log({ logIndex, proof });
 				if (proof) {
 					if (preHook) await preHook(sourceChain);
 
-					const transcationHash = await walletClient.writeContract({
+					const transactionHash = await walletClient.writeContract({
 						chain: chainMap[sourceChain],
 						account: account(),
 						address: order.inputOracle,
@@ -174,33 +207,28 @@ export class Solver {
 					});
 
 					const result = await clients[sourceChain].waitForTransactionReceipt({
-						hash: transcationHash
+						hash: transactionHash
 					});
 					if (postHook) await postHook();
 					return result;
 				}
-			}
+			} else if (order.inputOracle === COIN_FILLER) {
+				const log = logs.find((log) => log.logIndex === logIndex)!;
+				const transactionHash = await walletClient.writeContract({
+					chain: chainMap[sourceChain],
+					account: account(),
+					address: order.inputOracle,
+					abi: COIN_FILLER_ABI,
+					functionName: "setAttestation",
+					args: [log.args.orderId, log.args.solver, log.args.timestamp, log.args.output]
+				});
 
-			// if (order.inputOracle === getOracle("wormhole", sourceChain)) {
-			// 	// TODO: get sequence from event.
-			// 	const sequence = 0;
-			// 	// Get VAA
-			// 	const wormholeChainId = wormholeChainIds[outputChain];
-			// 	const requestUrl = `https://api.testnet.wormholescan.io/v1/signed_vaa/${wormholeChainId}/${output.oracle.replace(
-			// 		"0x",
-			// 		""
-			// 	)}/${sequence}?network=Testnet`;
-			// 	const response = await axios.get(requestUrl);
-			// 	console.log(response.data);
-			// return $walletClient.writeContract({
-			// 	account: connectedAccount.address,
-			// 	address: order.inputOracle,
-			// 	abi: WROMHOLE_ORACLE_ABI,
-			// 	functionName: 'receiveMessage',
-			// 	args: [encodedOutput]
-			// });
-			// 	return;
-			// }
+				const result = await clients[sourceChain].waitForTransactionReceipt({
+					hash: transactionHash
+				});
+				if (postHook) await postHook();
+				return result;
+			}
 		};
 	}
 
@@ -208,7 +236,8 @@ export class Solver {
 		walletClient: WC,
 		args: {
 			orderContainer: OrderContainer;
-			fillTransactionHash: string;
+			fillTransactionHashes: string[];
+			sourceChain: chain;
 		},
 		opts: {
 			preHook?: (chain: chain) => Promise<any>;
@@ -218,67 +247,48 @@ export class Solver {
 	) {
 		return async () => {
 			const { preHook, postHook, account } = opts;
-			const { orderContainer, fillTransactionHash } = args;
-			const { order } = orderContainer;
-			const outputChain = getChainName(order.outputs[0].chainId);
-			if (order.outputs.length !== 1) {
-				throw new Error("Order must have exactly one output");
-			}
-			const transactionReceipt = await clients[outputChain].getTransactionReceipt({
-				hash: fillTransactionHash as `0x${string}`
-			});
-			const blockHashOfFill = transactionReceipt.blockHash;
-			const block = await clients[outputChain].getBlock({
-				blockHash: blockHashOfFill
+			const { orderContainer, fillTransactionHashes, sourceChain } = args;
+			const { order, inputSettler } = orderContainer;
+			const intent = orderToIntent({
+				inputSettler,
+				order
 			});
-			const fillTimestamp = block.timestamp;
 
-			const sourceChain = getChainName(order.originChainId);
-			if (preHook) await preHook(sourceChain);
+			const outputChain = getChainName(order.outputs[0].chainId);
+			const transactionReceipts = await Promise.all(
+				fillTransactionHashes.map((fth) =>
+					clients[outputChain].getTransactionReceipt({
+						hash: fth as `0x${string}`
+					})
+				)
+			);
+			const blocks = await Promise.all(
+				transactionReceipts.map((r) =>
+					clients[outputChain].getBlock({
+						blockHash: r.blockHash
+					})
+				)
+			);
+			const fillTimestamps = blocks.map((b) => b.timestamp);
 
-			const inputSettler = orderContainer.inputSettler;
-			console.log({ orderContainer });
-			let transactionHash: `0x${string}`;
-			const actionChain = chainMap[sourceChain];
+			if (preHook) await preHook(sourceChain);
 
-			const solveParam = {
-				timestamp: Number(fillTimestamp),
-				solver: addressToBytes32(account())
-			};
+			const solveParams = fillTimestamps.map((fillTimestamp) => {
+				return {
+					timestamp: Number(fillTimestamp),
+					solver: addressToBytes32(account())
+				};
+			});
 
-			if (inputSettler.toLowerCase() === INPUT_SETTLER_ESCROW_LIFI.toLowerCase()) {
-				transactionHash = await walletClient.writeContract({
-					chain: actionChain,
-					account: account(),
-					address: inputSettler,
-					abi: SETTLER_ESCROW_ABI,
-					functionName: "finalise",
-					args: [order, [solveParam], addressToBytes32(account()), "0x"]
-				});
-			} else if (inputSettler.toLowerCase() === INPUT_SETTLER_COMPACT_LIFI.toLowerCase()) {
-				// Check whether or not we have a signature.
-				const { sponsorSignature, allocatorSignature } = orderContainer;
-				console.log({
-					sponsorSignature,
-					allocatorSignature
-				});
-				const combinedSignatures = encodeAbiParameters(parseAbiParameters(["bytes", "bytes"]), [
-					sponsorSignature.payload ?? "0x",
-					allocatorSignature.payload
-				]);
-				transactionHash = await walletClient.writeContract({
-					chain: actionChain,
-					account: account(),
-					address: inputSettler,
-					abi: SETTLER_COMPACT_ABI,
-					functionName: "finalise",
-					args: [order, combinedSignatures, [solveParam], addressToBytes32(account()), "0x"]
-				});
-			} else {
-				throw new Error(`Could not detect settler type ${orderContainer.inputSettler}`);
-			}
+			const transactionHash = await intent.finalise({
+				sourceChain,
+				account: account(),
+				walletClient,
+				solveParams,
+				signatures: orderContainer
+			});
 			const result = await clients[sourceChain].waitForTransactionReceipt({
-				hash: transactionHash
+				hash: transactionHash!
 			});
 			if (postHook) await postHook();
 			return result;
diff --git a/src/lib/libraries/token.ts b/src/lib/libraries/token.ts
new file mode 100644
index 0000000..2ae71f7
--- /dev/null
+++ b/src/lib/libraries/token.ts
@@ -0,0 +1,59 @@
+import { maxUint256 } from "viem";
+import { COMPACT_ABI } from "../abi/compact";
+import { ERC20_ABI } from "../abi/erc20";
+import { ADDRESS_ZERO, clients, COMPACT } from "../config";
+import { ResetPeriod, toId } from "../utils/idLib";
+
+export async function getBalance(
+	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]
+		});
+	}
+}
+
+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]
+		});
+	};
+}
+
+export async function getCompactBalance(
+	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);
+	return client.readContract({
+		address: COMPACT,
+		abi: COMPACT_ABI,
+		functionName: "balanceOf",
+		args: [user, assetId]
+	});
+}
diff --git a/src/lib/screens/FillIntent.svelte b/src/lib/screens/FillIntent.svelte
index e14aaf2..c086650 100644
--- a/src/lib/screens/FillIntent.svelte
+++ b/src/lib/screens/FillIntent.svelte
@@ -9,25 +9,25 @@
 		type WC
 	} from "$lib/config";
 	import { bytes32ToAddress } from "$lib/utils/convert";
-	import { getOrderId, getOutputHash } from "$lib/utils/orderLib";
+	import { getOutputHash } from "$lib/utils/orderLib";
 	import type { MandateOutput, OrderContainer } from "../../types";
 	import { Solver } from "$lib/libraries/solver";
 	import { COIN_FILLER_ABI } from "$lib/abi/outputsettler";
 	import AwaitButton from "$lib/components/AwaitButton.svelte";
+	import store from "$lib/state.svelte";
+	import { Intent, orderToIntent } from "$lib/libraries/intent";
+	import { compactTypes } from "$lib/utils/typedMessage";
+	import { hashStruct } from "viem";
 
 	let {
 		scroll,
 		orderContainer,
-		walletClient,
-		fillTransactionHash = $bindable(),
 		account,
 		preHook,
 		postHook
 	}: {
 		scroll: (direction: boolean | number) => () => void;
 		orderContainer: OrderContainer;
-		walletClient: WC;
-		fillTransactionHash: `0x${string}` | undefined;
 		preHook?: (chain: chain) => Promise<any>;
 		postHook: () => Promise<any>;
 		account: () => `0x${string}`;
@@ -49,40 +49,48 @@
 			functionName: "getFillRecord",
 			args: [orderId, outputHash]
 		});
-		console.log({ orderId, output, result, outputHash });
 		return result;
 	}
 
 	function sortOutputsByChain(orderContainer: OrderContainer) {
 		const outputs = orderContainer.order.outputs;
-		const postionMap: { [chainId: string]: number } = {};
+		const positionMap: { [chainId: string]: number } = {};
 		const arrMap: [bigint, MandateOutput[]][] = [];
 		for (const output of outputs) {
 			const chainId = output.chainId;
 			// Check if chainId exists.
-			let position = postionMap[chainId.toString()];
+			let position = positionMap[chainId.toString()];
 			if (position == undefined) {
 				position = arrMap.length;
-				postionMap[chainId.toString()] = position;
+				positionMap[chainId.toString()] = position;
 				arrMap.push([chainId, []]);
 			}
 			arrMap[position][1].push(output);
 		}
-		console.log(arrMap);
 		return arrMap;
 	}
 
 	const filledStatusPromises: [bigint, Promise<`0x${string}`>[]][] = $derived(
 		sortOutputsByChain(orderContainer).map(([c, outputs]) => [
 			c,
-			outputs.map((output) => isFilled(getOrderId(orderContainer), output, refreshValidation))
+			outputs.map((output) =>
+				isFilled(orderToIntent(orderContainer).orderId(), output, refreshValidation)
+			)
 		])
 	);
 
-	const fillWrapper = (func: ReturnType<typeof Solver.fill>) => {
+	const fillWrapper = (outputs: MandateOutput[], func: ReturnType<typeof Solver.fill>) => {
 		return async () => {
 			const result = await func();
-			fillTransactionHash = result;
+
+			for (const output of outputs) {
+				const outputHash = hashStruct({
+					data: output,
+					types: compactTypes,
+					primaryType: "MandateOutput"
+				});
+				store.fillTransactions[outputHash] = result;
+			}
 		};
 	};
 </script>
@@ -94,9 +102,9 @@
 		hash in the input box.
 	</p>
 	<div class="w-full">
-		{#each sortOutputsByChain(orderContainer) as [chainId, outputs], c}
+		{#each sortOutputsByChain(orderContainer) as chainIdAndOutputs, c}
 			<h2 class="w-full text-center text-lg font-medium">
-				{getChainName(chainId)}
+				{getChainName(chainIdAndOutputs[0])}
 			</h2>
 			<hr class="my-1" />
 			<div class="flex w-full flex-row space-x-1 overflow-y-hidden">
@@ -108,11 +116,12 @@
 					<AwaitButton
 						buttonFunction={filledStatus.every((v) => v == BYTES32_ZERO)
 							? fillWrapper(
+									chainIdAndOutputs[1],
 									Solver.fill(
-										walletClient,
+										store.walletClient,
 										{
 											orderContainer,
-											outputs
+											outputs: chainIdAndOutputs[1]
 										},
 										{
 											preHook,
@@ -131,7 +140,7 @@
 						{/snippet}
 					</AwaitButton>
 				{/await}
-				{#each outputs as output, i}
+				{#each chainIdAndOutputs[1] as output, i}
 					{#await filledStatusPromises[c][1][i]}
 						<div class="h-8 w-28 rounded bg-slate-200 pt-0.5 text-center">
 							<div class="flex flex-col items-center justify-center align-middle">
@@ -139,7 +148,10 @@
 									<div>
 										{formatTokenAmount(
 											output.amount,
-											getCoin({ address: output.token, chain: getChainName(output.chainId) })
+											getCoin({
+												address: output.token,
+												chain: getChainName(output.chainId)
+											}).decimals
 										)}
 									</div>
 									<div>
@@ -160,7 +172,10 @@
 									<div>
 										{formatTokenAmount(
 											output.amount,
-											getCoin({ address: output.token, chain: getChainName(output.chainId) })
+											getCoin({
+												address: output.token,
+												chain: getChainName(output.chainId)
+											}).decimals
 										)}
 									</div>
 									<div>
@@ -172,12 +187,22 @@
 					{/await}
 				{/each}
 			</div>
+			<!-- <input
+				class="w-20 rounded border px-2 py-1"
+				placeholder="fillTransactionHash"
+				bind:value={
+					store.fillTransactions[
+						hashStruct({
+							data: { outputs: chainIdAndOutputs.outputs },
+							types: {
+								...compactTypes,
+								Outputs
+							},
+							primaryType: "Outputs"
+						})
+					]
+				}
+			/> -->
 		{/each}
-
-		<input
-			class="w-20 rounded border px-2 py-1"
-			placeholder="fillTransactionHash"
-			bind:value={fillTransactionHash}
-		/>
 	</div>
 </div>
diff --git a/src/lib/screens/Finalise.svelte b/src/lib/screens/Finalise.svelte
index 58d2b04..eb902e1 100644
--- a/src/lib/screens/Finalise.svelte
+++ b/src/lib/screens/Finalise.svelte
@@ -11,65 +11,74 @@
 		getCoin,
 		INPUT_SETTLER_COMPACT_LIFI,
 		INPUT_SETTLER_ESCROW_LIFI,
+		MULTICHAIN_INPUT_SETTLER_COMPACT,
+		MULTICHAIN_INPUT_SETTLER_ESCROW,
 		type chain,
 		type WC
 	} from "$lib/config";
 	import { COMPACT_ABI } from "$lib/abi/compact";
 	import { SETTLER_ESCROW_ABI } from "$lib/abi/escrow";
 	import { idToToken } from "$lib/utils/convert";
+	import store from "$lib/state.svelte";
+	import { orderToIntent } from "$lib/libraries/intent";
+	import { hashStruct } from "viem";
+	import { compactTypes } from "$lib/utils/typedMessage";
 
 	let {
 		orderContainer,
-		walletClient,
-		fillTransactionHash,
 		account,
 		preHook,
 		postHook
 	}: {
 		orderContainer: OrderContainer;
-		walletClient: WC;
-		fillTransactionHash: `0x${string}`;
 		preHook?: (chain: chain) => Promise<any>;
 		postHook?: () => Promise<any>;
 		account: () => `0x${string}`;
 	} = $props();
 
+	let refreshClaimed = $state(0);
+	const postHookRefreshValidate = async () => {
+		if (postHook) await postHook();
+		refreshClaimed += 1;
+	};
+
 	// Order status enum
 	const OrderStatus_None = 0;
 	const OrderStatus_Deposited = 1;
 	const OrderStatus_Claimed = 2;
 	const OrderStatus_Refunded = 3;
 
-	async function isClaimed(
-		container: { order: StandardOrder; inputSettler: `0x${string}` },
-		_: any
-	) {
+	async function isClaimed(chainId: bigint, container: OrderContainer, _: any) {
 		const { order, inputSettler } = container;
-		const inputChainClient = getClient(order.originChainId);
+		const inputChainClient = getClient(chainId);
 
+		const intent = orderToIntent(container);
+		const orderId = intent.orderId();
 		// Determine the order type.
-		if (inputSettler == INPUT_SETTLER_ESCROW_LIFI) {
+		if (
+			inputSettler === INPUT_SETTLER_ESCROW_LIFI ||
+			inputSettler === MULTICHAIN_INPUT_SETTLER_ESCROW
+		) {
 			// Check order status
-			const orderId = await inputChainClient.readContract({
-				address: inputSettler,
-				abi: SETTLER_ESCROW_ABI,
-				functionName: "orderIdentifier",
-				args: [order]
-			});
 			const orderStatus = await inputChainClient.readContract({
 				address: inputSettler,
 				abi: SETTLER_ESCROW_ABI,
 				functionName: "orderStatus",
 				args: [orderId]
 			});
-			return orderStatus == OrderStatus_Claimed || orderStatus == OrderStatus_Refunded;
-		} else if (inputSettler == INPUT_SETTLER_COMPACT_LIFI) {
+			return orderStatus === OrderStatus_Claimed || orderStatus === OrderStatus_Refunded;
+		} else if (
+			inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
+			inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT
+		) {
 			// Check claim status
+			const flattenedInputs = "originChainId" in order ? order.inputs : order.inputs[0].inputs;
+
 			const [token, allocator, resetPeriod, scope] = await inputChainClient.readContract({
 				address: COMPACT,
 				abi: COMPACT_ABI,
 				functionName: "getLockDetails",
-				args: [order.inputs[0][0]]
+				args: [flattenedInputs[0][0]]
 			});
 			// Check if nonce is spent.
 			return await inputChainClient.readContract({
@@ -85,41 +94,85 @@
 <div class="h-[29rem] w-[25rem] flex-shrink-0 snap-center snap-always p-4">
 	<h1 class="mb-2 w-full text-center text-2xl font-medium">Finalise Intent</h1>
 	<p>Finalise the order to receive the inputs.</p>
-	<div class="w-full">
-		<h2 class="w-full text-center text-lg font-medium">
-			{getChainName(orderContainer.order.originChainId)}
-		</h2>
-		<hr class="my-1" />
-		<div class="flex w-full flex-row space-x-1 overflow-y-hidden">
-			{#await isClaimed(orderContainer, "")}
-				<button
-					type="button"
-					class="h-8 rounded-r border px-4 text-xl font-bold text-gray-300"
-					disabled
-				>
-					Finalise
-				</button>
-			{:then isClaimed}
-				{#if isClaimed}
+	{#each orderToIntent(orderContainer).inputChains() as inputChain}
+		<div class="w-full">
+			<h2 class="w-full text-center text-lg font-medium">
+				{getChainName(inputChain)}
+			</h2>
+			<hr class="my-1" />
+			<div class="flex w-full flex-row space-x-1 overflow-y-hidden">
+				{#await isClaimed(inputChain, orderContainer, "")}
 					<button
 						type="button"
 						class="h-8 rounded-r border px-4 text-xl font-bold text-gray-300"
 						disabled
 					>
-						Finalised
+						Finalise
 					</button>
-				{:else}
+				{:then isClaimed}
+					{#if isClaimed}
+						<button
+							type="button"
+							class="h-8 rounded-r border px-4 text-xl font-bold text-gray-300"
+							disabled
+						>
+							Finalised
+						</button>
+					{:else}
+						<AwaitButton
+							buttonFunction={Solver.claim(
+								store.walletClient,
+								{
+									sourceChain: getChainName(inputChain),
+									orderContainer,
+									fillTransactionHashes: orderContainer.order.outputs.map(
+										(output) =>
+											store.fillTransactions[
+												hashStruct({
+													data: output,
+													types: compactTypes,
+													primaryType: "MandateOutput"
+												})
+											] as string
+									)
+								},
+								{
+									account,
+									preHook,
+									postHook: postHookRefreshValidate
+								}
+							)}
+						>
+							{#snippet name()}
+								Claim
+							{/snippet}
+							{#snippet awaiting()}
+								Waiting for transaction...
+							{/snippet}
+						</AwaitButton>
+					{/if}
+				{:catch}
 					<AwaitButton
 						buttonFunction={Solver.claim(
-							walletClient,
+							store.walletClient,
 							{
+								sourceChain: getChainName(inputChain),
 								orderContainer,
-								fillTransactionHash
+								fillTransactionHashes: orderContainer.order.outputs.map(
+									(output) =>
+										store.fillTransactions[
+											hashStruct({
+												data: output,
+												types: compactTypes,
+												primaryType: "MandateOutput"
+											})
+										] as string
+								)
 							},
 							{
 								account,
 								preHook,
-								postHook
+								postHook: postHookRefreshValidate
 							}
 						)}
 					>
@@ -130,55 +183,59 @@
 							Waiting for transaction...
 						{/snippet}
 					</AwaitButton>
-				{/if}
-			{:catch}
-				<AwaitButton
-					buttonFunction={Solver.claim(
-						walletClient,
-						{
-							orderContainer,
-							fillTransactionHash
-						},
-						{
-							account,
-							preHook,
-							postHook
-						}
-					)}
-				>
-					{#snippet name()}
-						Claim
-					{/snippet}
-					{#snippet awaiting()}
-						Waiting for transaction...
-					{/snippet}
-				</AwaitButton>
-			{/await}
-			<div class="flex">
-				{#each orderContainer.order.inputs as input}
-					<div class="h-8 w-28 rounded bg-slate-200 pt-0.5 text-center">
-						<div class="flex flex-col items-center justify-center align-middle">
-							<div class="flex flex-row space-x-1">
-								<div>
-									{formatTokenAmount(
-										input[1],
-										getCoin({
-											address: idToToken(input[0]),
-											chain: getChainName(orderContainer.order.originChainId)
-										})
-									)}
+				{/await}
+				<div class="flex">
+					{#if "originChainId" in orderContainer.order}
+						{#each orderContainer.order.inputs as input}
+							<div class="h-8 w-28 rounded bg-slate-200 pt-0.5 text-center">
+								<div class="flex flex-col items-center justify-center align-middle">
+									<div class="flex flex-row space-x-1">
+										<div>
+											{formatTokenAmount(
+												input[1],
+												getCoin({
+													address: idToToken(input[0]),
+													chain: getChainName(orderContainer.order.originChainId)
+												}).decimals
+											)}
+										</div>
+										<div>
+											{getCoin({
+												address: idToToken(input[0]),
+												chain: getChainName(orderContainer.order.originChainId)
+											}).name}
+										</div>
+									</div>
 								</div>
-								<div>
-									{getCoin({
-										address: idToToken(input[0]),
-										chain: getChainName(orderContainer.order.originChainId)
-									}).name}
+							</div>
+						{/each}
+					{:else}
+						{#each orderContainer.order.inputs.find((v) => v.chainId === inputChain)?.inputs as input}
+							<div class="h-8 w-28 rounded bg-slate-200 pt-0.5 text-center">
+								<div class="flex flex-col items-center justify-center align-middle">
+									<div class="flex flex-row space-x-1">
+										<div>
+											{formatTokenAmount(
+												input[1],
+												getCoin({
+													address: idToToken(input[0]),
+													chain: getChainName(inputChain)
+												}).decimals
+											)}
+										</div>
+										<div>
+											{getCoin({
+												address: idToToken(input[0]),
+												chain: getChainName(inputChain)
+											}).name}
+										</div>
+									</div>
 								</div>
 							</div>
-						</div>
-					</div>
-				{/each}
+						{/each}
+					{/if}
+				</div>
 			</div>
 		</div>
-	</div>
+	{/each}
 </div>
diff --git a/src/lib/screens/IntentList.svelte b/src/lib/screens/IntentList.svelte
index c7fc3b2..6435acb 100644
--- a/src/lib/screens/IntentList.svelte
+++ b/src/lib/screens/IntentList.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { formatTokenAmount, getChainName, getCoin } from "$lib/config";
+	import { orderToIntent } from "$lib/libraries/intent";
 	import { idToToken } from "$lib/utils/convert";
-	import { getOrderId } from "$lib/utils/orderLib";
 	import type { OrderContainer } from "../../types";
 
 	let {
@@ -13,6 +13,19 @@
 		selectedOrder: OrderContainer | undefined;
 		orderContainers: OrderContainer[];
 	} = $props();
+
+	function flattenInputs(
+		inputs: { chainId: bigint; inputs: [bigint, bigint][] }[]
+	): { chainId: bigint; input: [bigint, bigint] }[] {
+		return inputs.flatMap((chainInput) => {
+			return chainInput.inputs.flatMap((i) => {
+				return {
+					chainId: chainInput.chainId,
+					input: i
+				};
+			});
+		});
+	}
 </script>
 
 <div class="h-[29rem] w-[25rem] flex-shrink-0 snap-center snap-always p-4">
@@ -33,37 +46,64 @@
 				<div class="flex w-full flex-row justify-evenly">
 					<div class="flex flex-col">
 						<div class="text-center font-medium">OrderId</div>
-						<div>{getOrderId(orderContainer).slice(2, 12)}</div>
+						<div>{orderToIntent(orderContainer).orderId().slice(2, 12)}</div>
 						<div class="text-center font-medium">User</div>
 						<div>{orderContainer.order.user.slice(0, 8)}...</div>
 					</div>
 					<div class="flex flex-col">
 						<div class="text-center font-medium">Inputs</div>
 						<div class="flex flex-col">
-							{#each orderContainer.order.inputs as input}
-								<div class="h-12 w-24 rounded bg-sky-100 text-center">
-									<div class="flex flex-col items-center justify-center align-middle">
-										<div class="flex flex-row space-x-1">
-											<div>
-												{formatTokenAmount(
-													input[1],
-													getCoin({
+							{#if "originChainId" in orderContainer.order}
+								{#each orderContainer.order.inputs as input}
+									<div class="h-12 w-24 rounded bg-sky-100 text-center">
+										<div class="flex flex-col items-center justify-center align-middle">
+											<div class="flex flex-row space-x-1">
+												<div>
+													{formatTokenAmount(
+														input[1],
+														getCoin({
+															address: idToToken(input[0]),
+															chain: getChainName(orderContainer.order.originChainId)
+														}).decimals
+													)}
+												</div>
+												<div>
+													{getCoin({
 														address: idToToken(input[0]),
 														chain: getChainName(orderContainer.order.originChainId)
-													})
-												)}
+													}).name}
+												</div>
 											</div>
-											<div>
-												{getCoin({
-													address: idToToken(input[0]),
-													chain: getChainName(orderContainer.order.originChainId)
-												}).name}
+											<div>{getChainName(orderContainer.order.originChainId)}</div>
+										</div>
+									</div>
+								{/each}
+							{:else}
+								{#each flattenInputs(orderContainer.order.inputs) as input}
+									<div class="h-12 w-24 rounded bg-sky-100 text-center">
+										<div class="flex flex-col items-center justify-center align-middle">
+											<div class="flex flex-row space-x-1">
+												<div>
+													{formatTokenAmount(
+														input.input[1],
+														getCoin({
+															address: idToToken(input.input[0]),
+															chain: getChainName(input.chainId)
+														}).decimals
+													)}
+												</div>
+												<div>
+													{getCoin({
+														address: idToToken(input.input[0]),
+														chain: getChainName(input.chainId)
+													}).name}
+												</div>
 											</div>
+											<div>{getChainName(input.chainId)}</div>
 										</div>
-										<div>{getChainName(orderContainer.order.originChainId)}</div>
 									</div>
-								</div>
-							{/each}
+								{/each}
+							{/if}
 						</div>
 					</div>
 					<div class="flex flex-col">
@@ -76,6 +116,7 @@
 											{formatTokenAmount(
 												output.amount,
 												getCoin({ address: output.token, chain: getChainName(output.chainId) })
+													.decimals
 											)}
 										</div>
 										<div>
diff --git a/src/lib/screens/IssueIntent.svelte b/src/lib/screens/IssueIntent.svelte
index 911b78f..f162a9f 100644
--- a/src/lib/screens/IssueIntent.svelte
+++ b/src/lib/screens/IssueIntent.svelte
@@ -3,80 +3,51 @@
 	import GetQuote from "$lib/components/GetQuote.svelte";
 	import {
 		INPUT_SETTLER_COMPACT_LIFI,
-		type WC,
-		type availableAllocators,
-		type availableInputSettlers,
-		type balanceQuery,
-		type Token,
-		type Verifier,
 		POLYMER_ALLOCATOR,
 		formatTokenAmount,
 		type chain,
-		INPUT_SETTLER_ESCROW_LIFI
+		INPUT_SETTLER_ESCROW_LIFI,
+		MULTICHAIN_INPUT_SETTLER_COMPACT
 	} from "$lib/config";
 	import { IntentFactory, escrowApprove } from "$lib/libraries/intentFactory";
 	import { CompactLib } from "$lib/libraries/compactLib";
-	import type { OrderContainer } from "../../types";
+	import store from "$lib/state.svelte";
+	import InputTokenModal from "../components/InputTokenModal.svelte";
+	import OutputTokenModal from "$lib/components/OutputTokenModal.svelte";
+	import { ResetPeriod } from "$lib/utils/idLib";
+	import type { CreateIntentOptions } from "$lib/libraries/intent";
+
+	const bigIntSum = (...nums: bigint[]) => nums.reduce((a, b) => a + b, 0n);
 
 	let {
 		scroll,
-		showTokenSelector = $bindable(),
-		exclusiveFor = $bindable(),
-		mainnet,
-		inputSettler,
-		allocatorId,
-		inputAmounts,
-		outputAmount,
-		inputTokens,
-		outputToken,
-		verifier,
-		compactBalances,
-		balances,
-		allowances,
-		walletClient,
-		orders = $bindable(),
 		preHook,
 		postHook,
 		account
 	}: {
 		scroll: (direction: boolean | number) => () => void;
-		showTokenSelector: {
-			active: number;
-			input: boolean;
-			index: number;
-		};
-		exclusiveFor: string;
-		inputSettler: availableInputSettlers;
-		mainnet: boolean;
-		allocatorId: availableAllocators;
-		inputAmounts: bigint[];
-		outputAmount: bigint;
-		inputTokens: Token[];
-		outputToken: Token;
-		compactBalances: balanceQuery;
-		verifier: Verifier;
-		balances: balanceQuery;
-		allowances: balanceQuery;
-		walletClient: WC;
-		orders: OrderContainer[];
 		preHook?: (chain: chain) => Promise<any>;
 		postHook: () => Promise<void>;
 		account: () => `0x${string}`;
 	} = $props();
 
+	let inputTokenSelectorActive = $state<boolean>(false);
+	let outputTokenSelectorActive = $state<boolean>(false);
+
 	const opts = $derived({
-		exclusiveFor,
-		allocatorId,
-		inputTokens,
+		exclusiveFor: store.exclusiveFor,
+		inputTokens: store.inputTokens,
+		outputTokens: store.outputTokens,
 		preHook,
 		postHook,
-		outputToken,
-		inputAmounts,
-		outputAmount,
-		verifier,
-		inputSettler,
+		verifier: store.verifier,
+		lock: {
+			type: store.intentType,
+			allocatorId: store.allocatorId,
+			resetPeriod: ResetPeriod.OneDay
+		},
 		account
-	});
+	} as CreateIntentOptions);
 
 	const postHookScroll = async () => {
 		await postHook();
@@ -85,107 +56,149 @@
 
 	const intentFactory = $derived(
 		new IntentFactory({
-			mainnet,
-			walletClient,
+			mainnet: store.mainnet,
+			walletClient: store.walletClient,
 			preHook,
 			postHook: postHookScroll,
-			ordersPointer: orders
+			ordersPointer: store.orders
 		})
 	);
 
 	const approveFunction = $derived(
-		inputSettler === INPUT_SETTLER_COMPACT_LIFI
-			? CompactLib.compactApprove(walletClient, opts)
-			: escrowApprove(walletClient, opts)
+		store.intentType === "compact"
+			? CompactLib.compactApprove(store.walletClient, opts)
+			: escrowApprove(store.walletClient, opts)
 	);
 
 	let allowanceCheck = $state(true);
 	$effect(() => {
 		allowanceCheck = true;
-		if (!allowances[inputTokens[0].chain]) {
+		if (!store.allowances[store.inputTokens[0].token.chain]) {
 			allowanceCheck = false;
 			return;
 		}
-		for (let i = 0; i < inputTokens.length; ++i) {
-			const token = inputTokens[i];
-			const inputAmount = inputAmounts[i];
-			allowances[token.chain][token.address].then((a) => {
-				allowanceCheck = allowanceCheck && a >= inputAmount;
+		for (let i = 0; i < store.inputTokens.length; ++i) {
+			const { token, amount } = store.inputTokens[i];
+			store.allowances[token.chain][token.address].then((a) => {
+				allowanceCheck = allowanceCheck && a >= amount;
 			});
 		}
 	});
 	let balanceCheckWallet = $state(true);
 	$effect(() => {
 		balanceCheckWallet = true;
-		if (!balances[inputTokens[0].chain]) {
+		if (!store.balances[store.inputTokens[0].token.chain]) {
 			balanceCheckWallet = false;
 			return;
 		}
-		for (let i = 0; i < inputTokens.length; ++i) {
-			const token = inputTokens[i];
-			const inputAmount = inputAmounts[i];
-			balances[token.chain][token.address].then((b) => {
-				balanceCheckWallet = balanceCheckWallet && b >= inputAmount;
+		for (let i = 0; i < store.inputTokens.length; ++i) {
+			const { token, amount } = store.inputTokens[i];
+			store.balances[token.chain][token.address].then((b) => {
+				balanceCheckWallet = balanceCheckWallet && b >= amount;
 			});
 		}
 	});
 	let balanceCheckCompact = $state(true);
 	$effect(() => {
 		balanceCheckCompact = true;
-		if (!compactBalances[inputTokens[0].chain]) {
+		if (!store.compactBalances[store.inputTokens[0].token.chain]) {
 			balanceCheckCompact = false;
 			return;
 		}
-		for (let i = 0; i < inputTokens.length; ++i) {
-			const token = inputTokens[i];
-			const inputAmount = inputAmounts[i];
-			compactBalances[token.chain][token.address].then((b) => {
-				balanceCheckCompact = balanceCheckCompact && b >= inputAmount;
+		for (let i = 0; i < store.inputTokens.length; ++i) {
+			const { token, amount } = store.inputTokens[i];
+			store.compactBalances[token.chain][token.address].then((b) => {
+				balanceCheckCompact = balanceCheckCompact && b >= amount;
 			});
 		}
 	});
 
-	const allSameChains = $derived(inputTokens.every((v) => inputTokens[0].chain === v.chain));
+	const abstractInputs = $derived.by(() => {
+		const inputs: {
+			name: string;
+			amount: bigint;
+			decimals: number;
+		}[] = [];
+		// Get all unique tokens.
+		const allUniqueNames = [
+			...new Set(
+				store.inputTokens.map((v) => {
+					return v.token.name;
+				})
+			)
+		];
+		for (let i = 0; i < allUniqueNames.length; ++i) {
+			const name = allUniqueNames[i];
+			inputs[i] = {
+				name,
+				amount: bigIntSum(
+					...store.inputTokens.map((v, i) => (v.token.name == name ? v.amount : 0n))
+				),
+				decimals: store.inputTokens.find((v) => v.token.name == name)!.token.decimals
+			};
+		}
+		return inputs;
+	});
+
+	const numInputChains = $derived.by(() => {
+		const tokenChains = store.inputTokens.map(({ token }) => token.chain);
+		const uniqueChains = [...new Set(tokenChains)];
+		return uniqueChains.length;
+	});
+
+	const sameChain = $derived.by(() => {
+		if (numInputChains > 1) return false;
+
+		// Only 1 input chain is used.
+		const inputChain = store.inputTokens[0].token.chain;
+		const outputChains = store.outputTokens.map((o) => o.token.chain);
+		const numOutputChains = [...new Set(outputChains)].length;
+		if (numOutputChains > 1) return false;
+		const outputChain = outputChains[0];
+		return inputChain === outputChain;
+	});
 </script>
 
-<div class="h-[29rem] w-[25rem] flex-shrink-0 snap-center snap-always p-4">
+<div class="relative h-[29rem] w-[25rem] flex-shrink-0 snap-center snap-always p-4">
 	<h1 class="w-full text-center text-2xl font-medium">Intent Issuance</h1>
 	<p class="text-sm">
 		Select assets for your intent along with the verifier for the intent. Then choose your desired
 		style of execution. Your intent will be sent to the LI.FI dev order server.
 	</p>
+	{#if inputTokenSelectorActive}
+		<InputTokenModal
+			bind:active={inputTokenSelectorActive}
+			bind:currentInputTokens={store.inputTokens}
+		></InputTokenModal>
+	{/if}
+	{#if outputTokenSelectorActive}
+		<OutputTokenModal
+			bind:active={outputTokenSelectorActive}
+			bind:currentOutputTokens={store.outputTokens}
+		></OutputTokenModal>
+	{/if}
 	<div class="my-4 flex w-full flex-row justify-evenly">
 		<div class="flex flex-col justify-center space-y-1">
-			{#each inputTokens as inputToken, i}
+			<h2 class="text-center text-sm">You Pay</h2>
+			{#each abstractInputs as input, i}
 				<button
 					class="h-16 w-28 cursor-pointer rounded bg-sky-100 text-center hover:bg-sky-200 hover:shadow-sm"
-					onclick={() =>
-						(showTokenSelector = {
-							active: new Date().getTime(),
-							input: true,
-							index: i
-						})}
+					onclick={() => (inputTokenSelectorActive = true)}
 				>
 					<div class="flex flex-col items-center justify-center align-middle">
 						<div class="flex flex-row space-x-1">
-							<div>{formatTokenAmount(inputAmounts[i], inputToken)}</div>
-							<div>{inputToken.name.toUpperCase()}</div>
+							<div>{formatTokenAmount(input.amount, input.decimals)}</div>
 						</div>
-						<div>{inputToken.chain}</div>
+						<div>{input.name.toUpperCase()}</div>
 					</div>
 				</button>
 			{/each}
-			<button
-				class="flex h-16 w-28 cursor-pointer items-center justify-center rounded border border-dashed border-gray-200 bg-gray-100 text-center align-middle"
-				onclick={() =>
-					(showTokenSelector = {
-						active: new Date().getTime(),
-						input: true,
-						index: -1
-					})}
-			>
-				+
-			</button>
+			{#if numInputChains > 1}
+				<div class="text-center font-medium text-fuchsia-500">Multichain!</div>
+			{/if}
+			{#if sameChain}
+				<div class="text-center font-medium text-violet-500">SameChain!</div>
+			{/if}
 		</div>
 		<div class="flex flex-col justify-center">
 			<div class="flex flex-col items-center">
@@ -195,51 +208,48 @@
 			</div>
 		</div>
 		<div class="flex flex-col justify-center space-y-1">
-			<button
-				class="h-16 w-28 cursor-pointer rounded bg-sky-100 text-center hover:bg-sky-200 hover:shadow-sm"
-				onclick={() =>
-					(showTokenSelector = {
-						active: new Date().getTime(),
-						input: false,
-						index: 0
-					})}
-			>
-				<div class="flex flex-col items-center justify-center align-middle">
-					<div class="flex flex-row space-x-1">
-						<div>{formatTokenAmount(outputAmount, outputToken)}</div>
-						<div>{outputToken.name.toUpperCase()}</div>
+			<h2 class="text-center text-sm">You Receive</h2>
+			{#each store.outputTokens as outputToken}
+				<button
+					class="h-16 w-28 cursor-pointer rounded bg-sky-100 text-center hover:bg-sky-200 hover:shadow-sm"
+					onclick={() => (outputTokenSelectorActive = true)}
+				>
+					<div class="flex flex-col items-center justify-center align-middle">
+						<div class="flex flex-row space-x-1">
+							<div>
+								{formatTokenAmount(outputToken.amount, outputToken.token.decimals)}
+							</div>
+							<div>{outputToken.token.name.toUpperCase()}</div>
+						</div>
+						<div>{outputToken.token.chain}</div>
 					</div>
-					<div>{outputToken.chain}</div>
-				</div>
-			</button>
-			<GetQuote
-				bind:exclusiveFor
-				{inputAmounts}
-				{mainnet}
-				bind:outputAmount
-				{inputTokens}
-				{outputToken}
-				{account}
-			></GetQuote>
-			<!-- <button
-				class="flex h-16 w-28 cursor-pointer items-center justify-center rounded border border-dashed border-gray-200 bg-gray-100 text-center align-middle"
-				onclick={() => (showTokenSelector = {
-						active: new Date().getTime(),
-						input: false,
-						index: -1
-					})}
-			>
-				+
-			</button> -->
+				</button>
+			{/each}
 		</div>
 	</div>
 
+	<div class="mx-auto w-2/5">
+		<GetQuote
+			bind:exclusiveFor={store.exclusiveFor}
+			mainnet={store.mainnet}
+			inputTokens={store.inputTokens}
+			bind:outputTokens={store.outputTokens}
+			{account}
+		></GetQuote>
+	</div>
 	<div class="mb-2 flex flex-wrap items-center justify-center gap-2">
-		<span class="font-medium">Verified by</span>
-		<select id="verified-by" class="rounded border px-2 py-1">
-			<option value="polymer" selected> Polymer </option>
-			<option value="wormhole" disabled> Wormhole </option>
-		</select>
+		{#if sameChain}
+			<span class="font-medium">Verified by</span>
+			<select class="rounded border px-2 py-1 text-gray-400" disabled>
+				<option selected disabled> Settler </option>
+			</select>
+		{:else}
+			<span class="font-medium">Verified by</span>
+			<select id="verified-by" class="rounded border px-2 py-1">
+				<option value="polymer" selected> Polymer </option>
+				<option value="wormhole" disabled> Wormhole </option>
+			</select>
+		{/if}
 	</div>
 	<div class="mb-2 flex flex-wrap items-center justify-center gap-2">
 		<span class="font-medium">Exclusive For</span>
@@ -247,29 +257,13 @@
 			type="text"
 			class="w-20 rounded border border-gray-800 bg-gray-50 px-2 py-1"
 			placeholder="0x..."
-			bind:value={exclusiveFor}
+			bind:value={store.exclusiveFor}
 		/>
 	</div>
 
 	<!-- Action Button -->
 	<div class="flex justify-center">
-		{#if !allSameChains}
-			<button
-				type="button"
-				class="h-8 rounded border px-4 text-xl font-bold text-gray-300"
-				disabled
-			>
-				Not Same Chain Inputs
-			</button>
-		{:else if inputTokens.length != 1}
-			<button
-				type="button"
-				class="h-8 rounded border px-4 text-xl font-bold text-gray-300"
-				disabled
-			>
-				Not supported yet
-			</button>
-		{:else if !allowanceCheck}
+		{#if !allowanceCheck}
 			<AwaitButton buttonFunction={approveFunction}>
 				{#snippet name()}
 					Set allowance
@@ -288,7 +282,7 @@
 					>
 						Low Balance
 					</button>
-				{:else if inputSettler === INPUT_SETTLER_ESCROW_LIFI}
+				{:else if store.intentType === "escrow"}
 					<AwaitButton buttonFunction={intentFactory.openIntent(opts)}>
 						{#snippet name()}
 							Execute Open
@@ -297,17 +291,8 @@
 							Waiting for transaction...
 						{/snippet}
 					</AwaitButton>
-				{:else if inputSettler === INPUT_SETTLER_COMPACT_LIFI}
-					<AwaitButton buttonFunction={intentFactory.compactDepositAndRegister(opts)}>
-						{#snippet name()}
-							Execute Deposit and Open
-						{/snippet}
-						{#snippet awaiting()}
-							Waiting for transaction...
-						{/snippet}
-					</AwaitButton>
 				{/if}
-				{#if inputSettler === INPUT_SETTLER_COMPACT_LIFI && allocatorId !== POLYMER_ALLOCATOR}
+				{#if store.intentType === "compact" && store.allocatorId !== POLYMER_ALLOCATOR}
 					{#if !balanceCheckCompact}
 						<button
 							type="button"
@@ -317,7 +302,7 @@
 							Low Compact Balance
 						</button>
 					{:else}
-						<AwaitButton buttonFunction={intentFactory.openIntent(opts)}>
+						<AwaitButton buttonFunction={intentFactory.compact(opts)}>
 							{#snippet name()}
 								Sign Order
 							{/snippet}
@@ -330,4 +315,10 @@
 			</div>
 		{/if}
 	</div>
+	{#if numInputChains > 1 && store.intentType !== "compact"}
+		<p class="mx-auto mt-1 w-4/5 text-sm">
+			You'll need to open the order on {numInputChains} chains. Be prepared and do not interrupt the
+			process.
+		</p>
+	{/if}
 </div>
diff --git a/src/lib/screens/ManageDeposit.svelte b/src/lib/screens/ManageDeposit.svelte
index 197cec7..48caaab 100644
--- a/src/lib/screens/ManageDeposit.svelte
+++ b/src/lib/screens/ManageDeposit.svelte
@@ -18,32 +18,15 @@
 	import AwaitButton from "$lib/components/AwaitButton.svelte";
 	import { CompactLib } from "$lib/libraries/compactLib";
 	import { toBigIntWithDecimals } from "$lib/utils/convert";
+	import store from "$lib/state.svelte";
 
 	let {
 		scroll,
-		mainnet = $bindable(),
-		inputSettler = $bindable(),
-		allocatorId = $bindable(),
-		inputNumber = $bindable(),
-		inputToken = $bindable(),
-		compactBalances,
-		balances,
-		allowances,
-		walletClient,
 		preHook,
 		postHook,
 		account
 	}: {
 		scroll: (direction: boolean | number) => () => void;
-		mainnet: boolean;
-		inputSettler: availableInputSettlers;
-		allocatorId: availableAllocators;
-		inputNumber: number;
-		inputToken: Token;
-		compactBalances: balanceQuery;
-		balances: balanceQuery;
-		allowances: balanceQuery;
-		walletClient: WC;
 		preHook: (chain: chain) => Promise<void>;
 		postHook: () => Promise<void>;
 		account: () => `0x${string}`;
@@ -51,18 +34,23 @@
 
 	let manageAssetAction: "deposit" | "withdraw" = $state("deposit");
 
+	let inputNumber = $state<number>(1);
+
 	let allowance = $state(0n);
-	const inputAmount = $derived(toBigIntWithDecimals(inputNumber, inputToken.decimals));
+	const inputAmount = $derived(toBigIntWithDecimals(inputNumber, token.decimals));
 	$effect(() => {
 		// Check if allowances contain the chain.
-		if (!allowances[inputToken.chain]) {
+		if (!store.allowances[token.chain]) {
 			allowance = 0n;
 			return;
 		}
-		allowances[inputToken.chain][inputToken.address].then((a) => {
+		store.allowances[token.chain][token.address].then((a) => {
 			allowance = a;
 		});
 	});
+
+	let selectedTokenIndex = $state<number>(0);
+	const token = $derived<Token>(coinList(store.mainnet)[selectedTokenIndex]);
 </script>
 
 <div class="h-[29rem] w-[25rem] flex-shrink-0 snap-center snap-always p-4">
@@ -76,57 +64,57 @@
 		<h2 class="text-md mt-0.5 mr-4 font-medium">Network</h2>
 		<button
 			class="h-8 rounded-l border px-4"
-			class:hover:bg-gray-100={mainnet !== false}
-			class:font-bold={mainnet === false}
-			onclick={() => (mainnet = false)}
+			class:hover:bg-gray-100={store.mainnet !== false}
+			class:font-bold={store.mainnet === false}
+			onclick={() => (store.mainnet = false)}
 		>
 			Testnet
 		</button>
 		<button
 			class=" h-8 rounded-r border border-l-0 px-4"
-			class:hover:bg-gray-100={mainnet !== true}
-			class:font-bold={mainnet === true}
-			onclick={() => (mainnet = true)}
+			class:hover:bg-gray-100={store.mainnet !== true}
+			class:font-bold={store.mainnet === true}
+			onclick={() => (store.mainnet = true)}
 		>
 			Mainnet
 		</button>
 	</div>
 	<div class="my-4 flex flex-row">
 		<h2 class="text-md mt-0.5 mr-4 font-medium">Input Type</h2>
-		<!-- <button
+		<button
 			class="h-8 rounded-l border px-4"
-			class:hover:bg-gray-100={inputSettler !== INPUT_SETTLER_COMPACT_LIFI}
-			class:font-bold={inputSettler === INPUT_SETTLER_COMPACT_LIFI}
-			onclick={() => (inputSettler = INPUT_SETTLER_COMPACT_LIFI)}
+			class:hover:bg-gray-100={store.intentType !== "compact"}
+			class:font-bold={store.intentType === "compact"}
+			onclick={() => (store.intentType = "compact")}
 		>
 			Compact Lock
-		</button> -->
+		</button>
 		<button
-			class=" h-8 rounded border px-4"
-			class:hover:bg-gray-100={inputSettler !== INPUT_SETTLER_ESCROW_LIFI}
-			class:font-bold={inputSettler === INPUT_SETTLER_ESCROW_LIFI}
-			onclick={() => (inputSettler = INPUT_SETTLER_ESCROW_LIFI)}
+			class=" h-8 rounded-r border border-l-0 px-4"
+			class:hover:bg-gray-100={store.intentType !== "escrow"}
+			class:font-bold={store.intentType === "escrow"}
+			onclick={() => (store.intentType = "escrow")}
 		>
 			Escrow
 		</button>
 	</div>
-	{#if inputSettler === INPUT_SETTLER_COMPACT_LIFI}
+	{#if store.intentType === "compact"}
 		<form class="w-full space-y-4 rounded-md">
 			<div class="flex flex-row">
 				<h2 class="text-md mr-4 font-medium">Allocator</h2>
 				<button
 					class="h-8 rounded-l border px-4"
-					class:hover:bg-gray-100={allocatorId !== ALWAYS_OK_ALLOCATOR}
-					class:font-bold={allocatorId === ALWAYS_OK_ALLOCATOR}
-					onclick={() => (allocatorId = ALWAYS_OK_ALLOCATOR)}
+					class:hover:bg-gray-100={store.allocatorId !== ALWAYS_OK_ALLOCATOR}
+					class:font-bold={store.allocatorId === ALWAYS_OK_ALLOCATOR}
+					onclick={() => (store.allocatorId = ALWAYS_OK_ALLOCATOR)}
 				>
 					AlwaysYesAllocator
 				</button>
 				<button
 					class=" h-8 rounded-r border border-l-0 px-4"
-					class:hover:bg-gray-100={allocatorId !== POLYMER_ALLOCATOR}
-					class:font-bold={allocatorId === POLYMER_ALLOCATOR}
-					onclick={() => (allocatorId = POLYMER_ALLOCATOR)}
+					class:hover:bg-gray-100={store.allocatorId !== POLYMER_ALLOCATOR}
+					class:font-bold={store.allocatorId === POLYMER_ALLOCATOR}
+					onclick={() => (store.allocatorId = POLYMER_ALLOCATOR)}
 				>
 					Polymer
 				</button>
@@ -138,19 +126,17 @@
 				</select>
 				<input type="number" class="w-20 rounded border px-2 py-1" bind:value={inputNumber} />
 				<span>of</span>
-				<BalanceField
-					value={(manageAssetAction === "withdraw" ? compactBalances : balances)[inputToken.chain][
-						inputToken.address
-					]}
-					decimals={inputToken.decimals}
-				/>
-				<select
-					id="inputToken"
-					class="rounded border px-2 py-1"
-					bind:value={() => getIndexOf(inputToken), (v) => (inputToken = coinList(mainnet)[v])}
-				>
-					{#each coinList(mainnet) as token, i}
-						<option value={i}>{printToken(token)}</option>
+				{#if (manageAssetAction === "withdraw" ? store.compactBalances : store.balances)[token.chain]}
+					<BalanceField
+						value={(manageAssetAction === "withdraw" ? store.compactBalances : store.balances)[
+							token.chain
+						][token.address]}
+						decimals={token.decimals}
+					/>
+				{/if}
+				<select id="inputToken" class="rounded border px-2 py-1" bind:value={selectedTokenIndex}>
+					{#each coinList(store.mainnet) as tkn, i}
+						<option value={i}>{printToken(tkn)}</option>
 					{/each}
 				</select>
 			</div>
@@ -159,13 +145,12 @@
 			<div class="flex justify-center">
 				{#if manageAssetAction === "withdraw"}
 					<AwaitButton
-						buttonFunction={CompactLib.compactWithdraw(walletClient, {
+						buttonFunction={CompactLib.compactWithdraw(store.walletClient, {
 							preHook,
 							postHook,
-							inputToken,
+							inputToken: { token, amount: inputAmount },
 							account,
-							inputAmount,
-							allocatorId
+							allocatorId: store.allocatorId
 						})}
 					>
 						{#snippet name()}
@@ -177,11 +162,10 @@
 					</AwaitButton>
 				{:else if allowance < inputAmount}
 					<AwaitButton
-						buttonFunction={CompactLib.compactApprove(walletClient, {
+						buttonFunction={CompactLib.compactApprove(store.walletClient, {
 							preHook,
 							postHook,
-							inputTokens: [inputToken],
-							inputAmounts: [inputAmount],
+							inputTokens: [{ token, amount: inputAmount }],
 							account
 						})}
 					>
@@ -194,13 +178,12 @@
 					</AwaitButton>
 				{:else}
 					<AwaitButton
-						buttonFunction={CompactLib.compactDeposit(walletClient!, {
+						buttonFunction={CompactLib.compactDeposit(store.walletClient!, {
 							preHook,
 							postHook,
-							inputToken,
+							inputToken: { token, amount: inputAmount },
 							account,
-							inputAmount,
-							allocatorId
+							allocatorId: store.allocatorId
 						})}
 					>
 						{#snippet name()}
diff --git a/src/lib/screens/ReceiveMessage.svelte b/src/lib/screens/ReceiveMessage.svelte
index e045d6c..0dd2288 100644
--- a/src/lib/screens/ReceiveMessage.svelte
+++ b/src/lib/screens/ReceiveMessage.svelte
@@ -1,38 +1,28 @@
 <script lang="ts">
-	import {
-		formatTokenAmount,
-		getChainName,
-		getClient,
-		getCoin,
-		type chain,
-		type WC
-	} from "$lib/config";
+	import { formatTokenAmount, getChainName, getClient, getCoin, type chain } from "$lib/config";
 	import { addressToBytes32 } from "$lib/utils/convert";
-	import { encodeMandateOutput, getOrderId } from "$lib/utils/orderLib";
-	import { keccak256 } from "viem";
+	import { encodeMandateOutput } from "$lib/utils/orderLib";
+	import { hashStruct, keccak256 } from "viem";
 	import type { MandateOutput, OrderContainer } from "../../types";
 	import { POLYMER_ORACLE_ABI } from "$lib/abi/polymeroracle";
 	import { Solver } from "$lib/libraries/solver";
 	import AwaitButton from "$lib/components/AwaitButton.svelte";
+	import store from "$lib/state.svelte";
+	import { orderToIntent } from "$lib/libraries/intent";
+	import { compactTypes } from "$lib/utils/typedMessage";
 
 	// This script needs to be updated to be able to fetch the associated events of fills. Currently, this presents an issue since it can only fill single outputs.
 
 	let {
 		orderContainer,
-		walletClient,
-		fillTransactionHash,
 		account,
 		preHook,
-		postHook,
-		mainnet
+		postHook
 	}: {
 		orderContainer: OrderContainer;
-		walletClient: WC;
-		fillTransactionHash: `0x${string}`;
 		preHook?: (chain: chain) => Promise<any>;
 		postHook: () => Promise<any>;
 		account: () => `0x${string}`;
-		mainnet: boolean;
 	} = $props();
 
 	let refreshValidation = $state(0);
@@ -43,11 +33,13 @@
 
 	async function isValidated(
 		orderId: `0x${string}`,
+		chainId: bigint,
 		orderContainer: OrderContainer,
 		output: MandateOutput,
 		fillTransactionHash: `0x${string}`,
 		_?: any
 	) {
+		if (!fillTransactionHash) return false;
 		if (
 			!fillTransactionHash ||
 			!fillTransactionHash.startsWith("0x") ||
@@ -70,7 +62,7 @@
 			output
 		);
 		const outputHash = keccak256(encodedOutput);
-		const sourceChainClient = getClient(order.originChainId);
+		const sourceChainClient = getClient(chainId);
 		return await sourceChainClient.readContract({
 			address: order.inputOracle,
 			abi: POLYMER_ORACLE_ABI,
@@ -78,6 +70,25 @@
 			args: [output.chainId, output.oracle, output.settler, outputHash]
 		});
 	}
+
+	// const validations = $derived(
+	// 	orderContainer.order.outputs.map((output) => {
+	// 		return orderToIntent(orderContainer)
+	// 			.inputChains()
+	// 			.map((inputChain) => {
+	// 				return isValidated(
+	// 					orderToIntent(orderContainer).orderId(),
+	// 					inputChain,
+	// 					orderContainer,
+	// 					output,
+	// 					store.fillTransactions[
+	// 						hashStruct({ data: output, types: compactTypes, primaryType: "MandateOutput" })
+	// 					],
+	// 					refreshValidation
+	// 				);
+	// 			});
+	// 	})
+	// );
 </script>
 
 <div class="h-[29rem] w-[25rem] flex-shrink-0 snap-center snap-always p-4">
@@ -86,78 +97,93 @@
 		Click on each output and wait until they turn green. Polymer does not support batch validation.
 		Continue to the right.
 	</p>
-	<div class="w-full">
-		<h2 class="w-full text-center text-lg font-medium">
-			{getChainName(orderContainer.order.originChainId)}
-		</h2>
-		<hr class="my-1" />
-		<div class="flex w-full flex-row space-x-1 overflow-y-hidden">
-			{#each orderContainer.order.outputs as output}
-				{#await isValidated(getOrderId(orderContainer), orderContainer, output, fillTransactionHash, refreshValidation)}
-					<div class="h-8 w-28 cursor-pointer rounded bg-slate-100 text-center">
-						<div class="flex flex-col items-center justify-center align-middle">
-							<div class="flex flex-row space-x-1">
-								<div>
-									{formatTokenAmount(
-										output.amount,
-										getCoin({ address: output.token, chain: getChainName(output.chainId) })
-									)}
-								</div>
-								<div>
-									{getCoin({ address: output.token, chain: getChainName(output.chainId) }).name}
+	{#each orderToIntent(orderContainer).inputChains() as inputChain}
+		<div class="w-full">
+			<h2 class="w-full text-center text-lg font-medium">
+				{getChainName(inputChain)}
+			</h2>
+			<hr class="my-1" />
+			<div class="flex w-full flex-row space-x-1 overflow-y-hidden">
+				{#each orderContainer.order.outputs as output}
+					{#await isValidated(orderToIntent(orderContainer).orderId(), inputChain, orderContainer, output, store.fillTransactions[hashStruct( { data: output, types: compactTypes, primaryType: "MandateOutput" } )], refreshValidation)}
+						<div class="h-8 w-28 cursor-pointer rounded bg-slate-100 text-center">
+							<div class="flex flex-col items-center justify-center align-middle">
+								<div class="flex flex-row space-x-1">
+									<div>
+										{formatTokenAmount(
+											output.amount,
+											getCoin({ address: output.token, chain: getChainName(output.chainId) })
+												.decimals
+										)}
+									</div>
+									<div>
+										{getCoin({ address: output.token, chain: getChainName(output.chainId) }).name}
+									</div>
 								</div>
 							</div>
 						</div>
-					</div>
-				{:then validated}
-					<AwaitButton
-						baseClass={["h-8 w-28 rounded text-center", validated ? "bg-green-50" : "bg-yellow-50"]}
-						hoverClass={[validated ? "" : "hover:bg-yellow-100 cursor-pointer"]}
-						buttonFunction={validated
-							? async () => console.log("Has already been validated")
-							: Solver.validate(
-									walletClient,
-									{
-										orderContainer,
-										fillTransactionHash,
-										mainnet
-									},
-									{
-										preHook,
-										postHook: postHookRefreshValidate,
-										account
-									}
-								)}
-					>
-						{#snippet name()}
-							<div class="flex flex-row items-center justify-center space-x-1 text-center">
-								<div>
-									{formatTokenAmount(
-										output.amount,
-										getCoin({ address: output.token, chain: getChainName(output.chainId) })
-									)}
-								</div>
-								<div>
-									{getCoin({ address: output.token, chain: getChainName(output.chainId) }).name}
+					{:then validated}
+						<AwaitButton
+							baseClass={[
+								"h-8 w-28 rounded text-center",
+								validated ? "bg-green-50" : "bg-yellow-50"
+							]}
+							hoverClass={[validated ? "" : "hover:bg-yellow-100 cursor-pointer"]}
+							buttonFunction={Solver.validate(
+								store.walletClient,
+								{
+									output,
+									orderContainer,
+									fillTransactionHash:
+										store.fillTransactions[
+											hashStruct({
+												data: output,
+												types: compactTypes,
+												primaryType: "MandateOutput"
+											})
+										],
+									sourceChain: getChainName(inputChain),
+									mainnet: store.mainnet
+								},
+								{
+									preHook,
+									postHook: postHookRefreshValidate,
+									account
+								}
+							)}
+						>
+							{#snippet name()}
+								<div class="flex flex-row items-center justify-center space-x-1 text-center">
+									<div>
+										{formatTokenAmount(
+											output.amount,
+											getCoin({ address: output.token, chain: getChainName(output.chainId) })
+												.decimals
+										)}
+									</div>
+									<div>
+										{getCoin({ address: output.token, chain: getChainName(output.chainId) }).name}
+									</div>
 								</div>
-							</div>
-						{/snippet}
-						{#snippet awaiting()}
-							<div class="flex flex-row items-center justify-center space-x-1 text-center">
-								<div>
-									{formatTokenAmount(
-										output.amount,
-										getCoin({ address: output.token, chain: getChainName(output.chainId) })
-									)}
-								</div>
-								<div>
-									{getCoin({ address: output.token, chain: getChainName(output.chainId) }).name}
+							{/snippet}
+							{#snippet awaiting()}
+								<div class="flex flex-row items-center justify-center space-x-1 text-center">
+									<div>
+										{formatTokenAmount(
+											output.amount,
+											getCoin({ address: output.token, chain: getChainName(output.chainId) })
+												.decimals
+										)}
+									</div>
+									<div>
+										{getCoin({ address: output.token, chain: getChainName(output.chainId) }).name}
+									</div>
 								</div>
-							</div>
-						{/snippet}
-					</AwaitButton>
-				{/await}
-			{/each}
+							{/snippet}
+						</AwaitButton>
+					{/await}
+				{/each}
+			</div>
 		</div>
-	</div>
+	{/each}
 </div>
diff --git a/src/lib/screens/TokenModal.svelte b/src/lib/screens/TokenModal.svelte
deleted file mode 100644
index 84aa4d2..0000000
--- a/src/lib/screens/TokenModal.svelte
+++ /dev/null
@@ -1,142 +0,0 @@
-<script lang="ts">
-	import BalanceField from "$lib/components/BalanceField.svelte";
-	import {
-		ADDRESS_ZERO,
-		coinList,
-		getCoin,
-		INPUT_SETTLER_COMPACT_LIFI,
-		INPUT_SETTLER_ESCROW_LIFI,
-		printToken,
-		type availableInputSettlers,
-		type balanceQuery,
-		type chain,
-		type Token
-	} from "$lib/config";
-	import { toBigIntWithDecimals } from "$lib/utils/convert";
-
-	let {
-		showTokenSelector = $bindable(),
-		inputSettler,
-		compactBalances,
-		balances,
-		inputTokens = $bindable(),
-		outputToken = $bindable(),
-		inputAmounts = $bindable(),
-		outputAmount = $bindable(),
-		mainnet
-	}: {
-		showTokenSelector: {
-			active: number;
-			input: boolean;
-			index: number;
-		};
-		inputSettler: availableInputSettlers;
-		compactBalances: balanceQuery;
-		balances: balanceQuery;
-		inputTokens: Token[];
-		outputToken: Token;
-		inputAmounts: bigint[];
-		outputAmount: bigint;
-		mainnet: boolean;
-	} = $props();
-
-	$effect(() => {
-		const tkn = showTokenSelector.input
-			? (inputTokens[showTokenSelector.index] ?? coinList(mainnet)[0])
-			: outputToken;
-		const defaultModelValue =
-			(showTokenSelector.input
-				? Number(inputAmounts[showTokenSelector.index])
-				: Number(outputAmount)) /
-			10 ** tkn.decimals;
-		modalNumber = (defaultModelValue ?? 0) > 0 ? defaultModelValue : 1;
-		selectedToken = tkn;
-	});
-
-	let selectedToken: Token = $state(
-		showTokenSelector.input ? inputTokens[showTokenSelector.index] : outputToken
-	);
-	let modalNumber: number = $state(1);
-
-	function submit() {
-		// Input side
-		if (showTokenSelector.input) {
-			const val = toBigIntWithDecimals(modalNumber, selectedToken.decimals);
-			if (showTokenSelector.index === -1) {
-				console.log("push");
-				inputAmounts.push(val);
-				inputTokens.push(selectedToken);
-			} else {
-				console.log("update", showTokenSelector.index);
-				inputAmounts[showTokenSelector.index] = val;
-				inputTokens[showTokenSelector.index] = selectedToken;
-			}
-		} else {
-			// Output side
-			outputToken = selectedToken;
-			outputAmount = toBigIntWithDecimals(modalNumber, outputToken.decimals);
-		}
-		showTokenSelector.active = 0;
-	}
-</script>
-
-{#if showTokenSelector.active > 0}
-	<div
-		style="position: fixed; inset: 0; z-index: 0; background: transparent; pointer-events: auto;"
-		aria-hidden="true"
-		onclick={() => {
-			if (showTokenSelector.active < new Date().getTime() - 200) showTokenSelector.active = 0;
-		}}
-	></div>
-	<div
-		class="absolute top-30 left-10 z-10 h-[12rem] w-[20rem] rounded border border-gray-200 bg-sky-50"
-	>
-		<div class="flex h-full w-full flex-col items-center justify-center space-y-3 align-middle">
-			{#if showTokenSelector.index === -1}
-				<h3 class="-mt-2 text-center text-xl font-medium">Add Asset</h3>
-			{:else}
-				<h3 class="-mt-2 text-center text-xl font-medium">Select Asset</h3>
-			{/if}
-			<div class="flex flex-row space-x-2">
-				<input type="number" class="w-20 rounded border px-2 py-1" bind:value={modalNumber} />
-				{#if showTokenSelector.input}
-					<span class="mt-0.5">of</span>
-					<BalanceField
-						value={(inputSettler === INPUT_SETTLER_COMPACT_LIFI ? compactBalances : balances)[
-							selectedToken.chain
-						][selectedToken.address]}
-						decimals={selectedToken.decimals}
-					/>
-				{:else}{/if}
-			</div>
-			<div class="flex flex-row space-x-2">
-				<select
-					id="tokenSelector"
-					class="rounded border px-2 py-1"
-					bind:value={
-						() => `${selectedToken.address},${selectedToken.chain}`,
-						(v) => {
-							console.log(v);
-							const [address, chain] = v.split(",");
-							selectedToken = getCoin({ address: address as `0x${string}`, chain: chain as chain });
-						}
-					}
-				>
-					{#if showTokenSelector.input}
-						{#each coinList(mainnet).filter( (v) => (inputSettler === INPUT_SETTLER_ESCROW_LIFI ? v.address != ADDRESS_ZERO : true) ) as token, i}
-							<option value={`${token.address},${token.chain}`}>{printToken(token)}</option>
-						{/each}
-					{:else}
-						{#each coinList(mainnet) as token, i}
-							<option value={`${token.address},${token.chain}`}>{printToken(token)}</option>
-						{/each}
-					{/if}
-				</select>
-			</div>
-			<button
-				class="bg-gray h-8 rounded border px-4 text-xl font-bold text-gray-600 hover:text-blue-600"
-				onclick={submit}>Save</button
-			>
-		</div>
-	</div>
-{/if}
diff --git a/src/lib/state.svelte.ts b/src/lib/state.svelte.ts
index cfb2856..78d6fe9 100644
--- a/src/lib/state.svelte.ts
+++ b/src/lib/state.svelte.ts
@@ -1,59 +1,160 @@
-import { maxUint256 } from "viem";
-import { COMPACT_ABI } from "./abi/compact";
-import { ERC20_ABI } from "./abi/erc20";
-import { ADDRESS_ZERO, clients, COMPACT } from "./config";
-import { ResetPeriod, toId } from "./utils/idLib";
-
-export async function getBalance(
-	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]
-		});
+import type { WalletState } from "@web3-onboard/core";
+import type { OrderContainer } from "../types";
+import {
+	ALWAYS_OK_ALLOCATOR,
+	chainMap,
+	clients,
+	coinList,
+	COMPACT,
+	INPUT_SETTLER_COMPACT_LIFI,
+	INPUT_SETTLER_ESCROW_LIFI,
+	MULTICHAIN_INPUT_SETTLER_COMPACT,
+	MULTICHAIN_INPUT_SETTLER_ESCROW,
+	POLYMER_ALLOCATOR,
+	type availableAllocators,
+	type availableInputSettlers,
+	type chain,
+	type Token,
+	type Verifier
+} from "./config";
+import { getAllowance, getBalance, getCompactBalance } from "./libraries/token";
+import onboard from "./utils/web3-onboard";
+import { createWalletClient, custom } from "viem";
+
+export type TokenContext = {
+	token: Token;
+	amount: bigint;
+};
+
+class Store {
+	mainnet = $state<boolean>(true);
+	orders = $state<OrderContainer[]>([]);
+
+	// --- Wallet --- //
+	wallets = onboard.state.select("wallets");
+	activeWallet = $state<{ wallet?: WalletState }>({});
+	connectedAccount = $derived(this.activeWallet.wallet?.accounts?.[0]);
+	walletClient = $derived(
+		this.activeWallet?.wallet?.provider
+			? createWalletClient({
+					transport: custom(this.activeWallet?.wallet?.provider)
+				})
+			: undefined
+	)!;
+
+	// --- Token --- //
+	inputTokens = $state<TokenContext[]>([]);
+	outputTokens = $state<TokenContext[]>([]);
+
+	// inputTokens = $state<Token[]>([]);
+	// outputTokens = $state<Token[]>([]);
+	// inputAmounts = $state<bigint[]>([1000000n]);
+	// outputAmounts = $state<bigint[]>([1000000n]);
+
+	fillTransactions = $state<{ [outputId: string]: `0x${string}` }>({});
+
+	balances = $derived.by(() => {
+		return this.mapOverCoins(getBalance, this.mainnet, this.updatedDerived);
+	});
+	allowances = $derived.by(() => {
+		return this.mapOverCoins(
+			getAllowance(
+				this.inputSettler === INPUT_SETTLER_COMPACT_LIFI ||
+					this.inputSettler === MULTICHAIN_INPUT_SETTLER_COMPACT
+					? COMPACT
+					: this.inputSettler
+			),
+			this.mainnet,
+			this.updatedDerived
+		);
+	});
+	compactBalances = $derived.by(() => {
+		return this.mapOverCoins(
+			(
+				user: `0x${string}` | undefined,
+				asset: `0x${string}`,
+				client: (typeof clients)[keyof typeof clients]
+			) => getCompactBalance(user, asset, client, this.allocatorId),
+			this.mainnet,
+			this.updatedDerived
+		);
+	});
+
+	multichain = $derived([...new Set(this.inputTokens.map((i) => i.token.chain))].length > 1);
+
+	// --- Input Side --- //
+	// TODO: remove
+	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<availableAllocators>(ALWAYS_OK_ALLOCATOR);
+
+	// --- Oracle --- //
+	verifier = $state<Verifier>("polymer");
+
+	// --- Output Side --- //
+	exclusiveFor: string = $state("");
+
+	// --- Misc --- //
+	updatedDerived = $state(0);
+
+	forceUpdate = () => {
+		this.updatedDerived += 1;
+	};
+
+	async setWalletToCorrectChain(chain: chain) {
+		try {
+			return await this.walletClient?.switchChain({ id: chainMap[chain].id });
+		} catch (error) {
+			console.warn(
+				`Wallet does not support switchChain or failed to switch chain: ${chainMap[chain].id}`,
+				error
+			);
+			return undefined;
+		}
 	}
-}
 
-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]
+	mapOverCoins<T>(
+		func: (
+			user: `0x${string}` | undefined,
+			asset: `0x${string}`,
+			client: (typeof clients)[keyof typeof clients]
+		) => T,
+		isMainnet: boolean,
+		_: any
+	) {
+		const resolved: Record<chain, Record<`0x${string}`, T>> = {} as any;
+		for (const token of coinList(isMainnet)) {
+			// Check whether we have me the chain before.
+			if (!resolved[token.chain as chain]) resolved[token.chain] = {};
+			resolved[token.chain][token.address] = func(
+				this.connectedAccount?.address,
+				token.address,
+				clients[token.chain]
+			);
+		}
+		return resolved;
+	}
+
+	constructor() {
+		this.inputTokens = [{ token: coinList(this.mainnet)[0], amount: 1000000n }];
+		this.outputTokens = [{ token: coinList(this.mainnet)[1], amount: 1000000n }];
+
+		this.wallets.subscribe((v) => {
+			this.activeWallet.wallet = v?.[0];
 		});
-	};
+		setInterval(() => {
+			this.updatedDerived += 1;
+		}, 10000);
+	}
 }
 
-export async function getCompactBalance(
-	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);
-	return client.readContract({
-		address: COMPACT,
-		abi: COMPACT_ABI,
-		functionName: "balanceOf",
-		args: [user, assetId]
-	});
-}
+export const store = new Store();
+export default store;
diff --git a/src/lib/utils/idLib.ts b/src/lib/utils/idLib.ts
index 1ea5561..3f1010e 100644
--- a/src/lib/utils/idLib.ts
+++ b/src/lib/utils/idLib.ts
@@ -21,14 +21,14 @@ export enum ResetPeriod {
  *  - Bits 160-251: allocator ID (92 bits)
  *  - Bits 0-159: token address (20 bytes = 160 bits)
  *
- * @param isMultichain Whether the lock is multichain (maps to scope)
+ * @param inputChains Whether the lock is multichain (maps to scope)
  * @param resetPeriod Reset period (0-7)
  * @param allocatorId Allocator ID as string
  * @param token Token address as hex string
  * @returns The derived resource lock ID as a BigInt
  */
 export function toId(
-	isMultichain: boolean,
+	inputChains: boolean,
 	resetPeriod: number,
 	allocatorId: string,
 	token: string
@@ -40,8 +40,8 @@ export function toId(
 	// Validate token is a valid address and normalize it
 	const normalizedToken = getAddress(token);
 
-	// Convert isMultichain to scope (inverse relationship)
-	const scope = isMultichain ? 0n : 1n;
+	// Convert inputChains to scope (inverse relationship)
+	const scope = inputChains ? 0n : 1n;
 
 	// Convert allocatorId from decimal string to BigInt
 	const allocatorBigInt = BigInt(allocatorId);
diff --git a/src/lib/utils/interopableAddresses.ts b/src/lib/utils/interopableAddresses.ts
index d779b3d..0ff6e4b 100644
--- a/src/lib/utils/interopableAddresses.ts
+++ b/src/lib/utils/interopableAddresses.ts
@@ -2,20 +2,35 @@ function padEven(s: string, minimal = 2, pad: string = "0") {
 	return s.padStart(((Math.max(s.length + 1, minimal) / 2) | 0) * 2, pad);
 }
 
-function toHex(num: number | bigint, bytes: number = 1) {
-	return padEven(num.toString(16), bytes * 2);
+export function toHex<T extends string = "">(
+	num: number | bigint,
+	bytes: number = 1,
+	prefix?: T
+): `${T}${string}` {
+	const p = (prefix ?? "") as T;
+	return `${p}${padEven(num.toString(16), bytes * 2)}` as `${T}${string}`;
 }
 
-export const getInteropableAddress = (address: `0x${string}`, chainId: number | bigint) => {
+type Version = "0001";
+type ChainType = "0000";
+type ChainReferenceLength = string;
+type ChainReference = string;
+type Address = string;
+
+export type InteropableAddress =
+	`0x${Version}${ChainType}${ChainReferenceLength}${ChainReference}${Address}`;
+
+export const getInteropableAddress = (
+	address: `0x${string}`,
+	chainId: number | bigint
+): InteropableAddress => {
 	const version = "0001";
 	const chainType = "0000";
 
 	const chainReference = padEven(chainId.toString(16));
 	const chainReferenceLength = toHex(chainReference.length / 2);
 
-	const interopableAddress = `0x${version}${chainType}${chainReferenceLength}${chainReference}${toHex(
+	return `0x${version}${chainType}${chainReferenceLength}${chainReference}${toHex(
 		address.replace("0x", "").length / 2
 	)}${address.replace("0x", "")}`;
-
-	return interopableAddress;
 };
diff --git a/src/lib/utils/multichainOrder.ts b/src/lib/utils/multichainOrder.ts
deleted file mode 100644
index dadc724..0000000
--- a/src/lib/utils/multichainOrder.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { encodePacked, hashTypedData, keccak256, toHex } from "viem";
-import type { CompactMandate, MultichainOrder, MultichainOrderComponent } from "../../types";
-import { INPUT_SETTLER_ESCROW_LIFI } from "$lib/config";
-import { compactTypes } from "./typedMessage";
-
-function selectAllBut<T>(arr: T[], index: number): T[] {
-	return [...arr.slice(0, index), ...arr.slice(index + 1, arr.length)];
-}
-
-function secondariesEcsrow(
-	order: MultichainOrder
-): { chainIdField: bigint; additionalChains: `0x${string}`[] }[] {
-	const inputsHash: `0x${string}`[] = order.inputs.map((input) =>
-		keccak256(encodePacked(["uint256", "uint256[2][]"], [input.chainId, input.inputs]))
-	);
-	return order.inputs.map((v, i) => {
-		return {
-			chainIdField: v.chainId,
-			additionalChains: selectAllBut(inputsHash, i)
-		};
-	});
-}
-
-type Lock = {
-	lockTag: `0x${string}`;
-	token: `0x${string}`;
-	amount: bigint;
-};
-
-function inputsToLocks(inputs: [bigint, bigint][]): Lock[] {
-	return inputs.map((input) => {
-		const bytes32 = toHex(input[0]).replace("0x", "");
-		return {
-			lockTag: `0x${bytes32.slice(0, 12 * 2)}`,
-			token: `0x${bytes32.slice(12 * 2, 32 * 2)}`,
-			amount: input[1]
-		};
-	});
-}
-
-function secondariesCompact(
-	order: MultichainOrder,
-	inputSettler: `0x${string}`
-): { chainIdField: bigint; additionalChains: `0x${string}`[] }[] {
-	const mandate: CompactMandate = {
-		fillDeadline: order.fillDeadline,
-		inputOracle: order.inputOracle,
-		outputs: order.outputs
-	};
-	const elements = order.inputs.map((inputs) => {
-		const element: {
-			arbiter: `0x${string}`;
-			chainId: bigint;
-			commitments: Lock[];
-			mandate: CompactMandate;
-		} = {
-			arbiter: inputSettler,
-			chainId: inputs.chainId,
-			commitments: inputsToLocks(inputs.inputs),
-			mandate
-		};
-		return hashTypedData({
-			types: compactTypes,
-			primaryType: "Element",
-			message: element
-		});
-	});
-	return order.inputs.map((_, i) => {
-		return {
-			chainIdField: order.inputs[0].chainId,
-			additionalChains: selectAllBut(elements, i)
-		};
-	});
-}
-
-function ComponentizeOrder(
-	order: MultichainOrder,
-	inputSettler: `0x${string}`
-): MultichainOrderComponent[] {
-	const inputs = order.inputs;
-	const secondaries =
-		inputSettler === INPUT_SETTLER_ESCROW_LIFI
-			? secondariesEcsrow(order)
-			: secondariesCompact(order, inputSettler);
-	const components: MultichainOrderComponent[] = [];
-	for (let i = 0; i < inputs.length; ++i) {
-		const { chainIdField, additionalChains } = secondaries[i];
-
-		const orderComponent: MultichainOrderComponent = {
-			user: order.user,
-			nonce: order.nonce,
-			chainIdField: chainIdField,
-			chainIndex: BigInt(i),
-			expires: order.expires,
-			fillDeadline: order.fillDeadline,
-			inputOracle: order.inputOracle,
-			inputs: order.inputs[i].inputs,
-			outputs: order.outputs,
-			additionalChains: additionalChains
-		};
-		components.push(orderComponent);
-	}
-	return components;
-}
diff --git a/src/lib/utils/orderLib.ts b/src/lib/utils/orderLib.ts
index 84f6d66..17e9ea9 100644
--- a/src/lib/utils/orderLib.ts
+++ b/src/lib/utils/orderLib.ts
@@ -1,42 +1,7 @@
 import { encodeAbiParameters, encodePacked, keccak256, parseAbiParameters } from "viem";
-import type { MandateOutput, StandardOrder } from "../../types";
+import type { MandateOutput, MultichainOrder, StandardOrder } from "../../types";
 import { type chain, chainMap, POLYMER_ORACLE, WORMHOLE_ORACLE } from "$lib/config";
 
-export function getOrderId(orderContainer: { order: StandardOrder; inputSettler: `0x${string}` }) {
-	const { order, inputSettler } = orderContainer;
-	return keccak256(
-		encodePacked(
-			[
-				"uint256",
-				"address",
-				"address",
-				"uint256",
-				"uint32",
-				"uint32",
-				"address",
-				"bytes32",
-				"bytes"
-			],
-			[
-				order.originChainId,
-				inputSettler,
-				order.user,
-				order.nonce,
-				order.expires,
-				order.fillDeadline,
-				order.inputOracle,
-				keccak256(encodePacked(["uint256[2][]"], [order.inputs])),
-				encodeAbiParameters(
-					parseAbiParameters(
-						"(bytes32 oracle, bytes32 settler, uint256 chainId, bytes32 token, uint256 amount, bytes32 recipient, bytes callbackData, bytes context)[]"
-					),
-					[order.outputs]
-				)
-			]
-		)
-	);
-}
-
 export function getOutputHash(output: MandateOutput) {
 	return keccak256(
 		encodePacked(
diff --git a/src/lib/utils/typedMessage.ts b/src/lib/utils/typedMessage.ts
index 1174984..d1f1ea0 100644
--- a/src/lib/utils/typedMessage.ts
+++ b/src/lib/utils/typedMessage.ts
@@ -7,55 +7,44 @@ const BatchCompact = [
 	{ name: "expires", type: "uint256" },
 	{ name: "commitments", type: "Lock[]" },
 	{ name: "mandate", type: "Mandate" }
-];
+] as const;
 
 const MultichainCompact = [
 	{ name: "sponsor", type: "address" },
 	{ name: "nonce", type: "uint256" },
 	{ name: "expires", type: "uint256" },
 	{ name: "elements", type: "Element[]" }
-];
+] as const;
 
 const Lock = [
 	{ name: "lockTag", type: "bytes12" },
 	{ name: "token", type: "address" },
 	{ name: "amount", type: "uint256" }
-];
+] as const;
 
 const Element = [
 	{ name: "arbiter", type: "address" },
 	{ name: "chainId", type: "uint256" },
 	{ name: "commitments", type: "Lock[]" },
 	{ name: "mandate", type: "Mandate" }
-];
+] as const;
 
 const Mandate = [
 	{ name: "fillDeadline", type: "uint32" },
 	{ name: "inputOracle", type: "address" },
 	{ name: "outputs", type: "MandateOutput[]" }
-];
+] as const;
 
-const MandateOutput = [
+export const MandateOutput = [
 	{ name: "oracle", type: "bytes32" },
 	{ name: "settler", type: "bytes32" },
 	{ name: "chainId", type: "uint256" },
 	{ name: "token", type: "bytes32" },
 	{ name: "amount", type: "uint256" },
 	{ name: "recipient", type: "bytes32" },
-	{ name: "call", type: "bytes" },
+	{ name: "callbackData", type: "bytes" },
 	{ name: "context", type: "bytes" }
-];
-
-export const StandardOrderAbi = [
-	{ name: "user", type: "address" },
-	{ name: "nonce", type: "uint256" },
-	{ name: "originChainId", type: "uint256" },
-	{ name: "expires", type: "uint32" },
-	{ name: "fillDeadline", type: "uint32" },
-	{ name: "inputOracle", type: "address" },
-	{ name: "inputs", type: "uint256[2][]" },
-	{ name: "outputs", type: "tuple[]", components: MandateOutput }
-];
+] as const;
 
 // The named list of all type definitions
 export const compactTypes = {
@@ -77,3 +66,14 @@ if (compact_type_hash != compact_type_hash_contract) {
 		`Computed typehash ${compact_type_hash} does not match expected ${compact_type_hash_contract}`
 	);
 }
+
+const multichain_compact_type =
+	"MultichainCompact(address sponsor,uint256 nonce,uint256 expires,Element[] elements)Element(address arbiter,uint256 chainId,Lock[] commitments,Mandate mandate)Lock(bytes12 lockTag,address token,uint256 amount)Mandate(uint32 fillDeadline,address inputOracle,MandateOutput[] outputs)MandateOutput(bytes32 oracle,bytes32 settler,uint256 chainId,bytes32 token,uint256 amount,bytes32 recipient,bytes callbackData,bytes context)" as const;
+export const multichain_compact_type_hash = keccak256(toHex(multichain_compact_type));
+const multichain_compact_type_hash_contract =
+	"0x6bc0624272798c7a3ff97563d8a009ea96cffd8ea74a971b2946ca790fc50319";
+if (multichain_compact_type_hash != multichain_compact_type_hash_contract) {
+	throw Error(
+		`Computed multichain typehash ${multichain_compact_type_hash} does not match expected ${multichain_compact_type_hash_contract}`
+	);
+}
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 192d71e..17cb27a 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -1,26 +1,10 @@
 <script lang="ts">
 	import onboard from "$lib/utils/web3-onboard";
-	import { createWalletClient, custom } from "viem";
-	import type { WalletState } from "@web3-onboard/core";
 	import type { NoSignature, OrderContainer, Signature, StandardOrder } from "../types";
-	import {
-		type Token,
-		type chain,
-		type Verifier,
-		ALWAYS_OK_ALLOCATOR,
-		POLYMER_ALLOCATOR,
-		chainMap,
-		clients,
-		INPUT_SETTLER_COMPACT_LIFI,
-		INPUT_SETTLER_ESCROW_LIFI,
-		COMPACT,
-		coinList
-	} from "$lib/config";
+	import { coinList, type chain } from "$lib/config";
 	import { onDestroy, onMount } from "svelte";
 	import Introduction from "$lib/components/Introduction.svelte";
-	import { getBalance, getAllowance, getCompactBalance } from "$lib/state.svelte";
 	import { OrderServer } from "$lib/libraries/orderServer";
-	import { validateOrder } from "$lib/utils/orderLib";
 	import ManageDeposit from "$lib/screens/ManageDeposit.svelte";
 	import IssueIntent from "$lib/screens/IssueIntent.svelte";
 	import IntentList from "$lib/screens/IntentList.svelte";
@@ -28,7 +12,7 @@
 	import ReceiveMessage from "$lib/screens/ReceiveMessage.svelte";
 	import Finalise from "$lib/screens/Finalise.svelte";
 	import ConnectWallet from "$lib/screens/ConnectWallet.svelte";
-	import TokenModal from "$lib/screens/TokenModal.svelte";
+	import store from "$lib/state.svelte";
 
 	// Fix bigint so we can json serialize it:
 	(BigInt.prototype as any).toJSON = function () {
@@ -42,15 +26,21 @@
 		allocatorSignature?: `0x${string}`;
 	};
 
-	let mainnet = $state(true);
-	const orderServer = $derived(new OrderServer(mainnet));
+	$effect(() => {
+		store.mainnet;
+		store.inputTokens = [{ token: coinList(store.mainnet)[0], amount: 0n }];
+		store.outputTokens = [{ token: coinList(store.mainnet)[1], amount: 0n }];
+	});
 
-	let orders = $state<OrderContainer[]>([]);
+	const orderServer = $derived(new OrderServer(store.mainnet));
 
 	let s: WebSocket;
-	function initatePage() {
+	function initiatePage() {
 		if (s) s.close();
-		orders = [];
+		// Empty store.orders without changing the pointer:
+		store.orders.forEach(() => {
+			store.orders.pop();
+		});
 		// Connect to websocket server
 		let { socket } = orderServer.connectOrderServerSocket((order: OrderPackage) => {
 			const allocatorSignature = order.allocatorSignature
@@ -71,153 +61,34 @@
 						type: "None",
 						payload: "0x"
 					} as NoSignature);
-			orders.push({ ...order, allocatorSignature, sponsorSignature });
-			console.log({ orders, order });
+			store.orders.push({ ...order, allocatorSignature, sponsorSignature });
+			console.log({ orders: store.orders, order });
 		});
 		s = socket;
 		onDestroy(() => s.close());
 	}
 
-	$effect(() => {
-		mainnet;
-		initatePage();
-	});
+	// $effect(() => {
+	// 	store.mainnet;
+	// 	initiatePage();
+	// });
 
-	onMount(() => {
-		initatePage();
-	});
+	// onMount(() => {
+	// 	initiatePage();
+	// });
 
 	// --- Wallet --- //
-	const wallets = onboard.state.select("wallets");
-	const activeWallet = $state<{ wallet?: WalletState }>({});
-	wallets.subscribe((v) => {
-		activeWallet.wallet = v?.[0];
-	});
-	const connectedAccount = $derived(activeWallet.wallet?.accounts?.[0]);
-
-	const walletClient = $derived(
-		activeWallet?.wallet?.provider
-			? createWalletClient({
-					transport: custom(activeWallet?.wallet?.provider)
-				})
-			: undefined
-	);
-
-	export async function setWalletToCorrectChain(chain: chain) {
-		try {
-			return await walletClient?.switchChain({ id: chainMap[chain].id });
-		} catch (error) {
-			console.warn(
-				`Wallet does not support switchChain or failed to switch chain: ${chainMap[chain].id}`,
-				error
-			);
-			return undefined;
-		}
-	}
 
 	export async function connect() {
 		await onboard.connectWallet();
 	}
 
 	// --- Execute Transaction Variables --- //
-	const preHook = setWalletToCorrectChain;
-	const postHook = async () => forceUpdate();
-	const account = () => connectedAccount?.address!;
-	let inputNumber = $state(1); // Window number
-	let outputNumber = $state(1); // Window number
-
-	let exclusiveFor: string = $state("");
-
-	$effect(() => {
-		mainnet;
-		console.log(coinList(mainnet));
-		inputTokens = [coinList(mainnet)[0]];
-		outputToken = coinList(mainnet)[1];
-	});
-
-	// svelte-ignore state_referenced_locally
-	let inputTokens: Token[] = $state([coinList(mainnet)[0]]);
-	let inputToken = $derived(inputTokens[0]);
-	// svelte-ignore state_referenced_locally
-	let outputToken: Token = $state(coinList(mainnet)[1]);
-	let inputAmounts = $state([1000000n]);
-	let outputAmount = $state(1000000n);
-	// const verifier: verifier = 'polymer';
-	let allocatorId: typeof ALWAYS_OK_ALLOCATOR | typeof POLYMER_ALLOCATOR =
-		$state(POLYMER_ALLOCATOR);
-	let inputSettler: typeof INPUT_SETTLER_COMPACT_LIFI | typeof INPUT_SETTLER_ESCROW_LIFI =
-		$state(INPUT_SETTLER_ESCROW_LIFI);
+	const preHook = (chain: chain) => store.setWalletToCorrectChain(chain);
+	const postHook = async () => store.forceUpdate();
+	const account = () => store.connectedAccount?.address!;
 
-	let verifier: Verifier = $state("polymer");
-
-	// Filling Orders
-	let selectedOrder: OrderContainer | undefined = $state(undefined);
-	let fillTransactionHash: `0x${string}` | undefined = $state(undefined);
-
-	let showTokenSelector: {
-		active: number;
-		input: boolean;
-		index: number;
-	} = $state({
-		active: 0,
-		input: true,
-		index: 0
-	});
-
-	let updatedDerived = $state(0);
-	setInterval(() => {
-		updatedDerived += 1;
-	}, 10000);
-	const forceUpdate = () => {
-		updatedDerived += 1;
-	};
-
-	function mapOverCoins<T>(
-		func: (
-			user: `0x${string}` | undefined,
-			asset: `0x${string}`,
-			client: (typeof clients)[keyof typeof clients]
-		) => T,
-		isMainnet: boolean,
-		_: any
-	) {
-		const resolved: Record<chain, Record<`0x${string}`, T>> = {} as any;
-		for (const token of coinList(isMainnet)) {
-			// Check whether we have me the chain before.
-			if (!resolved[token.chain as chain]) resolved[token.chain] = {};
-
-			resolved[token.chain][token.address] = func(
-				connectedAccount?.address,
-				token.address,
-				clients[token.chain]
-			);
-		}
-		return resolved;
-	}
-
-	const balances = $derived.by(() => {
-		return mapOverCoins(getBalance, mainnet, updatedDerived);
-	});
-
-	const allowances = $derived.by(() => {
-		return mapOverCoins(
-			getAllowance(inputSettler == INPUT_SETTLER_COMPACT_LIFI ? COMPACT : inputSettler),
-			mainnet,
-			updatedDerived
-		);
-	});
-
-	const compactBalances = $derived.by(() => {
-		return mapOverCoins(
-			(
-				user: `0x${string}` | undefined,
-				asset: `0x${string}`,
-				client: (typeof clients)[keyof typeof clients]
-			) => getCompactBalance(user, asset, client, allocatorId),
-			mainnet,
-			updatedDerived
-		);
-	});
+	let selectedOrder = $state<OrderContainer | undefined>(undefined);
 
 	let snapContainer: HTMLDivElement;
 
@@ -225,7 +96,7 @@
 		return () => {
 			if (!snapContainer) return;
 			const scrollLeft = snapContainer.scrollLeft;
-			const width = snapContainer.clientWidth;
+			const width = snapContainer.clientWidth + 1;
 			snapContainer.scrollTo({
 				left: next ? scrollLeft + Number(next) * width : scrollLeft - width,
 				behavior: "smooth"
@@ -257,105 +128,36 @@
 					Preview by LI.FI
 				</a>
 
-				<!-- Asset Overlay -->
-				<TokenModal
-					bind:showTokenSelector
-					{mainnet}
-					{inputSettler}
-					{compactBalances}
-					{balances}
-					bind:inputTokens
-					bind:outputToken
-					bind:inputAmounts
-					bind:outputAmount
-				></TokenModal>
-				{#if !(!connectedAccount || !walletClient)}
+				{#if !(!store.connectedAccount || !store.walletClient)}
 					<!-- Right Button -->
 					<button
-						class="absolute top-1.5 left-[23rem] cursor-pointer rounded bg-sky-50 px-1"
+						class="absolute top-1.5 left-[23rem] z-50 cursor-pointer rounded bg-sky-50 px-1"
 						onclick={scroll(true)}
 					>
 						→
 					</button>
 					<!-- Back Button -->
 					<button
-						class="absolute top-1.5 left-[1rem] cursor-pointer rounded bg-sky-50 px-1"
+						class="absolute top-1.5 left-[1rem] z-50 cursor-pointer rounded bg-sky-50 px-1"
 						onclick={scroll(false)}
 					>
 						←
 					</button>
 				{/if}
 				<div class="flex h-full w-max flex-row">
-					{#if !connectedAccount || !walletClient}
+					{#if !store.connectedAccount || !store.walletClient}
 						<ConnectWallet {onboard}></ConnectWallet>
 					{:else}
-						<ManageDeposit
-							{scroll}
-							bind:inputSettler
-							bind:allocatorId
-							bind:inputNumber
-							bind:inputToken
-							bind:mainnet
-							{compactBalances}
-							{balances}
-							{allowances}
-							{walletClient}
-							{preHook}
-							{postHook}
-							{account}
-						></ManageDeposit>
-						<IssueIntent
-							{scroll}
-							bind:showTokenSelector
-							{inputSettler}
-							bind:exclusiveFor
-							{mainnet}
-							{allocatorId}
-							{inputAmounts}
-							{outputAmount}
-							{inputTokens}
-							{outputToken}
-							{verifier}
-							{compactBalances}
-							{balances}
-							{allowances}
-							{walletClient}
-							bind:orders
-							{preHook}
-							{postHook}
-							{account}
-						></IssueIntent>
-						<IntentList {scroll} bind:selectedOrder orderContainers={orders}></IntentList>
+						<ManageDeposit {scroll} {preHook} {postHook} {account}></ManageDeposit>
+						<IssueIntent {scroll} {preHook} {postHook} {account}></IssueIntent>
+						<IntentList {scroll} bind:selectedOrder orderContainers={store.orders}></IntentList>
 						{#if selectedOrder !== undefined}
 							<!-- <IntentDescription></IntentDescription> -->
-							<FillIntent
-								{scroll}
-								orderContainer={selectedOrder}
-								{walletClient}
-								{account}
-								{preHook}
-								{postHook}
-								bind:fillTransactionHash
+							<FillIntent {scroll} orderContainer={selectedOrder} {account} {preHook} {postHook}
 							></FillIntent>
-							{#if fillTransactionHash}
-								<ReceiveMessage
-									orderContainer={selectedOrder}
-									{walletClient}
-									{fillTransactionHash}
-									{account}
-									{preHook}
-									{postHook}
-									{mainnet}
-								></ReceiveMessage>
-								<Finalise
-									orderContainer={selectedOrder}
-									{walletClient}
-									{fillTransactionHash}
-									{preHook}
-									{postHook}
-									{account}
-								></Finalise>
-							{/if}
+							<ReceiveMessage orderContainer={selectedOrder} {account} {preHook} {postHook}
+							></ReceiveMessage>
+							<Finalise orderContainer={selectedOrder} {preHook} {postHook} {account}></Finalise>
 						{/if}
 					{/if}
 				</div>
diff --git a/src/types/index.ts b/src/types/index.ts
index e95bf8a..bf774de 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -34,11 +34,25 @@ export type BatchCompact = {
 	arbiter: `0x${string}`; // The account tasked with verifying and submitting the claim.
 	sponsor: `0x${string}`; // The account to source the tokens from.
 	nonce: bigint; // A parameter to enforce replay protection, scoped to allocator.
-	expires: number; // The time at which the claim expires.
+	expires: bigint; // The time at which the claim expires.
 	commitments: Lock[]; // The allocated token IDs and amounts.
 	mandate: CompactMandate;
 };
 
+export type Element = {
+	arbiter: `0x${string}`;
+	chainId: bigint;
+	commitments: Lock[];
+	mandate: CompactMandate;
+};
+export type MultichainCompact = {
+	sponsor: `0x${string}`; // The account tasked with verifying and submitting the claim.
+	nonce: bigint; // A parameter to enforce replay protection, scoped to allocator.
+	expires: bigint; // The time at which the claim expires.
+	elements: Element[];
+	mandate: CompactMandate;
+};
+
 export type StandardOrder = {
 	user: `0x${string}`;
 	nonce: bigint;
@@ -85,7 +99,7 @@ export type Signature = {
 
 export type OrderContainer = {
 	inputSettler: `0x${string}`;
-	order: StandardOrder;
+	order: StandardOrder | MultichainOrder;
 	sponsorSignature: Signature | NoSignature;
 	allocatorSignature: Signature | NoSignature;
 };