- add Token module; add iso instruction to hex

- add faov2 support to ucs03

Signed-off-by: Eric Hegnes <eric@hegnes.com>

Author: ehegnes

ts-sdk/examples/UCS03/send-funds-faov2.ts

@@ -0,0 +1,61 @@
+/**
+ * @title Send Funds Holesky → Xion
+ * @description Example transfer from Holesky to Xion.
+ * @badge ✓:success
+ */
+/// <reference types="effect" />
+/// <reference types="viem" />
+// @paths: {"@unionlabs/sdk": ["../ts-sdk/src"], "@unionlabs/sdk/*": ["../ts-sdk/src/*"]}
+// @ts-ignore
+if (typeof BigInt.prototype.toJSON !== "function") {
+  // @ts-ignore
+  BigInt.prototype.toJSON = function() {
+    return this.toString()
+  }
+}
+// ---cut---
+// EVM
+import { http, toHex } from "viem"
+import { bscTestnet } from "viem/chains"
+// Union
+import * as Evm from "@unionlabs/sdk/Evm"
+import * as Ucs03 from "@unionlabs/sdk/Ucs03"
+import * as Ucs05 from "@unionlabs/sdk/Ucs05"
+import { Effect, pipe } from "effect"
+import { privateKeyToAccount } from "viem/accounts"
+
+const SENDER = Ucs05.AddressEvmZkgm.make("0xfaebe5bf141cc04a3f0598062b98d2df01ab3c4d")
+const RECEIVER = Ucs05.AddressCosmosZkgm.make(toHex("bbn122ny3mep2l7nhtafpwav2y9e5jrslhekrn8frh"))
+
+const walletClient = Evm.WalletClient.Live({
+  account: privateKeyToAccount(
+    "0x..." as const,
+  ),
+  chain: bscTestnet,
+  transport: http("https://rpc.97.bsc.chain.kitchen"),
+})
+const sourceChannel = Evm.ChannelSource.Live({
+  ucs03address: "0x5fbe74a283f7954f10aa04c2edf55578811aeb03",
+  channelId: 1,
+})
+
+const main = pipe(
+  Ucs03.FungibleAssetOrderV2.fromOperand([
+    SENDER,
+    RECEIVER,
+    "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+    10n,
+    1,
+    "0x996be231a091877022ccdbf41da6e2f92e097c0ccc9480f8b3c630e5c2b14ff1",
+    toHex("bbn1gm8473g2vszxepfyn884trrxtgkyf8572wa4csev5t8hjumja7csnllkkr"),
+    10n,
+  ]),
+  Evm.sendInstruction,
+  Effect.provide(walletClient),
+  Effect.provide(sourceChannel),
+)
+
+// Run main program
+Effect.runPromise(main)
+  .then(console.log)
+  .catch(console.error)

ts-sdk/examples/UCS03/send-funds-holesky-to-xion.ts

@@ -34,7 +34,7 @@ const sourceClient = Evm.PublicClientSource.Live({
   chain: holesky,
   transport: http("https://rpc.17000.ethereum.chain.kitchen"),
 })
