diff --git a/packages/bridge-ui/.env.example b/packages/bridge-ui/.env.example
index 35a9b244252..68003b3861c 100644
--- a/packages/bridge-ui/.env.example
+++ b/packages/bridge-ui/.env.example
@@ -34,4 +34,7 @@ export CONFIGURED_RELAYER=
 export CONFIGURED_EVENT_INDEXER=
 
 # Show the slow L1 bridging warning
-export PUBLIC_SLOW_L1_BRIDGING_WARNING=false
\ No newline at end of file
+export PUBLIC_SLOW_L1_BRIDGING_WARNING=false
+
+# Fees
+export PUBLIC_BASE_FEE_MULTIPLIER = 
\ No newline at end of file
diff --git a/packages/bridge-ui/__mocks__/$customToken.ts b/packages/bridge-ui/__mocks__/$customToken.ts
index f30b01fee2e..eabf9987a71 100644
--- a/packages/bridge-ui/__mocks__/$customToken.ts
+++ b/packages/bridge-ui/__mocks__/$customToken.ts
@@ -1,29 +1,3 @@
-import { zeroAddress } from 'viem';
+import { MOCK_ERC20, MOCK_ERC721 } from './../src/tests/mocks/tokens';
 
-const mockERC20 = {
-  name: 'MockERC20',
-  addresses: { '1': zeroAddress },
-  symbol: 'MTF',
-  decimals: 18,
-  type: 'ERC20',
-};
-
-const mockERC1155 = {
-  name: 'MockERC1155',
-  addresses: { '1': zeroAddress },
-  symbol: 'MNFT',
-  balance: 1337n,
-  tokenId: 123,
-  uri: 'some/uri/123',
-  type: 'ERC1155',
-};
-
-const mockERC721 = {
-  name: 'MockERC721',
-  addresses: { '1': zeroAddress },
-  symbol: 'MNFT',
-  decimals: 18,
-  type: 'ERC721',
-};
-
-export const customToken = [mockERC20, mockERC1155, mockERC721];
+export const customToken = [MOCK_ERC20, MOCK_ERC721, MOCK_ERC721];
diff --git a/packages/bridge-ui/src/abi/index.ts b/packages/bridge-ui/src/abi/index.ts
index 82687d42e8c..145ae25b2de 100644
--- a/packages/bridge-ui/src/abi/index.ts
+++ b/packages/bridge-ui/src/abi/index.ts
@@ -7,34 +7,31 @@ export const bridgeAbi = [
   {
     type: 'function',
     inputs: [],
-    name: 'acceptOwnership',
-    outputs: [],
-    stateMutability: 'nonpayable',
-  },
-  {
-    type: 'function',
-    inputs: [{ name: 'addr', internalType: 'address', type: 'address' }],
-    name: 'addressBanned',
-    outputs: [{ name: 'banned', internalType: 'bool', type: 'bool' }],
+    name: 'GAS_OVERHEAD',
+    outputs: [{ name: '', internalType: 'uint32', type: 'uint32' }],
     stateMutability: 'view',
   },
   {
     type: 'function',
     inputs: [],
-    name: 'addressManager',
-    outputs: [{ name: '', internalType: 'address', type: 'address' }],
+    name: 'GAS_RESERVE',
+    outputs: [{ name: '', internalType: 'uint32', type: 'uint32' }],
     stateMutability: 'view',
   },
   {
     type: 'function',
-    inputs: [
-      { name: '_addr', internalType: 'address', type: 'address' },
-      { name: '_ban', internalType: 'bool', type: 'bool' },
-    ],
-    name: 'banAddress',
+    inputs: [],
+    name: 'acceptOwnership',
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'addressManager',
+    outputs: [{ name: '', internalType: 'address', type: 'address' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -55,17 +52,36 @@ export const bridgeAbi = [
   },
   {
     type: 'function',
-    inputs: [],
-    name: 'getInvocationDelays',
-    outputs: [
-      { name: 'invocationDelay_', internalType: 'uint256', type: 'uint256' },
+    inputs: [
       {
-        name: 'invocationExtraDelay_',
-        internalType: 'uint256',
-        type: 'uint256',
+        name: '_message',
+        internalType: 'struct IBridge.Message',
+        type: 'tuple',
+        components: [
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
+          { name: 'from', internalType: 'address', type: 'address' },
+          { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
+          { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
+          { name: 'destOwner', internalType: 'address', type: 'address' },
+          { name: 'to', internalType: 'address', type: 'address' },
+          { name: 'value', internalType: 'uint256', type: 'uint256' },
+          { name: 'data', internalType: 'bytes', type: 'bytes' },
+        ],
       },
     ],
-    stateMutability: 'view',
+    name: 'failMessage',
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    inputs: [{ name: 'dataLength', internalType: 'uint256', type: 'uint256' }],
+    name: 'getMessageMinGasLimit',
+    outputs: [{ name: '', internalType: 'uint32', type: 'uint32' }],
+    stateMutability: 'pure',
   },
   {
     type: 'function',
@@ -75,19 +91,17 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -105,6 +119,13 @@ export const bridgeAbi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'init2',
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
   {
     type: 'function',
     inputs: [{ name: '_chainId', internalType: 'uint64', type: 'uint64' }],
@@ -123,19 +144,71 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
+          { name: 'srcOwner', internalType: 'address', type: 'address' },
           { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
+          { name: 'destOwner', internalType: 'address', type: 'address' },
+          { name: 'to', internalType: 'address', type: 'address' },
+          { name: 'value', internalType: 'uint256', type: 'uint256' },
+          { name: 'data', internalType: 'bytes', type: 'bytes' },
+        ],
+      },
+      { name: '_proof', internalType: 'bytes', type: 'bytes' },
+    ],
+    name: 'isMessageFailed',
+    outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    inputs: [
+      {
+        name: '_message',
+        internalType: 'struct IBridge.Message',
+        type: 'tuple',
+        components: [
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
+          { name: 'from', internalType: 'address', type: 'address' },
+          { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
+          { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
+          { name: 'destOwner', internalType: 'address', type: 'address' },
+          { name: 'to', internalType: 'address', type: 'address' },
+          { name: 'value', internalType: 'uint256', type: 'uint256' },
+          { name: 'data', internalType: 'bytes', type: 'bytes' },
+        ],
+      },
+      { name: '_proof', internalType: 'bytes', type: 'bytes' },
+    ],
+    name: 'isMessageReceived',
+    outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    inputs: [
+      {
+        name: '_message',
+        internalType: 'struct IBridge.Message',
+        type: 'tuple',
+        components: [
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
+          { name: 'from', internalType: 'address', type: 'address' },
+          { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -143,6 +216,13 @@ export const bridgeAbi = [
     outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
     stateMutability: 'view',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'lastUnpausedAt',
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [{ name: 'msgHash', internalType: 'bytes32', type: 'bytes32' }],
@@ -156,7 +236,7 @@ export const bridgeAbi = [
     type: 'function',
     inputs: [],
     name: 'nextMessageId',
-    outputs: [{ name: '', internalType: 'uint128', type: 'uint128' }],
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
     stateMutability: 'view',
   },
   {
@@ -195,19 +275,17 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
       { name: '_proof', internalType: 'bytes', type: 'bytes' },
@@ -216,74 +294,6 @@ export const bridgeAbi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
-  {
-    type: 'function',
-    inputs: [{ name: 'msgHash', internalType: 'bytes32', type: 'bytes32' }],
-    name: 'proofReceipt',
-    outputs: [
-      { name: 'receivedAt', internalType: 'uint64', type: 'uint64' },
-      { name: 'preferredExecutor', internalType: 'address', type: 'address' },
-    ],
-    stateMutability: 'view',
-  },
-  {
-    type: 'function',
-    inputs: [
-      {
-        name: '_message',
-        internalType: 'struct IBridge.Message',
-        type: 'tuple',
-        components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
-          { name: 'from', internalType: 'address', type: 'address' },
-          { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'srcOwner', internalType: 'address', type: 'address' },
-          { name: 'destOwner', internalType: 'address', type: 'address' },
-          { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
-          { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
-          { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
-        ],
-      },
-      { name: '_proof', internalType: 'bytes', type: 'bytes' },
-    ],
-    name: 'proveMessageFailed',
-    outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
-    stateMutability: 'view',
-  },
-  {
-    type: 'function',
-    inputs: [
-      {
-        name: '_message',
-        internalType: 'struct IBridge.Message',
-        type: 'tuple',
-        components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
-          { name: 'from', internalType: 'address', type: 'address' },
-          { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'srcOwner', internalType: 'address', type: 'address' },
-          { name: 'destOwner', internalType: 'address', type: 'address' },
-          { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
-          { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
-          { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
-        ],
-      },
-      { name: '_proof', internalType: 'bytes', type: 'bytes' },
-    ],
-    name: 'proveMessageReceived',
-    outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
-    stateMutability: 'view',
-  },
   {
     type: 'function',
     inputs: [],
@@ -299,19 +309,17 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
       { name: '_proof', internalType: 'bytes', type: 'bytes' },
@@ -356,19 +364,17 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
       { name: '_isLastAttempt', internalType: 'bool', type: 'bool' },
@@ -385,19 +391,17 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -409,19 +413,17 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -434,16 +436,6 @@ export const bridgeAbi = [
     outputs: [{ name: '', internalType: 'bytes32', type: 'bytes32' }],
     stateMutability: 'pure',
   },
-  {
-    type: 'function',
-    inputs: [
-      { name: '_msgHashes', internalType: 'bytes32[]', type: 'bytes32[]' },
-      { name: '_suspend', internalType: 'bool', type: 'bool' },
-    ],
-    name: 'suspendMessages',
-    outputs: [],
-    stateMutability: 'nonpayable',
-  },
   {
     type: 'function',
     inputs: [{ name: 'newOwner', internalType: 'address', type: 'address' }],
@@ -477,15 +469,6 @@ export const bridgeAbi = [
     outputs: [],
     stateMutability: 'payable',
   },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
-      { name: 'addr', internalType: 'address', type: 'address', indexed: true },
-      { name: 'banned', internalType: 'bool', type: 'bool', indexed: false },
-    ],
-    name: 'AddressBanned',
-  },
   {
     type: 'event',
     anonymous: false,
@@ -526,32 +509,6 @@ export const bridgeAbi = [
     ],
     name: 'Initialized',
   },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
-      {
-        name: 'msgHash',
-        internalType: 'bytes32',
-        type: 'bytes32',
-        indexed: true,
-      },
-    ],
-    name: 'MessageExecuted',
-  },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
-      {
-        name: 'msgHash',
-        internalType: 'bytes32',
-        type: 'bytes32',
-        indexed: true,
-      },
-    ],
-    name: 'MessageRecalled',
-  },
   {
     type: 'event',
     anonymous: false,
@@ -567,38 +524,33 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
         indexed: false,
       },
-      { name: 'isRecall', internalType: 'bool', type: 'bool', indexed: false },
-    ],
-    name: 'MessageReceived',
-  },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
       {
-        name: 'msgHash',
-        internalType: 'bytes32',
-        type: 'bytes32',
-        indexed: true,
+        name: 'stats',
+        internalType: 'struct Bridge.ProcessingStats',
+        type: 'tuple',
+        components: [
+          { name: 'gasUsedInFeeCalc', internalType: 'uint32', type: 'uint32' },
+          { name: 'proofSize', internalType: 'uint32', type: 'uint32' },
+          { name: 'numCacheOps', internalType: 'uint32', type: 'uint32' },
+        ],
+        indexed: false,
       },
     ],
-    name: 'MessageRetried',
+    name: 'MessageProcessed',
   },
   {
     type: 'event',
@@ -615,19 +567,17 @@ export const bridgeAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
         indexed: false,
       },
@@ -653,20 +603,6 @@ export const bridgeAbi = [
     ],
     name: 'MessageStatusChanged',
   },
-  {
-    type: 'event',
-    anonymous: false,
-    inputs: [
-      {
-        name: 'msgHash',
-        internalType: 'bytes32',
-        type: 'bytes32',
-        indexed: false,
-      },
-      { name: 'suspended', internalType: 'bool', type: 'bool', indexed: false },
-    ],
-    name: 'MessageSuspended',
-  },
   {
     type: 'event',
     anonymous: false,
@@ -744,19 +680,18 @@ export const bridgeAbi = [
     ],
     name: 'Upgraded',
   },
+  { type: 'error', inputs: [], name: 'B_INSUFFICIENT_GAS' },
   { type: 'error', inputs: [], name: 'B_INVALID_CHAINID' },
   { type: 'error', inputs: [], name: 'B_INVALID_CONTEXT' },
+  { type: 'error', inputs: [], name: 'B_INVALID_FEE' },
   { type: 'error', inputs: [], name: 'B_INVALID_GAS_LIMIT' },
   { type: 'error', inputs: [], name: 'B_INVALID_STATUS' },
   { type: 'error', inputs: [], name: 'B_INVALID_USER' },
   { type: 'error', inputs: [], name: 'B_INVALID_VALUE' },
-  { type: 'error', inputs: [], name: 'B_INVOCATION_TOO_EARLY' },
   { type: 'error', inputs: [], name: 'B_MESSAGE_NOT_SENT' },
-  { type: 'error', inputs: [], name: 'B_NON_RETRIABLE' },
-  { type: 'error', inputs: [], name: 'B_NOT_FAILED' },
-  { type: 'error', inputs: [], name: 'B_NOT_RECEIVED' },
   { type: 'error', inputs: [], name: 'B_PERMISSION_DENIED' },
-  { type: 'error', inputs: [], name: 'B_STATUS_MISMATCH' },
+  { type: 'error', inputs: [], name: 'B_RETRY_FAILED' },
+  { type: 'error', inputs: [], name: 'B_SIGNAL_NOT_RECEIVED' },
   { type: 'error', inputs: [], name: 'ETH_TRANSFER_FAILED' },
   { type: 'error', inputs: [], name: 'INVALID_PAUSE_STATUS' },
   { type: 'error', inputs: [], name: 'REENTRANT_CALL' },
@@ -836,20 +771,6 @@ export const crossChainSyncAbi = [
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export const erc1155VaultAbi = [
-  {
-    type: 'function',
-    inputs: [],
-    name: 'ERC1155_INTERFACE_ID',
-    outputs: [{ name: '', internalType: 'bytes4', type: 'bytes4' }],
-    stateMutability: 'view',
-  },
-  {
-    type: 'function',
-    inputs: [],
-    name: 'ERC721_INTERFACE_ID',
-    outputs: [{ name: '', internalType: 'bytes4', type: 'bytes4' }],
-    stateMutability: 'view',
-  },
   {
     type: 'function',
     inputs: [],
@@ -903,6 +824,13 @@ export const erc1155VaultAbi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'lastUnpausedAt',
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -951,19 +879,17 @@ export const erc1155VaultAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
       { name: 'msgHash', internalType: 'bytes32', type: 'bytes32' },
@@ -1046,13 +972,11 @@ export const erc1155VaultAbi = [
           { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
           { name: 'token', internalType: 'address', type: 'address' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'tokenIds', internalType: 'uint256[]', type: 'uint256[]' },
           { name: 'amounts', internalType: 'uint256[]', type: 'uint256[]' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -1063,19 +987,17 @@ export const erc1155VaultAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -1086,7 +1008,7 @@ export const erc1155VaultAbi = [
     inputs: [{ name: 'interfaceId', internalType: 'bytes4', type: 'bytes4' }],
     name: 'supportsInterface',
     outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
-    stateMutability: 'view',
+    stateMutability: 'pure',
   },
   {
     type: 'function',
@@ -1507,6 +1429,13 @@ export const erc20VaultAbi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'lastUnpausedAt',
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -1529,19 +1458,17 @@ export const erc20VaultAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
       { name: '_msgHash', internalType: 'bytes32', type: 'bytes32' },
@@ -1624,12 +1551,10 @@ export const erc20VaultAbi = [
           { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
           { name: 'token', internalType: 'address', type: 'address' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'amount', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -1640,19 +1565,17 @@ export const erc20VaultAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -1663,7 +1586,7 @@ export const erc20VaultAbi = [
     inputs: [{ name: '_interfaceId', internalType: 'bytes4', type: 'bytes4' }],
     name: 'supportsInterface',
     outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
-    stateMutability: 'view',
+    stateMutability: 'pure',
   },
   {
     type: 'function',
@@ -2047,20 +1970,6 @@ export const erc20VaultAbi = [
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export const erc721VaultAbi = [
-  {
-    type: 'function',
-    inputs: [],
-    name: 'ERC1155_INTERFACE_ID',
-    outputs: [{ name: '', internalType: 'bytes4', type: 'bytes4' }],
-    stateMutability: 'view',
-  },
-  {
-    type: 'function',
-    inputs: [],
-    name: 'ERC721_INTERFACE_ID',
-    outputs: [{ name: '', internalType: 'bytes4', type: 'bytes4' }],
-    stateMutability: 'view',
-  },
   {
     type: 'function',
     inputs: [],
@@ -2114,6 +2023,13 @@ export const erc721VaultAbi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'lastUnpausedAt',
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -2148,19 +2064,17 @@ export const erc721VaultAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
       { name: '_msgHash', internalType: 'bytes32', type: 'bytes32' },
@@ -2243,13 +2157,11 @@ export const erc721VaultAbi = [
           { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
           { name: 'token', internalType: 'address', type: 'address' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'tokenIds', internalType: 'uint256[]', type: 'uint256[]' },
           { name: 'amounts', internalType: 'uint256[]', type: 'uint256[]' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -2260,19 +2172,17 @@ export const erc721VaultAbi = [
         internalType: 'struct IBridge.Message',
         type: 'tuple',
         components: [
-          { name: 'id', internalType: 'uint128', type: 'uint128' },
+          { name: 'id', internalType: 'uint64', type: 'uint64' },
+          { name: 'fee', internalType: 'uint64', type: 'uint64' },
+          { name: 'gasLimit', internalType: 'uint32', type: 'uint32' },
           { name: 'from', internalType: 'address', type: 'address' },
           { name: 'srcChainId', internalType: 'uint64', type: 'uint64' },
-          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'srcOwner', internalType: 'address', type: 'address' },
+          { name: 'destChainId', internalType: 'uint64', type: 'uint64' },
           { name: 'destOwner', internalType: 'address', type: 'address' },
           { name: 'to', internalType: 'address', type: 'address' },
-          { name: 'refundTo', internalType: 'address', type: 'address' },
           { name: 'value', internalType: 'uint256', type: 'uint256' },
-          { name: 'fee', internalType: 'uint256', type: 'uint256' },
-          { name: 'gasLimit', internalType: 'uint256', type: 'uint256' },
           { name: 'data', internalType: 'bytes', type: 'bytes' },
-          { name: 'memo', internalType: 'string', type: 'string' },
         ],
       },
     ],
@@ -2283,7 +2193,7 @@ export const erc721VaultAbi = [
     inputs: [{ name: '_interfaceId', internalType: 'bytes4', type: 'bytes4' }],
     name: 'supportsInterface',
     outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
-    stateMutability: 'view',
+    stateMutability: 'pure',
   },
   {
     type: 'function',
@@ -2674,6 +2584,16 @@ export const erc1155Abi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'canonical',
+    outputs: [
+      { name: '', internalType: 'address', type: 'address' },
+      { name: '', internalType: 'uint256', type: 'uint256' },
+    ],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [
@@ -2698,6 +2618,13 @@ export const erc1155Abi = [
     outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
     stateMutability: 'view',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'lastUnpausedAt',
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [
@@ -3112,6 +3039,13 @@ export const erc1155Abi = [
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export const erc20Abi = [
+  {
+    type: 'function',
+    inputs: [],
+    name: 'CLOCK_MODE',
+    outputs: [{ name: '', internalType: 'string', type: 'string' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -3172,10 +3106,7 @@ export const erc20Abi = [
   },
   {
     type: 'function',
-    inputs: [
-      { name: '_account', internalType: 'address', type: 'address' },
-      { name: '_amount', internalType: 'uint256', type: 'uint256' },
-    ],
+    inputs: [{ name: '_amount', internalType: 'uint256', type: 'uint256' }],
     name: 'burn',
     outputs: [],
     stateMutability: 'nonpayable',
@@ -3220,6 +3151,13 @@ export const erc20Abi = [
     ],
     stateMutability: 'view',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'clock',
+    outputs: [{ name: '', internalType: 'uint48', type: 'uint48' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -3267,7 +3205,22 @@ export const erc20Abi = [
   },
   {
     type: 'function',
-    inputs: [{ name: 'blockNumber', internalType: 'uint256', type: 'uint256' }],
+    inputs: [],
+    name: 'eip712Domain',
+    outputs: [
+      { name: 'fields', internalType: 'bytes1', type: 'bytes1' },
+      { name: 'name', internalType: 'string', type: 'string' },
+      { name: 'version', internalType: 'string', type: 'string' },
+      { name: 'chainId', internalType: 'uint256', type: 'uint256' },
+      { name: 'verifyingContract', internalType: 'address', type: 'address' },
+      { name: 'salt', internalType: 'bytes32', type: 'bytes32' },
+      { name: 'extensions', internalType: 'uint256[]', type: 'uint256[]' },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    inputs: [{ name: 'timepoint', internalType: 'uint256', type: 'uint256' }],
     name: 'getPastTotalSupply',
     outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
     stateMutability: 'view',
@@ -3276,7 +3229,7 @@ export const erc20Abi = [
     type: 'function',
     inputs: [
       { name: 'account', internalType: 'address', type: 'address' },
-      { name: 'blockNumber', internalType: 'uint256', type: 'uint256' },
+      { name: 'timepoint', internalType: 'uint256', type: 'uint256' },
     ],
     name: 'getPastVotes',
     outputs: [{ name: '', internalType: 'uint256', type: 'uint256' }],
@@ -3314,6 +3267,13 @@ export const erc20Abi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'lastUnpausedAt',
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [],
@@ -3437,15 +3397,6 @@ export const erc20Abi = [
     outputs: [{ name: '', internalType: 'address payable', type: 'address' }],
     stateMutability: 'view',
   },
-  {
-    type: 'function',
-    inputs: [
-      { name: '_snapshooter', internalType: 'address', type: 'address' },
-    ],
-    name: 'setSnapshoter',
-    outputs: [],
-    stateMutability: 'nonpayable',
-  },
   {
     type: 'function',
     inputs: [],
@@ -3453,13 +3404,6 @@ export const erc20Abi = [
     outputs: [{ name: '', internalType: 'address', type: 'address' }],
     stateMutability: 'view',
   },
-  {
-    type: 'function',
-    inputs: [],
-    name: 'snapshot',
-    outputs: [],
-    stateMutability: 'nonpayable',
-  },
   {
     type: 'function',
     inputs: [],
@@ -3656,6 +3600,7 @@ export const erc20Abi = [
     ],
     name: 'DelegateVotesChanged',
   },
+  { type: 'event', anonymous: false, inputs: [], name: 'EIP712DomainChanged' },
   {
     type: 'event',
     anonymous: false,
@@ -3808,7 +3753,6 @@ export const erc20Abi = [
   { type: 'error', inputs: [], name: 'BB_PERMISSION_DENIED' },
   { type: 'error', inputs: [], name: 'BTOKEN_CANNOT_RECEIVE' },
   { type: 'error', inputs: [], name: 'BTOKEN_INVALID_PARAMS' },
-  { type: 'error', inputs: [], name: 'BTOKEN_UNAUTHORIZED' },
   { type: 'error', inputs: [], name: 'INVALID_PAUSE_STATUS' },
   { type: 'error', inputs: [], name: 'REENTRANT_CALL' },
   { type: 'error', inputs: [], name: 'RESOLVER_DENIED' },
@@ -3871,6 +3815,16 @@ export const erc721Abi = [
     outputs: [],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'canonical',
+    outputs: [
+      { name: '', internalType: 'address', type: 'address' },
+      { name: '', internalType: 'uint256', type: 'uint256' },
+    ],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [{ name: 'tokenId', internalType: 'uint256', type: 'uint256' }],
@@ -3902,6 +3856,13 @@ export const erc721Abi = [
     outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
     stateMutability: 'view',
   },
+  {
+    type: 'function',
+    inputs: [],
+    name: 'lastUnpausedAt',
+    outputs: [{ name: '', internalType: 'uint64', type: 'uint64' }],
+    stateMutability: 'view',
+  },
   {
     type: 'function',
     inputs: [
@@ -4523,7 +4484,9 @@ export const signalServiceAbi = [
       { name: '_proof', internalType: 'bytes', type: 'bytes' },
     ],
     name: 'proveSignalReceived',
-    outputs: [],
+    outputs: [
+      { name: 'numCacheOps_', internalType: 'uint256', type: 'uint256' },
+    ],
     stateMutability: 'nonpayable',
   },
   {
@@ -4556,6 +4519,18 @@ export const signalServiceAbi = [
     outputs: [{ name: 'signal_', internalType: 'bytes32', type: 'bytes32' }],
     stateMutability: 'nonpayable',
   },
+  {
+    type: 'function',
+    inputs: [
+      { name: '_chainId', internalType: 'uint64', type: 'uint64' },
+      { name: '_app', internalType: 'address', type: 'address' },
+      { name: '_signal', internalType: 'bytes32', type: 'bytes32' },
+      { name: '_proof', internalType: 'bytes', type: 'bytes' },
+    ],
+    name: 'verifySignalReceived',
+    outputs: [],
+    stateMutability: 'view',
+  },
   {
     type: 'event',
     anonymous: false,
diff --git a/packages/bridge-ui/src/app.config.ts b/packages/bridge-ui/src/app.config.ts
index 0afc7671bcc..4f147f0b621 100644
--- a/packages/bridge-ui/src/app.config.ts
+++ b/packages/bridge-ui/src/app.config.ts
@@ -1,4 +1,5 @@
 export const recommendProcessingFeeConfig = {
+  GAS_RESERVE: 650_000, // based on Bridge.sol
   ethGasLimit: BigInt(900_000),
   erc20NotDeployedGasLimit: BigInt(1_650_000),
   erc20DeployedGasLimit: BigInt(1_100_000),
@@ -39,7 +40,7 @@ export const bridgeTransactionPoller = {
 };
 
 export const claimConfig = {
-  minimumEthToClaim: 0.0001,
+  minimumEthToClaim: 0.001,
 };
 
 export const transactionConfig = {
diff --git a/packages/bridge-ui/src/components/Bridge/FungibleBridgeComponents/ImportStep/TokenInput/TokenInput.svelte b/packages/bridge-ui/src/components/Bridge/FungibleBridgeComponents/ImportStep/TokenInput/TokenInput.svelte
index 9f24c23da4c..8f81bbb7da8 100644
--- a/packages/bridge-ui/src/components/Bridge/FungibleBridgeComponents/ImportStep/TokenInput/TokenInput.svelte
+++ b/packages/bridge-ui/src/components/Bridge/FungibleBridgeComponents/ImportStep/TokenInput/TokenInput.svelte
@@ -25,8 +25,7 @@
   import { OnNetwork } from '$components/OnNetwork';
   import { TokenDropdown } from '$components/TokenDropdown';
   import { getMaxAmountToBridge } from '$libs/bridge';
-  import { UnknownTokenTypeError } from '$libs/error';
-  import { fetchBalance, tokens, TokenType } from '$libs/token';
+  import { fetchBalance, tokens } from '$libs/token';
   import { refreshUserBalance, renderBalance } from '$libs/util/balance';
   import { debounce } from '$libs/util/debounce';
   import { getLogger } from '$libs/util/logger';
@@ -70,30 +69,6 @@
       return;
     }
 
-    if (!$tokenBalance) {
-      $tokenBalance = await fetchBalance({ userAddress: user, token, srcChainId: $connectedSourceChain?.id });
-      if (!$tokenBalance?.value) {
-        $insufficientBalance = true;
-        $validatingAmount = false;
-      }
-    }
-
-    switch (token.type) {
-      case TokenType.ERC20:
-      case TokenType.ERC1155:
-        if ($tokenBalance?.value && ($ethBalance <= 0n || $enteredAmount > $tokenBalance?.value)) {
-          $insufficientBalance = true;
-        }
-        break;
-      case TokenType.ETH:
-      case TokenType.ERC721:
-        if ($enteredAmount >= $ethBalance) {
-          $insufficientBalance = true;
-        }
-        break;
-      default:
-        throw new UnknownTokenTypeError();
-    }
     $validatingAmount = false;
     $computingBalance = false;
   }
@@ -105,22 +80,7 @@
     $validatingAmount = true;
     $errorComputingBalance = false;
 
-    if ($selectedToken.type === TokenType.ERC1155) {
-      // For ERC1155, no decimals are allowed
-      if (/[.,]/.test(value)) {
-        $errorComputingBalance = true;
-        return;
-      }
-    }
-    if (
-      $selectedToken.type !== TokenType.ERC1155 &&
-      $selectedToken.type !== TokenType.ERC721 &&
-      !$selectedToken.decimals
-    ) {
-      $enteredAmount = BigInt(value);
-    } else {
-      $enteredAmount = parseUnits(value, $selectedToken.decimals);
-    }
+    $enteredAmount = parseUnits(value, $selectedToken.decimals);
     debouncedValidateAmount();
   };
 
@@ -156,15 +116,14 @@
     $computingBalance = true;
     value = '';
     $enteredAmount = 0n;
-    if ($account && $account.address && $account?.isConnected) {
+    if ($account && $account.address && $account?.isConnected && $selectedToken) {
       validateAmount($selectedToken);
       refreshUserBalance();
-      if ($selectedToken)
-        $tokenBalance = await fetchBalance({
-          userAddress: $account.address,
-          token: $selectedToken,
-          srcChainId: $connectedSourceChain?.id,
-        });
+      $tokenBalance = await fetchBalance({
+        userAddress: $account.address,
+        token: $selectedToken,
+        srcChainId: $connectedSourceChain?.id,
+      });
       previousSelectedToken = $selectedToken;
     } else {
       balance = '0.00';
diff --git a/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ManualImport.svelte b/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ManualImport.svelte
index 323c702e4ce..92ecb6f7e24 100644
--- a/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ManualImport.svelte
+++ b/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ManualImport.svelte
@@ -5,11 +5,11 @@
   import { FlatAlert } from '$components/Alert';
   import IdInput from '$components/Bridge/NFTBridgeComponents/IDInput/IDInput.svelte';
   import { IDInputState } from '$components/Bridge/NFTBridgeComponents/IDInput/state';
+  import TokenAmountInput from '$components/Bridge/NFTBridgeComponents/ImportStep/TokenAmountInput.svelte';
   import AddressInput from '$components/Bridge/SharedBridgeComponents/AddressInput/AddressInput.svelte';
   import { AddressInputState } from '$components/Bridge/SharedBridgeComponents/AddressInput/state';
   import { enteredAmount, selectedNFTs, selectedToken, tokenBalance } from '$components/Bridge/state';
   import { importDone } from '$components/Bridge/state';
-  import TokenAmountInput from '$components/Bridge/TokenAmountInput.svelte';
   import { detectContractType, type NFT, TokenType } from '$libs/token';
   import { checkOwnership } from '$libs/token/checkOwnership';
   import { getTokenWithInfoFromAddress } from '$libs/token/getTokenWithInfoFromAddress';
diff --git a/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ScannedImport.svelte b/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ScannedImport.svelte
index 1f3975fac37..3743a9a6c56 100644
--- a/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ScannedImport.svelte
+++ b/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/ScannedImport.svelte
@@ -2,8 +2,8 @@
   import { onMount } from 'svelte';
   import { t } from 'svelte-i18n';
 
+  import TokenAmountInput from '$components/Bridge/NFTBridgeComponents/ImportStep/TokenAmountInput.svelte';
   import { enteredAmount, selectedNFTs, tokenBalance } from '$components/Bridge/state';
-  import TokenAmountInput from '$components/Bridge/TokenAmountInput.svelte';
   import { ImportMethod } from '$components/Bridge/types';
   import { ActionButton, Button } from '$components/Button';
   import { IconFlipper } from '$components/Icon';
diff --git a/packages/bridge-ui/src/components/Bridge/TokenAmountInput.svelte b/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/TokenAmountInput.svelte
similarity index 97%
rename from packages/bridge-ui/src/components/Bridge/TokenAmountInput.svelte
rename to packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/TokenAmountInput.svelte
index d5a92e927b5..e37cd4030ae 100644
--- a/packages/bridge-ui/src/components/Bridge/TokenAmountInput.svelte
+++ b/packages/bridge-ui/src/components/Bridge/NFTBridgeComponents/ImportStep/TokenAmountInput.svelte
@@ -8,7 +8,6 @@
   import { warningToast } from '$components/NotificationToast';
   import { InvalidParametersProvidedError, UnknownTokenTypeError } from '$libs/error';
   import { ETHToken, fetchBalance, fetchBalance as getTokenBalance, TokenType } from '$libs/token';
-  import { renderBalance } from '$libs/util/balance';
   import { debounce } from '$libs/util/debounce';
   import { getLogger } from '$libs/util/logger';
   import { uid } from '$libs/util/uid';
@@ -27,7 +26,7 @@
     selectedToken,
     tokenBalance,
     validatingAmount,
-  } from './state';
+  } from '../../state';
 
   const log = getLogger('component:Amount');
 
@@ -212,7 +211,7 @@
           {#if computingMaxAmount}
             <LoadingText mask={$tokenBalance?.toString() || '100'} />
           {:else}
-            {renderBalance($tokenBalance)}
+            <!-- {renderBalance($tokenBalance)} -->
           {/if}
         </span>
       {/if}
@@ -231,7 +230,6 @@
         on:input={inputAmount}
         bind:this={inputBox}
         class="py-6 pr-16 px-[26px] title-subsection-bold border-0  {$$props.class}" />
-      <!-- TODO: talk to Jane about the MAX button and its styling -->
       {#if maxButtonEnabled}
         <button class="absolute right-6 uppercase hover:font-bold" on:click={useMaxAmount}>
           {$t('inputs.amount.button.max')}
diff --git a/packages/bridge-ui/src/components/Bridge/SharedBridgeComponents/ConfirmationStep/ConfirmationStep.svelte b/packages/bridge-ui/src/components/Bridge/SharedBridgeComponents/ConfirmationStep/ConfirmationStep.svelte
index 5fdd86fc1d6..b7c42ae6310 100644
--- a/packages/bridge-ui/src/components/Bridge/SharedBridgeComponents/ConfirmationStep/ConfirmationStep.svelte
+++ b/packages/bridge-ui/src/components/Bridge/SharedBridgeComponents/ConfirmationStep/ConfirmationStep.svelte
@@ -170,6 +170,7 @@
         srcChainId: $connectedSourceChain.id,
         destChainId: $destNetwork?.id,
         fee: $processingFee,
+        tokenObject: $selectedToken,
       };
 
       const type: TokenType = $selectedToken.type;
@@ -178,7 +179,7 @@
         if (!tokenIds) throw new Error('tokenIds not found');
         const bridgeArgs = await getBridgeArgs($selectedToken, $enteredAmount, commonArgs, tokenIds);
 
-        const args = { ...bridgeArgs, tokenIds };
+        const args = { ...bridgeArgs, tokenIds, tokenObject: $selectedToken };
 
         bridgeTxHash = await $bridgeService.bridge(args);
       } else {
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/Claim.svelte b/packages/bridge-ui/src/components/Dialogs/Claim.svelte
similarity index 62%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/Claim.svelte
rename to packages/bridge-ui/src/components/Dialogs/Claim.svelte
index 53f0058d8d9..29ac2070a30 100644
--- a/packages/bridge-ui/src/components/Transactions/Dialogs/Claim.svelte
+++ b/packages/bridge-ui/src/components/Dialogs/Claim.svelte
@@ -13,23 +13,37 @@
 
   import { selectedRetryMethod } from './RetryDialog/state';
   import { RETRY_OPTION } from './RetryDialog/types';
+  import { ClaimAction } from './Shared/types';
 
   const dispatch = createEventDispatcher();
 
   export let bridgeTx: BridgeTransaction;
 
-  async function ensureCorrectChain(currentChainId: number, wannaBeChainId: number) {
-    const isCorrectChain = currentChainId === wannaBeChainId;
+  async function ensureCorrectChain(action: ClaimAction) {
+    const currentChainId = Number($connectedSourceChain.id);
+    const txDestChain = Number(bridgeTx.destChainId);
+    const txSrcChain = Number(bridgeTx.srcChainId);
+
+    let isCorrectChain: boolean;
+    let expectedChainId: number;
+
+    if (action === ClaimAction.RELEASE) {
+      // If we are releasing, we need to be on the source chain
+      expectedChainId = txSrcChain;
+    } else {
+      expectedChainId = txDestChain;
+    }
+
+    isCorrectChain = currentChainId === expectedChainId;
+
     log(`Are we on the correct chain? ${isCorrectChain}`);
 
     if (!isCorrectChain) {
-      // TODO: shouldn't we inform the user about this change? wallet will popup,
-      //       but it's not clear why
-      await switchChain(config, { chainId: wannaBeChainId });
+      await switchChain(config, { chainId: expectedChainId });
     }
   }
 
-  export const claim = async () => {
+  export const claim = async (action: ClaimAction) => {
     if (!$account.address) {
       throw new NotConnectedError('User is not connected');
     }
@@ -42,7 +56,7 @@
       }
 
       // Step 1: make sure the user is on the correct chain
-      await ensureCorrectChain(Number($connectedSourceChain.id), Number(bridgeTx.destChainId));
+      await ensureCorrectChain(action);
 
       // Step 2: Find out the type of bridge: ETHBridge, ERC20Bridge, etc
       const bridge = bridges[bridgeTx.tokenType];
@@ -56,14 +70,14 @@
       let txHash: Hash;
       if ($selectedRetryMethod === RETRY_OPTION.RETRY_ONCE) {
         log('Claiming with lastAttempt flag');
-        txHash = await bridge.claim({ wallet, bridgeTx, lastAttempt: true });
+        txHash = await bridge.processMessage({ wallet, bridgeTx, lastAttempt: true });
       } else {
-        txHash = await bridge.claim({ wallet, bridgeTx });
+        txHash = await bridge.processMessage({ wallet, bridgeTx });
       }
 
-      dispatch('claimingTxSent', { txHash, type: 'claim' });
+      dispatch('claimingTxSent', { txHash, action });
     } catch (err) {
-      dispatch('error', { error: err, action: 'claim' });
+      dispatch('error', { error: err, action });
     }
   };
 </script>
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimDialog.svelte b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimDialog.svelte
similarity index 67%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimDialog.svelte
rename to packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimDialog.svelte
index d76caa71787..a16a9a7ba1b 100644
--- a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimDialog.svelte
+++ b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimDialog.svelte
@@ -1,10 +1,11 @@
 <script lang="ts">
   import { createEventDispatcher } from 'svelte';
   import { t } from 'svelte-i18n';
-  import { ContractFunctionExecutionError, type Hash, UserRejectedRequestError, zeroAddress } from 'viem';
+  import { ContractFunctionExecutionError, type Hash, UserRejectedRequestError } from 'viem';
 
   import { chainConfig } from '$chainConfig';
   import { CloseButton } from '$components/Button';
+  import Claim from '$components/Dialogs/Claim.svelte';
   import {
     errorToast,
     infoToast,
@@ -12,10 +13,7 @@
     warningToast,
   } from '$components/NotificationToast/NotificationToast.svelte';
   import OnAccount from '$components/OnAccount/OnAccount.svelte';
-  import Claim from '$components/Transactions/Dialogs/Claim.svelte';
-  import { getInvocationDelaysForDestBridge } from '$libs/bridge/getInvocationDelaysForDestBridge';
-  import { getProofReceiptForMsgHash } from '$libs/bridge/getProofReceiptForMsgHash';
-  import type { BridgeTransaction, GetProofReceiptResponse } from '$libs/bridge/types';
+  import type { BridgeTransaction } from '$libs/bridge/types';
   import {
     InsufficientBalanceError,
     InvalidProofError,
@@ -23,19 +21,18 @@
     ProcessMessageError,
     RetryError,
   } from '$libs/error';
-  import type { startPolling } from '$libs/polling/messageStatusPoller';
   import type { NFT } from '$libs/token';
   import { getLogger } from '$libs/util/logger';
   import { uid } from '$libs/util/uid';
   import { connectedSourceChain } from '$stores/network';
   import { pendingTransactions } from '$stores/pendingTransactions';
 
+  import { ClaimConfirmStep, ReviewStep } from '../Shared';
+  import { ClaimAction } from '../Shared/types';
   import { DialogStep, DialogStepper } from '../Stepper';
   import ClaimStepNavigation from './ClaimStepNavigation.svelte';
-  import ClaimConfirmStep from './ClaimSteps/ClaimConfirmStep.svelte';
   import ClaimPreCheck from './ClaimSteps/ClaimPreCheck.svelte';
-  import ClaimReviewStep from './ClaimSteps/ClaimReviewStep.svelte';
-  import { ClaimSteps, ClaimTypes, INITIAL_STEP, TWO_STEP_STATE } from './types';
+  import { ClaimSteps, INITIAL_STEP } from './types';
 
   const log = getLogger('ClaimDialog');
 
@@ -44,23 +41,17 @@
 
   export let dialogOpen = false;
 
-  export let polling: ReturnType<typeof startPolling>;
-
-  export let delays: readonly bigint[];
-
   export let loading = false;
 
   export let nft: NFT | null = null;
 
-  export let proofReceipt: GetProofReceiptResponse;
-
   export let activeStep: ClaimSteps = INITIAL_STEP;
 
   export let bridgeTx: BridgeTransaction;
 
   export const handleClaimClick = async () => {
     claiming = true;
-    await ClaimComponent.claim();
+    await ClaimComponent.claim(ClaimAction.CLAIM);
   };
 
   let canContinue = false;
@@ -68,9 +59,10 @@
   let claimingDone = false;
   let ClaimComponent: Claim;
   let txHash: Hash;
+  let hideContinueButton: boolean;
 
   const handleAccountChange = () => {
-    activeStep = INITIAL_STEP;
+    reset();
   };
 
   const closeDialog = () => {
@@ -78,15 +70,15 @@
     reset();
   };
 
-  const handleClaimTxSent = async (event: CustomEvent<{ txHash: Hash; type: ClaimTypes }>) => {
-    const { txHash: transactionHash, type } = event.detail;
+  const handleClaimTxSent = async (event: CustomEvent<{ txHash: Hash; action: ClaimAction }>) => {
+    const { txHash: transactionHash, action } = event.detail;
     txHash = transactionHash;
-    log('handle claim tx sent', txHash, type);
+    log('handle claim tx sent', txHash, action);
     claiming = true;
 
     const explorer = chainConfig[Number(bridgeTx.destChainId)]?.blockExplorers?.default.url;
 
-    if (type === ClaimTypes.CLAIM) {
+    if (action === ClaimAction.CLAIM) {
       infoToast({
         title: $t('transactions.actions.claim.tx.title'),
         message: $t('transactions.actions.claim.tx.message', {
@@ -98,7 +90,7 @@
       });
       await pendingTransactions.add(txHash, Number(bridgeTx.destChainId));
     } else {
-      // TODO, retry, release etc.
+      // Retry
       infoToast({
         title: $t('transactions.actions.claim.tx.title'),
         message: $t('transactions.actions.claim.tx.message', {
@@ -115,28 +107,17 @@
 
     dispatch('claimingDone');
 
-    if (proveOrClaimStep === TWO_STEP_STATE.PROVE) {
-      successToast({
-        title: $t('transactions.actions.claim.success.title'),
-        message: $t('transactions.actions.claim.success.message', {
-          values: {
-            network: $connectedSourceChain.name,
-          },
-        }),
-      });
-    } else if (proveOrClaimStep === TWO_STEP_STATE.CLAIM) {
-      successToast({
-        title: $t('transactions.actions.claim.success.title'),
-        message: $t('transactions.actions.claim.success.message', {
-          values: {
-            network: $connectedSourceChain.name,
-          },
-        }),
-      });
-    }
+    successToast({
+      title: $t('transactions.actions.claim.success.title'),
+      message: $t('transactions.actions.claim.success.message', {
+        values: {
+          network: $connectedSourceChain.name,
+        },
+      }),
+    });
   };
 
-  const handleClaimError = (event: CustomEvent<{ error: unknown; type: ClaimTypes }>) => {
+  const handleClaimError = (event: CustomEvent<{ error: unknown; action: ClaimAction }>) => {
     //TODO: update this to display info alongside toasts
     const err = event.detail.error;
     switch (true) {
@@ -160,12 +141,7 @@
         break;
       case err instanceof ContractFunctionExecutionError:
         console.error(err);
-        if (err.message.includes('B_INVOCATION_TOO_EARLY')) {
-          errorToast({
-            title: $t('bridge.errors.claim.too_early.title'),
-            message: $t('bridge.errors.claim.too_early.message'),
-          });
-        } else if (err.message.includes('B_NOT_RECEIVED')) {
+        if (err.message.includes('B_NOT_RECEIVED')) {
           errorToast({
             title: $t('bridge.errors.claim.not_received.title'),
             message: $t('bridge.errors.claim.not_received.message'),
@@ -194,45 +170,11 @@
   };
 
   let checkingPrerequisites: boolean;
-  const fetchDelayAndReceipt = async () => {
-    checkingPrerequisites = true;
-
-    if (!proofReceipt) {
-      const receipt = await getProofReceiptForMsgHash({
-        msgHash: bridgeTx.msgHash,
-        srcChainId: bridgeTx.srcChainId,
-        destChainId: bridgeTx.destChainId,
-      });
-
-      if (receipt) {
-        proofReceipt = receipt;
-      }
-    }
-
-    if (!delays) {
-      delays = await getInvocationDelaysForDestBridge({
-        srcChainId: bridgeTx.srcChainId,
-        destChainId: bridgeTx.destChainId,
-      });
-    }
-    checkingPrerequisites = false;
-  };
 
   let previousStep: ClaimSteps;
   $: if (activeStep !== previousStep) {
     previousStep = activeStep;
-    fetchDelayAndReceipt();
   }
-  $: if (dialogOpen) {
-    fetchDelayAndReceipt();
-  }
-
-  $: proveOrClaimStep =
-    proofReceipt && proofReceipt[1] !== zeroAddress
-      ? TWO_STEP_STATE.CLAIM
-      : delays && delays[0] > 0n
-        ? TWO_STEP_STATE.PROVE
-        : TWO_STEP_STATE.CLAIM;
 </script>
 
 <dialog id={dialogId} class="modal" class:modal-open={dialogOpen}>
@@ -242,7 +184,6 @@
       <h3 class="title-body-bold">{$t('transactions.claim.steps.title')}</h3>
     </div>
     <div class="h-sep mx-[-24px] mt-[20px]" />
-
     <div class="w-full h-full f-col">
       <DialogStepper>
         <DialogStep
@@ -259,15 +200,9 @@
           isActive={activeStep === ClaimSteps.CONFIRM}>{$t('bridge.step.confirm.title')}</DialogStep>
       </DialogStepper>
       {#if activeStep === ClaimSteps.CHECK}
-        <ClaimPreCheck
-          tx={bridgeTx}
-          bind:canContinue
-          bind:proofReceipt
-          {polling}
-          bridgeDelays={delays}
-          {checkingPrerequisites} />
+        <ClaimPreCheck tx={bridgeTx} bind:canContinue {checkingPrerequisites} bind:hideContinueButton />
       {:else if activeStep === ClaimSteps.REVIEW}
-        <ClaimReviewStep tx={bridgeTx} {nft} />
+        <ReviewStep tx={bridgeTx} {nft} />
       {:else if activeStep === ClaimSteps.CONFIRM}
         <ClaimConfirmStep
           {bridgeTx}
@@ -275,8 +210,7 @@
           on:claim={handleClaimClick}
           bind:claiming
           bind:canClaim={canContinue}
-          bind:claimingDone
-          bind:proveOrClaimStep />
+          bind:claimingDone />
       {/if}
       <div class="f-col text-left self-end h-full w-full">
         <div class="f-col gap-4 mt-[20px]">
@@ -285,6 +219,7 @@
             bind:canContinue
             bind:loading
             bind:claiming
+            {hideContinueButton}
             on:closeDialog={closeDialog}
             bind:claimingDone />
         </div>
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimStepNavigation.svelte b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimStepNavigation.svelte
similarity index 89%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimStepNavigation.svelte
rename to packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimStepNavigation.svelte
index 04737022b73..8838da9be52 100644
--- a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimStepNavigation.svelte
+++ b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimStepNavigation.svelte
@@ -14,6 +14,7 @@
   export let canContinue = false;
   export let claimingDone = false;
   export let claiming = false;
+  export let hideContinueButton: boolean;
 
   const INITIAL_STEP = ClaimSteps.CHECK;
 
@@ -65,11 +66,12 @@
   }
 
   $: isNextStepDisabled =
-    !(activeStep === ClaimSteps.CHECK && canContinue) &&
-    (loading || (activeStep === ClaimSteps.CONFIRM && !claimingDone));
+    loading ||
+    (activeStep === ClaimSteps.CHECK && !canContinue) ||
+    (activeStep === ClaimSteps.CONFIRM && !claimingDone);
 </script>
 
-{#if (activeStep !== ClaimSteps.CONFIRM || claimingDone) && (activeStep !== ClaimSteps.CHECK || canContinue)}
+{#if (activeStep !== ClaimSteps.CONFIRM || claimingDone) && !hideContinueButton}
   <div class="h-sep" />
   <ActionButton onPopup priority="primary" disabled={isNextStepDisabled} {loading} on:click={handleNextStep}>
     {nextStepButtonText}
diff --git a/packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimSteps/ClaimPreCheck.svelte b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimSteps/ClaimPreCheck.svelte
new file mode 100644
index 00000000000..e6fc289fe35
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/ClaimSteps/ClaimPreCheck.svelte
@@ -0,0 +1,113 @@
+<script lang="ts">
+  import { getBalance, switchChain } from '@wagmi/core';
+  import { t } from 'svelte-i18n';
+  import { type Address, parseEther } from 'viem';
+
+  import { ActionButton } from '$components/Button';
+  import { Icon } from '$components/Icon';
+  import Spinner from '$components/Spinner/Spinner.svelte';
+  import { claimConfig } from '$config';
+  import type { BridgeTransaction } from '$libs/bridge';
+  import { getChainName } from '$libs/chain';
+  import { config } from '$libs/wagmi';
+  import { account } from '$stores/account';
+  import { connectedSourceChain, switchingNetwork } from '$stores/network';
+
+  export let tx: BridgeTransaction;
+  export let canContinue = false;
+  export let checkingPrerequisites: boolean;
+  export let hideContinueButton = false;
+
+  const switchChains = async () => {
+    $switchingNetwork = true;
+    try {
+      await switchChain(config, { chainId: Number(tx.destChainId) });
+    } catch (err) {
+      console.error(err);
+    } finally {
+      $switchingNetwork = false;
+    }
+  };
+
+  const checkEnoughBalance = async (address: Maybe<Address>, chainId: number) => {
+    if (!address) {
+      return false;
+    }
+    checkingPrerequisites = true;
+
+    const balance = await getBalance(config, { address, chainId });
+
+    if (balance.value <= parseEther(String(claimConfig.minimumEthToClaim))) {
+      hasEnoughEth = false;
+    } else {
+      hasEnoughEth = true;
+    }
+
+    checkingPrerequisites = false;
+  };
+
+  const checkConditions = async () => {
+    await checkEnoughBalance($account.address, Number(tx.destChainId));
+  };
+
+  $: txDestChainName = getChainName(Number(tx.destChainId));
+
+  $: correctChain = Number(tx.destChainId) === $connectedSourceChain.id;
+
+  $: if (correctChain && !checkingPrerequisites && hasEnoughEth && $account) {
+    hideContinueButton = false;
+    canContinue = true;
+  } else {
+    if (!correctChain) {
+      hideContinueButton = true;
+    }
+    canContinue = false;
+  }
+
+  $: $account && tx.destChainId, checkConditions();
+
+  $: hasEnoughEth = false;
+</script>
+
+<div class="space-y-[25px] mt-[20px]">
+  <div class="flex justify-between mb-2 items-center">
+    <div class="font-bold text-primary-content">{$t('transactions.claim.steps.pre_check.title')}</div>
+  </div>
+  <div class="min-h-[150px] grid content-between">
+    <div>
+      <div class="f-between-center">
+        <span class="text-secondary-content">{$t('transactions.claim.steps.pre_check.chain_check')}</span>
+        {#if checkingPrerequisites}
+          <Spinner />
+        {:else if correctChain}
+          <Icon type="check-circle" fillClass="fill-positive-sentiment" />
+        {:else}
+          <Icon type="x-close-circle" fillClass="fill-negative-sentiment" />
+        {/if}
+      </div>
+      <div class="f-between-center">
+        <span class="text-secondary-content">{$t('transactions.claim.steps.pre_check.funds_check')}</span>
+        {#if checkingPrerequisites}
+          <Spinner />
+        {:else if hasEnoughEth}
+          <Icon type="check-circle" fillClass="fill-positive-sentiment" />
+        {:else}
+          <Icon type="x-close-circle" fillClass="fill-negative-sentiment" />
+        {/if}
+      </div>
+    </div>
+  </div>
+  {#if !canContinue && !correctChain}
+    <div class="h-sep" />
+    <div class="f-col space-y-[16px]">
+      <ActionButton
+        onPopup
+        priority="primary"
+        disabled={$switchingNetwork}
+        loading={$switchingNetwork}
+        on:click={() => {
+          switchChains();
+        }}>{$t('common.switch_to')} {txDestChainName}</ActionButton>
+    </div>
+  {/if}
+</div>
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/types.ts b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/types.ts
similarity index 77%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/types.ts
rename to packages/bridge-ui/src/components/Dialogs/ClaimDialog/types.ts
index fbbe5e3a589..4843fdc56aa 100644
--- a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/types.ts
+++ b/packages/bridge-ui/src/components/Dialogs/ClaimDialog/types.ts
@@ -6,12 +6,6 @@ export const enum ClaimSteps {
 
 export const INITIAL_STEP = ClaimSteps.CHECK;
 
-export const enum ClaimTypes {
-  CLAIM,
-  RETRY,
-  RELEASE,
-}
-
 export const enum ClaimStatus {
   PENDING,
   DONE,
diff --git a/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseDialog.svelte b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseDialog.svelte
new file mode 100644
index 00000000000..f94455f30ad
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseDialog.svelte
@@ -0,0 +1,212 @@
+<script lang="ts">
+  import { createEventDispatcher } from 'svelte';
+  import { t } from 'svelte-i18n';
+  import { ContractFunctionExecutionError, type Hash, UserRejectedRequestError } from 'viem';
+
+  import { chainConfig } from '$chainConfig';
+  import { CloseButton } from '$components/Button';
+  import { errorToast, successToast, warningToast } from '$components/NotificationToast';
+  import { infoToast } from '$components/NotificationToast/NotificationToast.svelte';
+  import { OnAccount } from '$components/OnAccount';
+  import type { BridgeTransaction } from '$libs/bridge';
+  import {
+    InsufficientBalanceError,
+    InvalidProofError,
+    NotConnectedError,
+    ProcessMessageError,
+    RetryError,
+  } from '$libs/error';
+  import { getLogger } from '$libs/util/logger';
+  import { uid } from '$libs/util/uid';
+  import { connectedSourceChain } from '$stores/network';
+  import { pendingTransactions } from '$stores/pendingTransactions';
+
+  import Claim from '../Claim.svelte';
+  import { ClaimConfirmStep, ReviewStep } from '../Shared';
+  import { ClaimAction } from '../Shared/types';
+  import { DialogStep, DialogStepper } from '../Stepper';
+  import ReleaseStepNavigation from './ReleaseStepNavigation.svelte';
+  import ReleasePreCheck from './ReleaseSteps/ReleasePreCheck.svelte';
+  import { INITIAL_STEP, ReleaseSteps } from './types';
+
+  const log = getLogger('ReleaseDialog');
+
+  const dialogId = `dialog-${uid()}`;
+  const dispatch = createEventDispatcher();
+
+  export let bridgeTx: BridgeTransaction;
+
+  export let dialogOpen = false;
+
+  let canContinue = false;
+  let activeStep: ReleaseSteps = INITIAL_STEP;
+  let txHash: Hash;
+  let releasing: boolean;
+  let releasingDone = false;
+  let ClaimComponent: Claim;
+  let hideContinueButton: boolean;
+
+  const closeDialog = () => {
+    dialogOpen = false;
+    reset();
+  };
+
+  const handleAccountChange = () => {
+    reset();
+  };
+
+  const reset = () => {
+    releasing = false;
+    activeStep = INITIAL_STEP;
+  };
+
+  const handleClaimTxSent = async (event: CustomEvent<{ txHash: Hash; action: ClaimAction }>) => {
+    const { txHash: transactionHash, action } = event.detail;
+    txHash = transactionHash;
+    log('handle claim tx sent', txHash, action);
+    releasing = true;
+
+    const explorer = chainConfig[Number(bridgeTx.destChainId)]?.blockExplorers?.default.url;
+
+    infoToast({
+      title: $t('transactions.actions.claim.tx.title'),
+      message: $t('transactions.actions.claim.tx.message', {
+        values: {
+          token: bridgeTx.symbol,
+          url: `${explorer}/tx/${txHash}`,
+        },
+      }),
+    });
+    await pendingTransactions.add(txHash, Number(bridgeTx.destChainId));
+
+    releasingDone = true;
+
+    dispatch('claimingDone');
+
+    successToast({
+      title: $t('transactions.actions.claim.success.title'),
+      message: $t('transactions.actions.claim.success.message', {
+        values: {
+          network: $connectedSourceChain.name,
+        },
+      }),
+    });
+  };
+
+  const handleClaimError = (event: CustomEvent<{ error: unknown; type: ClaimAction }>) => {
+    //TODO: update this to display info alongside toasts
+    const err = event.detail.error;
+    switch (true) {
+      case err instanceof NotConnectedError:
+        warningToast({ title: $t('messages.account.required') });
+        break;
+      case err instanceof UserRejectedRequestError:
+        warningToast({ title: $t('transactions.actions.claim.rejected.title') });
+        break;
+      case err instanceof InsufficientBalanceError:
+        dispatch('insufficientFunds', { tx: bridgeTx });
+        break;
+      case err instanceof InvalidProofError:
+        errorToast({ title: $t('common.error'), message: $t('bridge.errors.invalid_proof_provided') });
+        break;
+      case err instanceof ProcessMessageError:
+        errorToast({ title: $t('bridge.errors.process_message_error') });
+        break;
+      case err instanceof RetryError:
+        errorToast({ title: $t('bridge.errors.retry_error') });
+        break;
+      case err instanceof ContractFunctionExecutionError:
+        console.error(err);
+        if (err.message.includes('B_INVOCATION_TOO_EARLY')) {
+          errorToast({
+            title: $t('bridge.errors.claim.too_early.title'),
+            message: $t('bridge.errors.claim.too_early.message'),
+          });
+        } else if (err.message.includes('B_NOT_RECEIVED')) {
+          errorToast({
+            title: $t('bridge.errors.claim.not_received.title'),
+            message: $t('bridge.errors.claim.not_received.message'),
+          });
+        } else {
+          errorToast({
+            title: $t('bridge.errors.unknown_error.title'),
+            message: $t('bridge.errors.unknown_error.message'),
+          });
+        }
+        break;
+      default:
+        console.error(err);
+        errorToast({
+          title: $t('bridge.errors.unknown_error.title'),
+          message: $t('bridge.errors.unknown_error.message'),
+        });
+        break;
+    }
+    releasing = false;
+  };
+
+  const handleReleaseClick = async () => {
+    releasing = true;
+    await ClaimComponent.claim(ClaimAction.RELEASE);
+    releasing = false;
+  };
+
+  $: releasing = false;
+
+  $: loading = releasing;
+</script>
+
+<dialog id={dialogId} class="modal" class:modal-open={dialogOpen}>
+  <div class="modal-box relative w-full bg-neutral-background absolute">
+    <div class="w-full f-between-center">
+      <CloseButton onClick={closeDialog} />
+      <h3 class="title-body-bold">{$t('transactions.release.title')}</h3>
+    </div>
+    <div class="h-sep mx-[-24px] mt-[20px]" />
+    <div class="w-full h-full f-col">
+      <DialogStepper>
+        <DialogStep
+          stepIndex={ReleaseSteps.CHECK}
+          currentStepIndex={activeStep}
+          isActive={activeStep === ReleaseSteps.CHECK}>{$t('transactions.claim.steps.pre_check.title')}</DialogStep>
+        <DialogStep
+          stepIndex={ReleaseSteps.REVIEW}
+          currentStepIndex={activeStep}
+          isActive={activeStep === ReleaseSteps.REVIEW}>{$t('common.review')}</DialogStep>
+        <DialogStep
+          stepIndex={ReleaseSteps.CONFIRM}
+          currentStepIndex={activeStep}
+          isActive={activeStep === ReleaseSteps.CONFIRM}>{$t('bridge.step.confirm.title')}</DialogStep>
+      </DialogStepper>
+      {#if activeStep === ReleaseSteps.CHECK}
+        <ReleasePreCheck tx={bridgeTx} bind:canContinue bind:hideContinueButton />
+      {:else if activeStep === ReleaseSteps.REVIEW}
+        <ReviewStep tx={bridgeTx} />
+      {:else if activeStep === ReleaseSteps.CONFIRM}
+        <ClaimConfirmStep
+          {bridgeTx}
+          bind:txHash
+          on:claim={handleReleaseClick}
+          bind:claiming={releasing}
+          bind:canClaim={canContinue}
+          bind:claimingDone={releasingDone} />
+      {/if}
+      <div class="f-col text-left self-end h-full w-full">
+        <div class="f-col gap-4 mt-[20px]">
+          <ReleaseStepNavigation
+            bind:activeStep
+            bind:canContinue
+            {hideContinueButton}
+            bind:loading
+            bind:releasing
+            on:closeDialog={closeDialog}
+            bind:releasingDone />
+        </div>
+      </div>
+    </div>
+  </div>
+</dialog>
+
+<Claim bind:bridgeTx bind:this={ClaimComponent} on:error={handleClaimError} on:claimingTxSent={handleClaimTxSent} />
+
+<OnAccount change={handleAccountChange} />
diff --git a/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseStepNavigation.svelte b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseStepNavigation.svelte
new file mode 100644
index 00000000000..04e4d979ca5
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseStepNavigation.svelte
@@ -0,0 +1,82 @@
+<script lang="ts">
+  import { createEventDispatcher } from 'svelte';
+  import { t } from 'svelte-i18n';
+
+  import { ActionButton } from '$components/Button';
+  import { StepBack } from '$components/Stepper';
+
+  import { ReleaseSteps } from './types';
+
+  const dispatch = createEventDispatcher();
+
+  export let activeStep: ReleaseSteps;
+  export let loading = false;
+  export let canContinue = false;
+  export let releasingDone = false;
+  export let releasing = false;
+  export let hideContinueButton: boolean;
+
+  const INITIAL_STEP = ReleaseSteps.CHECK;
+
+  const getNextStepText = (step: ReleaseSteps) => {
+    if (step === ReleaseSteps.REVIEW) {
+      return $t('common.confirm');
+    }
+    if (step === ReleaseSteps.CONFIRM) {
+      return $t('common.ok');
+    } else {
+      return $t('common.continue');
+    }
+  };
+
+  const getPrevStepText = (step: ReleaseSteps) => {
+    if (step === INITIAL_STEP) {
+      return $t('common.cancel');
+    }
+    return $t('common.back');
+  };
+
+  const handleNextStep = () => {
+    if (activeStep === INITIAL_STEP) {
+      activeStep = ReleaseSteps.REVIEW;
+    } else if (activeStep === ReleaseSteps.REVIEW) {
+      activeStep = ReleaseSteps.CONFIRM;
+    } else if (activeStep === ReleaseSteps.CONFIRM) {
+      dispatch('closeDialog');
+    }
+  };
+
+  const handlePreviousStep = () => {
+    if (activeStep === INITIAL_STEP) {
+      dispatch('closeDialog');
+    }
+    if (activeStep === ReleaseSteps.REVIEW) {
+      activeStep = ReleaseSteps.CHECK;
+    } else if (activeStep === ReleaseSteps.CONFIRM) {
+      activeStep = ReleaseSteps.REVIEW;
+    }
+  };
+
+  $: nextStepButtonText = getNextStepText(activeStep);
+  $: prevStepButtonText = getPrevStepText(activeStep);
+
+  $: if (activeStep) {
+    getPrevStepText(activeStep);
+    getNextStepText(activeStep);
+  }
+
+  $: isNextStepDisabled =
+    loading ||
+    (activeStep === ReleaseSteps.CHECK && !canContinue) ||
+    (activeStep === ReleaseSteps.CONFIRM && !releasingDone);
+</script>
+
+{#if (activeStep !== ReleaseSteps.CONFIRM || releasingDone) && (activeStep !== ReleaseSteps.CHECK || canContinue) && !hideContinueButton}
+  <div class="h-sep" />
+  <ActionButton onPopup priority="primary" disabled={isNextStepDisabled} {loading} on:click={handleNextStep}>
+    {nextStepButtonText}
+  </ActionButton>
+{/if}
+{#if !releasingDone && !releasing}
+  <StepBack on:click={handlePreviousStep}>{prevStepButtonText}</StepBack>
+{/if}
diff --git a/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseSteps/ReleasePreCheck.svelte b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseSteps/ReleasePreCheck.svelte
new file mode 100644
index 00000000000..34b28f9745b
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/ReleaseSteps/ReleasePreCheck.svelte
@@ -0,0 +1,71 @@
+<script lang="ts">
+  import { switchChain } from '@wagmi/core';
+  import { t } from 'svelte-i18n';
+
+  import { ActionButton } from '$components/Button';
+  import { Icon } from '$components/Icon';
+  import type { BridgeTransaction } from '$libs/bridge';
+  import { getChainName } from '$libs/chain';
+  import { config } from '$libs/wagmi';
+  import { account } from '$stores/account';
+  import { connectedSourceChain, switchingNetwork } from '$stores/network';
+
+  export let tx: BridgeTransaction;
+
+  export let canContinue = false;
+  export let hideContinueButton = false;
+
+  const switchChains = async () => {
+    $switchingNetwork = true;
+    try {
+      await switchChain(config, { chainId: Number(tx.srcChainId) });
+    } catch (err) {
+      console.error(err);
+    } finally {
+      $switchingNetwork = false;
+    }
+  };
+
+  $: txDestChainName = getChainName(Number(tx.destChainId));
+
+  $: correctChain = Number(tx.srcChainId) === $connectedSourceChain.id;
+
+  $: if (correctChain && $account) {
+    hideContinueButton = false;
+    canContinue = true;
+  } else {
+    hideContinueButton = true;
+    canContinue = false;
+  }
+</script>
+
+<div class="space-y-[25px] mt-[20px]">
+  <div class="flex justify-between mb-2 items-center">
+    <div class="font-bold text-primary-content">{$t('transactions.claim.steps.pre_check.title')}</div>
+  </div>
+  <div class="min-h-[150px] grid content-between">
+    <div>
+      <div class="f-between-center">
+        <span class="text-secondary-content">{$t('transactions.claim.steps.pre_check.chain_check')}</span>
+        {#if correctChain}
+          <Icon type="check-circle" fillClass="fill-positive-sentiment" />
+        {:else}
+          <Icon type="x-close-circle" fillClass="fill-negative-sentiment" />
+        {/if}
+      </div>
+    </div>
+  </div>
+  {#if !canContinue && !correctChain}
+    <div class="h-sep" />
+    <div class="f-col space-y-[16px]">
+      <ActionButton
+        onPopup
+        priority="primary"
+        disabled={$switchingNetwork}
+        loading={$switchingNetwork}
+        on:click={() => {
+          switchChains();
+        }}>{$t('common.switch_to')} {txDestChainName}</ActionButton>
+    </div>
+  {/if}
+</div>
diff --git a/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/types.ts b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/types.ts
new file mode 100644
index 00000000000..2f17346df7c
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/ReleaseDialog/types.ts
@@ -0,0 +1,7 @@
+export const enum ReleaseSteps {
+  CHECK,
+  REVIEW,
+  CONFIRM,
+}
+
+export const INITIAL_STEP = ReleaseSteps.CHECK;
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/RetryDialog.svelte b/packages/bridge-ui/src/components/Dialogs/RetryDialog/RetryDialog.svelte
similarity index 91%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/RetryDialog.svelte
rename to packages/bridge-ui/src/components/Dialogs/RetryDialog/RetryDialog.svelte
index ce5288e18ec..78cab2f847b 100644
--- a/packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/RetryDialog.svelte
+++ b/packages/bridge-ui/src/components/Dialogs/RetryDialog/RetryDialog.svelte
@@ -5,9 +5,9 @@
 
   import { chainConfig } from '$chainConfig';
   import { CloseButton } from '$components/Button';
+  import { DialogStep, DialogStepper } from '$components/Dialogs/Stepper';
   import { infoToast, successToast } from '$components/NotificationToast/NotificationToast.svelte';
   import { OnAccount } from '$components/OnAccount';
-  import { DialogStep, DialogStepper } from '$components/Transactions/Dialogs/Stepper';
   import type { BridgeTransaction } from '$libs/bridge';
   import { closeOnEscapeOrOutsideClick } from '$libs/customActions';
   import { getLogger } from '$libs/util/logger';
@@ -15,9 +15,8 @@
   import { pendingTransactions } from '$stores/pendingTransactions';
 
   import Claim from '../Claim.svelte';
-  import ClaimConfirmStep from '../ClaimDialog/ClaimSteps/ClaimConfirmStep.svelte';
-  import ClaimReviewStep from '../ClaimDialog/ClaimSteps/ClaimReviewStep.svelte';
-  import { TWO_STEP_STATE } from '../ClaimDialog/types';
+  import { ClaimConfirmStep, ReviewStep } from '../Shared';
+  import { ClaimAction } from '../Shared/types';
   import RetryStepNavigation from './RetryStepNavigation.svelte';
   import RetryOptionStep from './RetrySteps/RetryOptionStep.svelte';
   import { selectedRetryMethod } from './state';
@@ -64,7 +63,7 @@
 
   export const handleClaimClick = async () => {
     retrying = true;
-    await ClaimComponent.claim();
+    await ClaimComponent.claim(ClaimAction.RETRY);
   };
 
   const handleRetryTxSent = async (event: CustomEvent<{ txHash: Hash }>) => {
@@ -132,7 +131,7 @@
       {#if activeStep === RetrySteps.SELECT}
         <RetryOptionStep bind:canContinue />
       {:else if activeStep === RetrySteps.REVIEW}
-        <ClaimReviewStep bind:tx={bridgeTx} />
+        <ReviewStep bind:tx={bridgeTx} />
       {:else if activeStep === RetrySteps.CONFIRM}
         <ClaimConfirmStep
           {bridgeTx}
@@ -140,8 +139,7 @@
           on:claim={handleClaimClick}
           bind:claiming={retrying}
           bind:canClaim={canContinue}
-          bind:claimingDone={retryDone}
-          proveOrClaimStep={TWO_STEP_STATE.CLAIM} />
+          bind:claimingDone={retryDone} />
       {/if}
       <div class="f-col text-left self-end h-full w-full">
         <div class="f-col gap-4 mt-[20px]">
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/RetryStepNavigation.svelte b/packages/bridge-ui/src/components/Dialogs/RetryDialog/RetryStepNavigation.svelte
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/RetryStepNavigation.svelte
rename to packages/bridge-ui/src/components/Dialogs/RetryDialog/RetryStepNavigation.svelte
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/RetrySteps/RetryOptionStep.svelte b/packages/bridge-ui/src/components/Dialogs/RetryDialog/RetrySteps/RetryOptionStep.svelte
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/RetrySteps/RetryOptionStep.svelte
rename to packages/bridge-ui/src/components/Dialogs/RetryDialog/RetrySteps/RetryOptionStep.svelte
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/state.ts b/packages/bridge-ui/src/components/Dialogs/RetryDialog/state.ts
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/state.ts
rename to packages/bridge-ui/src/components/Dialogs/RetryDialog/state.ts
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/types.ts b/packages/bridge-ui/src/components/Dialogs/RetryDialog/types.ts
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/RetryDialog/types.ts
rename to packages/bridge-ui/src/components/Dialogs/RetryDialog/types.ts
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimConfirmStep.svelte b/packages/bridge-ui/src/components/Dialogs/Shared/ClaimConfirmStep.svelte
similarity index 72%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimConfirmStep.svelte
rename to packages/bridge-ui/src/components/Dialogs/Shared/ClaimConfirmStep.svelte
index 5439a888e34..7c1fa690b03 100644
--- a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimConfirmStep.svelte
+++ b/packages/bridge-ui/src/components/Dialogs/Shared/ClaimConfirmStep.svelte
@@ -10,16 +10,12 @@
   import type { BridgeTransaction } from '$libs/bridge';
   import { theme } from '$stores/theme';
 
-  import { TWO_STEP_STATE } from '../types';
-
   export let canClaim = false;
 
   export let claimingDone = false;
 
   export let claiming = false;
 
-  export let proveOrClaimStep: TWO_STEP_STATE | null;
-
   export let bridgeTx: BridgeTransaction;
 
   export let txHash: Hash;
@@ -31,18 +27,12 @@
   };
 
   const getSuccessTitle = () => {
-    if (proveOrClaimStep === TWO_STEP_STATE.PROVE) {
-      return $t('bridge.step.confirm.success.prove');
-    }
-
     return $t('bridge.step.confirm.success.claim');
   };
 
   const getSuccessDescription = () => {
     if (!txHash) return;
-    if (proveOrClaimStep === TWO_STEP_STATE.PROVE) {
-      return $t('bridge.step.confirm.success.prove_description');
-    }
+
     const explorer = chainConfig[Number(bridgeTx.destChainId)]?.blockExplorers?.default.url;
     const url = `${explorer}/tx/${txHash}`;
 
@@ -53,21 +43,6 @@
     getSuccessDescription();
   }
 
-  $: claimOrProveActionButton =
-    proveOrClaimStep === TWO_STEP_STATE.CLAIM
-      ? $t('transactions.claim.steps.confirm.claim_button')
-      : $t('transactions.claim.steps.confirm.prove');
-
-  $: proceedText =
-    proveOrClaimStep === TWO_STEP_STATE.CLAIM
-      ? $t('transactions.claim.steps.confirm.proceed')
-      : $t('transactions.claim.steps.confirm.prove');
-
-  $: proceedDescription =
-    proveOrClaimStep === TWO_STEP_STATE.CLAIM
-      ? $t('transactions.claim.steps.confirm.claim_description')
-      : $t('transactions.claim.steps.confirm.prove_description');
-
   $: bridgeIcon = `bridge-${$theme}` as IconType;
   $: successIcon = `success-${$theme}` as IconType;
 
@@ -98,8 +73,8 @@
         {:else if !claiming && !claimingDone}
           <Icon type={bridgeIcon} size={160} />
           <div id="text" class="f-col my-[30px] text-center">
-            <h1 class="mb-[16px]">{proceedText}</h1>
-            <span>{proceedDescription}</span>
+            <h1 class="mb-[16px]">{$t('transactions.claim.steps.confirm.proceed')}</h1>
+            <span>{$t('transactions.claim.steps.confirm.claim_description')}</span>
           </div>
         {/if}
       </div>
@@ -112,7 +87,7 @@
           priority="primary"
           loading={claiming}
           on:click={() => handleClaimClick()}
-          disabled={claimDisabled}>{claimOrProveActionButton}</ActionButton>
+          disabled={claimDisabled}>{$t('transactions.claim.steps.confirm.claim_button')}</ActionButton>
       </section>
     {/if}
   </div>
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimReviewStep.svelte b/packages/bridge-ui/src/components/Dialogs/Shared/ReviewStep.svelte
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimReviewStep.svelte
rename to packages/bridge-ui/src/components/Dialogs/Shared/ReviewStep.svelte
diff --git a/packages/bridge-ui/src/components/Dialogs/Shared/index.ts b/packages/bridge-ui/src/components/Dialogs/Shared/index.ts
new file mode 100644
index 00000000000..5f66dad17bd
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/Shared/index.ts
@@ -0,0 +1,2 @@
+export { default as ClaimConfirmStep } from './ClaimConfirmStep.svelte';
+export { default as ReviewStep } from './ReviewStep.svelte';
diff --git a/packages/bridge-ui/src/components/Dialogs/Shared/types.ts b/packages/bridge-ui/src/components/Dialogs/Shared/types.ts
new file mode 100644
index 00000000000..8bf5465e792
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/Shared/types.ts
@@ -0,0 +1,5 @@
+export const enum ClaimAction {
+  CLAIM,
+  RETRY,
+  RELEASE,
+}
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/Stepper/DialogStep.svelte b/packages/bridge-ui/src/components/Dialogs/Stepper/DialogStep.svelte
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/Stepper/DialogStep.svelte
rename to packages/bridge-ui/src/components/Dialogs/Stepper/DialogStep.svelte
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/Stepper/DialogStepper.svelte b/packages/bridge-ui/src/components/Dialogs/Stepper/DialogStepper.svelte
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/Stepper/DialogStepper.svelte
rename to packages/bridge-ui/src/components/Dialogs/Stepper/DialogStepper.svelte
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/Stepper/index.ts b/packages/bridge-ui/src/components/Dialogs/Stepper/index.ts
similarity index 100%
rename from packages/bridge-ui/src/components/Transactions/Dialogs/Stepper/index.ts
rename to packages/bridge-ui/src/components/Dialogs/Stepper/index.ts
diff --git a/packages/bridge-ui/src/components/Dialogs/index.ts b/packages/bridge-ui/src/components/Dialogs/index.ts
new file mode 100644
index 00000000000..0130eb64f7d
--- /dev/null
+++ b/packages/bridge-ui/src/components/Dialogs/index.ts
@@ -0,0 +1,3 @@
+export { default as ClaimDialog } from './ClaimDialog/ClaimDialog.svelte';
+export { default as ReleaseDialog } from './ReleaseDialog/ReleaseDialog.svelte';
+export { default as RetryDialog } from './RetryDialog/RetryDialog.svelte';
diff --git a/packages/bridge-ui/src/components/Faucet/Faucet.svelte b/packages/bridge-ui/src/components/Faucet/Faucet.svelte
index 3813303ad5f..eb19cb8a8b6 100644
--- a/packages/bridge-ui/src/components/Faucet/Faucet.svelte
+++ b/packages/bridge-ui/src/components/Faucet/Faucet.svelte
@@ -1,5 +1,4 @@
 <script lang="ts">
-  import { switchChain } from '@wagmi/core';
   import { onMount } from 'svelte';
   import { t } from 'svelte-i18n';
   import { type Chain, ContractFunctionExecutionError, UserRejectedRequestError } from 'viem';
@@ -9,19 +8,15 @@
   import ActionButton from '$components/Button/ActionButton.svelte';
   import { Card } from '$components/Card';
   import { ChainSelector, ChainSelectorDirection, ChainSelectorType } from '$components/ChainSelectors';
-  import { Icon } from '$components/Icon';
   import { successToast, warningToast } from '$components/NotificationToast';
   import { errorToast, infoToast } from '$components/NotificationToast/NotificationToast.svelte';
   import { TokenDropdown } from '$components/TokenDropdown';
-  import { chains } from '$libs/chain';
   import { InsufficientBalanceError, MintError, TokenMintedError } from '$libs/error';
   import { checkMintable, mint, testERC20Tokens, testNFT, type Token } from '$libs/token';
-  import { config } from '$libs/wagmi';
   import { account, connectedSourceChain, pendingTransactions } from '$stores';
 
   let minting = false;
   let checkingMintable = false;
-  let switchingNetwork = false;
 
   let selectedToken: Token;
   let mintButtonEnabled = false;
@@ -30,27 +25,6 @@
 
   const onlyMintable: boolean = true;
 
-  async function switchNetworkToL1() {
-    if (switchingNetwork) return;
-
-    switchingNetwork = true;
-
-    try {
-      await switchChain(config, { chainId: Number(chains[0].id) });
-    } catch (err) {
-      console.error(err);
-
-      if (err instanceof UserRejectedRequestError) {
-        warningToast({
-          title: $t('messages.network.rejected.title'),
-          message: $t('messages.network.rejected.message'),
-        });
-      }
-    } finally {
-      switchingNetwork = false;
-    }
-  }
-
   async function mintToken() {
     // During loading state we make sure the user cannot use this function
     if (checkingMintable || minting) return;
@@ -108,17 +82,6 @@
     return Boolean(user?.isConnected);
   }
 
-  function isWrongChain(network: Maybe<Chain>) {
-    if (!selectedToken?.addresses) {
-      // nothing selected, can't determine if wrong chain
-      return false;
-    }
-    if (network?.id) {
-      return !selectedToken.addresses[network.id];
-    }
-    return true;
-  }
-
   // This function will check whether or not the button to mint should be
   // enabled. If it shouldn't it'll also set the reason why so we can inform
   // the user why they can't mint
@@ -153,13 +116,11 @@
       checkingMintable = false;
     }
 
-    alertMessage = getAlertMessage(connected, wrongChain, reasonNotMintable);
+    alertMessage = getAlertMessage(connected, reasonNotMintable);
   }
 
-  function getAlertMessage(connected: boolean, wrongChain: boolean, reasonNotMintable: string) {
+  function getAlertMessage(connected: boolean, reasonNotMintable: string) {
     if (!connected) return $t('messages.account.required');
-    //does this really need to be dynamic? Our mint tokens will most likely stay on Sepolia
-    if (wrongChain) return $t('faucet.wrong_chain.message', { values: { network: 'Sepolia' } });
     if (reasonNotMintable) return reasonNotMintable;
     return '';
   }
@@ -173,7 +134,6 @@
   });
 
   $: connected = isUserConnected($account);
-  $: wrongChain = isWrongChain($connectedSourceChain);
 
   $: disabled = !$account || !$account.isConnected;
 
@@ -197,34 +157,20 @@
       </Alert>
     {/if}
 
-    {#if connected && wrongChain}
-      <!-- We give the user an easier way to switch chains with this button -->
-      <ActionButton priority="primary" loading={switchingNetwork} on:click={switchNetworkToL1}>
-        {#if switchingNetwork}
-          <span>{$t('messages.network.switching')}</span>
+    <ActionButton
+      priority="primary"
+      disabled={!mintButtonEnabled || disabled}
+      loading={checkingMintable || minting}
+      on:click={mintToken}>
+      <span class="body-bold">
+        {#if checkingMintable}
+          {$t('faucet.button.checking')}
+        {:else if minting}
+          {$t('faucet.button.minting')}
         {:else}
-          <Icon type="up-down" fillClass="fill-white" class="rotate-90" height={24} width={24} />
-          <span class="body-bold">
-            {alertMessage}
-          </span>
+          {$t('faucet.button.mint')}
         {/if}
-      </ActionButton>
-    {:else}
-      <ActionButton
-        priority="primary"
-        disabled={!mintButtonEnabled || disabled}
-        loading={checkingMintable || minting}
-        on:click={mintToken}>
-        <span class="body-bold">
-          {#if checkingMintable}
-            {$t('faucet.button.checking')}
-          {:else if minting}
-            {$t('faucet.button.minting')}
-          {:else}
-            {$t('faucet.button.mint')}
-          {/if}
-        </span>
-      </ActionButton>
-    {/if}
+      </span>
+    </ActionButton>
   </div>
 </Card>
diff --git a/packages/bridge-ui/src/components/TokenDropdown/TokenDropdown.svelte b/packages/bridge-ui/src/components/TokenDropdown/TokenDropdown.svelte
index 139d95a2777..f20dac27762 100644
--- a/packages/bridge-ui/src/components/TokenDropdown/TokenDropdown.svelte
+++ b/packages/bridge-ui/src/components/TokenDropdown/TokenDropdown.svelte
@@ -165,14 +165,10 @@
   }
 
   const onAccountChange = (newAccount: Account, prevAccount?: Account) => {
-    if (newAccount?.chainId === prevAccount?.chainId || !newAccount || !prevAccount) updateBalance();
+    if (newAccount?.chainId === prevAccount?.chainId || !newAccount || !prevAccount) reset();
   };
 
-  $: textClass = disabled ? 'text-secondary-content' : 'font-bold ';
-
-  onDestroy(() => closeMenu());
-
-  onMount(async () => {
+  const reset = async () => {
     const srcChain = $connectedSourceChain;
     const destChain = $destNetwork;
     const user = $account?.address;
@@ -182,8 +178,15 @@
     $computingBalance = true;
     value = tokens[0];
     $selectedToken = value;
-    await updateBalance();
     $computingBalance = false;
+  };
+
+  $: textClass = disabled ? 'text-secondary-content' : 'font-bold ';
+
+  onDestroy(() => closeMenu());
+
+  onMount(async () => {
+    reset();
   });
 </script>
 
diff --git a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimPreCheck.svelte b/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimPreCheck.svelte
deleted file mode 100644
index d8fbf34bdc1..00000000000
--- a/packages/bridge-ui/src/components/Transactions/Dialogs/ClaimDialog/ClaimSteps/ClaimPreCheck.svelte
+++ /dev/null
@@ -1,216 +0,0 @@
-<script lang="ts">
-  import { getBalance, switchChain } from '@wagmi/core';
-  import { t } from 'svelte-i18n';
-  import { type Address, parseEther, zeroAddress } from 'viem';
-
-  import { ActionButton } from '$components/Button';
-  import { Icon } from '$components/Icon';
-  import Spinner from '$components/Spinner/Spinner.svelte';
-  import { claimConfig } from '$config';
-  import type { BridgeTransaction, GetProofReceiptResponse } from '$libs/bridge';
-  import { getInvocationDelayForTx } from '$libs/bridge/getInvocationDelayForTx';
-  import { getChainName } from '$libs/chain';
-  import { PollingEvent, type startPolling } from '$libs/polling/messageStatusPoller';
-  import { config } from '$libs/wagmi';
-  import { account } from '$stores/account';
-  import { connectedSourceChain, switchingNetwork } from '$stores/network';
-
-  export let tx: BridgeTransaction;
-  export let polling: ReturnType<typeof startPolling>;
-  export let canContinue = false;
-
-  export let bridgeDelays: readonly bigint[];
-  export let proofReceipt: GetProofReceiptResponse;
-
-  let proofReceiptAddress: Address;
-
-  const switchChains = async () => {
-    $switchingNetwork = true;
-    try {
-      await switchChain(config, { chainId: Number(tx.destChainId) });
-    } catch (err) {
-      console.error(err);
-    } finally {
-      $switchingNetwork = false;
-    }
-  };
-
-  export let checkingPrerequisites: boolean;
-
-  const checkEnoughBalance = async (address: Maybe<Address>, chainId: number) => {
-    if (!address) {
-      return false;
-    }
-    checkingPrerequisites = true;
-
-    const balance = await getBalance(config, { address, chainId });
-
-    if (balance.value < parseEther(String(claimConfig.minimumEthToClaim))) {
-      hasEnoughEth = false;
-      checkingPrerequisites = false;
-    }
-    hasEnoughEth = true;
-    checkingPrerequisites = false;
-  };
-
-  const convertSecondsToTime = (sec: number): { hours: number; minutes: number; seconds: number } => {
-    let totalSeconds = Number(sec);
-    const hours = Math.floor(totalSeconds / 3600);
-    totalSeconds -= hours * 3600;
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-
-    return { hours, minutes, seconds };
-  };
-
-  const formatTimeToString = ({
-    hours,
-    minutes,
-    seconds,
-  }: {
-    hours: number;
-    minutes: number;
-    seconds: number;
-  }): string => {
-    if (hours < 0 || minutes < 0 || seconds < 0) {
-      return $t('transactions.claim.steps.pre_check.no_delay');
-    }
-
-    if (hours > 0) {
-      // If hours are present, include hours and minutes in the output
-      return `~${hours}h ${minutes.toString().padStart(2, '0')}min`;
-    } else if (minutes > 0) {
-      // If no hours but minutes are present, include only minutes
-      return `~${minutes}min`;
-    } else if (seconds > 0) {
-      // If less than a minute, show seconds
-      return `~${seconds}sec`;
-    }
-    // If none of the above, it means no delay
-    return $t('transactions.claim.steps.pre_check.no_delay');
-  };
-
-  const onDelayChange = ({ remainingDelayInSeconds }: { remainingDelayInSeconds: bigint }) => {
-    if (remainingDelayInSeconds >= 0n) {
-      preferredDelayInSeconds = Number(remainingDelayInSeconds);
-    } else {
-      preferredDelayInSeconds = 0;
-    }
-  };
-
-  const checkTxDelay = async () => {
-    const invocationDelaysForTx = await getInvocationDelayForTx(tx);
-    preferredDelayInSeconds = Number(invocationDelaysForTx.preferredDelay);
-  };
-
-  const checkConditions = async () => {
-    await checkEnoughBalance($account.address, Number(tx.destChainId));
-    if (bridgeDelays && bridgeDelays[0] > 0n) {
-      await checkTxDelay();
-    }
-  };
-
-  $: if (proofReceipt) {
-    proofReceiptAddress = proofReceipt[1];
-  }
-
-  $: txDestChainName = getChainName(Number(tx.destChainId));
-
-  $: correctChain = Number(tx.destChainId) === $connectedSourceChain.id;
-
-  $: if (correctChain && !checkingPrerequisites && hasEnoughEth && $account && preferredDelayInSeconds <= 0) {
-    canContinue = true;
-  } else {
-    canContinue = false;
-  }
-
-  $: $account && tx.destChainId, checkConditions();
-
-  $: {
-    if (polling?.emitter) {
-      // The following listeners will trigger change in the UI
-      polling.emitter.on(PollingEvent.DELAY, onDelayChange);
-    }
-    remainingDelayString = formatTimeToString(convertSecondsToTime(Number(preferredDelayInSeconds)));
-  }
-  $: remainingDelayString = '';
-  $: invocationDelayString = bridgeDelays && formatTimeToString(convertSecondsToTime(Number(bridgeDelays[0])));
-  $: preferredDelayInSeconds = 0;
-  $: hasEnoughEth = false;
-
-  $: twoStepBridge = bridgeDelays && bridgeDelays[0] > 0n ? true : false;
-
-  $: claimStep = proofReceiptAddress && proofReceiptAddress !== zeroAddress ? '2/2' : '1/2';
-</script>
-
-<div class="space-y-[25px] mt-[20px]">
-  <div class="flex justify-between mb-2 items-center">
-    <div class="font-bold text-primary-content">{$t('transactions.claim.steps.pre_check.title')}</div>
-  </div>
-  <div class="min-h-[150px] grid content-between">
-    <div>
-      <!-- Two step claim process -->
-      {#if twoStepBridge}
-        <div class="h-sep" />
-        <span class="text-secondary-content">
-          <!-- eslint-disable-next-line svelte/no-at-html-tags -->
-          {@html $t('transactions.claim.steps.pre_check.two_step_claim.description', {
-            values: { delay: invocationDelayString },
-          })}
-        </span>
-        <div class="f-between-center mt-[20px]">
-          <span class="text-secondary-content">{$t('transactions.claim.steps.pre_check.step')}</span>
-          {#if checkingPrerequisites}
-            <Spinner />
-          {:else}
-            <span>{claimStep}</span>
-          {/if}
-        </div>
-        {#if proofReceiptAddress && proofReceiptAddress !== zeroAddress}
-          <div class="f-between-center">
-            <span class="text-secondary-content">{$t('transactions.claim.steps.pre_check.remaining_delay')}</span>
-            {#if checkingPrerequisites}
-              <Spinner />
-            {:else}
-              {remainingDelayString}
-            {/if}
-          </div>
-        {/if}
-        <div class="h-sep" />
-      {/if}
-      <div class="f-between-center">
-        <span class="text-secondary-content">{$t('transactions.claim.steps.pre_check.chain_check')}</span>
-        {#if checkingPrerequisites}
-          <Spinner />
-        {:else if correctChain}
-          <Icon type="check-circle" fillClass="fill-positive-sentiment" />
-        {:else}
-          <Icon type="x-close-circle" fillClass="fill-negative-sentiment" />
-        {/if}
-      </div>
-      <div class="f-between-center">
-        <span class="text-secondary-content">{$t('transactions.claim.steps.pre_check.funds_check')}</span>
-        {#if checkingPrerequisites}
-          <Spinner />
-        {:else if hasEnoughEth}
-          <Icon type="check-circle" fillClass="fill-positive-sentiment" />
-        {:else}
-          <Icon type="x-close-circle" fillClass="fill-negative-sentiment" />
-        {/if}
-      </div>
-    </div>
-  </div>
-  {#if !canContinue && !correctChain}
-    <div class="h-sep" />
-    <div class="f-col space-y-[16px]">
-      <ActionButton
-        onPopup
-        priority="primary"
-        disabled={$switchingNetwork}
-        loading={$switchingNetwork}
-        on:click={() => {
-          switchChains();
-        }}>{$t('common.switch_to')} {txDestChainName}</ActionButton>
-    </div>
-  {/if}
-</div>
diff --git a/packages/bridge-ui/src/components/Transactions/Status/Status.svelte b/packages/bridge-ui/src/components/Transactions/Status/Status.svelte
index 9fab4a673b7..2215fc52d22 100644
--- a/packages/bridge-ui/src/components/Transactions/Status/Status.svelte
+++ b/packages/bridge-ui/src/components/Transactions/Status/Status.svelte
@@ -1,13 +1,12 @@
 <script lang="ts">
   import { onDestroy, onMount } from 'svelte';
   import { t } from 'svelte-i18n';
-  import { zeroAddress } from 'viem';
 
+  import { ClaimDialog, ReleaseDialog, RetryDialog } from '$components/Dialogs';
   import { Spinner } from '$components/Spinner';
   import { StatusDot } from '$components/StatusDot';
-  import { type BridgeTransaction, type GetProofReceiptResponse, MessageStatus } from '$libs/bridge';
+  import { type BridgeTransaction, MessageStatus } from '$libs/bridge';
   import { getMessageStatusForMsgHash } from '$libs/bridge/getMessageStatusForMsgHash';
-  import { getProofReceiptForMsgHash } from '$libs/bridge/getProofReceiptForMsgHash';
   import { isTransactionProcessable } from '$libs/bridge/isTransactionProcessable';
   import { BridgePausedError } from '$libs/error';
   import { PollingEvent, startPolling } from '$libs/polling/messageStatusPoller';
@@ -16,15 +15,9 @@
   import { account } from '$stores/account';
   import { connectedSourceChain } from '$stores/network';
 
-  import ClaimDialog from '../Dialogs/ClaimDialog/ClaimDialog.svelte';
-  import RetryDialog from '../Dialogs/RetryDialog/RetryDialog.svelte';
-
   export let bridgeTx: BridgeTransaction;
   export let nft: NFT | null = null;
 
-  let delays: readonly bigint[];
-  let proofReceipt: GetProofReceiptResponse;
-
   let polling: ReturnType<typeof startPolling>;
 
   // UI state
@@ -38,13 +31,6 @@
   }
 
   async function claimingDone() {
-    // As the msg status for 2step remains on NEW we need to manually update it by fetching the proof receipt
-    proofReceipt = await getProofReceiptForMsgHash({
-      msgHash: bridgeTx.msgHash,
-      srcChainId: bridgeTx.srcChainId,
-      destChainId: bridgeTx.destChainId,
-    });
-
     // Keeping model and UI in sync
     bridgeTx.msgStatus = await getMessageStatusForMsgHash({
       msgHash: bridgeTx.msgHash,
@@ -67,6 +53,14 @@
     retryModalOpen = true;
   }
 
+  async function handleReleaseClick() {
+    isBridgePaused().then((paused) => {
+      if (paused) throw new BridgePausedError('Bridge is paused');
+    });
+    if (!$connectedSourceChain || !$account?.address) return;
+    releaseModalOpen = true;
+  }
+
   async function handleClaimClick() {
     isBridgePaused().then((paused) => {
       if (paused) throw new BridgePausedError('Bridge is paused');
@@ -76,10 +70,6 @@
     claimModalOpen = true;
   }
 
-  const onReceiptChange = ({ proofReceipt: p }: { proofReceipt: GetProofReceiptResponse }) => {
-    proofReceipt = p;
-  };
-
   async function release() {
     isBridgePaused().then((paused) => {
       if (paused) throw new BridgePausedError('Bridge is paused');
@@ -90,15 +80,7 @@
 
   $: claimModalOpen = false;
   $: retryModalOpen = false;
-
-  $: hasValidProofReceipt = proofReceipt && proofReceipt[1] !== zeroAddress ? true : false;
-
-  $: chainHasDelays = delays && delays[0] > 0n ? true : false;
-
-  // if the chain has delays and no validProof receipt it= true, otherwise false
-  $: needsConfirmation = chainHasDelays ? (hasValidProofReceipt ? false : true) : false;
-
-  // $: retryModalOpen = false;
+  $: releaseModalOpen = false;
 
   onMount(async () => {
     if (bridgeTx && $account?.address) {
@@ -116,7 +98,6 @@
           // The following listeners will trigger change in the UI
           polling.emitter.on(PollingEvent.PROCESSABLE, onProcessable);
           polling.emitter.on(PollingEvent.STATUS, onStatusChange);
-          polling.emitter.on(PollingEvent.PROOFRECEIPT, onReceiptChange);
         }
       } catch (err) {
         console.error(err);
@@ -141,14 +122,10 @@
       <Spinner />
       <span>{$t(`transactions.status.${loading}`)}</span>
     </div>
-  {:else if bridgeTxStatus === MessageStatus.NEW && !needsConfirmation}
+  {:else if bridgeTxStatus === MessageStatus.NEW}
     <button class="status-btn" on:click={handleClaimClick}>
       {$t('transactions.button.claim')}
     </button>
-  {:else if bridgeTxStatus === MessageStatus.NEW && needsConfirmation}
-    <button class="status-btn" on:click={handleClaimClick}>
-      {$t('transactions.button.prove')}
-    </button>
   {:else if bridgeTxStatus === MessageStatus.RETRIABLE}
     <button class="status-btn" on:click={handleRetryClick}>
       {$t('transactions.button.retry')}
@@ -157,7 +134,7 @@
     <StatusDot type="success" />
     <span>{$t('transactions.status.claimed.name')}</span>
   {:else if bridgeTxStatus === MessageStatus.FAILED}
-    <button class="status-btn" on:click={release} on:click={handleRetryClick}>
+    <button class="status-btn" on:click={release} on:click={handleReleaseClick}>
       {$t('transactions.button.release')}
     </button>
   {:else}
@@ -169,12 +146,6 @@
 
 <RetryDialog {bridgeTx} bind:dialogOpen={retryModalOpen} />
 
-<ClaimDialog
-  {bridgeTx}
-  bind:polling
-  bind:loading
-  bind:dialogOpen={claimModalOpen}
-  bind:proofReceipt
-  bind:delays
-  {nft}
-  on:claimingDone={() => claimingDone()} />
+<ReleaseDialog {bridgeTx} bind:dialogOpen={releaseModalOpen} />
+
+<ClaimDialog {bridgeTx} bind:loading bind:dialogOpen={claimModalOpen} {nft} on:claimingDone={() => claimingDone()} />
diff --git a/packages/bridge-ui/src/components/Transactions/Transaction.svelte b/packages/bridge-ui/src/components/Transactions/Transaction.svelte
index eb194303ca4..0f5abfb7cce 100644
--- a/packages/bridge-ui/src/components/Transactions/Transaction.svelte
+++ b/packages/bridge-ui/src/components/Transactions/Transaction.svelte
@@ -1,5 +1,4 @@
 <script lang="ts">
-  import { createEventDispatcher } from 'svelte';
   import { t } from 'svelte-i18n';
   import { formatEther, formatUnits } from 'viem';
 
@@ -18,7 +17,6 @@
 
   import ChainSymbolName from './ChainSymbolName.svelte';
   import InsufficientFunds from './InsufficientFunds.svelte';
-  import MobileDetailsDialog from './MobileDetailsDialog.svelte';
   import { Status } from './Status';
 
   export let item: BridgeTransaction;
@@ -26,7 +24,6 @@
 
   let token: NFT;
   let insufficientModal = false;
-  let detailsOpen = false;
   let nftInfoOpen = false;
   let isDesktopOrLarger = false;
 
@@ -34,35 +31,12 @@
 
   const placeholderUrl = '/placeholder.svg';
 
-  const dispatch = createEventDispatcher();
-
-  const handleClick = () => {
-    openDetails();
-    dispatch('click');
-  };
-
-  const handlePress = () => {
-    openDetails();
-    dispatch('press');
-  };
-
-  const closeDetails = () => {
-    detailsOpen = false;
-  };
-
-  const openDetails = () => {
-    if (!isDesktopOrLarger) {
-      detailsOpen = true;
-    }
-  };
-
   const openNFTInfo = () => {
     nftInfoOpen = true;
   };
 
   const handleInsufficientFunds = () => {
     insufficientModal = true;
-    openDetails();
   };
 
   async function analyzeTransactionInput(): Promise<void> {
@@ -97,7 +71,6 @@
 {#if isNFT}
   <!-- We disable these warnings as we dynamically add the role -->
   <!-- svelte-ignore a11y-no-noninteractive-tabindex -->
-  <!-- svelte-ignore a11y-no-static-element-interactions -->
   <div class="flex items-center text-primary-content md:h-[80px] h-[45px] w-full my-[10px] md:my-[0px]">
     {#if isDesktopOrLarger}
       <div class="flex md:w-3/12 gap-[8px]">
@@ -155,7 +128,7 @@
             <LoadingText mask="&nbsp;" class="min-w-[50px] max-w-[50px] h-3" />
           </div>
         {:else}
-          <div class="f-col" {...attrs} tabindex="0" on:click={handleClick} on:keydown={handlePress}>
+          <div class="f-col" {...attrs} tabindex="0">
             <div class="f-row font-bold">
               {truncateString(getChainName(Number(item.srcChainId)), 8)}
               <i role="img" aria-label="arrow to" class="mx-auto px-2">
@@ -168,17 +141,8 @@
         {/if}
       </div>
     {/if}
-    <div
-      class="flex md:w-2/12 py-2 flex flex-col justify-center text-center"
-      {...attrs}
-      tabindex="0"
-      on:click={handleClick}
-      on:keydown={handlePress}>
-      <Status
-        on:click={isDesktopOrLarger ? undefined : openDetails}
-        bridgeTx={item}
-        nft={token}
-        on:insufficientFunds={handleInsufficientFunds} />
+    <div class="flex md:w-2/12 py-2 flex flex-col justify-center text-center" {...attrs} tabindex="0">
+      <Status bridgeTx={item} nft={token} on:insufficientFunds={handleInsufficientFunds} />
     </div>
     <div class="hidden md:flex grow py-2 flex flex-col justify-center">
       <a
@@ -191,15 +155,7 @@
     </div>
   </div>
 {:else}
-  <!-- We disable these warnings as we dynamically add the role -->
-  <!-- svelte-ignore a11y-no-noninteractive-tabindex -->
-  <!-- svelte-ignore a11y-no-static-element-interactions -->
-  <div
-    {...attrs}
-    tabindex="0"
-    on:click={handleClick}
-    on:keydown={handlePress}
-    class="flex text-primary-content md:h-[80px] h-[45px] w-full my-[10px] md:my-[0px]">
+  <div {...attrs} class="flex text-primary-content md:h-[80px] h-[45px] w-full my-[10px] md:my-[0px]">
     {#if isDesktopOrLarger}
       <div class="w-1/5 py-2 flex flex-row">
         <ChainSymbolName chainId={item.srcChainId} />
@@ -238,10 +194,7 @@
     {/if}
 
     <div class="md:w-1/5 py-2 flex flex-col justify-center">
-      <Status
-        on:click={isDesktopOrLarger ? undefined : openDetails}
-        bridgeTx={item}
-        on:insufficientFunds={handleInsufficientFunds} />
+      <Status bridgeTx={item} on:insufficientFunds={handleInsufficientFunds} />
     </div>
     <div class="hidden md:flex w-1/5 py-2 flex flex-col justify-center">
       <a
@@ -252,19 +205,11 @@
         <Icon type="arrow-top-right" fillClass="fill-primary-link" />
       </a>
     </div>
-    <!-- <button on:click={() => (claimModalOpen = true)}>test</button> -->
   </div>
 {/if}
 
 <DesktopOrLarger bind:is={isDesktopOrLarger} />
 
-<MobileDetailsDialog
-  {token}
-  {closeDetails}
-  {detailsOpen}
-  selectedItem={item}
-  on:insufficientFunds={handleInsufficientFunds} />
-
-<NftInfoDialog nft={token} bind:modalOpen={nftInfoOpen} on:close={closeDetails} viewOnly />
+<NftInfoDialog nft={token} bind:modalOpen={nftInfoOpen} viewOnly />
 
 <InsufficientFunds bind:modalOpen={insufficientModal} />
diff --git a/packages/bridge-ui/src/i18n/en.json b/packages/bridge-ui/src/i18n/en.json
index 2ac0be68425..4295699de54 100644
--- a/packages/bridge-ui/src/i18n/en.json
+++ b/packages/bridge-ui/src/i18n/en.json
@@ -74,10 +74,6 @@
         "not_received": {
           "message": "The message is not proven and cannot be claimed right now.",
           "title": "Not received"
-        },
-        "too_early": {
-          "message": "You need to wait for the delay to pass before claiming",
-          "title": "Too early"
         }
       },
       "custom_token": {
@@ -167,9 +163,7 @@
         "processing": "Processing...",
         "success": {
           "claim": "Claim transaction sent successfully",
-          "claim_description": "You",
-          "prove": "Proof submitted",
-          "prove_description": "You have submitted your proof. Wait for the delay to pass, then you can claim your funds"
+          "prove": "Proof submitted"
         },
         "title": "Confirm"
       },
@@ -196,7 +190,7 @@
       }
     },
     "welcome_modal": {
-      "body": "Welcome to <span class='font-bold text-primary-brand'>Katla, our final testnet</span>.<br/>Strengthening security may cause some delay in L2→L1 bridging, <span class='font-bold text-primary-brand'>around 24 hours</span> on the testnet. We're striving for shorter delays on the mainnet.",
+      "body": "Welcome to <span class='font-bold text-primary-brand'>Hekla, our final testnet</span>.<br/>Strengthening security may cause some delay in L2→L1 bridging, <span class='font-bold text-primary-brand'>around 24 hours</span> on the testnet. We're striving for shorter delays on the mainnet.",
       "confirm": "I understand",
       "link": "Find out more",
       "title": "Important Update"
@@ -460,22 +454,15 @@
         "confirm": {
           "claim_button": "Claim now",
           "claim_description": "You can now claim your assets",
-          "proceed": "Proceed to claim",
-          "prove": "Submit proof",
-          "prove_description": "After successfully submitting your proof, wait for the cooldown delay. Then you can claim your funds."
+          "proceed": "Proceed to claim"
         },
         "pre_check": {
           "chain_check": "Connected to the correct chain",
           "funds_check": "Sufficient funds to claim",
-          "no_delay": "No delay",
           "ready": "You can continue with the claim process!",
-          "remaining_delay": "Remaining delay before claim",
           "step": "Claim step",
           "switch_chain": "This transaction is bridging to <span class=\"font-bold text-primary\">{chain}</span> You need to be connected           to this chain",
-          "title": "Requirements",
-          "two_step_claim": {
-            "description": "For your L2 to L1 transfer, a two-step claim with a <span class=\"font-bold text-primary\" >{delay}</span> waiting period in between is required. For detailed instructions, please consult our documentation."
-          }
+          "title": "Requirements"
         },
         "review": {
           "name": "Review",
@@ -513,6 +500,9 @@
       "explorer_short": "View"
     },
     "no_transactions": "No transactions found",
+    "release": {
+      "title": "Release assets"
+    },
     "retry": {
       "steps": {
         "select": {
@@ -543,7 +533,7 @@
         "name": "Failed"
       },
       "pending": {
-        "description": " Your asset is not yet eligible for claiming. The bridging process from Taiko to Sepolia may take several hours before becoming claimable. Sepolia to Taiko bridging should be claimable within minutes.",
+        "description": "Your asset is not yet eligible for claiming. The bridging process from Taiko to Holesky may take several hours before becoming claimable. Sepolia to Taiko bridging should be claimable within minutes.",
         "name": "Pending"
       },
       "processing": {
diff --git a/packages/bridge-ui/src/libs/bridge/Bridge.ts b/packages/bridge-ui/src/libs/bridge/Bridge.ts
index e4640a599b6..21968f74880 100644
--- a/packages/bridge-ui/src/libs/bridge/Bridge.ts
+++ b/packages/bridge-ui/src/libs/bridge/Bridge.ts
@@ -1,5 +1,5 @@
 import { readContract, simulateContract, writeContract } from '@wagmi/core';
-import { getContract, type Hash, UserRejectedRequestError } from 'viem';
+import { getContract, type Hash, UserRejectedRequestError, type WalletClient } from 'viem';
 
 import { bridgeAbi } from '$abi';
 import { routingContractsMap } from '$bridgeConfig';
@@ -11,6 +11,7 @@ import { config } from '$libs/wagmi';
 
 import {
   type BridgeArgs,
+  type BridgeTransaction,
   type ClaimArgs,
   MessageStatus,
   type ProcessMessageType,
@@ -29,24 +30,15 @@ export abstract class Bridge {
 
   /**
    * We are gonna run some common checks here:
-   * 1. Check that the wallet is connected to the destination chain
-   * 2. Check that the message is owned by the user
-   * 3. Check that the message has not been claimed already
-   * 4. Check that the message has not failed
-   *
-   * Important: wallet must be connected to the destination chain
+   * 1. Check that the message is owned by the user
+   * 2. Check that the message has not been claimed already
    */
-  protected async beforeClaiming({ bridgeTx, wallet }: ClaimArgs) {
-    const connectedChainId = await wallet.getChainId();
+  protected async beforeProcessing({ bridgeTx, wallet }: ClaimArgs) {
     const { msgHash, message } = bridgeTx;
     if (!message || !msgHash) throw new Error('Message is not defined');
 
-    const destChainId = Number(message.destChainId);
     const srcChainId = Number(message.srcChainId);
-    // Are we connected to the destination chain?
-    if (connectedChainId !== destChainId) {
-      throw new WrongChainError('wallet must be connected to the destination chain');
-    }
+    const destChainId = Number(message.destChainId);
 
     const { srcOwner } = message;
     if (!wallet || !wallet.account || !wallet.chain) throw new Error('Wallet is not connected');
@@ -57,18 +49,55 @@ export abstract class Bridge {
       throw new WrongOwnerError('user cannot process this as it is not their message');
     }
 
-    const destBridgeAddress = routingContractsMap[connectedChainId][srcChainId].bridgeAddress;
+    const destBridgeAddress = routingContractsMap[destChainId][srcChainId].bridgeAddress;
 
     const messageStatus = await readContract(config, {
       address: destBridgeAddress,
       abi: bridgeAbi,
       functionName: 'messageStatus',
       args: [msgHash],
-      chainId: connectedChainId,
+      chainId: destChainId,
     });
 
     log(`Claiming message with status ${messageStatus}`);
 
+    // Has it been claimed already?
+    if (messageStatus === MessageStatus.DONE) {
+      throw new MessageStatusError('message already processed');
+    }
+    return { messageStatus, destBridgeAddress };
+  }
+
+  /**
+   * 1. Check that the wallet is connected to the destination chain
+   * 2. Check that the message is owned by the user
+   * 3. Check that the message has not been claimed already
+   * 4. Check that the message has not failed
+   *
+   * Important: wallet must be connected to the destination chain
+   */
+  protected async beforeClaiming({
+    bridgeTx,
+    wallet,
+    messageStatus,
+  }: {
+    bridgeTx: BridgeTransaction;
+    wallet: WalletClient;
+    messageStatus: MessageStatus;
+  }) {
+    const connectedChainId = await wallet.getChainId();
+    const { msgHash, message } = bridgeTx;
+    if (!message || !msgHash) throw new Error('Message is not defined');
+
+    const destChainId = Number(message.destChainId);
+
+    // Are we connected to the correct chain?
+    if (connectedChainId !== destChainId) {
+      throw new WrongChainError('wallet must be connected to the destination chain');
+    }
+
+    log(`Claiming message with status ${messageStatus}`);
+
     // Has it been claimed already?
     if (messageStatus === MessageStatus.DONE) {
       throw new MessageStatusError('message already processed');
@@ -78,50 +107,56 @@ export abstract class Bridge {
     if (messageStatus === MessageStatus.FAILED) {
       throw new MessageStatusError('user can not process this as message has failed');
     }
+  }
 
-    return { messageStatus, destBridgeAddress };
+  // Currently identical to beforeClaiming
+  protected async beforeRetrying({
+    bridgeTx,
+    wallet,
+    messageStatus,
+  }: {
+    bridgeTx: BridgeTransaction;
+    wallet: WalletClient;
+    messageStatus: MessageStatus;
+  }) {
+    await this.beforeClaiming({ bridgeTx, wallet, messageStatus });
   }
 
   /**
-   * We are gonna run the following checks here:
-   * 1. Check that the wallet is connected to the source chain
+   * 1. Check that the wallet is connected to the destination chain
    * 2. Check that the message is owned by the user
-   * 3. Check that the message has failed
+   * 3. Check that the message has not been claimed already
+   * 4. Check that the message has not failed
+   *
+   * Important: wallet must be connected to the destination chain
    */
-  protected async beforeReleasing({ bridgeTx, wallet }: ClaimArgs) {
+  protected async beforeReleasing({
+    bridgeTx,
+    wallet,
+    messageStatus,
+  }: {
+    bridgeTx: BridgeTransaction;
+    wallet: WalletClient;
+    messageStatus: MessageStatus;
+  }) {
     const connectedChainId = await wallet.getChainId();
     const { msgHash, message } = bridgeTx;
     if (!message || !msgHash) throw new Error('Message is not defined');
 
     const srcChainId = Number(message.srcChainId);
-    // Are we connected to the source chain?
+
+    // Are we connected to the correct chain?
     if (connectedChainId !== srcChainId) {
-      throw new WrongChainError('wallet must be connected to the source chain');
+      throw new WrongChainError('wallet must be connected to the destination chain');
     }
 
-    const { srcOwner } = message;
-    if (!wallet || !wallet.account || !wallet.chain) throw new Error('Wallet is not connected');
+    log(`Claiming message with status ${messageStatus}`);
 
-    const userAddress = wallet.account.address;
-    // Are we the owner of the message?
-    if (srcOwner.toLowerCase() !== userAddress.toLowerCase()) {
-      throw new WrongOwnerError('user cannot process this as it is not their message');
+    // Has it been claimed already?
+    if (messageStatus === MessageStatus.DONE) {
+      throw new MessageStatusError('message already processed');
     }
 
-    // Before releasing we need to make sure the message has failed
-    const destChainId = Number(message.destChainId);
-    const destBridgeAddress = routingContractsMap[destChainId][srcChainId].bridgeAddress;
-
-    const messageStatus = await readContract(config, {
-      address: destBridgeAddress,
-      abi: bridgeAbi,
-      functionName: 'messageStatus',
-      args: [msgHash],
-      chainId: connectedChainId,
-    });
-
-    log(`Releasing message with status ${messageStatus}`);
-
     if (messageStatus !== MessageStatus.FAILED) {
       throw new MessageStatusError('message must fail to release funds');
     }
@@ -131,14 +166,21 @@ export abstract class Bridge {
   abstract estimateGas(args: BridgeArgs): Promise<bigint>;
   abstract bridge(args: BridgeArgs): Promise<Hash>;
 
-  async claim(args: ClaimArgs): Promise<Hash> {
-    const { messageStatus, destBridgeAddress } = await this.beforeClaiming(args);
-    const { blockNumber } = args.bridgeTx;
+  async processMessage(args: ClaimArgs): Promise<Hash> {
+    const { messageStatus, destBridgeAddress } = await this.beforeProcessing(args);
+    let blockNumber;
+
+    if (!args.bridgeTx.blockNumber && args.bridgeTx.receipt) {
+      blockNumber = args.bridgeTx.receipt?.blockNumber;
+    } else if (args.bridgeTx.blockNumber) {
+      blockNumber = args.bridgeTx.blockNumber;
+    } else {
+      throw new ProcessMessageError('Blocknumber is not defined');
+    }
+
     const { message, msgHash } = args.bridgeTx;
-    if (!message || !msgHash || !blockNumber)
-      throw new ProcessMessageError(
-        `message, msgHash or blocknumber is not defined, ${message}, ${msgHash}, ${blockNumber}`,
-      );
+    if (!message || !msgHash)
+      throw new ProcessMessageError(`message or msgHash  is not defined, ${message}, ${msgHash}, ${blockNumber}`);
 
     const client = await getConnectedWallet();
     if (!client) throw new Error('Client not found');
@@ -149,14 +191,27 @@ export abstract class Bridge {
       address: destBridgeAddress,
     });
 
+    const srcBridgeContract = await getContract({
+      client,
+      abi: bridgeAbi,
+      address: routingContractsMap[Number(message.srcChainId)][Number(message.destChainId)].bridgeAddress,
+    });
+
     try {
       let txHash: Hash;
       if (messageStatus === MessageStatus.NEW) {
+        // Initial claim
+        await this.beforeClaiming({ ...args, messageStatus });
+
         txHash = await this.processNewMessage({ ...args, bridgeContract, client });
       } else if (messageStatus === MessageStatus.RETRIABLE) {
+        // Claiming after a failed attempt
+        await this.beforeRetrying({ ...args, messageStatus });
         txHash = await this.retryMessage({ ...args, bridgeContract, client });
       } else if (messageStatus === MessageStatus.FAILED) {
-        txHash = await this.release({ ...args, bridgeContract, client });
+        // Release if the message has failed and the user wants to release the funds
+        await this.beforeReleasing({ ...args, messageStatus });
+        txHash = await this.release({ ...args, bridgeContract: srcBridgeContract, client });
       } else {
         throw new ProcessMessageError('Message status not supported for claiming.');
       }
@@ -175,9 +230,20 @@ export abstract class Bridge {
     const { message } = bridgeTx;
     if (!message) throw new ProcessMessageError('Message is not defined');
     const proof = await this._prover.getEncodedSignalProof({ bridgeTx });
+
     const estimatedGas = await bridgeContract.estimateGas.processMessage([message, proof], { account: client.account });
     log('Estimated gas for processMessage', estimatedGas);
 
+    // const wallet = await getConnectedWallet();
+
+    // return await wallet.writeContract({
+    //   address: bridgeContract.address,
+    //   abi: bridgeContract.abi,
+    //   functionName: 'processMessage',
+    //   args: [message, proof],
+    //   gas: 1000000n,
+    // });
+
     const { request } = await simulateContract(config, {
       address: bridgeContract.address,
       abi: bridgeContract.abi,
@@ -218,14 +284,15 @@ export abstract class Bridge {
   }
 
   private async release(args: ReleaseArgs) {
-    await this.beforeReleasing(args);
-
     const { bridgeTx, bridgeContract, client } = args;
     const { message } = bridgeTx;
     if (!message) throw new ReleaseError('Message is not defined');
-    const proof = await this._prover.getEncodedSignalProof({ bridgeTx });
+    const proof = await this._prover.getEncodedSignalProofForRecall({ bridgeTx });
+
+    log('Estimating gas for recallMessage', bridgeContract.address, [message, proof]);
+
     const estimatedGas = await bridgeContract.estimateGas.recallMessage([message, proof], { account: client.account });
-    log('Estimated gas for processMessage', estimatedGas);
+    log('Estimated gas for recallMessage', estimatedGas);
 
     const { request } = await simulateContract(config, {
       address: bridgeContract.address,
@@ -234,7 +301,7 @@ export abstract class Bridge {
       args: [message, proof],
       gas: estimatedGas,
     });
-    log('Simulate contract for processMessage', request);
+    log('Simulate contract for recallMessage', request);
 
     return await writeContract(config, request);
   }
diff --git a/packages/bridge-ui/src/libs/bridge/ERC1155Bridge.ts b/packages/bridge-ui/src/libs/bridge/ERC1155Bridge.ts
index 3c9a0c360d2..006bca550a5 100644
--- a/packages/bridge-ui/src/libs/bridge/ERC1155Bridge.ts
+++ b/packages/bridge-ui/src/libs/bridge/ERC1155Bridge.ts
@@ -1,7 +1,8 @@
 import { getPublicClient, simulateContract, writeContract } from '@wagmi/core';
 import { getContract, UserRejectedRequestError } from 'viem';
 
-import { erc1155Abi, erc1155VaultAbi } from '$abi';
+import { bridgeAbi, erc1155Abi, erc1155VaultAbi } from '$abi';
+import { routingContractsMap } from '$bridgeConfig';
 import { bridgeService } from '$config';
 import {
   ApproveError,
@@ -17,6 +18,7 @@ import { getLogger } from '$libs/util/logger';
 import { config } from '$libs/wagmi';
 
 import { Bridge } from './Bridge';
+import { calculateMessageDataSize } from './calculateMessageDataSize';
 import type { ERC1155BridgeArgs, NFTApproveArgs, NFTBridgeTransferOp, RequireApprovalArgs } from './types';
 
 const log = getLogger('ERC1155Bridge');
@@ -81,7 +83,7 @@ export class ERC1155Bridge extends Bridge {
       const isApprovedForAll = await this.isApprovedForAll({
         tokenAddress: token,
         spenderAddress: tokenVaultAddress,
-        tokenId: tokenId,
+        tokenId: BigInt(tokenId),
         owner: wallet.account.address,
         chainId: wallet.chain.id,
       });
@@ -96,28 +98,17 @@ export class ERC1155Bridge extends Bridge {
       log('Sending ERC1155 with fee', fee);
       log('Sending ERC1155 with args', sendERC1155Args);
 
-      // try {
-      //   const { request } = await simulateContract(config, {
-      //     address: tokenVaultContract.address,
-      //     abi: erc1155VaultAbi,
-      //     functionName: 'sendToken',
-      //     args: [sendERC1155Args],
-      //     value: fee,
-      //   });
-      //   log('Simulate contract', request);
-      // } catch (err) {
-      //   // TODO: Handle error
-      //   console.error(err);
-      // }
-
-      const tx = await writeContract(config, {
+      const { request } = await simulateContract(config, {
         address: tokenVaultContract.address,
         abi: erc1155VaultAbi,
         functionName: 'sendToken',
+        //@ts-ignore
         args: [sendERC1155Args],
-        chainId: wallet.chain.id,
         value: fee,
       });
+      log('Simulate contract', request);
+
+      const tx = await writeContract(config, request);
 
       log('ERC1155 sent', tx);
 
@@ -155,27 +146,16 @@ export class ERC1155Bridge extends Bridge {
     try {
       log(`Calling approve for spender "${spenderAddress}" for token`, tokenIds);
 
-      try {
-        const { request } = await simulateContract(config, {
-          address: tokenAddress,
-          abi: erc1155Abi,
-          functionName: 'setApprovalForAll',
-          args: [spenderAddress, true],
-          chainId: wallet.chain.id,
-        });
-        log('Simulate contract', request);
-      } catch (err) {
-        // TODO: Handle error
-        console.error(err);
-      }
-
-      const txHash = await writeContract(config, {
+      const { request } = await simulateContract(config, {
         address: tokenAddress,
         abi: erc1155Abi,
         functionName: 'setApprovalForAll',
         args: [spenderAddress, true],
         chainId: wallet.chain.id,
       });
+      log('Simulate contract', request);
+
+      const txHash = await writeContract(config, request);
 
       log('Transaction hash for approve call', txHash);
 
@@ -195,12 +175,13 @@ export class ERC1155Bridge extends Bridge {
     const {
       to,
       wallet,
+      srcChainId,
       destChainId,
       token,
+      tokenObject,
       fee,
       tokenVaultAddress,
       isTokenAlreadyDeployed,
-      memo = '',
       tokenIds,
       amounts,
     } = args;
@@ -213,12 +194,24 @@ export class ERC1155Bridge extends Bridge {
       address: tokenVaultAddress,
     });
 
-    const refundTo = wallet.account.address;
+    const { size } = await calculateMessageDataSize({ token: tokenObject, chainId: srcChainId, tokenIds, amounts });
+
+    const client = await getPublicClient(config, { chainId: destChainId });
+    if (!client) throw new Error('Could not get public client');
+
+    const destBridgeAddress = routingContractsMap[destChainId][srcChainId].bridgeAddress;
+    const destBridgeContract = getContract({
+      client,
+      abi: bridgeAbi,
+      address: destBridgeAddress,
+    });
+
+    const minGasLimit = await destBridgeContract.read.getMessageMinGasLimit([BigInt(size)]);
 
     const gasLimit = !isTokenAlreadyDeployed
-      ? BigInt(bridgeService.noERC1155TokenDeployedGasLimit)
+      ? minGasLimit + Number(bridgeService.noERC1155TokenDeployedGasLimit)
       : fee > 0
-        ? bridgeService.noOwnerGasLimit
+        ? minGasLimit + Number(bridgeService.erc1155GasLimitThreshold)
         : BigInt(0);
 
     const sendERC1155Args: NFTBridgeTransferOp = {
@@ -226,12 +219,10 @@ export class ERC1155Bridge extends Bridge {
       to,
       destOwner: to,
       token,
-      gasLimit,
+      gasLimit: Number(gasLimit),
       fee,
-      refundTo,
-      memo,
-      tokenIds,
-      amounts,
+      tokenIds: tokenIds.map(BigInt),
+      amounts: amounts.map(BigInt),
     };
 
     log('Preparing transaction with args', sendERC1155Args);
diff --git a/packages/bridge-ui/src/libs/bridge/ERC20Bridge.ts b/packages/bridge-ui/src/libs/bridge/ERC20Bridge.ts
index 9401a4f4eef..dcd0df52160 100644
--- a/packages/bridge-ui/src/libs/bridge/ERC20Bridge.ts
+++ b/packages/bridge-ui/src/libs/bridge/ERC20Bridge.ts
@@ -1,32 +1,41 @@
-import { readContract, simulateContract, writeContract } from '@wagmi/core';
+import { getPublicClient, readContract, simulateContract, writeContract } from '@wagmi/core';
 import { getContract, UserRejectedRequestError } from 'viem';
 
-import { erc20Abi, erc20VaultAbi } from '$abi';
-import { bridgeService } from '$config';
+import { bridgeAbi, erc20Abi, erc20VaultAbi } from '$abi';
+import { routingContractsMap } from '$bridgeConfig';
 import {
   ApproveError,
   BridgePausedError,
   InsufficientAllowanceError,
   NoAllowanceRequiredError,
-  NoTokenInfoFoundError,
   SendERC20Error,
 } from '$libs/error';
 import type { BridgeProver } from '$libs/proof';
-import { TokenType } from '$libs/token';
-import { getTokenAddressesForAddress } from '$libs/token/getTokenAddresses';
 import { isBridgePaused } from '$libs/util/checkForPausedContracts';
 import { getConnectedWallet } from '$libs/util/getConnectedWallet';
 import { getLogger } from '$libs/util/logger';
 import { config } from '$libs/wagmi';
 
 import { Bridge } from './Bridge';
+import { calculateMessageDataSize } from './calculateMessageDataSize';
 import type { ApproveArgs, BridgeTransferOp, ERC20BridgeArgs, RequireAllowanceArgs } from './types';
 
 const log = getLogger('ERC20Bridge');
 
 export class ERC20Bridge extends Bridge {
   private static async _prepareTransaction(args: ERC20BridgeArgs) {
-    const { to, amount, wallet, destChainId, token, fee, tokenVaultAddress, isTokenAlreadyDeployed, memo = '' } = args;
+    const {
+      to,
+      amount,
+      wallet,
+      srcChainId,
+      destChainId,
+      token,
+      tokenObject,
+      fee,
+      tokenVaultAddress,
+      isTokenAlreadyDeployed,
+    } = args;
     if (!wallet || !wallet.account) throw new Error('No wallet found');
 
     const tokenVaultContract = getContract({
@@ -35,25 +44,33 @@ export class ERC20Bridge extends Bridge {
       address: tokenVaultAddress,
     });
 
-    const refundTo = wallet.account.address;
+    const { size } = await calculateMessageDataSize({ token: tokenObject, chainId: srcChainId });
+
+    const client = await getPublicClient(config, { chainId: destChainId });
+    if (!client) throw new Error('Could not get public client');
+
+    const destBridgeAddress = routingContractsMap[destChainId][srcChainId].bridgeAddress;
+    const destBridgeContract = getContract({
+      client,
+      abi: bridgeAbi,
+      address: destBridgeAddress,
+    });
+
+    const minGasLimit = await destBridgeContract.read.getMessageMinGasLimit([BigInt(size)]);
+
+    const gasLimit = !isTokenAlreadyDeployed ? minGasLimit + 650_000 : fee > 0n ? minGasLimit + 650_000 : BigInt(0);
 
-    const gasLimit = !isTokenAlreadyDeployed
-      ? BigInt(bridgeService.noERC20TokenDeployedGasLimit)
-      : fee > 0
-        ? bridgeService.noOwnerGasLimit
-        : BigInt(0);
+    log('Calculated gasLimit for message', gasLimit);
 
-    const sendERC20Args: BridgeTransferOp = {
+    const sendERC20Args = {
       destChainId: BigInt(destChainId),
       destOwner: to,
       to,
       token,
       amount,
-      gasLimit,
+      gasLimit: Number(gasLimit),
       fee,
-      refundTo,
-      memo,
-    };
+    } satisfies BridgeTransferOp;
 
     log('Preparing transaction with args', sendERC20Args);
 
@@ -131,13 +148,7 @@ export class ERC20Bridge extends Bridge {
 
       if (!wallet || !wallet.account || !wallet.chain) throw new Error('Wallet is not connected');
 
-      const txHash = await writeContract(config, {
-        address: tokenAddress,
-        abi: erc20Abi,
-        functionName: 'approve',
-        args: [spenderAddress, amount],
-        chainId: wallet.chain.id,
-      });
+      const txHash = await writeContract(config, request);
 
       log('Transaction hash for approve call', txHash);
 
@@ -154,55 +165,35 @@ export class ERC20Bridge extends Bridge {
   }
 
   async bridge(args: ERC20BridgeArgs) {
-    const { amount, token, wallet, tokenVaultAddress, srcChainId, destChainId } = args;
-    const type = TokenType.ERC20;
-    const info = await getTokenAddressesForAddress({ address: token, srcChainId, destChainId, type });
-
-    if (!info) throw new NoTokenInfoFoundError(`Could not find any token info for ${token}`);
+    const { amount, token, wallet, tokenVaultAddress } = args;
 
-    const { canonical } = info;
-    const canonicalTokenAddress = canonical?.address;
     if (!wallet || !wallet.account || !wallet.chain) throw new Error('Wallet is not connected');
 
-    if (canonicalTokenAddress === token) {
-      // Token is native, we need to check if we have approval
-      const requireAllowance = await this.requireAllowance({
-        amount,
-        tokenAddress: token,
-        ownerAddress: wallet.account.address,
-        spenderAddress: tokenVaultAddress,
-      });
+    const requireAllowance = await this.requireAllowance({
+      amount,
+      tokenAddress: token,
+      ownerAddress: wallet.account.address,
+      spenderAddress: tokenVaultAddress,
+    });
 
-      if (requireAllowance) {
-        throw new InsufficientAllowanceError(`Insufficient allowance for the amount ${amount}`);
-      }
-    } else {
-      log('Token is bridged, no need to check for approval');
+    if (requireAllowance) {
+      throw new InsufficientAllowanceError(`Insufficient allowance for the amount ${amount}`);
     }
 
     const { tokenVaultContract, sendERC20Args } = await ERC20Bridge._prepareTransaction(args);
     const { fee } = sendERC20Args;
 
     try {
-      log('Calling sendERC20 with value', fee);
-
-      // const { request } = await simulateContract(config, {
-      //   address: tokenVaultContract.address,
-      //   abi: erc20VaultAbi,
-      //   functionName: 'sendToken',
-      //   args: [sendERC20Args],
-      //   value: fee,
-      // });
-      // log('Simulate contract', request);
-
-      const txHash = await writeContract(config, {
+      const { request } = await simulateContract(config, {
         address: tokenVaultContract.address,
         abi: erc20VaultAbi,
         functionName: 'sendToken',
         args: [sendERC20Args],
-        chainId: wallet.chain.id,
         value: fee,
       });
+      log('Simulate contract', request);
+
+      const txHash = await writeContract(config, request);
 
       log('Transaction hash for sendERC20 call', txHash);
 
diff --git a/packages/bridge-ui/src/libs/bridge/ERC721Bridge.ts b/packages/bridge-ui/src/libs/bridge/ERC721Bridge.ts
index d206839baf0..28100c00bf1 100644
--- a/packages/bridge-ui/src/libs/bridge/ERC721Bridge.ts
+++ b/packages/bridge-ui/src/libs/bridge/ERC721Bridge.ts
@@ -1,7 +1,8 @@
-import { getWalletClient, readContract, simulateContract, writeContract } from '@wagmi/core';
+import { getPublicClient, getWalletClient, readContract, simulateContract, writeContract } from '@wagmi/core';
 import { getContract, UserRejectedRequestError } from 'viem';
 
-import { erc721Abi, erc721VaultAbi } from '$abi';
+import { bridgeAbi, erc721Abi, erc721VaultAbi } from '$abi';
+import { routingContractsMap } from '$bridgeConfig';
 import { bridgeService } from '$config';
 import {
   ApproveError,
@@ -19,6 +20,7 @@ import { getLogger } from '$libs/util/logger';
 import { config } from '$libs/wagmi';
 
 import { Bridge } from './Bridge';
+import { calculateMessageDataSize } from './calculateMessageDataSize';
 import type { ERC721BridgeArgs, NFTApproveArgs, NFTBridgeTransferOp, RequireApprovalArgs } from './types';
 
 const log = getLogger('ERC721Bridge');
@@ -68,6 +70,7 @@ export class ERC721Bridge extends Bridge {
 
   async bridge(args: ERC721BridgeArgs) {
     const { token, tokenVaultAddress, tokenIds, wallet, srcChainId, destChainId } = args;
+
     const { tokenVaultContract, sendERC721Args } = await ERC721Bridge._prepareTransaction(args);
     const { fee } = sendERC721Args;
 
@@ -90,7 +93,7 @@ export class ERC721Bridge extends Bridge {
         const requireApproval = await this.requiresApproval({
           tokenAddress: token,
           spenderAddress: tokenVaultAddress,
-          tokenId: tokenId,
+          tokenId: BigInt(tokenId),
           chainId: wallet.chain.id,
         });
         if (requireApproval) {
@@ -107,28 +110,17 @@ export class ERC721Bridge extends Bridge {
       log('Sending ERC721 with fee', fee);
       log('Sending ERC721 with args', sendERC721Args);
 
-      // try {
-      //   const { request } = await simulateContract(config, {
-      //     address: tokenVaultContract.address,
-      //     abi: erc721VaultAbi,
-      //     functionName: 'sendToken',
-      //     args: [sendERC721Args],
-      //     value: fee,
-      //   });
-      //   log('Simulate contract', request);
-      // } catch (err) {
-      //   // TODO: Handle error
-      //   console.error(err);
-      // }
-
-      const txHash = await writeContract(config, {
+      const { request } = await simulateContract(config, {
         address: tokenVaultContract.address,
         abi: erc721VaultAbi,
         functionName: 'sendToken',
+        //@ts-ignore
         args: [sendERC721Args],
-        chainId: wallet.chain.id,
         value: fee,
       });
+      log('Simulate contract', request);
+
+      const txHash = await writeContract(config, request);
 
       log('Transaction hash for sendERC20 call', txHash);
 
@@ -165,7 +157,6 @@ export class ERC721Bridge extends Bridge {
     try {
       log(`Calling approve for spender "${spenderAddress}" for token`, tokenIds);
 
-      // const txHash = await tokenContract.write.approve([spenderAddress, tokenId]);
       const { request } = await simulateContract(config, {
         address: tokenAddress,
         abi: erc721Abi,
@@ -196,12 +187,13 @@ export class ERC721Bridge extends Bridge {
     const {
       to,
       wallet,
+      srcChainId,
       destChainId,
+      tokenObject,
       token,
       fee,
       tokenVaultAddress,
       isTokenAlreadyDeployed,
-      memo = '',
       tokenIds,
       amounts,
     } = args;
@@ -213,12 +205,25 @@ export class ERC721Bridge extends Bridge {
     });
 
     if (!wallet || !wallet.account) throw new Error('Wallet is not connected');
-    const refundTo = wallet.account.address;
+
+    const { size } = await calculateMessageDataSize({ token: tokenObject, chainId: srcChainId, tokenIds });
+
+    const client = await getPublicClient(config, { chainId: destChainId });
+    if (!client) throw new Error('Could not get public client');
+
+    const destBridgeAddress = routingContractsMap[destChainId][srcChainId].bridgeAddress;
+    const destBridgeContract = getContract({
+      client,
+      abi: bridgeAbi,
+      address: destBridgeAddress,
+    });
+
+    const minGasLimit = await destBridgeContract.read.getMessageMinGasLimit([BigInt(size)]);
 
     const gasLimit = !isTokenAlreadyDeployed
-      ? BigInt(bridgeService.noERC721TokenDeployedGasLimit)
+      ? minGasLimit + Number(bridgeService.noERC721TokenDeployedGasLimit)
       : fee > 0
-        ? bridgeService.noOwnerGasLimit
+        ? minGasLimit + Number(bridgeService.erc721GasLimitThreshold)
         : BigInt(0);
 
     const sendERC721Args: NFTBridgeTransferOp = {
@@ -226,13 +231,11 @@ export class ERC721Bridge extends Bridge {
       to,
       destOwner: to,
       token,
-      gasLimit,
+      gasLimit: Number(gasLimit),
       fee,
-      refundTo,
-      memo,
-      tokenIds,
-      amounts,
-    };
+      tokenIds: tokenIds.map(BigInt),
+      amounts: amounts.map(BigInt),
+    } satisfies NFTBridgeTransferOp;
 
     log('Preparing transaction with args', sendERC721Args);
 
diff --git a/packages/bridge-ui/src/libs/bridge/ETHBridge.ts b/packages/bridge-ui/src/libs/bridge/ETHBridge.ts
index abb18f5a8a7..881b2883646 100644
--- a/packages/bridge-ui/src/libs/bridge/ETHBridge.ts
+++ b/packages/bridge-ui/src/libs/bridge/ETHBridge.ts
@@ -2,7 +2,6 @@ import { getWalletClient, simulateContract, writeContract } from '@wagmi/core';
 import { getContract, UserRejectedRequestError } from 'viem';
 
 import { bridgeAbi } from '$abi';
-import { bridgeService } from '$config';
 import { BridgePausedError, SendMessageError } from '$libs/error';
 import type { BridgeProver } from '$libs/proof';
 import { isBridgePaused } from '$libs/util/checkForPausedContracts';
@@ -16,7 +15,7 @@ const log = getLogger('bridge:ETHBridge');
 
 export class ETHBridge extends Bridge {
   private static async _prepareTransaction(args: ETHBridgeArgs) {
-    const { to, amount, wallet, srcChainId, destChainId, bridgeAddress, fee: processingFee, memo = '' } = args;
+    const { to, amount, wallet, srcChainId, destChainId, bridgeAddress, fee: processingFee } = args;
 
     if (!wallet || !wallet.account) throw new Error('No wallet found');
 
@@ -39,30 +38,30 @@ export class ETHBridge extends Bridge {
       value = senderAmount;
     }
 
-    // If there is a processing fee, use the specified message gas limit
-    // as might not be called by the owner
-    const gasLimit = processingFee > 0 ? bridgeService.noOwnerGasLimit : BigInt(0);
-
     const message: Message = {
       to,
       srcOwner: owner,
       from: owner,
-      refundTo: owner,
 
       destOwner: to,
 
       srcChainId: BigInt(srcChainId),
       destChainId: BigInt(destChainId),
 
-      gasLimit,
+      gasLimit: 0,
       value,
       fee: processingFee,
 
-      memo,
       data: '0x',
       id: BigInt(0), // will be set in contract
     };
 
+    const minGasLimit = await bridgeContract.read.getMessageMinGasLimit([0n]);
+    log('Min gas limit for message', minGasLimit);
+
+    const gasLimit = minGasLimit + 1;
+    message.gasLimit = gasLimit;
+
     log('Preparing transaction with message', message);
 
     return { bridgeContract, message };
@@ -112,14 +111,7 @@ export class ETHBridge extends Bridge {
       });
       log('Simulate contract', request);
 
-      const txHash = await writeContract(config, {
-        address: bridgeContract.address,
-        abi: bridgeAbi,
-        functionName: 'sendMessage',
-        args: [message],
-        chainId,
-        value,
-      });
+      const txHash = await writeContract(config, request);
       log('Transaction hash for sendMessage call', txHash);
 
       return txHash;
diff --git a/packages/bridge-ui/src/libs/bridge/bridges.ts b/packages/bridge-ui/src/libs/bridge/bridges.ts
index d4e15042b26..2b9ef690c40 100644
--- a/packages/bridge-ui/src/libs/bridge/bridges.ts
+++ b/packages/bridge-ui/src/libs/bridge/bridges.ts
@@ -8,13 +8,28 @@ import { ERC721Bridge } from './ERC721Bridge';
 import { ERC1155Bridge } from './ERC1155Bridge';
 import { ETHBridge } from './ETHBridge';
 
-const prover = new BridgeProver();
+let proverInstance: BridgeProver | null = null;
+
+function getProverInstance(): BridgeProver {
+  if (!proverInstance) {
+    proverInstance = new BridgeProver();
+  }
+  return proverInstance;
+}
 
 export const bridges: Record<TokenType, Bridge> = {
-  ETH: new ETHBridge(prover),
-  ERC20: new ERC20Bridge(prover),
-  ERC721: new ERC721Bridge(prover),
-  ERC1155: new ERC1155Bridge(prover),
+  get ETH() {
+    return new ETHBridge(getProverInstance());
+  },
+  get ERC20() {
+    return new ERC20Bridge(getProverInstance());
+  },
+  get ERC721() {
+    return new ERC721Bridge(getProverInstance());
+  },
+  get ERC1155() {
+    return new ERC1155Bridge(getProverInstance());
+  },
 };
 
 export const hasBridge = (srcChainId: number, destChainId: number): boolean => {
diff --git a/packages/bridge-ui/src/libs/bridge/calculateMessageDataSize.test.ts b/packages/bridge-ui/src/libs/bridge/calculateMessageDataSize.test.ts
new file mode 100644
index 00000000000..dc1f5bc7e85
--- /dev/null
+++ b/packages/bridge-ui/src/libs/bridge/calculateMessageDataSize.test.ts
@@ -0,0 +1,98 @@
+import { zeroAddress } from 'viem';
+
+import { ETHToken } from '$libs/token';
+import { L1_CHAIN_ID, MOCK_ERC20, MOCK_ERC721, MOCK_ERC1155 } from '$mocks';
+
+import { calculateMessageDataSize } from './calculateMessageDataSize';
+
+vi.mock('../../generated/customTokenConfig', () => {
+  const mockERC20 = {
+    name: 'MockERC20',
+    addresses: { 1: zeroAddress },
+    symbol: 'MOCK',
+    decimals: 18,
+    type: 'ERC20',
+  };
+  return {
+    customToken: [mockERC20],
+  };
+});
+
+describe('calculateMessageDataSize', () => {
+  it('should calculate the message data size for ERC20 correctly', async () => {
+    // Given
+    const token = MOCK_ERC20;
+    const chainId = L1_CHAIN_ID;
+    const expectedSize = { size: 516 };
+
+    // When
+    const result = await calculateMessageDataSize({ token, chainId });
+
+    // Then
+    expect(result).toEqual(expectedSize);
+  });
+
+  it('should calculate the message data size for ETH correctly', async () => {
+    // Given
+    const token = ETHToken;
+    const chainId = L1_CHAIN_ID;
+    const expectedSize = { size: 0 };
+
+    // When
+    const result = await calculateMessageDataSize({ token, chainId });
+
+    expect(result).toEqual(expectedSize);
+  });
+
+  it('should calculate the message data size for ERC721 correctly', async () => {
+    // Given
+    const token = MOCK_ERC721;
+    const chainId = L1_CHAIN_ID;
+    const expectedSize = { size: 548 };
+
+    // When
+    const result = await calculateMessageDataSize({
+      token,
+      chainId,
+      tokenIds: [1],
+    });
+
+    // Then
+    expect(result).toEqual(expectedSize);
+  });
+
+  it('should calculate the message data size for multiple ERC721 correctly', async () => {
+    // Given
+    const token = MOCK_ERC721;
+    const chainId = L1_CHAIN_ID;
+    const expectedSize = { size: 612 };
+
+    // When
+    const result = await calculateMessageDataSize({
+      token,
+      chainId,
+      tokenIds: [1, 2, 3],
+    });
+
+    // Then
+    expect(result).toEqual(expectedSize);
+  });
+
+  it('should calculate the message data size for multiple ERC1155 correctly', async () => {
+    // Given
+    const token = MOCK_ERC1155;
+    const chainId = L1_CHAIN_ID;
+    const expectedSize = { size: 772 };
+
+    // When
+    const result = await calculateMessageDataSize({
+      token,
+      chainId,
+      tokenIds: [1, 2, 3],
+      amounts: [5, 1, 42],
+    });
+
+    // Then
+    expect(result).toEqual(expectedSize);
+  });
+});
diff --git a/packages/bridge-ui/src/libs/bridge/calculateMessageDataSize.ts b/packages/bridge-ui/src/libs/bridge/calculateMessageDataSize.ts
new file mode 100644
index 00000000000..d6e74b1d7b8
--- /dev/null
+++ b/packages/bridge-ui/src/libs/bridge/calculateMessageDataSize.ts
@@ -0,0 +1,220 @@
+import { encodeAbiParameters, encodeFunctionData, type Hex, zeroAddress } from 'viem';
+
+import { erc20VaultAbi, erc721VaultAbi, erc1155VaultAbi } from '$abi';
+import { type NFT, type Token, TokenType } from '$libs/token';
+import { getLogger } from '$libs/util/logger';
+
+type CanonicalERC20 = {
+  chainId: number;
+  addr: string;
+  decimals: number;
+  symbol: string;
+  name: string;
+};
+
+type CanonicalNFT = {
+  chainId: number;
+  addr: string;
+  symbol: string;
+  name: string;
+};
+
+const log = getLogger('calculateMessageDataSize');
+
+export async function calculateMessageDataSize({
+  token,
+  chainId,
+  tokenIds,
+  amounts,
+}: {
+  token: Token | NFT | NFT[];
+  chainId: number;
+  tokenIds?: number[];
+  amounts?: number[];
+}): Promise<{ size: number }> {
+  if (Array.isArray(token)) {
+    let totalSize = 0;
+    for (const nft of token) {
+      const encodedData = await encodeData(nft, chainId);
+
+      const tmpBuffer = Buffer.from(encodedData.substring(2), 'hex');
+
+      const buffer = Buffer.alloc(tmpBuffer.length + 32);
+
+      tmpBuffer.copy(buffer);
+
+      totalSize += buffer.length;
+    }
+    return { size: totalSize };
+  } else {
+    if (token.type === TokenType.ETH) {
+      return { size: 0 };
+    }
+
+    const encodedData = await encodeData(token, chainId, tokenIds, amounts);
+
+    const tmpBuffer = Buffer.from(encodedData.substring(2), 'hex');
+
+    const buffer = Buffer.alloc(tmpBuffer.length + 32);
+
+    tmpBuffer.copy(buffer);
+
+    return { size: buffer.length };
+  }
+}
+
+async function encodeData(token: Token, chainId: number, tokenIds?: number[], amounts?: number[]): Promise<Hex> {
+  if (token.type === TokenType.ERC20) {
+    const cToken = {
+      chainId, // technically should be the canonical chain but as we just are just calculating the data size it doesn't matter
+      addr: token.addresses[chainId], // same as above
+      decimals: token.decimals,
+      symbol: token.symbol,
+      name: token.name,
+    } satisfies CanonicalERC20;
+
+    const params = [
+      {
+        type: 'tuple',
+        name: 'ctoken',
+        components: [
+          { type: 'uint64', name: 'chainId' },
+          { type: 'address', name: 'addr' },
+          { type: 'uint8', name: 'decimals' },
+          { type: 'string', name: 'symbol' },
+          { type: 'string', name: 'name' },
+        ],
+      },
+      {
+        type: 'address',
+        name: 'user',
+      },
+      {
+        type: 'address',
+        name: 'to',
+      },
+      {
+        type: 'uint256',
+        name: 'balanceChange',
+      },
+    ];
+
+    const values = [
+      // cToken tuple
+      [cToken.chainId, cToken.addr, cToken.decimals, cToken.symbol, cToken.name],
+      zeroAddress, // user address
+      zeroAddress, // to address
+      0, // balanceChange
+    ];
+
+    const callData = encodeAbiParameters(params, values);
+    log('callData', callData);
+
+    const encodedData = encodeFunctionData({
+      abi: erc20VaultAbi,
+      functionName: 'onMessageInvocation',
+      args: [callData],
+    });
+
+    log('encodedData', encodedData);
+    return encodedData;
+  }
+  if (token.type === TokenType.ERC1155) {
+    const cNFT = {
+      chainId, // technically should be the canonical chain but as we just are just calculating the data size it doesn't matter
+      addr: token.addresses[chainId], // same as above
+      symbol: token.symbol,
+      name: token.name,
+    } satisfies CanonicalNFT;
+
+    const params = [
+      {
+        type: 'tuple',
+        name: 'cNFT',
+        components: [
+          { type: 'uint64', name: 'chainId' },
+          { type: 'address', name: 'addr' },
+          { type: 'string', name: 'symbol' },
+          { type: 'string', name: 'name' },
+        ],
+      },
+      {
+        type: 'address',
+        name: 'user',
+      },
+      {
+        type: 'address',
+        name: 'to',
+      },
+      {
+        type: 'uint[]',
+        name: 'tokenIds',
+      },
+      {
+        type: 'uint[]',
+        name: 'amounts',
+      },
+    ];
+
+    const values = [[cNFT.chainId, cNFT.addr, cNFT.symbol, cNFT.name], zeroAddress, zeroAddress, tokenIds, amounts];
+
+    const callData = encodeAbiParameters(params, values);
+    log('callData', callData);
+
+    const encodedData = encodeFunctionData({
+      abi: erc1155VaultAbi,
+      functionName: 'onMessageInvocation',
+      args: [callData],
+    });
+    log('encodedData', encodedData);
+    return encodedData;
+  } else if (token.type === TokenType.ERC721) {
+    const cNFT = {
+      chainId, // technically should be the canonical chain but as we just are just calculating the data size it doesn't matter
+      addr: token.addresses[chainId], // same as above
+      symbol: token.symbol,
+      name: token.name,
+    } satisfies CanonicalNFT;
+
+    const params = [
+      {
+        type: 'tuple',
+        name: 'cNFT',
+        components: [
+          { type: 'uint64', name: 'chainId' },
+          { type: 'address', name: 'addr' },
+          { type: 'string', name: 'symbol' },
+          { type: 'string', name: 'name' },
+        ],
+      },
+      {
+        type: 'address',
+        name: 'user',
+      },
+      {
+        type: 'address',
+        name: 'to',
+      },
+      {
+        type: 'uint[]',
+        name: 'tokenIds',
+      },
+    ];
+
+    const values = [[cNFT.chainId, cNFT.addr, cNFT.symbol, cNFT.name], zeroAddress, zeroAddress, tokenIds?.map(BigInt)];
+
+    const callData = encodeAbiParameters(params, values);
+    log('callData', callData);
+
+    const encodedData = encodeFunctionData({
+      abi: erc721VaultAbi,
+      functionName: 'onMessageInvocation',
+      args: [callData],
+    });
+
+    log('encodedData', encodedData);
+    return encodedData;
+  } else {
+    throw new Error('Unsupported token type');
+  }
+}
diff --git a/packages/bridge-ui/src/libs/bridge/checkBalanceToBridge.ts b/packages/bridge-ui/src/libs/bridge/checkBalanceToBridge.ts
index bfaed6b69d2..fc572826599 100644
--- a/packages/bridge-ui/src/libs/bridge/checkBalanceToBridge.ts
+++ b/packages/bridge-ui/src/libs/bridge/checkBalanceToBridge.ts
@@ -122,10 +122,12 @@ async function handleErc1155Bridge(args: CheckBalanceToBridgeTokenArgs) {
     estimatedCost = await estimateCostOfBridging(bridges.ERC1155, {
       ...args,
       wallet,
-      amounts: _amount,
+      amounts: _amount.map((a) => Number(a)),
       token: tokenAddress,
       tokenVaultAddress: erc1155VaultAddress,
       isTokenAlreadyDeployed,
+      tokenObject: token,
+      tokenIds: args.tokenIds?.map((a) => Number(a)),
     } as ERC1155BridgeArgs);
   } catch (err) {
     console.error(err);
@@ -182,6 +184,7 @@ async function handleErc20Bridge(args: CheckBalanceToBridgeTokenArgs): Promise<v
         token: tokenAddress,
         tokenVaultAddress: erc20VaultAddress,
         isTokenAlreadyDeployed,
+        tokenObject: token,
       } as ERC20BridgeArgs);
     } catch (err) {
       // TODO: same here. Error code or instance would be better
diff --git a/packages/bridge-ui/src/libs/bridge/getBridgeArgs.ts b/packages/bridge-ui/src/libs/bridge/getBridgeArgs.ts
index 51ee97a7661..4286cf9225c 100644
--- a/packages/bridge-ui/src/libs/bridge/getBridgeArgs.ts
+++ b/packages/bridge-ui/src/libs/bridge/getBridgeArgs.ts
@@ -88,8 +88,8 @@ export const getBridgeArgs = async (
         token: tokenAddress,
         tokenVaultAddress,
         isTokenAlreadyDeployed,
-        tokenIds,
-        amounts: [token.type === TokenType.ERC721 ? BigInt(0) : amount],
+        tokenIds: tokenIds.map((id) => Number(id)),
+        amounts: [token.type === TokenType.ERC721 ? 0 : Number(amount)],
       };
       return args as BridgeArgsMap[typeof token.type];
     }
diff --git a/packages/bridge-ui/src/libs/bridge/getInvocationDelayForTx.test.ts b/packages/bridge-ui/src/libs/bridge/getInvocationDelayForTx.test.ts
deleted file mode 100644
index a4b2a451832..00000000000
--- a/packages/bridge-ui/src/libs/bridge/getInvocationDelayForTx.test.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { getInvocationDelayForTx } from '$libs/bridge/getInvocationDelayForTx';
-import { getInvocationDelaysForDestBridge } from '$libs/bridge/getInvocationDelaysForDestBridge';
-import { getProofReceiptForMsgHash } from '$libs/bridge/getProofReceiptForMsgHash';
-import { getLatestBlockTimestamp } from '$libs/util/getLatestBlockTimestamp';
-import { ALICE, L1_CHAIN_ID, L2_CHAIN_ID, MOCK_BRIDGE_TX_1 } from '$mocks';
-
-vi.mock('$customToken', () => {
-  const mockERC20 = {
-    name: 'MockERC20',
-    addresses: { '1': '0x123' },
-    symbol: 'MTF',
-    decimals: 18,
-    type: 'ERC20',
-  };
-  return {
-    customToken: [mockERC20],
-  };
-});
-
-vi.mock('$libs/bridge/getInvocationDelaysForDestBridge');
-vi.mock('$libs/bridge/getProofReceiptForMsgHash');
-vi.mock('$libs/util/getLatestBlockTimestamp');
-
-describe('getInvocationDelayForTx()', () => {
-  it('should return the invocation delays for the transaction', async () => {
-    const MOCK_BLOCK_TIMESTAMP = 1632787200n;
-    const MOCK_RECEIPT_TIMESTAMP = 1632787200n - 200n;
-    const PREFERRED_CLAIMER_DELAY = 100n;
-    const NOT_PREFERRED_CLAIMER_DELAY = 200n;
-    const MOCK_DELAYS = [PREFERRED_CLAIMER_DELAY, NOT_PREFERRED_CLAIMER_DELAY] as const;
-
-    //Given
-    vi.mocked(getInvocationDelaysForDestBridge).mockResolvedValue(MOCK_DELAYS);
-    vi.mocked(getLatestBlockTimestamp).mockResolvedValue(MOCK_BLOCK_TIMESTAMP);
-    vi.mocked(getProofReceiptForMsgHash).mockResolvedValue([MOCK_RECEIPT_TIMESTAMP, ALICE]);
-
-    //When
-    const result = await getInvocationDelayForTx(MOCK_BRIDGE_TX_1);
-
-    //Then
-    expect(result).toStrictEqual({
-      preferredDelay: PREFERRED_CLAIMER_DELAY - (MOCK_BLOCK_TIMESTAMP - MOCK_RECEIPT_TIMESTAMP),
-      notPreferredDelay: NOT_PREFERRED_CLAIMER_DELAY - (MOCK_BLOCK_TIMESTAMP - MOCK_RECEIPT_TIMESTAMP),
-    });
-    expect(getInvocationDelaysForDestBridge).toHaveBeenCalledWith({
-      srcChainId: BigInt(L1_CHAIN_ID),
-      destChainId: BigInt(L2_CHAIN_ID),
-    });
-    expect(getLatestBlockTimestamp).toHaveBeenCalledWith(BigInt(L2_CHAIN_ID));
-    expect(getProofReceiptForMsgHash).toHaveBeenCalledWith({
-      msgHash: MOCK_BRIDGE_TX_1.msgHash,
-      destChainId: BigInt(L2_CHAIN_ID),
-      srcChainId: BigInt(L1_CHAIN_ID),
-    });
-  });
-});
diff --git a/packages/bridge-ui/src/libs/bridge/getInvocationDelayForTx.ts b/packages/bridge-ui/src/libs/bridge/getInvocationDelayForTx.ts
deleted file mode 100644
index 6c3b2e6b06f..00000000000
--- a/packages/bridge-ui/src/libs/bridge/getInvocationDelayForTx.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import type { BridgeTransaction } from '$libs/bridge/types';
-import { NoDelaysForBridgeError } from '$libs/error';
-import { getLatestBlockTimestamp } from '$libs/util/getLatestBlockTimestamp';
-import { getLogger } from '$libs/util/logger';
-
-import { getInvocationDelaysForDestBridge } from './getInvocationDelaysForDestBridge';
-import { getProofReceiptForMsgHash } from './getProofReceiptForMsgHash';
-
-const log = getLogger('bridge:getInvocationDelayForTx');
-
-export const getInvocationDelayForTx = async (tx: BridgeTransaction) => {
-  log('getInvocationDelayForTx', tx);
-
-  const invocationDelays = await getInvocationDelaysForDestBridge({
-    srcChainId: tx.srcChainId,
-    destChainId: tx.destChainId,
-  });
-
-  if (invocationDelays[0] === 0n) {
-    throw new NoDelaysForBridgeError('Destination chain does not have delays');
-  }
-
-  const proofReceipt = await getProofReceiptForMsgHash({
-    msgHash: tx.msgHash,
-    destChainId: tx.destChainId,
-    srcChainId: tx.srcChainId,
-  });
-
-  if (proofReceipt[0] === 0n) {
-    // No proof receipt found, no delay (yet)
-    return {
-      preferredDelay: 0n,
-      notPreferredDelay: 0n,
-    };
-  }
-
-  const delayForPreferred = invocationDelays[0];
-  const delayForNotPreferred = invocationDelays[1];
-
-  log('invocationDelays', invocationDelays);
-
-  const latestBlockTimestamp = await getLatestBlockTimestamp(tx.destChainId);
-  log('latestBlockTimestamp', latestBlockTimestamp);
-
-  const provenAt = proofReceipt[0];
-  // const provenBy = proofReceipt[1];
-
-  log('time since last claim', latestBlockTimestamp - provenAt);
-  const delays = {
-    preferredDelay: delayForPreferred - (latestBlockTimestamp - provenAt),
-    notPreferredDelay: delayForNotPreferred - (latestBlockTimestamp - provenAt),
-  };
-  log('remaining delays', delays);
-  return delays;
-};
diff --git a/packages/bridge-ui/src/libs/bridge/getInvocationDelaysForDestBridge.test.ts b/packages/bridge-ui/src/libs/bridge/getInvocationDelaysForDestBridge.test.ts
deleted file mode 100644
index b7948aa8491..00000000000
--- a/packages/bridge-ui/src/libs/bridge/getInvocationDelaysForDestBridge.test.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { readContract } from '@wagmi/core';
-
-import { bridgeAbi } from '$abi';
-import { routingContractsMap } from '$bridgeConfig';
-import { getInvocationDelaysForDestBridge } from '$libs/bridge/getInvocationDelaysForDestBridge';
-import { config } from '$libs/wagmi';
-import { L1_CHAIN_ID, L2_CHAIN_ID } from '$mocks';
-
-vi.mock('$libs/bridge/readContract');
-vi.mock('$customToken', () => {
-  const mockERC20 = {
-    name: 'MockERC20',
-    addresses: { '1': '0x123' },
-    symbol: 'MTF',
-    decimals: 18,
-    type: 'ERC20',
-  };
-  return {
-    customToken: [mockERC20],
-  };
-});
-
-describe('getInvocationDelaysForDestBridge()', () => {
-  it('should return the invocation delays for the bridge', async () => {
-    //Given
-    vi.mocked(readContract).mockResolvedValue([300, 384]);
-
-    //When
-    const result = await getInvocationDelaysForDestBridge({
-      srcChainId: BigInt(L1_CHAIN_ID),
-      destChainId: BigInt(L2_CHAIN_ID),
-    });
-
-    //Then
-    expect(result).toStrictEqual([300, 384]);
-    expect(readContract).toHaveBeenCalledWith(config, {
-      abi: bridgeAbi,
-      address: routingContractsMap[L2_CHAIN_ID][L1_CHAIN_ID].bridgeAddress,
-      functionName: 'getInvocationDelays',
-      chainId: L2_CHAIN_ID,
-    });
-  });
-});
diff --git a/packages/bridge-ui/src/libs/bridge/getInvocationDelaysForDestBridge.ts b/packages/bridge-ui/src/libs/bridge/getInvocationDelaysForDestBridge.ts
deleted file mode 100644
index 3f22b5318e2..00000000000
--- a/packages/bridge-ui/src/libs/bridge/getInvocationDelaysForDestBridge.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { readContract } from '@wagmi/core';
-
-import { bridgeAbi } from '$abi';
-import { routingContractsMap } from '$bridgeConfig';
-import { getLogger } from '$libs/util/logger';
-import { config } from '$libs/wagmi';
-
-// returns [bigint, bigint] e.g. [300,384]
-// First is preferred claimer, second the fallback
-
-//TODO: cache this
-const log = getLogger('getInvocationDelaysForDestBridge');
-export const getInvocationDelaysForDestBridge = async ({
-  srcChainId,
-  destChainId,
-}: {
-  srcChainId: bigint;
-  destChainId: bigint;
-}) => {
-  log('getting invocation delays for dest bridge', srcChainId, '->', destChainId);
-  const destBridgeAddress = routingContractsMap[Number(destChainId)][Number(srcChainId)].bridgeAddress;
-  const delay = await readContract(config, {
-    abi: bridgeAbi,
-    address: destBridgeAddress,
-    functionName: 'getInvocationDelays',
-    chainId: Number(destChainId),
-  });
-  log('invocation delay', delay);
-  return delay;
-};
diff --git a/packages/bridge-ui/src/libs/bridge/getProofReceiptForMsgHash.test.ts b/packages/bridge-ui/src/libs/bridge/getProofReceiptForMsgHash.test.ts
deleted file mode 100644
index d9f2115b467..00000000000
--- a/packages/bridge-ui/src/libs/bridge/getProofReceiptForMsgHash.test.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { readContract } from '@wagmi/core';
-import { zeroAddress } from 'viem';
-
-import { bridgeAbi } from '$abi';
-import { routingContractsMap } from '$bridgeConfig';
-import { getProofReceiptForMsgHash } from '$libs/bridge/getProofReceiptForMsgHash';
-import type { GetProofReceiptParams } from '$libs/bridge/types';
-import { config } from '$libs/wagmi';
-import { ALICE, MOCK_BRIDGE_TX_1 } from '$mocks';
-
-vi.mock('$libs/bridge/readContract');
-vi.mock('$customToken', () => {
-  const mockERC20 = {
-    name: 'MockERC20',
-    addresses: { '1': zeroAddress },
-    symbol: 'MTF',
-    decimals: 18,
-    type: 'ERC20',
-  };
-  return {
-    customToken: [mockERC20],
-  };
-});
-
-describe('getProofReceiptForMsgHash()', () => {
-  const mockArgs = {
-    msgHash: MOCK_BRIDGE_TX_1.msgHash,
-    destChainId: MOCK_BRIDGE_TX_1.destChainId,
-    srcChainId: MOCK_BRIDGE_TX_1.srcChainId,
-  } as GetProofReceiptParams;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should call readContract with the correct parameters', async () => {
-    const mockDestBridgeAddress =
-      routingContractsMap[Number(mockArgs.destChainId)][Number(mockArgs.srcChainId)].bridgeAddress;
-
-    vi.mocked(readContract).mockResolvedValue([0n, ALICE]);
-
-    await getProofReceiptForMsgHash(mockArgs);
-
-    expect(readContract).toHaveBeenCalledWith(config, {
-      abi: bridgeAbi,
-      address: mockDestBridgeAddress,
-      functionName: 'proofReceipt',
-      args: [mockArgs.msgHash],
-      chainId: Number(mockArgs.destChainId),
-    });
-  });
-
-  it('should return the result from readContract', async () => {
-    const mockResult = [0n, ALICE];
-
-    vi.mocked(readContract).mockResolvedValue(mockResult);
-
-    const result = await getProofReceiptForMsgHash(mockArgs);
-
-    expect(result).toStrictEqual(mockResult);
-  });
-});
diff --git a/packages/bridge-ui/src/libs/bridge/getProofReceiptForMsgHash.ts b/packages/bridge-ui/src/libs/bridge/getProofReceiptForMsgHash.ts
deleted file mode 100644
index 854135a77d8..00000000000
--- a/packages/bridge-ui/src/libs/bridge/getProofReceiptForMsgHash.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { readContract } from '@wagmi/core';
-import { get } from 'svelte/store';
-import { zeroAddress } from 'viem';
-
-import { bridgeAbi } from '$abi';
-import { routingContractsMap } from '$bridgeConfig';
-import { getLogger } from '$libs/util/logger';
-import { config } from '$libs/wagmi';
-import { proofReceiptForMsgHash } from '$stores/proofReceiptForMsgHash';
-
-import type { GetProofReceiptParams, GetProofReceiptResponse } from './types';
-
-const log = getLogger('getProofReceiptForMsgHash');
-
-export const getProofReceiptForMsgHash = async (args: GetProofReceiptParams): Promise<GetProofReceiptResponse> => {
-  const { msgHash, destChainId, srcChainId } = args;
-  const destBridgeAddress = routingContractsMap[Number(destChainId)][Number(srcChainId)].bridgeAddress;
-
-  log('getting proof receipt for msgHash', srcChainId, '->', destChainId, msgHash);
-
-  // Check store first for cached proof receipts
-  const proofReceiptCache = get(proofReceiptForMsgHash);
-
-  if (proofReceiptCache && proofReceiptCache[msgHash]) {
-    log('proof receipt found in cache', proofReceiptCache[msgHash]);
-    return proofReceiptCache[msgHash];
-  }
-
-  const response: GetProofReceiptResponse = await readContract(config, {
-    abi: bridgeAbi,
-    address: destBridgeAddress,
-    functionName: 'proofReceipt',
-    args: [msgHash],
-    chainId: Number(destChainId),
-  });
-
-  if (response[1] !== zeroAddress) {
-    log('proof receipt found for message hash, caching', msgHash);
-    proofReceiptForMsgHash.updateCache(msgHash, response);
-  }
-  return response;
-};
diff --git a/packages/bridge-ui/src/libs/bridge/types.ts b/packages/bridge-ui/src/libs/bridge/types.ts
index 00100df3b36..cc3e656ac36 100644
--- a/packages/bridge-ui/src/libs/bridge/types.ts
+++ b/packages/bridge-ui/src/libs/bridge/types.ts
@@ -2,7 +2,7 @@ import type { Address, GetContractReturnType, Hash, Hex, TransactionReceipt, Wal
 
 import type { bridgeAbi } from '$abi';
 import type { ChainID } from '$libs/chain';
-import type { Token, TokenType } from '$libs/token';
+import type { NFT, Token, TokenType } from '$libs/token';
 
 export enum MessageStatus {
   NEW,
@@ -12,9 +12,37 @@ export enum MessageStatus {
   PROVEN, // UI ONLY
 }
 
-// Bridge sendMessage()
-// Claim/Retry processMessage()/retryMessage()
-// Release releaseEther()/releaseERC20()
+// struct Message {
+// Message ID whose value is automatically assigned.
+// uint64 id;
+// The max processing fee for the relayer. This fee has 3 parts:
+// - the fee for message calldata.
+// - the minimal fee reserve for general processing, excluding function call.
+// - the invocation fee for the function call.
+// Any unpaid fee will be refunded to the destOwner on the destination chain.
+// Note that fee must be 0 if gasLimit is 0, or large enough to make the invocation fee
+// non-zero.
+// uint64 fee;
+// gasLimit that the processMessage call must have.
+// uint32 gasLimit;
+// The address, EOA or contract, that interacts with this bridge.
+// The value is automatically assigned.
+// address from;
+// Source chain ID whose value is automatically assigned.
+// uint64 srcChainId;
+// The owner of the message on the source chain.
+// address srcOwner;
+// Destination chain ID where the `to` address lives.
+// uint64 destChainId;
+// The owner of the message on the destination chain.
+// address destOwner;
+// The destination address on the destination chain.
+// address to;
+// value to invoke on the destination chain.
+// uint256 value;
+// callData to invoke on the destination chain.
+// bytes data;
+// }
 export type Message = {
   // Message ID. Will be set in contract
   id: bigint;
@@ -30,18 +58,14 @@ export type Message = {
   destOwner: Address;
   // Destination owner address
   to: Address;
-  // Alternate address to send any refund. If blank, defaults to owner.
-  refundTo: Address;
   // value to invoke on the destination chain, for ERC20 transfers.
   value: bigint;
   // Processing fee for the relayer. Zero if owner will process themself.
   fee: bigint;
   // gasLimit to invoke on the destination chain, for ERC20 transfers.
-  gasLimit: bigint;
+  gasLimit: number;
   // callData to invoke on the destination chain, for ERC20 transfers.
   data: Hex;
-  // Optional memo / unused at the moment
-  memo: string;
 };
 
 // Todo: adjust relayer to return same as bridge
@@ -57,7 +81,7 @@ export type RelayerMessage = {
   RefundTo: Address;
   Value: bigint;
   Fee: bigint;
-  GasLimit: bigint;
+  GasLimit: number;
   Data: Hex | string;
   Memo: string;
 };
@@ -91,10 +115,8 @@ interface BaseBridgeTransferOp {
   destOwner: Address;
   to: Address;
   token: Address;
-  gasLimit: bigint;
+  gasLimit: number;
   fee: bigint;
-  refundTo: Address;
-  memo: string;
 }
 
 export interface BridgeTransferOp extends BaseBridgeTransferOp {
@@ -106,10 +128,8 @@ export interface NFTBridgeTransferOp {
   destOwner: Address;
   to: Address;
   token: Address;
-  gasLimit: bigint;
+  gasLimit: number;
   fee: bigint;
-  refundTo: Address;
-  memo: string;
   tokenIds: bigint[];
   amounts: bigint[];
 }
@@ -135,7 +155,7 @@ export type BridgeArgs = {
   srcChainId: number;
   destChainId: number;
   fee: bigint;
-  memo?: string;
+  tokenObject: Token | NFT;
 };
 
 export type ETHBridgeArgs = BridgeArgs & {
@@ -154,8 +174,8 @@ export type ERC721BridgeArgs = BridgeArgs & {
   token: Address;
   tokenVaultAddress: Address;
   isTokenAlreadyDeployed?: boolean;
-  tokenIds: bigint[];
-  amounts: bigint[];
+  tokenIds: number[];
+  amounts: number[];
 };
 
 export type ERC1155BridgeArgs = ERC721BridgeArgs;
@@ -245,20 +265,6 @@ export type GetContractAddressType = {
   contractType: ContractType;
 };
 
-export type GetProofReceiptParams = {
-  msgHash: Hash;
-  destChainId: bigint;
-  srcChainId: bigint;
-};
-
-// timestamp, preferred claimer address
-export type GetProofReceiptResponse = readonly [bigint, Address];
-
-export type DetermineTransactionStatusArgs = {
-  tx: BridgeTransaction;
-  claimer: Maybe<Address>;
-};
-
 export type GetMaxToBridgeArgs = {
   to: Address;
   token: Token;
diff --git a/packages/bridge-ui/src/libs/fee/index.ts b/packages/bridge-ui/src/libs/fee/index.ts
index 1542b31fe74..ccc3a225c6b 100644
--- a/packages/bridge-ui/src/libs/fee/index.ts
+++ b/packages/bridge-ui/src/libs/fee/index.ts
@@ -1,3 +1,2 @@
-export * from './processingFees';
 export * from './recommendProcessingFee';
 export * from './types';
diff --git a/packages/bridge-ui/src/libs/fee/processingFees.ts b/packages/bridge-ui/src/libs/fee/processingFees.ts
deleted file mode 100644
index 6effa5449a6..00000000000
--- a/packages/bridge-ui/src/libs/fee/processingFees.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { type ProcessingFeeDetails, ProcessingFeeMethod } from './types';
-
-// Order is important, and the reason to use a Map
-export const processingFees: Map<ProcessingFeeMethod, ProcessingFeeDetails> = new Map([
-  [
-    ProcessingFeeMethod.RECOMMENDED,
-    {
-      method: ProcessingFeeMethod.RECOMMENDED,
-      timeToConfirm: 15 * 60 * 1000,
-    },
-  ],
-  [
-    ProcessingFeeMethod.NONE,
-    {
-      method: ProcessingFeeMethod.NONE,
-      timeToConfirm: 15 * 60 * 1000,
-    },
-  ],
-  [
-    ProcessingFeeMethod.CUSTOM,
-    {
-      method: ProcessingFeeMethod.CUSTOM,
-      timeToConfirm: 15 * 60 * 1000,
-    },
-  ],
-]);
diff --git a/packages/bridge-ui/src/libs/fee/recommendProcessingFee.ts b/packages/bridge-ui/src/libs/fee/recommendProcessingFee.ts
index 9941d79e0ec..1b5fb24f8bf 100644
--- a/packages/bridge-ui/src/libs/fee/recommendProcessingFee.ts
+++ b/packages/bridge-ui/src/libs/fee/recommendProcessingFee.ts
@@ -1,9 +1,13 @@
+import { getPublicClient } from '@wagmi/core';
+
+import { recommendProcessingFeeConfig } from '$config';
+import { PUBLIC_BASE_FEE_MULTIPLIER } from '$env/static/public';
 import { NoCanonicalInfoFoundError } from '$libs/error';
-import { relayerApiServices } from '$libs/relayer';
-import { FeeTypes } from '$libs/relayer/types';
 import { type Token, TokenType } from '$libs/token';
 import { getTokenAddresses } from '$libs/token/getTokenAddresses';
+import { getBaseFee } from '$libs/util/getBaseFee';
 import { getLogger } from '$libs/util/logger';
+import { config } from '$libs/wagmi';
 
 const log = getLogger('libs:recommendedProcessingFee');
 
@@ -22,7 +26,19 @@ export async function recommendProcessingFee({
     return 0n;
   }
 
-  let fee;
+  let gasLimit;
+
+  const baseFee = await getBaseFee(BigInt(destChainId));
+  log(`Base fee: ${baseFee}`);
+
+  const destPublicClient = getPublicClient(config, { chainId: destChainId });
+
+  if (!destPublicClient) throw new Error('Could not get public client');
+
+  const maxPriorityFee = await destPublicClient.estimateMaxPriorityFeePerGas();
+  log(`Max priority fee: ${maxPriorityFee}`);
+
+  if (!baseFee) throw new Error('Unable to get base fee');
 
   if (token.type !== TokenType.ETH) {
     const tokenInfo = await getTokenAddresses({ token, srcChainId, destChainId });
@@ -36,60 +52,50 @@ export async function recommendProcessingFee({
         isTokenAlreadyDeployed = true;
       }
     }
+
     if (token.type === TokenType.ERC20) {
       if (isTokenAlreadyDeployed) {
         log(`token ${token.symbol} is already deployed on chain ${destChainId}`);
-
-        fee = await relayerApiServices[0].recommendedProcessingFees({
-          typeFilter: FeeTypes.Erc20Deployed,
-          destChainIDFilter: destChainId,
-        });
+        gasLimit = BigInt(recommendProcessingFeeConfig.GAS_RESERVE) + 516n;
       } else {
-        fee = await relayerApiServices[0].recommendedProcessingFees({
-          typeFilter: FeeTypes.Erc20NotDeployed,
-          destChainIDFilter: destChainId,
-        });
         log(`token ${token.symbol} is not deployed on chain ${destChainId}`);
+        gasLimit = BigInt(recommendProcessingFeeConfig.GAS_RESERVE) + 516n;
       }
     } else if (token.type === TokenType.ERC721) {
       if (isTokenAlreadyDeployed) {
         log(`token ${token.symbol} is already deployed on chain ${destChainId}`);
-        fee = await relayerApiServices[0].recommendedProcessingFees({
-          typeFilter: FeeTypes.Erc721Deployed,
-          destChainIDFilter: destChainId,
-        });
+        gasLimit = BigInt(recommendProcessingFeeConfig.GAS_RESERVE) + 600n;
       } else {
         log(`token ${token.symbol} is not deployed on chain ${destChainId}`);
-        fee = await relayerApiServices[0].recommendedProcessingFees({
-          typeFilter: FeeTypes.Erc721NotDeployed,
-          destChainIDFilter: destChainId,
-        });
+        gasLimit = BigInt(recommendProcessingFeeConfig.GAS_RESERVE) + 600n;
       }
     } else if (token.type === TokenType.ERC1155) {
       if (isTokenAlreadyDeployed) {
         log(`token ${token.symbol} is already deployed on chain ${destChainId}`);
-        fee = await relayerApiServices[0].recommendedProcessingFees({
-          typeFilter: FeeTypes.Erc1155Deployed,
-          destChainIDFilter: destChainId,
-        });
+        gasLimit = BigInt(recommendProcessingFeeConfig.GAS_RESERVE) + 600n;
       } else {
         log(`token ${token.symbol} is not deployed on chain ${destChainId}`);
-        fee = await relayerApiServices[0].recommendedProcessingFees({
-          typeFilter: FeeTypes.Erc1155NotDeployed,
-          destChainIDFilter: destChainId,
-        });
+        gasLimit = BigInt(recommendProcessingFeeConfig.GAS_RESERVE) + 600n;
       }
     }
   } else {
     log(`Fee for ETH bridging`);
-    fee = await relayerApiServices[0].recommendedProcessingFees({
-      typeFilter: FeeTypes.Eth,
-      destChainIDFilter: destChainId,
-    });
+    gasLimit = BigInt(recommendProcessingFeeConfig.GAS_RESERVE);
   }
-  if (!fee) throw new Error('Unable to get fee from relayer API');
+  if (!gasLimit) throw new Error('Unable to calculate fee');
+
+  const fee = gasLimit * (BigInt(PUBLIC_BASE_FEE_MULTIPLIER) * (baseFee + maxPriorityFee));
+  log(`Recommended fee: ${fee.toString()}`);
+  return roundWeiTo6DecimalPlaces(fee);
+}
+
+function roundWeiTo6DecimalPlaces(wei: bigint): bigint {
+  const roundingFactor = BigInt('1000000000000'); // 10^12
+
+  // Calculate how many "10^12 wei" units are in the input
+  const units = wei / roundingFactor;
 
-  const feeInWei = BigInt(fee[0].amount);
-  log(`Recommended fee: ${feeInWei.toString()}`);
-  return feeInWei;
+  // Multiply back to get the rounded wei value
+  const roundedWei = units * roundingFactor;
+  return roundedWei;
 }
diff --git a/packages/bridge-ui/src/libs/polling/messageStatusPoller.ts b/packages/bridge-ui/src/libs/polling/messageStatusPoller.ts
index feed2a3291e..b517e8f41dc 100644
--- a/packages/bridge-ui/src/libs/polling/messageStatusPoller.ts
+++ b/packages/bridge-ui/src/libs/polling/messageStatusPoller.ts
@@ -1,26 +1,24 @@
+import { getTransactionReceipt } from '@wagmi/core';
 import { EventEmitter } from 'events';
-import { createPublicClient, getContract, type Hash, http, zeroAddress } from 'viem';
+import { createPublicClient, getContract, type Hash, type Hex, http, toHex } from 'viem';
 
 import { bridgeAbi } from '$abi';
 import { routingContractsMap } from '$bridgeConfig';
 import { bridgeTransactionPoller } from '$config';
-import { getInvocationDelayForTx } from '$libs/bridge/getInvocationDelayForTx';
-import { getProofReceiptForMsgHash } from '$libs/bridge/getProofReceiptForMsgHash';
 import { chains } from '$libs/chain';
-import { BridgeTxPollingError, NoDelaysForBridgeError } from '$libs/error';
+import { BridgeTxPollingError } from '$libs/error';
 import { getLogger } from '$libs/util/logger';
 import { nextTick } from '$libs/util/nextTick';
+import { config } from '$libs/wagmi';
 
 import { isTransactionProcessable } from '../bridge/isTransactionProcessable';
-import { type BridgeTransaction, type GetProofReceiptResponse, MessageStatus } from '../bridge/types';
+import { type BridgeTransaction, MessageStatus } from '../bridge/types';
 
 const log = getLogger('bridge:messageStatusPoller');
 
 export enum PollingEvent {
   STOP = 'stop',
   STATUS = 'status', // emits MessageStatus
-  DELAY = 'remainingDelayInSeconds', // emits remaining claim delay in seconds
-  PROOFRECEIPT = 'proofReceipt', // emits proof receipt
 
   // Whether or not the tx can be clamied/retried/released
   PROCESSABLE = 'processable',
@@ -36,12 +34,6 @@ const hashEmitterMap: Record<Hash, EventEmitter> = {};
 // associated to this hash, so we don't want to start another one
 const hashIntervalMap: Record<Hash, Interval> = {};
 
-// Keep track of the last delay we fetched for a transaction, so we can stop polling if it's 0
-const hashDelayMap: Record<Hash, bigint> = {};
-
-// bridgeTx hash => proof receipt. We want to keep track of the proof receipt
-const hashProofReceiptMap: Record<Hash, GetProofReceiptResponse> = {};
-
 /**
  * @example
  * try {
@@ -116,51 +108,13 @@ export function startPolling(bridgeTx: BridgeTransaction, runImmediately = true)
       const messageStatus: MessageStatus = await destBridgeContract.read.messageStatus([bridgeTx.msgHash]);
       emitter.emit(PollingEvent.STATUS, messageStatus);
 
-      // 1. check if we already have a proof receipt for this message hash
-      // 2. if not, fetch it and store it
-      // 3. if the stored proof receipt is not 0, get the delays and store them
-      // 4. emit the remaining delay
-      // 5. if the delay is 0, stop polling
-
-      let proofReceipts = null;
-      if (hashProofReceiptMap[hash] === undefined || hashProofReceiptMap[hash] === null) {
-        proofReceipts = await getProofReceiptForMsgHash({
-          msgHash,
-          destChainId,
-          srcChainId,
-        });
-        hashProofReceiptMap[hash] = proofReceipts;
-      }
-      if (
-        hashProofReceiptMap[hash] !== undefined &&
-        hashProofReceiptMap[hash] !== null &&
-        hashProofReceiptMap[hash][1] !== zeroAddress
-      ) {
-        log('Proof receipt found for message hash, checking delays', msgHash);
-        emitter.emit(PollingEvent.PROOFRECEIPT, { proofReceipt: hashProofReceiptMap[hash] });
-        if (hashDelayMap[hash] <= 0n) {
-          log(`Delay for hash ${hash} is already 0 or negative. Skipping.`);
-        } else if (hashDelayMap[hash] > 0n || hashDelayMap[hash] === null || hashDelayMap[hash] === undefined) {
-          try {
-            const txDelays = await getInvocationDelayForTx(bridgeTx);
-            const remainingDelayInSeconds = txDelays.preferredDelay;
-            log('Remaining delay in seconds', remainingDelayInSeconds);
-            hashDelayMap[hash] = remainingDelayInSeconds;
-            emitter.emit(PollingEvent.DELAY, { remainingDelayInSeconds });
-
-            if (remainingDelayInSeconds === 0n) {
-              log(`Delay for hash ${hash} is 0, will not fetch again.`);
-            }
-          } catch (err) {
-            if (err instanceof NoDelaysForBridgeError) {
-              log('Destination chain does not have delays, not fetching again.');
-              hashDelayMap[hash] = 0n;
-            } else {
-              throw err;
-            }
-          }
-        }
+      let blockNumber: Hex;
+      if (!bridgeTx.blockNumber) {
+        const receipt = await getTransactionReceipt(config, { hash: bridgeTx.hash });
+        blockNumber = toHex(receipt.blockNumber);
+        bridgeTx.blockNumber = blockNumber;
       }
+
       if (messageStatus === MessageStatus.DONE) {
         log(`Poller has picked up the change of status to DONE for hash ${hash}.`);
         stopPolling();
diff --git a/packages/bridge-ui/src/libs/proof/BridgeProver.test.ts b/packages/bridge-ui/src/libs/proof/BridgeProver.test.ts
index eb805974989..ed67a04ed9a 100644
--- a/packages/bridge-ui/src/libs/proof/BridgeProver.test.ts
+++ b/packages/bridge-ui/src/libs/proof/BridgeProver.test.ts
@@ -137,10 +137,8 @@ describe('BridgeProver', () => {
         destOwner: '0x8626f6940e2eb28930efb4cef49b2d1f2c9c1199',
         fee: 0n,
         from: '0x8626f6940e2eb28930efb4cef49b2d1f2c9c1199',
-        gasLimit: 0n,
+        gasLimit: 0,
         id: 4829n,
-        memo: '',
-        refundTo: '0x8626f6940e2eb28930efb4cef49b2d1f2c9c1199',
         srcChainId: 32382n,
         srcOwner: '0x8626f6940e2eb28930efb4cef49b2d1f2c9c1199',
         to: '0x8626f6940e2eb28930efb4cef49b2d1f2c9c1199',
diff --git a/packages/bridge-ui/src/libs/proof/BridgeProver.ts b/packages/bridge-ui/src/libs/proof/BridgeProver.ts
index 8f3ef522e78..9ff338e88b4 100644
--- a/packages/bridge-ui/src/libs/proof/BridgeProver.ts
+++ b/packages/bridge-ui/src/libs/proof/BridgeProver.ts
@@ -4,6 +4,7 @@ import {
   BlockNotFoundError,
   encodeAbiParameters,
   encodePacked,
+  type Hash,
   type Hex,
   hexToBigInt,
   keccak256,
@@ -14,7 +15,7 @@ import {
 
 import { signalServiceAbi } from '$abi';
 import { routingContractsMap } from '$bridgeConfig';
-import type { BridgeTransaction } from '$libs/bridge';
+import { type BridgeTransaction, MessageStatus } from '$libs/bridge';
 import { BlockNotSyncedError, ClientError, ProofGenerationError } from '$libs/error';
 import { getLogger } from '$libs/util/logger';
 import { config } from '$libs/wagmi';
@@ -36,6 +37,16 @@ export class BridgeProver {
     );
   }
 
+  async getSignalForFailedMessage(msgHash: Hash): Promise<Hash> {
+    const msgHashBigInt = BigInt(msgHash);
+    const failedStatusBigInt = BigInt(MessageStatus.FAILED);
+    const resultBigInt = msgHashBigInt ^ failedStatusBigInt;
+    let resultHex = resultBigInt.toString(16).padStart(64, '0');
+    resultHex = '0x' + resultHex;
+
+    return resultHex as Hash;
+  }
+
   async getEncodedSignalProof({ bridgeTx }: { bridgeTx: BridgeTransaction }) {
     const { blockNumber, message, msgHash } = bridgeTx;
 
@@ -199,6 +210,143 @@ export class BridgeProver {
     }
   }
 
+  async getEncodedSignalProofForRecall({ bridgeTx }: { bridgeTx: BridgeTransaction }) {
+    const { message, msgHash } = bridgeTx;
+
+    log('msgHash', msgHash);
+    if (!message) throw new ProofGenerationError('Message is not defined');
+    const { srcChainId, destChainId } = message;
+
+    let previousDestChainId = destChainId;
+    const key = await this.getSignalSlot(
+      Number(destChainId),
+      routingContractsMap[Number(destChainId)][Number(srcChainId)].bridgeAddress,
+      msgHash,
+    );
+    const configuredHops = routingContractsMap[Number(destChainId)][Number(srcChainId)].hops;
+
+    if (configuredHops && configuredHops.length > 0) {
+      const hopProofs: HopProof[] = [];
+
+      for (let i = 0; i < configuredHops.length; i++) {
+        const currentHop = configuredHops[i];
+        let currentSignalServiceAddress: Address;
+
+        if (i + 1 < configuredHops.length) {
+          // There is a next hop
+          currentSignalServiceAddress = configuredHops[i + 1].signalServiceAddress;
+        } else {
+          // This is the last hop, so use the destination's signal service address
+          currentSignalServiceAddress =
+            routingContractsMap[Number(destChainId)][Number(srcChainId)].signalServiceAddress;
+        }
+
+        // const syncedChainData = await readContract(config, {
+        //   address: currentSignalServiceAddress,
+        //   abi: signalServiceAbi,
+        //   functionName: 'getSyncedChainData',
+        //   args: [BigInt(destChainId), keccak256(toBytes('STATE_ROOT')), 0n],
+        //   chainId: Number(previousSrcChainId),
+        // });
+
+        const latestBlockNumber = await this.getLatestSrcBlockNumber(previousDestChainId, srcChainId);
+
+        const hopClient = getPublicClient(config, { chainId: Number(currentHop.chainId) });
+        if (!hopClient) throw new Error('Could not get public client');
+
+        const block = await hopClient.getBlock({ blockNumber: latestBlockNumber });
+        if (block.hash === null || block.number === null) {
+          throw new BlockNotFoundError({ blockHash: block.hash, blockNumber: block.number });
+        }
+        if (latestBlockNumber < block.number) {
+          //TODO handle this earlier somehow
+          throw new Error('block is not synced yet');
+        }
+
+        const clientWithEthProofRequest = hopClient as ClientWithEthGetProofRequest;
+        const hopProof = await clientWithEthProofRequest.request({
+          method: 'eth_getProof',
+          params: [currentSignalServiceAddress, [key], numberToHex(latestBlockNumber as bigint)],
+        });
+        log('Proof from eth_getProof', hopProof);
+
+        //TODO check for caching then do the following if cached
+        // hopProofs.push(
+        //   {
+        //     chainId: BigInt(currentHop.chainId),
+        //     blockId: BigInt(latestBlockNumber),
+        //     rootHash: <- root of signalservice ->
+        //     cacheOption: CacheOptions.CACHE_NOTHING,
+        //     accountProof: [],
+        //     storageProof: hopProof.storageProof[0].proof,
+        //   }
+
+        // Full proof
+        hopProofs.push({
+          chainId: BigInt(currentHop.chainId),
+          blockId: BigInt(latestBlockNumber),
+          rootHash: block.stateRoot,
+          cacheOption: 0n, // Todo: could be configurable
+          accountProof: hopProof.accountProof,
+          storageProof: hopProof.storageProof[0].proof,
+        });
+
+        previousDestChainId = BigInt(currentHop.chainId); // Update previousSrcChainId for the next iteration
+      }
+
+      return this.encodeHopProofs(hopProofs);
+    } else {
+      // Single hop proof
+      log('No hops configured, using default proof generation');
+      const destChainClient = getPublicClient(config, { chainId: Number(destChainId) });
+      if (!destChainClient) throw new ClientError('Could not get public client');
+
+      // Get the signalServiceAddress for the source chain
+      const destSignalServiceAddress =
+        routingContractsMap[Number(destChainId)][Number(srcChainId)].signalServiceAddress;
+
+      const block = await destChainClient.getBlock({ blockTag: 'latest' });
+
+      const signal = await this.getSignalForFailedMessage(msgHash);
+
+      // Build the signalSlot
+      const key = await this.getSignalSlot(
+        Number(destChainId),
+        routingContractsMap[Number(destChainId)][Number(srcChainId)].bridgeAddress,
+        signal,
+      );
+
+      log('Storage key', key);
+
+      // Call eth_getProof to get the proof
+      const ethProof = await this.getProof({
+        srcChainId: BigInt(destChainId),
+        blockNumber: block.number,
+        key,
+        signalServiceAddress: destSignalServiceAddress,
+      });
+
+      log('ethProof', ethProof, msgHash);
+
+      // Build the hopProof
+      const hopProof: HopProof = {
+        chainId: BigInt(destChainId),
+        blockId: BigInt(block.number),
+        rootHash: block.stateRoot,
+        cacheOption: 0n, // Todo: could be configurable
+        accountProof: ethProof.accountProof,
+        storageProof: ethProof.storageProof[0].proof,
+      };
+      log('hopProof', hopProof);
+
+      // Encode the hopProof
+      const encodedHopProofs = this.encodeHopProofs([hopProof]);
+      log('encodedHopProofs', encodedHopProofs);
+
+      return encodedHopProofs;
+    }
+  }
+
   encodeHopProofs = (hopProofs: HopProof[]) => {
     const params: AbiParameter[] = [
       {
@@ -260,17 +408,19 @@ export class BridgeProver {
 
     log(`calling eth_getProof with ${srcSignalServiceAddress}, ${key}, ${numberToHex(latestBlockNumber as bigint)}`);
 
-    const hopProof = await clientWithEthProofRequest.request({
+    const ethProof = await clientWithEthProofRequest.request({
       method: 'eth_getProof',
       params: [srcSignalServiceAddress, [key], numberToHex(latestBlockNumber as bigint)],
     });
 
-    log('Proof from eth_getProof', hopProof);
+    log('Proof from eth_getProof', ethProof);
+
+    // check if signal is failed:
 
-    if (hopProof.storageProof[0].value === toHex(0)) {
+    if (ethProof.storageProof[0].value === toHex(0)) {
       throw new ProofGenerationError('proof will not be valid, expected storageProof to not be 0 but was not');
     }
-    return hopProof;
+    return ethProof;
   }
 
   getLatestSrcBlockNumber = async (srcChainId: bigint, destChainId: bigint) => {
diff --git a/packages/bridge-ui/src/libs/relayer/RelayerAPIService.ts b/packages/bridge-ui/src/libs/relayer/RelayerAPIService.ts
index f5936204bd4..c4e7fb8fe9e 100644
--- a/packages/bridge-ui/src/libs/relayer/RelayerAPIService.ts
+++ b/packages/bridge-ui/src/libs/relayer/RelayerAPIService.ts
@@ -194,15 +194,13 @@ export class RelayerAPIService {
           to: tx.data.Message.To,
           destOwner: tx.data.Message.DestOwner,
           data: data as Hex,
-          memo: tx.data.Message.Memo,
           srcOwner: tx.data.Message.SrcOwner,
           from: tx.data.Message.From,
-          gasLimit: BigInt(tx.data.Message.GasLimit),
+          gasLimit: Number(tx.data.Message.GasLimit),
           value: BigInt(tx.data.Message.Value),
           srcChainId: BigInt(tx.data.Message.SrcChainId),
           destChainId: BigInt(tx.data.Message.DestChainId),
           fee: BigInt(tx.data.Message.Fee),
-          refundTo: tx.data.Message.RefundTo,
         },
       } satisfies BridgeTransaction;
 
diff --git a/packages/bridge-ui/src/libs/token/fetchNFTMetadata.test.ts b/packages/bridge-ui/src/libs/token/fetchNFTMetadata.test.ts
index 1d22ca682df..a307ab6c223 100644
--- a/packages/bridge-ui/src/libs/token/fetchNFTMetadata.test.ts
+++ b/packages/bridge-ui/src/libs/token/fetchNFTMetadata.test.ts
@@ -50,7 +50,7 @@ describe('fetchNFTMetadata()', () => {
       canonical: null,
       bridged: {
         chainId: L2_CHAIN_ID,
-        address: MOCK_ERC721.addresses.L2_CHAIN_ID as Address,
+        address: MOCK_ERC721.addresses[L1_CHAIN_ID] as Address,
       },
     } satisfies TokenInfo;
 
@@ -90,11 +90,11 @@ describe('fetchNFTMetadata()', () => {
       const mockTokenInfo = {
         canonical: {
           chainId: L1_CHAIN_ID,
-          address: MOCK_ERC721.addresses.L1_CHAIN_ID as Address,
+          address: MOCK_ERC721.addresses[L1_CHAIN_ID] as Address,
         },
         bridged: {
           chainId: L2_CHAIN_ID,
-          address: MOCK_ERC721.addresses.L2_CHAIN_ID as Address,
+          address: MOCK_ERC721.addresses[L2_CHAIN_ID] as Address,
         },
       } satisfies TokenInfo;
 
@@ -139,11 +139,11 @@ describe('fetchNFTMetadata()', () => {
       const mockTokenInfo = {
         canonical: {
           chainId: L1_CHAIN_ID,
-          address: MOCK_ERC721.addresses.L1_CHAIN_ID as Address,
+          address: MOCK_ERC721.addresses[L1_CHAIN_ID] as Address,
         },
         bridged: {
           chainId: L2_CHAIN_ID,
-          address: MOCK_ERC721.addresses.L2_CHAIN_ID as Address,
+          address: MOCK_ERC721.addresses[L2_CHAIN_ID] as Address,
         },
       } satisfies TokenInfo;
 
@@ -170,11 +170,11 @@ describe('fetchNFTMetadata()', () => {
       const mockTokenInfo = {
         canonical: {
           chainId: L1_CHAIN_ID,
-          address: MOCK_ERC721.addresses.L1_CHAIN_ID as Address,
+          address: MOCK_ERC721.addresses[L1_CHAIN_ID] as Address,
         },
         bridged: {
           chainId: L2_CHAIN_ID,
-          address: MOCK_ERC721.addresses.L2_CHAIN_ID as Address,
+          address: MOCK_ERC721.addresses[L2_CHAIN_ID] as Address,
         },
       } satisfies TokenInfo;
 
@@ -226,11 +226,11 @@ describe('fetchNFTMetadata()', () => {
           const mockTokenInfo = {
             canonical: {
               chainId: L1_CHAIN_ID,
-              address: MOCK_ERC721.addresses.L1_CHAIN_ID as Address,
+              address: MOCK_ERC721.addresses[L1_CHAIN_ID] as Address,
             },
             bridged: {
               chainId: L2_CHAIN_ID,
-              address: MOCK_ERC721.addresses.L2_CHAIN_ID as Address,
+              address: MOCK_ERC721.addresses[L2_CHAIN_ID] as Address,
             },
           } satisfies TokenInfo;
 
@@ -261,11 +261,11 @@ describe('fetchNFTMetadata()', () => {
           const mockTokenInfo = {
             canonical: {
               chainId: L1_CHAIN_ID,
-              address: MOCK_ERC721.addresses.L1_CHAIN_ID as Address,
+              address: MOCK_ERC721.addresses[L1_CHAIN_ID] as Address,
             },
             bridged: {
               chainId: L2_CHAIN_ID,
-              address: MOCK_ERC721.addresses.L2_CHAIN_ID as Address,
+              address: MOCK_ERC721.addresses[L2_CHAIN_ID] as Address,
             },
           } satisfies TokenInfo;
 
diff --git a/packages/bridge-ui/src/libs/token/getCanonicalInfoForToken.ts b/packages/bridge-ui/src/libs/token/getCanonicalInfoForToken.ts
index 388489e3e76..e75735dd4fe 100644
--- a/packages/bridge-ui/src/libs/token/getCanonicalInfoForToken.ts
+++ b/packages/bridge-ui/src/libs/token/getCanonicalInfoForToken.ts
@@ -189,9 +189,9 @@ const _getStatus = async ({ address, srcChainId, destChainId, type }: CheckCanon
     ])) as Address;
 
     if (checkDestChainForCanonicalChain === zeroAddress) {
-      canonicalChain = srcChainId;
-    } else {
       canonicalChain = destChainId;
+    } else {
+      canonicalChain = srcChainId;
     }
   } else if (destCanonicalCheck !== zeroAddress) {
     // if the destination is not zero, we found a canonical address there
diff --git a/packages/bridge-ui/src/libs/token/getTokenApprovalStatus.ts b/packages/bridge-ui/src/libs/token/getTokenApprovalStatus.ts
index 50c9b8857a6..94a5cbcf88d 100644
--- a/packages/bridge-ui/src/libs/token/getTokenApprovalStatus.ts
+++ b/packages/bridge-ui/src/libs/token/getTokenApprovalStatus.ts
@@ -13,26 +13,18 @@ import type { ERC20Bridge } from '$libs/bridge/ERC20Bridge';
 import type { ERC721Bridge } from '$libs/bridge/ERC721Bridge';
 import type { ERC1155Bridge } from '$libs/bridge/ERC1155Bridge';
 import { getContractAddressByType } from '$libs/bridge/getContractAddressByType';
-import {
-  InvalidParametersProvidedError,
-  NoCanonicalInfoFoundError,
-  NotConnectedError,
-  NoTokenError,
-  UnknownTokenTypeError,
-} from '$libs/error';
+import { InvalidParametersProvidedError, NotConnectedError, NoTokenError, UnknownTokenTypeError } from '$libs/error';
 import { getConnectedWallet } from '$libs/util/getConnectedWallet';
 import { getLogger } from '$libs/util/logger';
 import { account, connectedSourceChain } from '$stores';
 
 import { checkOwnershipOfNFT } from './checkOwnership';
-import { getTokenAddresses } from './getTokenAddresses';
 import { type NFT, type Token, TokenType } from './types';
 
 const log = getLogger('util:token:getTokenApprovalStatus');
 
 export enum ApprovalStatus {
   ETH_NO_APPROVAL_REQUIRED,
-  BRIDGED_NO_APPROVAL_REQUIRED,
   APPROVAL_REQUIRED,
   NO_APPROVAL_REQUIRED,
 }
@@ -59,21 +51,6 @@ export const getTokenApprovalStatus = async (token: Maybe<Token | NFT>): Promise
   const tokenAddress = get(selectedToken)?.addresses[currentChainId];
   log('selectedToken', get(selectedToken));
 
-  const tokenInfo = await getTokenAddresses({ token, srcChainId: currentChainId, destChainId: destinationChainId });
-  if (!tokenInfo) {
-    log('no token info found');
-    throw new NoCanonicalInfoFoundError();
-  }
-  if (tokenInfo.bridged && tokenInfo.bridged.address) {
-    const { address: bridgedTokenAddress } = tokenInfo.bridged;
-    if (bridgedTokenAddress === tokenAddress) {
-      // we have a bridged token, no need for allowance check as we will burn the token
-      log('token is bridged, no need for allowance check');
-      allApproved.set(true);
-      return ApprovalStatus.BRIDGED_NO_APPROVAL_REQUIRED;
-    }
-  }
-
   if (!ownerAddress || !tokenAddress) {
     log('no ownerAddress or tokenAddress', ownerAddress, tokenAddress);
     throw new InvalidParametersProvidedError('no ownerAddress or tokenAddress');
diff --git a/packages/bridge-ui/src/libs/util/getBaseFee.ts b/packages/bridge-ui/src/libs/util/getBaseFee.ts
new file mode 100644
index 00000000000..8183da7d713
--- /dev/null
+++ b/packages/bridge-ui/src/libs/util/getBaseFee.ts
@@ -0,0 +1,13 @@
+import { getPublicClient } from '@wagmi/core';
+
+import { ClientError } from '$libs/error';
+import { config } from '$libs/wagmi';
+
+export const getBaseFee = async (chainId: bigint) => {
+  const client = getPublicClient(config, { chainId: Number(chainId) });
+  if (!client) throw new ClientError('Client not found');
+  const block = await client.getBlock({
+    blockTag: 'latest',
+  });
+  return block.baseFeePerGas;
+};
diff --git a/packages/bridge-ui/src/stores/proofReceiptForMsgHash.ts b/packages/bridge-ui/src/stores/proofReceiptForMsgHash.ts
deleted file mode 100644
index cc3a6efb146..00000000000
--- a/packages/bridge-ui/src/stores/proofReceiptForMsgHash.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { get, type Writable, writable } from 'svelte/store';
-import type { Hash } from 'viem';
-
-import type { GetProofReceiptResponse } from '$libs/bridge';
-
-type CachedProofReceipt = Record<Hash, GetProofReceiptResponse>;
-
-function createCachedProofReceiptStore() {
-  const { subscribe, set, update }: Writable<CachedProofReceipt | null> = writable(null);
-
-  return {
-    subscribe,
-    updateCache: (hash: Hash, response: GetProofReceiptResponse) =>
-      update((currentCache) => {
-        if (currentCache === null) {
-          currentCache = {};
-        }
-        if (!currentCache[hash] || currentCache[hash] !== response) {
-          currentCache[hash] = response;
-        }
-        return currentCache;
-      }),
-    removeCache: (hash: Hash) =>
-      update((currentCache) => {
-        if (currentCache && currentCache[hash]) {
-          delete currentCache[hash];
-        }
-        return currentCache;
-      }),
-    clearCache: () => set(null),
-    getCache: (hash: Hash): GetProofReceiptResponse | undefined => {
-      const currentCache = get({ subscribe });
-      return currentCache ? currentCache[hash] : undefined;
-    },
-  };
-}
-
-export const proofReceiptForMsgHash = createCachedProofReceiptStore();
diff --git a/packages/bridge-ui/src/tests/mocks/messages.ts b/packages/bridge-ui/src/tests/mocks/messages.ts
index 9ca49c16067..b1793ba939e 100644
--- a/packages/bridge-ui/src/tests/mocks/messages.ts
+++ b/packages/bridge-ui/src/tests/mocks/messages.ts
@@ -17,10 +17,8 @@ export const MOCK_MESSAGE_L1_L2 = {
   destOwner: ALICE,
   value: 0n,
   data: '0x',
-  refundTo: ALICE,
   fee: 0n,
-  gasLimit: 0n,
-  memo: '',
+  gasLimit: 0,
   id: 420n,
 } satisfies Message;
 
@@ -33,9 +31,7 @@ export const MOCK_MESSAGE_L2_L1 = {
   destOwner: ALICE,
   value: 0n,
   data: '0x',
-  refundTo: ALICE,
   fee: 0n,
-  gasLimit: 0n,
-  memo: '',
+  gasLimit: 0,
   id: 420n,
 } satisfies Message;
diff --git a/packages/bridge-ui/src/tests/mocks/tokens.ts b/packages/bridge-ui/src/tests/mocks/tokens.ts
index 56ee8958d80..c7e4ad1b5ca 100644
--- a/packages/bridge-ui/src/tests/mocks/tokens.ts
+++ b/packages/bridge-ui/src/tests/mocks/tokens.ts
@@ -1,4 +1,6 @@
-import { type NFT, type NFTMetadata, TokenType } from '$libs/token/types';
+import { type NFT, type NFTMetadata, type Token, TokenType } from '$libs/token/types';
+
+import { L1_CHAIN_ID } from './chains';
 
 const base64Image =
   'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIwIiBoZWlnaHQ9IjMyMCIgdmlld0JveD0iMCAwIDMyMCAzMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgc2hhcGUtcmVuZGVyaW5nPSJjcmlzcEVkZ2VzIj48cmVjdCB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBmaWxsPSIjZDVkN2UxIiAvPjxyZWN0IHdpZHRoPSIxNDAiIGhlaWdodD0iMTAiIHg9IjkwIiB5PSIyMTAiIGZpbGw9IiNmZmZkZjIiIC8+PC9zdmc+';
@@ -14,14 +16,24 @@ export const MOCK_METADATA = {
 
 export const MOCK_ERC721 = {
   name: 'MockERC721',
-  addresses: { L1_CHAIN_ID: '0x123', L2_CHAIN_ID: '0x321' },
-  symbol: 'MNFT',
+  addresses: { 1: '0x123624fe5f48128B48F9D20428D33B89Bf7a3456', 2: '0x3456FE5F48128B48f9d20428d33B89BF7A123624' },
+  symbol: 'MERC721',
   decimals: 18,
   type: TokenType.ERC721,
   metadata: MOCK_METADATA,
   tokenId: 42,
 } satisfies NFT;
 
+export const MOCK_ERC1155 = {
+  name: 'MockERC721',
+  addresses: { 1: '0x123624fe5f48128B48F9D20428D33B89Bf7a3456', 2: '0x3456FE5F48128B48f9d20428d33B89BF7A123624' },
+  symbol: 'MERC721',
+  decimals: 18,
+  type: TokenType.ERC1155,
+  metadata: MOCK_METADATA,
+  tokenId: 42,
+} satisfies NFT;
+
 export const MOCK_ERC721_BASE64 = {
   ...MOCK_ERC721,
   uri: base64Metadata,
@@ -33,3 +45,14 @@ export const MOCK_METADATA_BASE64 = {
   image: base64Image,
   external_url: undefined,
 } satisfies NFTMetadata;
+
+export const MOCK_ERC20 = {
+  name: 'MockERC20',
+  addresses: {
+    [L1_CHAIN_ID]: '0x123624fe5f48128B48F9D20428D33B89Bf7a3456',
+    2: '0x3456FE5F48128B48f9d20428d33B89BF7A123624',
+  },
+  symbol: 'MERC20',
+  decimals: 18,
+  type: 'ERC20' as TokenType,
+} satisfies Token;