From 81d9954fe194aba548feb4a12ab3eb207e9ca244 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Mon, 3 Mar 2025 22:05:58 +0100
Subject: [PATCH 01/11] feat(app2): add test page

---
 app2/src/lib/examples/transfer-arguments.ts   | 75 +++++++++++++++++++
 app2/src/lib/schema/transfer-arguments.ts     |  0
 .../src/routes/transfer/validate/+page.svelte | 72 ++++++++++++++++++
 3 files changed, 147 insertions(+)
 create mode 100644 app2/src/lib/examples/transfer-arguments.ts
 create mode 100644 app2/src/lib/schema/transfer-arguments.ts
 create mode 100644 app2/src/routes/transfer/validate/+page.svelte

diff --git a/app2/src/lib/examples/transfer-arguments.ts b/app2/src/lib/examples/transfer-arguments.ts
new file mode 100644
index 0000000000..b40dbfdaa8
--- /dev/null
+++ b/app2/src/lib/examples/transfer-arguments.ts
@@ -0,0 +1,75 @@
+type EVMTransferInput = {
+  type: "evm";
+  baseToken: string;
+  baseAmount: string;
+  quoteToken: string;
+  quoteAmount: string;
+  sourceChannelId: number;
+  wethToken: string;
+  receiver: string;
+  ucs03address: string;
+};
+
+type CosmosTransferInput = {
+  type: "cosmos";
+  baseToken: string;
+  baseAmount: string;
+  quoteToken: string;
+  quoteAmount: string;
+  sourceChannelId: number;
+  wethToken: null;
+  receiver: string;
+  ucs03address: string;
+};
+
+type AptosTransferInput = {
+  type: "aptos";
+  baseToken: string;
+  baseAmount: string;
+  quoteToken: string;
+  quoteAmount: string;
+  sourceChannelId: number;
+  wethToken: null;
+  receiver: string;
+  ucs03address: string;
+};
+
+export const examples: {
+  evm: EVMTransferInput;
+  cosmos: CosmosTransferInput;
+  aptos: AptosTransferInput;
+} = {
+  evm: {
+    type: "evm",
+    baseToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+    baseAmount: "1000000000000000000",
+    quoteToken: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    quoteAmount: "1000000",
+    receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
+    sourceChannelId: 1,
+    ucs03address: "0x742d35cc6634c0532925a3b844bc454e4438f44e",
+    wethToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+  },
+  cosmos: {
+    type: "cosmos",
+    baseToken: "0x1234567890abcdef1234567890abcdef12345678",
+    baseAmount: "10000000",
+    quoteToken: "0xabcdef1234567890abcdef1234567890abcdef12",
+    quoteAmount: "10000000",
+    receiver: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    sourceChannelId: 2,
+    ucs03address: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890", // Hex, 32 bytes
+    wethToken: null
+  },
+  aptos: {
+    type: "aptos",
+    baseToken: "0x1abcdef1234567890abcdef1234567890abcdef12",
+    baseAmount: "1000000000000000000",
+    quoteToken: "0x2abcdef1234567890abcdef1234567890abcdef12",
+    quoteAmount: "10000000",
+    receiver: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    sourceChannelId: 3,
+    ucs03address: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+    wethToken: null
+  }
+};
\ No newline at end of file
diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/app2/src/routes/transfer/validate/+page.svelte b/app2/src/routes/transfer/validate/+page.svelte
new file mode 100644
index 0000000000..6fb2b6e1a2
--- /dev/null
+++ b/app2/src/routes/transfer/validate/+page.svelte
@@ -0,0 +1,72 @@
+<!-- src/routes/+page.svelte -->
+<script lang="ts">
+  import {Effect, Schema} from "effect";
+  import type { RpcType } from "$lib/schema/chain";
+  import {
+    AptosTransfer,
+    CosmosTransfer,
+    EVMTransfer,
+    type Transfer
+  } from "$lib/schema/transfer-arguments";
+  import {examples} from "$lib/examples/transfer-arguments";
+
+  type RpcTypeValue = Schema.Schema.Type<typeof RpcType>;
+
+  let results: { type: string; data?: Transfer | undefined; error?: string | undefined }[] = [];
+
+  function handleResult(type: RpcTypeValue, parsed: Transfer | undefined, error: unknown) {
+    if (parsed) {
+      console.log(`${type} example:`, parsed);
+      results = [...results, { type, data: parsed, error: undefined }];
+    } else {
+      console.error(`${type} example failed:`, error);
+      results = [...results, { type, error: String(error), data: undefined }];
+    }
+  }
+
+  function validateEvm() {
+    const effect = Schema.decode(EVMTransfer)(examples.evm);
+    Effect.runPromise(effect)
+      .then((parsed) => handleResult("evm", parsed, undefined))
+      .catch((error) => handleResult("evm", undefined, error));
+  }
+
+  function validateCosmos() {
+    const effect = Schema.decode(CosmosTransfer)(examples.cosmos);
+    Effect.runPromise(effect)
+      .then((parsed) => handleResult("cosmos", parsed, undefined))
+      .catch((error) => handleResult("cosmos", undefined, error));
+  }
+
+  function validateAptos() {
+    const effect = Schema.decode(AptosTransfer)(examples.aptos);
+    Effect.runPromise(effect)
+      .then((parsed) => handleResult("aptos", parsed, undefined))
+      .catch((error) => handleResult("aptos", undefined, error));
+  }
+</script>
+
+<main class="p-8 max-w-5xl mx-auto bg-zinc-950 min-h-screen">
+  <h1 class="text-4xl font-bold text-zinc-100 mb-4 text-center">Transfer Schema Validation</h1>
+  <p class="text-lg text-zinc-400 mb-8 text-center">Check the console for detailed logs of the examples.</p>
+
+  <div class="grid gap-6 mb-8">
+    {#each results as result}
+      <div class="bg-zinc-800 rounded-lg p-6 shadow-md border border-zinc-700">
+        <h2 class="text-2xl font-semibold text-zinc-200 mb-4">{result.type.toUpperCase()} Example</h2>
+        {#if result.data}
+          <p class="text-green-400 font-bold mb-4">Success!</p>
+          <pre class="bg-zinc-900 text-zinc-700 p-4 rounded-md text-sm font-mono overflow-x-auto whitespace-pre-wrap border border-zinc-600">{JSON.stringify(result.data, (_, v) => typeof v === "bigint" ? v.toString() : v, 2)}</pre>
+        {:else if result.error}
+          <p class="text-red-400 font-bold mb-4 break-words">Error: {result.error}</p>
+        {/if}
+      </div>
+    {/each}
+  </div>
+
+  <div class="flex justify-center gap-4 flex-wrap">
+    <button on:click={validateEvm} class="bg-zinc-700 text-zinc-100 px-6 py-3 rounded-md text-base font-medium hover:bg-zinc-600 active:bg-zinc-800 transition duration-200 hover:-translate-y-1 active:translate-y-0">Validate EVM Example</button>
+    <button on:click={validateCosmos} class="bg-zinc-700 text-zinc-100 px-6 py-3 rounded-md text-base font-medium hover:bg-zinc-600 active:bg-zinc-800 transition duration-200 hover:-translate-y-1 active:translate-y-0">Validate Cosmos Example</button>
+    <button on:click={validateAptos} class="bg-zinc-700 text-zinc-100 px-6 py-3 rounded-md text-base font-medium hover:bg-zinc-600 active:bg-zinc-800 transition duration-200 hover:-translate-y-1 active:translate-y-0">Validate Aptos Example</button>
+  </div>
+</main>
\ No newline at end of file

From 0ebe2b2d5c01d1e1533f1efcb62dbf018c9db5a8 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Mon, 3 Mar 2025 22:06:13 +0100
Subject: [PATCH 02/11] feat(app2): transfer args

---
 app2/src/lib/schema/transfer-arguments.ts | 96 +++++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
index e69de29bb2..8fa89a02bf 100644
--- a/app2/src/lib/schema/transfer-arguments.ts
+++ b/app2/src/lib/schema/transfer-arguments.ts
@@ -0,0 +1,96 @@
+import { Schema } from "effect";
+import { AddressAptosCanonical, AddressCosmosCanonical, AddressEvmCanonical } from "$lib/schema/address";
+import { RpcType } from "$lib/schema/chain";
+import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token";
+import { ChannelId } from "$lib/schema/channel";
+
+const CommonTransferFields = {
+  baseToken: TokenRawDenom.annotations({
+    message: () => "baseToken must be a non-empty string (e.g., token address or symbol)"
+  }),
+  baseAmount: TokenRawAmount.annotations({
+    message: () => "baseAmount must be a valid bigint string (e.g., '1000000')"
+  }),
+  quoteToken: TokenRawDenom.annotations({
+    message: () => "quoteToken must be a non-empty string (e.g., token address or symbol)"
+  }),
+  quoteAmount: TokenRawAmount.annotations({
+    message: () => "quoteAmount must be a valid bigint string (e.g., '1000000')"
+  }),
+  sourceChannelId: ChannelId.annotations({
+    message: () => "sourceChannelId must be a non-negative integer"
+  })
+};
+
+export class EVMTransfer extends Schema.Class<EVMTransfer>("EVMTransfer")({
+  type: RpcType.pipe(
+    Schema.filter((v) => v === "evm"),
+    Schema.annotations({ message: () => "type must be 'evm'" })
+  ),
+  ...CommonTransferFields,
+  wethToken: EVMWethToken,
+  receiver: AddressEvmCanonical.pipe(
+    Schema.annotations({
+      message: () => "receiver must be a valid EVM canonical address (e.g., 0x followed by 40 hex chars)"
+    })
+  ),
+  ucs03address: AddressEvmCanonical.pipe(
+    Schema.annotations({
+      message: () => "ucs03address must be a valid EVM Zkgm address (e.g., 0x followed by 40 hex chars)"
+    })
+  )
+}) {}
+
+export class CosmosTransfer extends Schema.Class<CosmosTransfer>("CosmosTransfer")({
+  type: RpcType.pipe(
+    Schema.filter((v) => v === "cosmos"),
+    Schema.annotations({ message: () => "type must be 'cosmos'" })
+  ),
+  ...CommonTransferFields,
+  wethToken: Schema.Null,
+  receiver: AddressCosmosCanonical.pipe(
+    Schema.annotations({
+      message: () => "receiver must be a valid Cosmos canonical address (e.g., 0x followed by 40 or 64 hex chars)"
+    })
+  ),
+  ucs03address: AddressCosmosCanonical.pipe( // Changed to hex
+    Schema.annotations({
+      message: () => "ucs03address must be a valid Cosmos Zkgm address in hex (e.g., 0x followed by 40 or 64 hex chars)"
+    })
+  )
+}) {}
+
+export class AptosTransfer extends Schema.Class<AptosTransfer>("AptosTransfer")({
+  type: RpcType.pipe(
+    Schema.filter((v) => v === "aptos"),
+    Schema.annotations({ message: () => "type must be 'aptos'" })
+  ),
+  ...CommonTransferFields,
+  wethToken: Schema.Null,
+  receiver: AddressAptosCanonical.pipe(
+    Schema.annotations({
+      message: () => "receiver must be a valid Aptos canonical address (e.g., 0x followed by 64 hex chars)"
+    })
+  ),
+  ucs03address: AddressAptosCanonical.pipe(
+    Schema.annotations({
+      message: () => "ucs03address must be a valid Aptos Zkgm address (e.g., 0x followed by 64 hex chars)"
+    })
+  )
+}) {}
+
+export const TransferSchema = Schema.Union(
+  EVMTransfer,
+  CosmosTransfer,
+  AptosTransfer
+).annotations({
+  identifier: "Transfer",
+  title: "Transfer",
+  description: "transfer arguments"
+});
+
+export type Transfer = Schema.Schema.Type<typeof TransferSchema>;
+
+export type EVMTransferType = Schema.Schema.Type<typeof EVMTransfer>;
+export type CosmosTransferType = Schema.Schema.Type<typeof CosmosTransfer>;
+export type AptosTransferType = Schema.Schema.Type<typeof AptosTransfer>;
\ No newline at end of file

From 2dc0dc1509b4dbd023fdbabcf1c294d2c257cf1d Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Mon, 3 Mar 2025 22:06:55 +0100
Subject: [PATCH 03/11] fix(app): update chain, channel and token schema

---
 app2/src/lib/schema/chain.ts   | 2 +-
 app2/src/lib/schema/channel.ts | 5 ++++-
 app2/src/lib/schema/token.ts   | 4 ++++
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/app2/src/lib/schema/chain.ts b/app2/src/lib/schema/chain.ts
index cdaeb48a72..ee4fd3c23e 100644
--- a/app2/src/lib/schema/chain.ts
+++ b/app2/src/lib/schema/chain.ts
@@ -7,7 +7,7 @@ export const RpcType = Schema.Union(
   Schema.Literal("evm"),
   Schema.Literal("cosmos"),
   Schema.Literal("aptos")
-)
+).annotations({ message: () => "type must be 'evm', 'cosmos', or 'aptos'" });
 
 export class ChainFeatures extends Schema.Class<ChainFeatures>("ChainFeatures")({
   channel_list: Schema.Boolean,
diff --git a/app2/src/lib/schema/channel.ts b/app2/src/lib/schema/channel.ts
index 56c851255e..560b471908 100644
--- a/app2/src/lib/schema/channel.ts
+++ b/app2/src/lib/schema/channel.ts
@@ -1,3 +1,6 @@
 import { Schema } from "effect"
 
-export const ChannelId = Schema.Int.pipe(Schema.brand("ChannelId"))
+export const ChannelId = Schema.Int.pipe(
+  Schema.nonNegative({ message: () => "sourceChannelId must be non-negative" }),
+  Schema.brand("ChannelId")
+)
\ No newline at end of file
diff --git a/app2/src/lib/schema/token.ts b/app2/src/lib/schema/token.ts
index 85515f3078..b5a5f0367c 100644
--- a/app2/src/lib/schema/token.ts
+++ b/app2/src/lib/schema/token.ts
@@ -1,5 +1,9 @@
 import { Schema } from "effect"
 import { Hex } from "$lib/schema/hex"
+import {AddressEvmCanonical} from "$lib/schema/address";
 
 export const TokenRawDenom = Hex.pipe(Schema.brand("TokenRawDenom"))
 export const TokenRawAmount = Schema.BigInt.pipe(Schema.brand("TokenRawAmount"))
+export const EVMWethToken = AddressEvmCanonical.pipe(
+  Schema.annotations({ message: () => "WETH token must be a valid EVM canonical address (e.g., 0x followed by 40 hex chars)" })
+);

From ce2da72db1224db30e5dd24ef0bd2065edc0b028 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Mon, 3 Mar 2025 22:08:01 +0100
Subject: [PATCH 04/11] chore(app2): pre commit

---
 app2/src/lib/examples/transfer-arguments.ts   | 68 ++++++++---------
 app2/src/lib/schema/chain.ts                  |  2 +-
 app2/src/lib/schema/channel.ts                |  2 +-
 app2/src/lib/schema/token.ts                  |  9 ++-
 app2/src/lib/schema/transfer-arguments.ts     | 59 ++++++++-------
 .../src/routes/transfer/validate/+page.svelte | 74 +++++++++----------
 6 files changed, 112 insertions(+), 102 deletions(-)

diff --git a/app2/src/lib/examples/transfer-arguments.ts b/app2/src/lib/examples/transfer-arguments.ts
index b40dbfdaa8..8377553072 100644
--- a/app2/src/lib/examples/transfer-arguments.ts
+++ b/app2/src/lib/examples/transfer-arguments.ts
@@ -1,43 +1,43 @@
 type EVMTransferInput = {
-  type: "evm";
-  baseToken: string;
-  baseAmount: string;
-  quoteToken: string;
-  quoteAmount: string;
-  sourceChannelId: number;
-  wethToken: string;
-  receiver: string;
-  ucs03address: string;
-};
+  type: "evm"
+  baseToken: string
+  baseAmount: string
+  quoteToken: string
+  quoteAmount: string
+  sourceChannelId: number
+  wethToken: string
+  receiver: string
+  ucs03address: string
+}
 
 type CosmosTransferInput = {
-  type: "cosmos";
-  baseToken: string;
-  baseAmount: string;
-  quoteToken: string;
-  quoteAmount: string;
-  sourceChannelId: number;
-  wethToken: null;
-  receiver: string;
-  ucs03address: string;
-};
+  type: "cosmos"
+  baseToken: string
+  baseAmount: string
+  quoteToken: string
+  quoteAmount: string
+  sourceChannelId: number
+  wethToken: null
+  receiver: string
+  ucs03address: string
+}
 
 type AptosTransferInput = {
-  type: "aptos";
-  baseToken: string;
-  baseAmount: string;
-  quoteToken: string;
-  quoteAmount: string;
-  sourceChannelId: number;
-  wethToken: null;
-  receiver: string;
-  ucs03address: string;
-};
+  type: "aptos"
+  baseToken: string
+  baseAmount: string
+  quoteToken: string
+  quoteAmount: string
+  sourceChannelId: number
+  wethToken: null
+  receiver: string
+  ucs03address: string
+}
 
 export const examples: {
-  evm: EVMTransferInput;
-  cosmos: CosmosTransferInput;
-  aptos: AptosTransferInput;
+  evm: EVMTransferInput
+  cosmos: CosmosTransferInput
+  aptos: AptosTransferInput
 } = {
   evm: {
     type: "evm",
@@ -72,4 +72,4 @@ export const examples: {
     ucs03address: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
     wethToken: null
   }
-};
\ No newline at end of file
+}
diff --git a/app2/src/lib/schema/chain.ts b/app2/src/lib/schema/chain.ts
index ee4fd3c23e..0862b365d9 100644
--- a/app2/src/lib/schema/chain.ts
+++ b/app2/src/lib/schema/chain.ts
@@ -7,7 +7,7 @@ export const RpcType = Schema.Union(
   Schema.Literal("evm"),
   Schema.Literal("cosmos"),
   Schema.Literal("aptos")
-).annotations({ message: () => "type must be 'evm', 'cosmos', or 'aptos'" });
+).annotations({ message: () => "type must be 'evm', 'cosmos', or 'aptos'" })
 
 export class ChainFeatures extends Schema.Class<ChainFeatures>("ChainFeatures")({
   channel_list: Schema.Boolean,
diff --git a/app2/src/lib/schema/channel.ts b/app2/src/lib/schema/channel.ts
index 560b471908..6ee6368c53 100644
--- a/app2/src/lib/schema/channel.ts
+++ b/app2/src/lib/schema/channel.ts
@@ -3,4 +3,4 @@ import { Schema } from "effect"
 export const ChannelId = Schema.Int.pipe(
   Schema.nonNegative({ message: () => "sourceChannelId must be non-negative" }),
   Schema.brand("ChannelId")
-)
\ No newline at end of file
+)
diff --git a/app2/src/lib/schema/token.ts b/app2/src/lib/schema/token.ts
index b5a5f0367c..ab07ef3473 100644
--- a/app2/src/lib/schema/token.ts
+++ b/app2/src/lib/schema/token.ts
@@ -1,9 +1,12 @@
 import { Schema } from "effect"
 import { Hex } from "$lib/schema/hex"
-import {AddressEvmCanonical} from "$lib/schema/address";
+import { AddressEvmCanonical } from "$lib/schema/address"
 
 export const TokenRawDenom = Hex.pipe(Schema.brand("TokenRawDenom"))
 export const TokenRawAmount = Schema.BigInt.pipe(Schema.brand("TokenRawAmount"))
 export const EVMWethToken = AddressEvmCanonical.pipe(
-  Schema.annotations({ message: () => "WETH token must be a valid EVM canonical address (e.g., 0x followed by 40 hex chars)" })
-);
+  Schema.annotations({
+    message: () =>
+      "WETH token must be a valid EVM canonical address (e.g., 0x followed by 40 hex chars)"
+  })
+)
diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
index 8fa89a02bf..b1241cab80 100644
--- a/app2/src/lib/schema/transfer-arguments.ts
+++ b/app2/src/lib/schema/transfer-arguments.ts
@@ -1,8 +1,12 @@
-import { Schema } from "effect";
-import { AddressAptosCanonical, AddressCosmosCanonical, AddressEvmCanonical } from "$lib/schema/address";
-import { RpcType } from "$lib/schema/chain";
-import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token";
-import { ChannelId } from "$lib/schema/channel";
+import { Schema } from "effect"
+import {
+  AddressAptosCanonical,
+  AddressCosmosCanonical,
+  AddressEvmCanonical
+} from "$lib/schema/address"
+import { RpcType } from "$lib/schema/chain"
+import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token"
+import { ChannelId } from "$lib/schema/channel"
 
 const CommonTransferFields = {
   baseToken: TokenRawDenom.annotations({
@@ -20,77 +24,80 @@ const CommonTransferFields = {
   sourceChannelId: ChannelId.annotations({
     message: () => "sourceChannelId must be a non-negative integer"
   })
-};
+}
 
 export class EVMTransfer extends Schema.Class<EVMTransfer>("EVMTransfer")({
   type: RpcType.pipe(
-    Schema.filter((v) => v === "evm"),
+    Schema.filter(v => v === "evm"),
     Schema.annotations({ message: () => "type must be 'evm'" })
   ),
   ...CommonTransferFields,
   wethToken: EVMWethToken,
   receiver: AddressEvmCanonical.pipe(
     Schema.annotations({
-      message: () => "receiver must be a valid EVM canonical address (e.g., 0x followed by 40 hex chars)"
+      message: () =>
+        "receiver must be a valid EVM canonical address (e.g., 0x followed by 40 hex chars)"
     })
   ),
   ucs03address: AddressEvmCanonical.pipe(
     Schema.annotations({
-      message: () => "ucs03address must be a valid EVM Zkgm address (e.g., 0x followed by 40 hex chars)"
+      message: () =>
+        "ucs03address must be a valid EVM Zkgm address (e.g., 0x followed by 40 hex chars)"
     })
   )
 }) {}
 
 export class CosmosTransfer extends Schema.Class<CosmosTransfer>("CosmosTransfer")({
   type: RpcType.pipe(
-    Schema.filter((v) => v === "cosmos"),
+    Schema.filter(v => v === "cosmos"),
     Schema.annotations({ message: () => "type must be 'cosmos'" })
   ),
   ...CommonTransferFields,
   wethToken: Schema.Null,
   receiver: AddressCosmosCanonical.pipe(
     Schema.annotations({
-      message: () => "receiver must be a valid Cosmos canonical address (e.g., 0x followed by 40 or 64 hex chars)"
+      message: () =>
+        "receiver must be a valid Cosmos canonical address (e.g., 0x followed by 40 or 64 hex chars)"
     })
   ),
-  ucs03address: AddressCosmosCanonical.pipe( // Changed to hex
+  ucs03address: AddressCosmosCanonical.pipe(
+    // Changed to hex
     Schema.annotations({
-      message: () => "ucs03address must be a valid Cosmos Zkgm address in hex (e.g., 0x followed by 40 or 64 hex chars)"
+      message: () =>
+        "ucs03address must be a valid Cosmos Zkgm address in hex (e.g., 0x followed by 40 or 64 hex chars)"
     })
   )
 }) {}
 
 export class AptosTransfer extends Schema.Class<AptosTransfer>("AptosTransfer")({
   type: RpcType.pipe(
-    Schema.filter((v) => v === "aptos"),
+    Schema.filter(v => v === "aptos"),
     Schema.annotations({ message: () => "type must be 'aptos'" })
   ),
   ...CommonTransferFields,
   wethToken: Schema.Null,
   receiver: AddressAptosCanonical.pipe(
     Schema.annotations({
-      message: () => "receiver must be a valid Aptos canonical address (e.g., 0x followed by 64 hex chars)"
+      message: () =>
+        "receiver must be a valid Aptos canonical address (e.g., 0x followed by 64 hex chars)"
     })
   ),
   ucs03address: AddressAptosCanonical.pipe(
     Schema.annotations({
-      message: () => "ucs03address must be a valid Aptos Zkgm address (e.g., 0x followed by 64 hex chars)"
+      message: () =>
+        "ucs03address must be a valid Aptos Zkgm address (e.g., 0x followed by 64 hex chars)"
     })
   )
 }) {}
 
-export const TransferSchema = Schema.Union(
-  EVMTransfer,
-  CosmosTransfer,
-  AptosTransfer
-).annotations({
+export const TransferSchema = Schema.Union(EVMTransfer, CosmosTransfer, AptosTransfer).annotations({
   identifier: "Transfer",
   title: "Transfer",
   description: "transfer arguments"
-});
+})
 
-export type Transfer = Schema.Schema.Type<typeof TransferSchema>;
+export type Transfer = Schema.Schema.Type<typeof TransferSchema>
 
-export type EVMTransferType = Schema.Schema.Type<typeof EVMTransfer>;
-export type CosmosTransferType = Schema.Schema.Type<typeof CosmosTransfer>;
-export type AptosTransferType = Schema.Schema.Type<typeof AptosTransfer>;
\ No newline at end of file
+export type EVMTransferType = Schema.Schema.Type<typeof EVMTransfer>
+export type CosmosTransferType = Schema.Schema.Type<typeof CosmosTransfer>
+export type AptosTransferType = Schema.Schema.Type<typeof AptosTransfer>
diff --git a/app2/src/routes/transfer/validate/+page.svelte b/app2/src/routes/transfer/validate/+page.svelte
index 6fb2b6e1a2..4d294b4edc 100644
--- a/app2/src/routes/transfer/validate/+page.svelte
+++ b/app2/src/routes/transfer/validate/+page.svelte
@@ -1,49 +1,49 @@
 <!-- src/routes/+page.svelte -->
 <script lang="ts">
-  import {Effect, Schema} from "effect";
-  import type { RpcType } from "$lib/schema/chain";
-  import {
-    AptosTransfer,
-    CosmosTransfer,
-    EVMTransfer,
-    type Transfer
-  } from "$lib/schema/transfer-arguments";
-  import {examples} from "$lib/examples/transfer-arguments";
+import { Effect, Schema } from "effect"
+import type { RpcType } from "$lib/schema/chain"
+import {
+  AptosTransfer,
+  CosmosTransfer,
+  EVMTransfer,
+  type Transfer
+} from "$lib/schema/transfer-arguments"
+import { examples } from "$lib/examples/transfer-arguments"
 
-  type RpcTypeValue = Schema.Schema.Type<typeof RpcType>;
+type RpcTypeValue = Schema.Schema.Type<typeof RpcType>
 
-  let results: { type: string; data?: Transfer | undefined; error?: string | undefined }[] = [];
+let results: Array<{ type: string; data?: Transfer | undefined; error?: string | undefined }> = []
 
-  function handleResult(type: RpcTypeValue, parsed: Transfer | undefined, error: unknown) {
-    if (parsed) {
-      console.log(`${type} example:`, parsed);
-      results = [...results, { type, data: parsed, error: undefined }];
-    } else {
-      console.error(`${type} example failed:`, error);
-      results = [...results, { type, error: String(error), data: undefined }];
-    }
+function handleResult(type: RpcTypeValue, parsed: Transfer | undefined, error: unknown) {
+  if (parsed) {
+    console.log(`${type} example:`, parsed)
+    results = [...results, { type, data: parsed, error: undefined }]
+  } else {
+    console.error(`${type} example failed:`, error)
+    results = [...results, { type, error: String(error), data: undefined }]
   }
+}
 
-  function validateEvm() {
-    const effect = Schema.decode(EVMTransfer)(examples.evm);
-    Effect.runPromise(effect)
-      .then((parsed) => handleResult("evm", parsed, undefined))
-      .catch((error) => handleResult("evm", undefined, error));
-  }
+function validateEvm() {
+  const effect = Schema.decode(EVMTransfer)(examples.evm)
+  Effect.runPromise(effect)
+    .then(parsed => handleResult("evm", parsed, undefined))
+    .catch(error => handleResult("evm", undefined, error))
+}
 
-  function validateCosmos() {
-    const effect = Schema.decode(CosmosTransfer)(examples.cosmos);
-    Effect.runPromise(effect)
-      .then((parsed) => handleResult("cosmos", parsed, undefined))
-      .catch((error) => handleResult("cosmos", undefined, error));
-  }
+function validateCosmos() {
+  const effect = Schema.decode(CosmosTransfer)(examples.cosmos)
+  Effect.runPromise(effect)
+    .then(parsed => handleResult("cosmos", parsed, undefined))
+    .catch(error => handleResult("cosmos", undefined, error))
+}
 
-  function validateAptos() {
-    const effect = Schema.decode(AptosTransfer)(examples.aptos);
-    Effect.runPromise(effect)
-      .then((parsed) => handleResult("aptos", parsed, undefined))
-      .catch((error) => handleResult("aptos", undefined, error));
-  }
+function validateAptos() {
+  const effect = Schema.decode(AptosTransfer)(examples.aptos)
+  Effect.runPromise(effect)
+    .then(parsed => handleResult("aptos", parsed, undefined))
+    .catch(error => handleResult("aptos", undefined, error))
+}
 </script>
 
 <main class="p-8 max-w-5xl mx-auto bg-zinc-950 min-h-screen">

From 0947ebeb3265cdb4fc0e4fc712cf5964156cd0d0 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Tue, 4 Mar 2025 00:05:15 +0100
Subject: [PATCH 05/11] feat(app2): update reciever

---
 app2/src/lib/schema/address.ts            |  9 +++++++++
 app2/src/lib/schema/channel.ts            |  2 +-
 app2/src/lib/schema/transfer-arguments.ts | 24 +++++------------------
 3 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/app2/src/lib/schema/address.ts b/app2/src/lib/schema/address.ts
index 4533804923..cf9473438c 100644
--- a/app2/src/lib/schema/address.ts
+++ b/app2/src/lib/schema/address.ts
@@ -24,3 +24,12 @@ export const AddressAptosCanonical = AddressCanonicalBytes.pipe(
 )
 export const AddressAptosDisplay = AddressAptosCanonical
 export const AddressAptosZkgm = AddressAptosCanonical
+
+export const ReceiverAddress = Schema.Union(
+  AddressCosmosCanonical,
+  AddressEvmCanonical,
+  AddressAptosCanonical
+).annotations({
+  identifier: "ReceiverAddress",
+  message: () => "receiver must be a valid address (e.g., cosmos1... or 0x...)"
+})
diff --git a/app2/src/lib/schema/channel.ts b/app2/src/lib/schema/channel.ts
index 6ee6368c53..0d1f7525a2 100644
--- a/app2/src/lib/schema/channel.ts
+++ b/app2/src/lib/schema/channel.ts
@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 
 export const ChannelId = Schema.Int.pipe(
-  Schema.nonNegative({ message: () => "sourceChannelId must be non-negative" }),
+  Schema.nonNegative({ message: () => "ChannelId must be non-negative" }),
   Schema.brand("ChannelId")
 )
diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
index b1241cab80..df9765b4f4 100644
--- a/app2/src/lib/schema/transfer-arguments.ts
+++ b/app2/src/lib/schema/transfer-arguments.ts
@@ -2,7 +2,8 @@ import { Schema } from "effect"
 import {
   AddressAptosCanonical,
   AddressCosmosCanonical,
-  AddressEvmCanonical
+  AddressEvmCanonical,
+  ReceiverAddress
 } from "$lib/schema/address"
 import { RpcType } from "$lib/schema/chain"
 import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token"
@@ -33,12 +34,7 @@ export class EVMTransfer extends Schema.Class<EVMTransfer>("EVMTransfer")({
   ),
   ...CommonTransferFields,
   wethToken: EVMWethToken,
-  receiver: AddressEvmCanonical.pipe(
-    Schema.annotations({
-      message: () =>
-        "receiver must be a valid EVM canonical address (e.g., 0x followed by 40 hex chars)"
-    })
-  ),
+  receiver: ReceiverAddress,
   ucs03address: AddressEvmCanonical.pipe(
     Schema.annotations({
       message: () =>
@@ -54,12 +50,7 @@ export class CosmosTransfer extends Schema.Class<CosmosTransfer>("CosmosTransfer
   ),
   ...CommonTransferFields,
   wethToken: Schema.Null,
-  receiver: AddressCosmosCanonical.pipe(
-    Schema.annotations({
-      message: () =>
-        "receiver must be a valid Cosmos canonical address (e.g., 0x followed by 40 or 64 hex chars)"
-    })
-  ),
+  receiver: ReceiverAddress,
   ucs03address: AddressCosmosCanonical.pipe(
     // Changed to hex
     Schema.annotations({
@@ -76,12 +67,7 @@ export class AptosTransfer extends Schema.Class<AptosTransfer>("AptosTransfer")(
   ),
   ...CommonTransferFields,
   wethToken: Schema.Null,
-  receiver: AddressAptosCanonical.pipe(
-    Schema.annotations({
-      message: () =>
-        "receiver must be a valid Aptos canonical address (e.g., 0x followed by 64 hex chars)"
-    })
-  ),
+  receiver: ReceiverAddress,
   ucs03address: AddressAptosCanonical.pipe(
     Schema.annotations({
       message: () =>

From 8ab43885e108a9edce34fc9be8cb7d4da13dbc52 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Tue, 4 Mar 2025 00:05:45 +0100
Subject: [PATCH 06/11] fix(app2): user state in page

---
 app2/src/routes/transfer/validate/+page.svelte | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app2/src/routes/transfer/validate/+page.svelte b/app2/src/routes/transfer/validate/+page.svelte
index 4d294b4edc..d045e55a03 100644
--- a/app2/src/routes/transfer/validate/+page.svelte
+++ b/app2/src/routes/transfer/validate/+page.svelte
@@ -1,4 +1,3 @@
-<!-- src/routes/+page.svelte -->
 <script lang="ts">
 import { Effect, Schema } from "effect"
 import type { RpcType } from "$lib/schema/chain"
@@ -12,7 +11,8 @@ import { examples } from "$lib/examples/transfer-arguments"
 
 type RpcTypeValue = Schema.Schema.Type<typeof RpcType>
 
-let results: Array<{ type: string; data?: Transfer | undefined; error?: string | undefined }> = []
+let results: Array<{ type: string; data?: Transfer | undefined; error?: string | undefined }> =
+  $state([])
 
 function handleResult(type: RpcTypeValue, parsed: Transfer | undefined, error: unknown) {
   if (parsed) {

From bb39014e375b0618f9f0632a3262ed48a8a63c02 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Tue, 4 Mar 2025 00:44:47 +0100
Subject: [PATCH 07/11] feat(app2): add dest type and change source type name

---
 app2/src/lib/examples/transfer-arguments.ts | 20 ++++++++++++++------
 app2/src/lib/schema/transfer-arguments.ts   | 17 ++++++++++-------
 app2/src/lib/utils/convert-display.ts       |  0
 3 files changed, 24 insertions(+), 13 deletions(-)
 create mode 100644 app2/src/lib/utils/convert-display.ts

diff --git a/app2/src/lib/examples/transfer-arguments.ts b/app2/src/lib/examples/transfer-arguments.ts
index 8377553072..abe0168846 100644
--- a/app2/src/lib/examples/transfer-arguments.ts
+++ b/app2/src/lib/examples/transfer-arguments.ts
@@ -1,5 +1,8 @@
+import type { RpcType } from "$lib/schema/chain"
+
 type EVMTransferInput = {
-  type: "evm"
+  sourceRpcType: "evm"
+  destinationRpcType: typeof RpcType.Type
   baseToken: string
   baseAmount: string
   quoteToken: string
@@ -11,7 +14,8 @@ type EVMTransferInput = {
 }
 
 type CosmosTransferInput = {
-  type: "cosmos"
+  sourceRpcType: "cosmos"
+  destinationRpcType: typeof RpcType.Type
   baseToken: string
   baseAmount: string
   quoteToken: string
@@ -23,7 +27,8 @@ type CosmosTransferInput = {
 }
 
 type AptosTransferInput = {
-  type: "aptos"
+  sourceRpcType: "aptos"
+  destinationRpcType: typeof RpcType.Type
   baseToken: string
   baseAmount: string
   quoteToken: string
@@ -40,7 +45,8 @@ export const examples: {
   aptos: AptosTransferInput
 } = {
   evm: {
-    type: "evm",
+    sourceRpcType: "evm",
+    destinationRpcType: "cosmos",
     baseToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
     baseAmount: "1000000000000000000",
     quoteToken: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
@@ -51,7 +57,8 @@ export const examples: {
     wethToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
   },
   cosmos: {
-    type: "cosmos",
+    sourceRpcType: "cosmos",
+    destinationRpcType: "evm",
     baseToken: "0x1234567890abcdef1234567890abcdef12345678",
     baseAmount: "10000000",
     quoteToken: "0xabcdef1234567890abcdef1234567890abcdef12",
@@ -62,7 +69,8 @@ export const examples: {
     wethToken: null
   },
   aptos: {
-    type: "aptos",
+    sourceRpcType: "aptos",
+    destinationRpcType: "evm",
     baseToken: "0x1abcdef1234567890abcdef1234567890abcdef12",
     baseAmount: "1000000000000000000",
     quoteToken: "0x2abcdef1234567890abcdef1234567890abcdef12",
diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
index df9765b4f4..774c1473ac 100644
--- a/app2/src/lib/schema/transfer-arguments.ts
+++ b/app2/src/lib/schema/transfer-arguments.ts
@@ -9,7 +9,7 @@ import { RpcType } from "$lib/schema/chain"
 import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token"
 import { ChannelId } from "$lib/schema/channel"
 
-const CommonTransferFields = {
+const BaseTransferFields = {
   baseToken: TokenRawDenom.annotations({
     message: () => "baseToken must be a non-empty string (e.g., token address or symbol)"
   }),
@@ -24,15 +24,18 @@ const CommonTransferFields = {
   }),
   sourceChannelId: ChannelId.annotations({
     message: () => "sourceChannelId must be a non-negative integer"
+  }),
+  destinationRpcType: RpcType.annotations({
+    message: () => "destinationType must be a valid RPC type ('evm', 'cosmos', or 'aptos')"
   })
 }
 
 export class EVMTransfer extends Schema.Class<EVMTransfer>("EVMTransfer")({
-  type: RpcType.pipe(
+  ...BaseTransferFields,
+  sourceRpcType: RpcType.pipe(
     Schema.filter(v => v === "evm"),
     Schema.annotations({ message: () => "type must be 'evm'" })
   ),
-  ...CommonTransferFields,
   wethToken: EVMWethToken,
   receiver: ReceiverAddress,
   ucs03address: AddressEvmCanonical.pipe(
@@ -44,11 +47,11 @@ export class EVMTransfer extends Schema.Class<EVMTransfer>("EVMTransfer")({
 }) {}
 
 export class CosmosTransfer extends Schema.Class<CosmosTransfer>("CosmosTransfer")({
-  type: RpcType.pipe(
+  ...BaseTransferFields,
+  sourceRpcType: RpcType.pipe(
     Schema.filter(v => v === "cosmos"),
     Schema.annotations({ message: () => "type must be 'cosmos'" })
   ),
-  ...CommonTransferFields,
   wethToken: Schema.Null,
   receiver: ReceiverAddress,
   ucs03address: AddressCosmosCanonical.pipe(
@@ -61,11 +64,11 @@ export class CosmosTransfer extends Schema.Class<CosmosTransfer>("CosmosTransfer
 }) {}
 
 export class AptosTransfer extends Schema.Class<AptosTransfer>("AptosTransfer")({
-  type: RpcType.pipe(
+  ...BaseTransferFields,
+  sourceRpcType: RpcType.pipe(
     Schema.filter(v => v === "aptos"),
     Schema.annotations({ message: () => "type must be 'aptos'" })
   ),
-  ...CommonTransferFields,
   wethToken: Schema.Null,
   receiver: ReceiverAddress,
   ucs03address: AddressAptosCanonical.pipe(
diff --git a/app2/src/lib/utils/convert-display.ts b/app2/src/lib/utils/convert-display.ts
new file mode 100644
index 0000000000..e69de29bb2

From 5e79f2b654d7bc2277c221b8333e48ccf0ea5364 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Tue, 4 Mar 2025 04:06:22 +0100
Subject: [PATCH 08/11] fix(app2): save progress

---
 app2/package-lock.json                      |   1 +
 app2/package.json                           |   1 +
 app2/src/lib/examples/transfer-arguments.ts |  42 ++++----
 app2/src/lib/schema/transfer-arguments.ts   | 108 +++++++++++++-------
 4 files changed, 91 insertions(+), 61 deletions(-)

diff --git a/app2/package-lock.json b/app2/package-lock.json
index c7fed5eda2..c263c7c33f 100644
--- a/app2/package-lock.json
+++ b/app2/package-lock.json
@@ -13,6 +13,7 @@
         "@eslint/js": "^9.20.0",
         "@keplr-wallet/types": "^0.12.190",
         "@leapwallet/types": "^0.0.5",
+        "@scure/base": "^1.2.4",
         "@sveltejs/adapter-static": "^3.0.8",
         "@sveltejs/kit": "^2.17.2",
         "@sveltejs/vite-plugin-svelte": "^5.0.3",
diff --git a/app2/package.json b/app2/package.json
index e05b91496c..644d80afb7 100644
--- a/app2/package.json
+++ b/app2/package.json
@@ -20,6 +20,7 @@
     "@eslint/js": "^9.20.0",
     "@keplr-wallet/types": "^0.12.190",
     "@leapwallet/types": "^0.0.5",
+    "@scure/base": "^1.2.4",
     "@sveltejs/adapter-static": "^3.0.8",
     "@sveltejs/kit": "^2.17.2",
     "@sveltejs/vite-plugin-svelte": "^5.0.3",
diff --git a/app2/src/lib/examples/transfer-arguments.ts b/app2/src/lib/examples/transfer-arguments.ts
index abe0168846..fda72a9ea5 100644
--- a/app2/src/lib/examples/transfer-arguments.ts
+++ b/app2/src/lib/examples/transfer-arguments.ts
@@ -21,7 +21,6 @@ type CosmosTransferInput = {
   quoteToken: string
   quoteAmount: string
   sourceChannelId: number
-  wethToken: null
   receiver: string
   ucs03address: string
 }
@@ -34,7 +33,6 @@ type AptosTransferInput = {
   quoteToken: string
   quoteAmount: string
   sourceChannelId: number
-  wethToken: null
   receiver: string
   ucs03address: string
 }
@@ -47,37 +45,35 @@ export const examples: {
   evm: {
     sourceRpcType: "evm",
     destinationRpcType: "cosmos",
-    baseToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
-    baseAmount: "1000000000000000000",
-    quoteToken: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-    quoteAmount: "1000000",
-    receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
+    baseToken: "enter-test-data",
+    baseAmount: "1000",
+    quoteToken: "enter-test-data",
+    quoteAmount: "100",
+    receiver: "enter-test-data",
     sourceChannelId: 1,
-    ucs03address: "0x742d35cc6634c0532925a3b844bc454e4438f44e",
-    wethToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+    ucs03address: "enter-test-data",
+    wethToken: "enter-test-data"
   },
   cosmos: {
     sourceRpcType: "cosmos",
     destinationRpcType: "evm",
-    baseToken: "0x1234567890abcdef1234567890abcdef12345678",
-    baseAmount: "10000000",
-    quoteToken: "0xabcdef1234567890abcdef1234567890abcdef12",
-    quoteAmount: "10000000",
-    receiver: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    baseToken: "enter-test-data",
+    baseAmount: "100",
+    quoteToken: "enter-test-data",
+    quoteAmount: "100",
+    receiver: "enter-test-data",
     sourceChannelId: 2,
-    ucs03address: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890", // Hex, 32 bytes
-    wethToken: null
+    ucs03address: "enter-test-data"
   },
   aptos: {
     sourceRpcType: "aptos",
     destinationRpcType: "evm",
-    baseToken: "0x1abcdef1234567890abcdef1234567890abcdef12",
-    baseAmount: "1000000000000000000",
-    quoteToken: "0x2abcdef1234567890abcdef1234567890abcdef12",
-    quoteAmount: "10000000",
-    receiver: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    baseToken: "enter-test-data",
+    baseAmount: "100",
+    quoteToken: "enter-test-data",
+    quoteAmount: "100",
+    receiver: "enter-test-data",
     sourceChannelId: 3,
-    ucs03address: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
-    wethToken: null
+    ucs03address: "enter-test-data"
   }
 }
diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
index 774c1473ac..4d84fbd7aa 100644
--- a/app2/src/lib/schema/transfer-arguments.ts
+++ b/app2/src/lib/schema/transfer-arguments.ts
@@ -1,13 +1,8 @@
 import { Schema } from "effect"
-import {
-  AddressAptosCanonical,
-  AddressCosmosCanonical,
-  AddressEvmCanonical,
-  ReceiverAddress
-} from "$lib/schema/address"
 import { RpcType } from "$lib/schema/chain"
 import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token"
 import { ChannelId } from "$lib/schema/channel"
+import { AddressAptosDisplay, AddressCosmosDisplay, AddressEvmDisplay } from "$lib/schema/address"
 
 const BaseTransferFields = {
   baseToken: TokenRawDenom.annotations({
@@ -30,54 +25,92 @@ const BaseTransferFields = {
   })
 }
 
-export class EVMTransfer extends Schema.Class<EVMTransfer>("EVMTransfer")({
+const isValidReceiverDisplayForChain = (receiver: string, destinationRpcType: string): boolean => {
+  if (receiver.length === 0) {
+    return false
+  }
+
+  const isValidDisplay = (schema: Schema.Schema<any, any>) => {
+    try {
+      Schema.decodeSync(schema)(receiver, { errors: "all" })
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+
+  switch (destinationRpcType) {
+    case "evm":
+      return isValidDisplay(AddressEvmDisplay)
+    case "cosmos":
+      return isValidDisplay(AddressCosmosDisplay)
+    case "aptos":
+      return isValidDisplay(AddressAptosDisplay)
+    default:
+      return false
+  }
+}
+
+const EVMTransferSchema = Schema.Struct({
   ...BaseTransferFields,
   sourceRpcType: RpcType.pipe(
-    Schema.filter(v => v === "evm"),
-    Schema.annotations({ message: () => "type must be 'evm'" })
+    Schema.filter(v => v === "evm", { message: () => "type must be 'evm'" })
   ),
   wethToken: EVMWethToken,
-  receiver: ReceiverAddress,
-  ucs03address: AddressEvmCanonical.pipe(
-    Schema.annotations({
-      message: () =>
-        "ucs03address must be a valid EVM Zkgm address (e.g., 0x followed by 40 hex chars)"
-    })
+  receiver: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => "receiver must be a non-empty string" })
+  )
+}).pipe(
+  Schema.filter(data =>
+    isValidReceiverDisplayForChain(data.receiver, data.destinationRpcType)
+      ? true
+      : `receiver must be a valid display address for ${data.destinationRpcType}`
   )
-}) {}
+)
+
+export class EVMTransfer extends Schema.Class<EVMTransfer>("EVMTransfer")(EVMTransferSchema) {}
 
-export class CosmosTransfer extends Schema.Class<CosmosTransfer>("CosmosTransfer")({
+const CosmosTransferSchema = Schema.Struct({
   ...BaseTransferFields,
   sourceRpcType: RpcType.pipe(
-    Schema.filter(v => v === "cosmos"),
-    Schema.annotations({ message: () => "type must be 'cosmos'" })
+    Schema.filter(v => v === "cosmos", { message: () => "type must be 'cosmos'" })
   ),
   wethToken: Schema.Null,
-  receiver: ReceiverAddress,
-  ucs03address: AddressCosmosCanonical.pipe(
-    // Changed to hex
-    Schema.annotations({
-      message: () =>
-        "ucs03address must be a valid Cosmos Zkgm address in hex (e.g., 0x followed by 40 or 64 hex chars)"
-    })
+  receiver: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => "receiver must be a non-empty string" })
   )
-}) {}
+}).pipe(
+  Schema.filter(data =>
+    isValidReceiverDisplayForChain(data.receiver, data.destinationRpcType)
+      ? true
+      : `receiver must be a valid display address for ${data.destinationRpcType}`
+  )
+)
+
+export class CosmosTransfer extends Schema.Class<CosmosTransfer>("CosmosTransfer")(
+  CosmosTransferSchema
+) {}
 
-export class AptosTransfer extends Schema.Class<AptosTransfer>("AptosTransfer")({
+const AptosTransferSchema = Schema.Struct({
   ...BaseTransferFields,
   sourceRpcType: RpcType.pipe(
-    Schema.filter(v => v === "aptos"),
-    Schema.annotations({ message: () => "type must be 'aptos'" })
+    Schema.filter(v => v === "aptos", { message: () => "type must be 'aptos'" })
   ),
   wethToken: Schema.Null,
-  receiver: ReceiverAddress,
-  ucs03address: AddressAptosCanonical.pipe(
-    Schema.annotations({
-      message: () =>
-        "ucs03address must be a valid Aptos Zkgm address (e.g., 0x followed by 64 hex chars)"
-    })
+  receiver: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => "receiver must be a non-empty string" })
+  )
+}).pipe(
+  Schema.filter(data =>
+    isValidReceiverDisplayForChain(data.receiver, data.destinationRpcType)
+      ? true
+      : `receiver must be a valid display address for ${data.destinationRpcType}`
   )
-}) {}
+)
+
+export class AptosTransfer extends Schema.Class<AptosTransfer>("AptosTransfer")(
+  AptosTransferSchema
+) {}
 
 export const TransferSchema = Schema.Union(EVMTransfer, CosmosTransfer, AptosTransfer).annotations({
   identifier: "Transfer",
@@ -86,7 +119,6 @@ export const TransferSchema = Schema.Union(EVMTransfer, CosmosTransfer, AptosTra
 })
 
 export type Transfer = Schema.Schema.Type<typeof TransferSchema>
-
 export type EVMTransferType = Schema.Schema.Type<typeof EVMTransfer>
 export type CosmosTransferType = Schema.Schema.Type<typeof CosmosTransfer>
 export type AptosTransferType = Schema.Schema.Type<typeof AptosTransfer>

From 60d277c7c8dbe72213bee74673c5af91078f239f Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Tue, 4 Mar 2025 10:59:19 +0100
Subject: [PATCH 09/11] fix(app2): functions to convert

---
 app2/src/lib/schema/address.ts            |   9 --
 app2/src/lib/schema/transfer-arguments.ts |  34 +-----
 app2/src/lib/utils/convert-display.ts     | 131 ++++++++++++++++++++++
 3 files changed, 135 insertions(+), 39 deletions(-)

diff --git a/app2/src/lib/schema/address.ts b/app2/src/lib/schema/address.ts
index cf9473438c..4533804923 100644
--- a/app2/src/lib/schema/address.ts
+++ b/app2/src/lib/schema/address.ts
@@ -24,12 +24,3 @@ export const AddressAptosCanonical = AddressCanonicalBytes.pipe(
 )
 export const AddressAptosDisplay = AddressAptosCanonical
 export const AddressAptosZkgm = AddressAptosCanonical
-
-export const ReceiverAddress = Schema.Union(
-  AddressCosmosCanonical,
-  AddressEvmCanonical,
-  AddressAptosCanonical
-).annotations({
-  identifier: "ReceiverAddress",
-  message: () => "receiver must be a valid address (e.g., cosmos1... or 0x...)"
-})
diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
index 4d84fbd7aa..de3d89b28b 100644
--- a/app2/src/lib/schema/transfer-arguments.ts
+++ b/app2/src/lib/schema/transfer-arguments.ts
@@ -2,7 +2,7 @@ import { Schema } from "effect"
 import { RpcType } from "$lib/schema/chain"
 import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token"
 import { ChannelId } from "$lib/schema/channel"
-import { AddressAptosDisplay, AddressCosmosDisplay, AddressEvmDisplay } from "$lib/schema/address"
+import { isValidCanonicalForChain } from "$lib/utils/convert-display";
 
 const BaseTransferFields = {
   baseToken: TokenRawDenom.annotations({
@@ -25,32 +25,6 @@ const BaseTransferFields = {
   })
 }
 
-const isValidReceiverDisplayForChain = (receiver: string, destinationRpcType: string): boolean => {
-  if (receiver.length === 0) {
-    return false
-  }
-
-  const isValidDisplay = (schema: Schema.Schema<any, any>) => {
-    try {
-      Schema.decodeSync(schema)(receiver, { errors: "all" })
-      return true
-    } catch (e) {
-      return false
-    }
-  }
-
-  switch (destinationRpcType) {
-    case "evm":
-      return isValidDisplay(AddressEvmDisplay)
-    case "cosmos":
-      return isValidDisplay(AddressCosmosDisplay)
-    case "aptos":
-      return isValidDisplay(AddressAptosDisplay)
-    default:
-      return false
-  }
-}
-
 const EVMTransferSchema = Schema.Struct({
   ...BaseTransferFields,
   sourceRpcType: RpcType.pipe(
@@ -62,7 +36,7 @@ const EVMTransferSchema = Schema.Struct({
   )
 }).pipe(
   Schema.filter(data =>
-    isValidReceiverDisplayForChain(data.receiver, data.destinationRpcType)
+    isValidCanonicalForChain(data.receiver, data.destinationRpcType)
       ? true
       : `receiver must be a valid display address for ${data.destinationRpcType}`
   )
@@ -81,7 +55,7 @@ const CosmosTransferSchema = Schema.Struct({
   )
 }).pipe(
   Schema.filter(data =>
-    isValidReceiverDisplayForChain(data.receiver, data.destinationRpcType)
+    isValidCanonicalForChain(data.receiver, data.destinationRpcType)
       ? true
       : `receiver must be a valid display address for ${data.destinationRpcType}`
   )
@@ -102,7 +76,7 @@ const AptosTransferSchema = Schema.Struct({
   )
 }).pipe(
   Schema.filter(data =>
-    isValidReceiverDisplayForChain(data.receiver, data.destinationRpcType)
+    isValidCanonicalForChain(data.receiver, data.destinationRpcType)
       ? true
       : `receiver must be a valid display address for ${data.destinationRpcType}`
   )
diff --git a/app2/src/lib/utils/convert-display.ts b/app2/src/lib/utils/convert-display.ts
index e69de29bb2..8e82ffa634 100644
--- a/app2/src/lib/utils/convert-display.ts
+++ b/app2/src/lib/utils/convert-display.ts
@@ -0,0 +1,131 @@
+import { bech32 } from "@scure/base"
+import {Schema} from "effect";
+import {AddressAptosDisplay, AddressCosmosDisplay, AddressEvmDisplay} from "$lib/schema/address";
+
+/**
+ * Convert a bech32 display address to canonical bytes
+ */
+export function cosmosDisplayToCanonical(displayAddress: string): Uint8Array {
+  try {
+    const decoded = bech32.decode(displayAddress as `${string}1${string}`)
+    const canonicalAddress = bech32.fromWords(decoded.words)
+    return new Uint8Array(canonicalAddress)
+  } catch (error: any) {
+    throw new Error(`Invalid Cosmos bech32 address: ${error.message}`)
+  }
+}
+
+/**
+ * Convert an EVM display address (hex) to canonical bytes
+ */
+export function evmDisplayToCanonical(displayAddress: string): Uint8Array {
+  // Validate EVM address format (0x + 40 hex characters)
+  if (!/^0x[0-9a-fA-F]{40}$/.test(displayAddress)) {
+    throw new Error("EVM address must be 0x followed by 40 hex characters")
+  }
+
+  // Remove 0x prefix and convert to bytes
+  const hexWithoutPrefix = displayAddress.slice(2)
+  const bytes = new Uint8Array(20)
+
+  for (let i = 0; i < 40; i += 2) {
+    bytes[i / 2] = Number.parseInt(hexWithoutPrefix.substring(i, i + 2), 16)
+  }
+
+  return bytes
+}
+
+/**
+ * Convert an Aptos display address (hex) to canonical bytes
+ */
+export function aptosDisplayToCanonical(displayAddress: string): Uint8Array {
+  // Validate Aptos address format (0x + 64 hex characters)
+  if (!/^0x[0-9a-fA-F]{64}$/.test(displayAddress)) {
+    throw new Error("Aptos address must be 0x followed by 64 hex characters")
+  }
+
+  // Remove 0x prefix and convert to bytes
+  const hexWithoutPrefix = displayAddress.slice(2)
+  const bytes = new Uint8Array(32)
+
+  for (let i = 0; i < 64; i += 2) {
+    bytes[i / 2] = Number.parseInt(hexWithoutPrefix.substring(i, i + 2), 16)
+  }
+
+  return bytes
+}
+
+/**
+ * Converts a Uint8Array to a hex string
+ */
+export function bytesToHex(bytes: Uint8Array): string {
+  let hexString = ""
+  for (const byte of bytes) {
+    hexString += byte.toString(16).padStart(2, "0")
+  }
+  return `0x${hexString}`
+}
+
+export const isValidCanonicalForChain = (displayAddress: string, destinationRpcType: string): boolean => {
+  if (!displayAddress || displayAddress.length === 0) {
+    return false;
+  }
+
+  // Function to validate display format using schema
+  const isValidDisplay = (schema: Schema.Schema<any, any>): boolean => {
+    try {
+      Schema.decodeSync(schema)(displayAddress, { errors: "all" });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  };
+
+  // First validate the display format using appropriate schema
+  let isValidDisplayFormat = false;
+  switch (destinationRpcType) {
+    case "evm":
+      isValidDisplayFormat = isValidDisplay(AddressEvmDisplay);
+      break;
+    case "cosmos":
+      isValidDisplayFormat = isValidDisplay(AddressCosmosDisplay);
+      break;
+    case "aptos":
+      isValidDisplayFormat = isValidDisplay(AddressAptosDisplay);
+      break;
+    default:
+      return false;
+  }
+
+  // If display format is invalid, canonical format cannot be valid
+  if (!isValidDisplayFormat) {
+    return false;
+  }
+
+  // Then convert from display to canonical and validate
+  try {
+    let canonicalBytes: Uint8Array;
+
+    switch (destinationRpcType) {
+      case "evm":
+        // Convert EVM display address (checksum hex) to canonical bytes (20 bytes)
+        canonicalBytes = evmDisplayToCanonical(displayAddress);
+        return canonicalBytes.length === 20;
+
+      case "cosmos":
+        // Convert Cosmos display address (bech32) to canonical bytes
+        canonicalBytes = cosmosDisplayToCanonical(displayAddress);
+        return canonicalBytes.length === 20 || canonicalBytes.length === 32;
+
+      case "aptos":
+        // Convert Aptos display address (hex) to canonical bytes
+        canonicalBytes = aptosDisplayToCanonical(displayAddress);
+        return canonicalBytes.length === 32;
+
+      default:
+        return false;
+    }
+  } catch (error) {
+    return false;
+  }
+};
\ No newline at end of file

From 4c3785c32eee40c26a824ef741b4bcd1025333cf Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Tue, 4 Mar 2025 11:03:32 +0100
Subject: [PATCH 10/11] fix(app2): fmt and remove null weth

---
 app2/src/lib/examples/transfer-arguments.ts | 36 +++++------
 app2/src/lib/schema/transfer-arguments.ts   |  4 +-
 app2/src/lib/utils/convert-display.ts       | 66 +++++++++++----------
 3 files changed, 55 insertions(+), 51 deletions(-)

diff --git a/app2/src/lib/examples/transfer-arguments.ts b/app2/src/lib/examples/transfer-arguments.ts
index fda72a9ea5..5a39229749 100644
--- a/app2/src/lib/examples/transfer-arguments.ts
+++ b/app2/src/lib/examples/transfer-arguments.ts
@@ -45,35 +45,35 @@ export const examples: {
   evm: {
     sourceRpcType: "evm",
     destinationRpcType: "cosmos",
-    baseToken: "enter-test-data",
+    baseToken: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238",
     baseAmount: "1000",
-    quoteToken: "enter-test-data",
-    quoteAmount: "100",
-    receiver: "enter-test-data",
+    quoteToken: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    quoteAmount: "1000",
+    receiver: "union10z7xxj2m8q3f7j58uxmff38ws9u8m0vmne2key",
     sourceChannelId: 1,
-    ucs03address: "enter-test-data",
-    wethToken: "enter-test-data"
+    ucs03address: "0x742d35cc6634c0532925a3b844bc454e4438f44e",
+    wethToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
   },
   cosmos: {
     sourceRpcType: "cosmos",
     destinationRpcType: "evm",
-    baseToken: "enter-test-data",
-    baseAmount: "100",
-    quoteToken: "enter-test-data",
-    quoteAmount: "100",
-    receiver: "enter-test-data",
+    baseToken: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238",
+    baseAmount: "1000",
+    quoteToken: "0xabcdef1234567890abcdef1234567890abcdef12",
+    quoteAmount: "1000",
+    receiver: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
     sourceChannelId: 2,
-    ucs03address: "enter-test-data"
+    ucs03address: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
   },
   aptos: {
     sourceRpcType: "aptos",
     destinationRpcType: "evm",
-    baseToken: "enter-test-data",
-    baseAmount: "100",
-    quoteToken: "enter-test-data",
-    quoteAmount: "100",
-    receiver: "enter-test-data",
+    baseToken: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238",
+    baseAmount: "1000",
+    quoteToken: "0x2abcdef1234567890abcdef1234567890abcdef12",
+    quoteAmount: "1000",
+    receiver: "0x1f9090aae28b8a3dceadf281b0f12828e676c326",
     sourceChannelId: 3,
-    ucs03address: "enter-test-data"
+    ucs03address: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
   }
 }
diff --git a/app2/src/lib/schema/transfer-arguments.ts b/app2/src/lib/schema/transfer-arguments.ts
index de3d89b28b..031e73c522 100644
--- a/app2/src/lib/schema/transfer-arguments.ts
+++ b/app2/src/lib/schema/transfer-arguments.ts
@@ -2,7 +2,7 @@ import { Schema } from "effect"
 import { RpcType } from "$lib/schema/chain"
 import { EVMWethToken, TokenRawAmount, TokenRawDenom } from "$lib/schema/token"
 import { ChannelId } from "$lib/schema/channel"
-import { isValidCanonicalForChain } from "$lib/utils/convert-display";
+import { isValidCanonicalForChain } from "$lib/utils/convert-display"
 
 const BaseTransferFields = {
   baseToken: TokenRawDenom.annotations({
@@ -49,7 +49,6 @@ const CosmosTransferSchema = Schema.Struct({
   sourceRpcType: RpcType.pipe(
     Schema.filter(v => v === "cosmos", { message: () => "type must be 'cosmos'" })
   ),
-  wethToken: Schema.Null,
   receiver: Schema.String.pipe(
     Schema.nonEmptyString({ message: () => "receiver must be a non-empty string" })
   )
@@ -70,7 +69,6 @@ const AptosTransferSchema = Schema.Struct({
   sourceRpcType: RpcType.pipe(
     Schema.filter(v => v === "aptos", { message: () => "type must be 'aptos'" })
   ),
-  wethToken: Schema.Null,
   receiver: Schema.String.pipe(
     Schema.nonEmptyString({ message: () => "receiver must be a non-empty string" })
   )
diff --git a/app2/src/lib/utils/convert-display.ts b/app2/src/lib/utils/convert-display.ts
index 8e82ffa634..4c7cf62710 100644
--- a/app2/src/lib/utils/convert-display.ts
+++ b/app2/src/lib/utils/convert-display.ts
@@ -1,6 +1,6 @@
 import { bech32 } from "@scure/base"
-import {Schema} from "effect";
-import {AddressAptosDisplay, AddressCosmosDisplay, AddressEvmDisplay} from "$lib/schema/address";
+import { Schema } from "effect"
+import { AddressAptosDisplay, AddressCosmosDisplay, AddressEvmDisplay } from "$lib/schema/address"
 
 /**
  * Convert a bech32 display address to canonical bytes
@@ -66,66 +66,72 @@ export function bytesToHex(bytes: Uint8Array): string {
   return `0x${hexString}`
 }
 
-export const isValidCanonicalForChain = (displayAddress: string, destinationRpcType: string): boolean => {
+export const isValidCanonicalForChain = (
+  displayAddress: string,
+  destinationRpcType: string
+): boolean => {
   if (!displayAddress || displayAddress.length === 0) {
-    return false;
+    return false
   }
 
   // Function to validate display format using schema
   const isValidDisplay = (schema: Schema.Schema<any, any>): boolean => {
     try {
-      Schema.decodeSync(schema)(displayAddress, { errors: "all" });
-      return true;
+      Schema.decodeSync(schema)(displayAddress, { errors: "all" })
+      return true
     } catch (e) {
-      return false;
+      return false
     }
-  };
+  }
 
   // First validate the display format using appropriate schema
-  let isValidDisplayFormat = false;
+  let isValidDisplayFormat = false
   switch (destinationRpcType) {
     case "evm":
-      isValidDisplayFormat = isValidDisplay(AddressEvmDisplay);
-      break;
+      isValidDisplayFormat = isValidDisplay(AddressEvmDisplay)
+      break
     case "cosmos":
-      isValidDisplayFormat = isValidDisplay(AddressCosmosDisplay);
-      break;
+      isValidDisplayFormat = isValidDisplay(AddressCosmosDisplay)
+      break
     case "aptos":
-      isValidDisplayFormat = isValidDisplay(AddressAptosDisplay);
-      break;
+      isValidDisplayFormat = isValidDisplay(AddressAptosDisplay)
+      break
     default:
-      return false;
+      return false
   }
 
   // If display format is invalid, canonical format cannot be valid
   if (!isValidDisplayFormat) {
-    return false;
+    return false
   }
 
   // Then convert from display to canonical and validate
   try {
-    let canonicalBytes: Uint8Array;
+    let canonicalBytes: Uint8Array
 
     switch (destinationRpcType) {
-      case "evm":
+      case "evm": {
         // Convert EVM display address (checksum hex) to canonical bytes (20 bytes)
-        canonicalBytes = evmDisplayToCanonical(displayAddress);
-        return canonicalBytes.length === 20;
+        canonicalBytes = evmDisplayToCanonical(displayAddress)
+        return canonicalBytes.length === 20
+      }
 
-      case "cosmos":
+      case "cosmos": {
         // Convert Cosmos display address (bech32) to canonical bytes
-        canonicalBytes = cosmosDisplayToCanonical(displayAddress);
-        return canonicalBytes.length === 20 || canonicalBytes.length === 32;
+        canonicalBytes = cosmosDisplayToCanonical(displayAddress)
+        return canonicalBytes.length === 20 || canonicalBytes.length === 32
+      }
 
-      case "aptos":
+      case "aptos": {
         // Convert Aptos display address (hex) to canonical bytes
-        canonicalBytes = aptosDisplayToCanonical(displayAddress);
-        return canonicalBytes.length === 32;
+        canonicalBytes = aptosDisplayToCanonical(displayAddress)
+        return canonicalBytes.length === 32
+      }
 
       default:
-        return false;
+        return false
     }
   } catch (error) {
-    return false;
+    return false
   }
-};
\ No newline at end of file
+}

From 82a72bc8595cf35c67cd7237f74ec9a1f2665d38 Mon Sep 17 00:00:00 2001
From: Lukas <Lukas.nyberg@gmail.com>
Date: Tue, 4 Mar 2025 11:10:52 +0100
Subject: [PATCH 11/11] fix(app2): dep hash

---
 app2/app2.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app2/app2.nix b/app2/app2.nix
index ae52a9a94e..6b40022990 100644
--- a/app2/app2.nix
+++ b/app2/app2.nix
@@ -20,7 +20,7 @@ _: {
     {
       packages = {
         app2 = jsPkgs.buildNpmPackage {
-          npmDepsHash = "sha256-4iHm9HkGsQzVmonjtTLbRIHHQRC9ser23gfMzYL6z2A=";
+          npmDepsHash = "sha256-qo3INRx9IMbe5lfJrm/7/S++u9TVun7NqtXuvqpzCII=";
           src = ./.;
           sourceRoot = "app2";
           npmFlags = [ "--legacy-peer-deps" ];