-const destinationClient = Cosmos.ClientDestination.Live(
+const destinationClient = Cosmos.Client.Live(
   "https://rpc.xion-testnet-2.xion.chain.kitchen/",
 )
 const walletClient = Evm.WalletClient.Live({

ts-sdk/src/Client.ts

@@ -1,7 +1,4 @@
 /**
-
- * TODO: - assume user specifies quote token up-front
-         - later consider deterimning ranked quote token
  * @since 1.0.0
  */
 import type * as Context from "effect/Context"
@@ -94,3 +91,23 @@ export const make: (
     fiber: RuntimeFiber<ClientResponse.ClientResponse, ClientError.ClientError>,
   ) => Effect.Effect<ClientResponse.ClientResponse, ClientError.ClientError>,
 ) => Client = internal.make
+
+/**
+ * @since 1.0.0
+ * @category mapping & sequencing
+ */
+export const transform: {
+  <E, R, E1, R1>(
+    f: (
+      effect: Effect.Effect<ClientResponse.ClientResponse, E, R>,
+      request: ClientRequest.ClientRequest,
+    ) => Effect.Effect<ClientResponse.ClientResponse, E1, R1>,
+  ): (self: Client.With<E, R>) => Client.With<E | E1, R | R1>
+  <E, R, E1, R1>(
+    self: Client.With<E, R>,
+    f: (
+      effect: Effect.Effect<ClientResponse.ClientResponse, E, R>,
+      request: ClientRequest.ClientRequest,
+    ) => Effect.Effect<ClientResponse.ClientResponse, E1, R1>,
+  ): Client.With<E | E1, R | R1>
+} = internal.transform

ts-sdk/src/ClientRequest.ts

@@ -4,6 +4,7 @@ import type { Pipeable } from "effect/Pipeable"
 import type { ReadonlyRecord } from "effect/Record"
 import * as internal from "./internal/clientRequest.js"
 import type { Channel } from "./schema/channel.js"
+import * as Token from "./Token.js"
 
 /**
  * @category type ids
@@ -33,8 +34,9 @@ export interface ClientRequest extends Inspectable, Pipeable {
   readonly method: Method
   readonly sender: string
   readonly receiver: string
-  readonly baseToken: Token.Any
-  readonly quoteToken: Token.Any | "auto"
+  readonly amount: bigint
+  readonly baseToken: Token.Any | string
+  readonly quoteToken: Token.Any | string | "auto"
 }
 
 /**
@@ -87,7 +89,7 @@ export const make: <M extends Method>(
 ) => (
   sender: string,
   receiver: string,
-  options?: (M extends "SEND" ? Options.Send : Options.NoUrl) | undefined,
+  options?: (M extends "SEND" ? Options.Send : Options.NoQuote) | undefined,
 ) => ClientRequest = internal.make
 
 /**

ts-sdk/src/Evm.ts

@@ -3,7 +3,7 @@
  *
  * @since 2.0.0
  */
-import { Context, Data, Effect, flow, Layer, pipe } from "effect"
+import { Context, Data, Effect, flow, Layer, pipe, Schema as S } from "effect"
 import { type Address, erc20Abi } from "viem"
 import {
   Abi,
@@ -582,6 +582,8 @@ export const sendInstruction = (instruction: Ucs03.Instruction) =>
     const timeoutTimestamp = Utils.getTimeoutInNanoseconds24HoursFromNow()
     const salt = yield* Utils.generateSalt("evm")
 
+    const operand = yield* S.encode(Ucs03.InstructionFromHex)(instruction)
+
     return yield* writeContract({
       account: walletClient.account,
       abi: Ucs03.Abi,
@@ -596,34 +598,9 @@ export const sendInstruction = (instruction: Ucs03.Instruction) =>
         {
           opcode: instruction.opcode,
           version: instruction.version,
-          operand: Ucs03.encode(instruction),
+          operand,
         },
       ],
+      value: 10n,
     })
   })
-
-/**
- * @category utils
- * @since 2.0.0
- */
-export const estimateL1Fee = pipe(
-  PublicClient,
-  Effect.andThen(({ client }) =>
-    Effect.tryPromise({
-      try: () =>
-        client
-          .extend(publicActionsL2())
-          .estimateL1Fee({
-            account: "0x0000000000000000000000000000000000000000",
-            chain: undefined,
-          }),
-      catch: cause =>
-        new GasPriceError({
-          module: "Evm",
-          method: "additiveFee",
-          description: `Could not calculate L1 fee for ${id}`,
-          cause,
-        }),
-    })
-  ),
-)

ts-sdk/src/Token.ts

@@ -1,59 +1,88 @@
-import {
-  Effect,
-  Either as E,
-  flow,
-  Match,
-  Option as O,
-  ParseResult,
-  pipe,
-  Schema as S,
-  String as Str,
-} from "effect"
+import { Effect, flow, ParseResult, pipe, Schema as S, Struct } from "effect"
 
 export const Erc20 = S.Struct({
   _tag: S.tag("Erc20"),
-  address: S.String,
+  address: S.String.pipe(
+    S.pattern(/^0x[0-9a-fA-F]{40}$/),
+    S.annotations({
+      examples: ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"],
+    }),
+  ),
 })
 export type Erc20 = typeof Erc20.Type
 
+export const EvmGas = S.Struct({
+  _tag: S.tag("EvmGas"),
+  address: S.String.pipe(
+    S.pattern(/^0x[eE]{40}$/),
+    S.annotations({
+      examples: ["0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"],
+    }),
+  ),
+})
+export type EvmGas = typeof EvmGas.Type
+
+export const CosmosIbcClassic = S.Struct({
+  _tag: S.tag("CosmosIbcClassic"),
+  address: S.String.pipe(
+    S.pattern(/^ibc\/[0-9A-Fa-f]{64}$/),
+    S.annotations({
+      examples: [""],
+    }),
+  ),
+})
+export type CosmosIbcClassic = typeof CosmosIbcClassic.Type
+
+export const CosmosTokenFactory = S.Struct({
+  _tag: S.tag("CosmosTokenFactory"),
+  address: S.String.pipe(
+    S.pattern(/^factory\/.+$/),
+  ),
+})
+export type CosmosTokenFactory = typeof CosmosTokenFactory.Type
+
+export const Cw20 = S.Struct({
+  _tag: S.tag("Cw20"),
+  address: S.String.pipe(
+    S.pattern(/^[a-z0-9]{1,15}1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38,64}$/),
+  ),
+})
+export type Cw20 = typeof Cw20.Type
+
 export const CosmosBank = S.Struct({
   _tag: S.tag("CosmosBank"),
-  address: S.String,
+  address: S.String.pipe(
+    S.pattern(/^[a-z][a-z0-9]{1,127}$/),
+  ),
 })
 export type CosmosBank = typeof CosmosBank.Type
 
-export const IbcClassic = S.Struct({
-  _tag: S.tag("IbcClassic"),
-  address: S.String,
-})
-export type IbcClassic = typeof IbcClassic.Type
-
 export const Any = S.Union(
   Erc20,
+  EvmGas,
+  Cw20,
+  CosmosTokenFactory,
   CosmosBank,
-  IbcClassic,
+  CosmosIbcClassic,
 )
 export type Any = typeof Any.Type
 
 export const TokenFromString = S.transformOrFail(
-  S.NonEmptyString,
+  S.String,
   Any,
   {
-    decode: (fromA, _, ast) =>
+    decode: (address) =>
       pipe(
-        Match.value(fromA),
-        // XXX: revise string matching
-        Match.when(flow(Str.match(/^0x[a-fA-F0-9]{40}$/), O.isSome), (address) =>
-          Effect.succeed(Erc20.make({ address }))),
-        Match.when(flow(Str.match(/^[a-zA-Z0-9/.:_-]+$/), O.isSome), (address) =>
-          Effect.succeed(CosmosBank.make({ address }))),
-        Match.when(flow(Str.match(/^ibc\/[a-fA-F0-9]{64}$/), O.isSome), (address) =>
-          Effect.succeed(IbcClassic.make({ address }))),
-        Match.orElse(() =>
-          ParseResult.fail(new ParseResult.Type(ast, fromA, "No match"))
-        ),
+        Effect.raceAll([
+          S.decodeEither(EvmGas)({ _tag: "EvmGas", address }),
+          S.decodeEither(CosmosIbcClassic)({ _tag: "CosmosIbcClassic", address }),
+          S.decodeEither(CosmosTokenFactory)({ _tag: "CosmosTokenFactory", address }),
+          S.decodeEither(Cw20)({ _tag: "Cw20", address }),
+        ]),
+        Effect.orElse(() => S.decodeEither(Erc20)({ _tag: "Erc20", address })),
+        Effect.orElse(() => S.decodeEither(CosmosBank)({ _tag: "CosmosBank", address })),
+        Effect.catchTag("ParseError", (error) => ParseResult.fail(error.issue)),
       ),
-    encode: (toI) => Effect.succeed(toI.address),
+    encode: flow(Struct.get("address"), Effect.succeed),
   },
 )
-export type TokenFromString = typeof TokenFromString.Type