add Token module

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

Author: ehegnes

ts-sdk/src/Client.ts

@@ -1,4 +1,7 @@
 /**
+
+ * 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"

ts-sdk/src/ClientRequest.ts

@@ -1,4 +1,4 @@
-import type { Option } from "effect"
+import type { Brand, Option } from "effect"
 import type { Inspectable } from "effect/Inspectable"
 import type { Pipeable } from "effect/Pipeable"
 import type { ReadonlyRecord } from "effect/Record"
@@ -33,8 +33,8 @@ export interface ClientRequest extends Inspectable, Pipeable {
   readonly method: Method
   readonly sender: string
   readonly receiver: string
-  readonly asset: string
-  readonly quote: Option.Option<string>
+  readonly baseToken: Token.Any
+  readonly quoteToken: Token.Any | "auto"
 }
 
 /**
@@ -46,6 +46,10 @@ export interface Options {
   readonly method?: Method | undefined
   /** Address to send from. */
   readonly sender?: string | undefined
+  /** Base token */
+  readonly baseToken?: string | undefined
+  /** Quote tooken. */
+  readonly quoteToken?: string | undefined
   /** Address to send from. */
   readonly receiver?: string | undefined
   /** Fee priority for gas calculation. */
@@ -71,7 +75,7 @@ export declare namespace Options {
    * @category models
    * @since 2.0.0
    */
-  export interface NoUrl extends Omit<Options, "method" | "url"> {}
+  export interface NoQuote extends Omit<Options, "method" | "sender" | "receiver" | "quoteToken"> {}
 }
 
 /**

ts-sdk/src/Token.ts

@@ -0,0 +1,59 @@
+import {
+  Effect,
+  Either as E,
+  flow,
+  Match,
+  Option as O,
+  ParseResult,
+  pipe,
+  Schema as S,
+  String as Str,
+} from "effect"
+
+export const Erc20 = S.Struct({
+  _tag: S.tag("Erc20"),
+  address: S.String,
+})
+export type Erc20 = typeof Erc20.Type
+
+export const CosmosBank = S.Struct({
+  _tag: S.tag("CosmosBank"),
+  address: S.String,
+})
+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,
+  CosmosBank,
+  IbcClassic,
+)
+export type Any = typeof Any.Type
+
+export const TokenFromString = S.transformOrFail(
+  S.NonEmptyString,
+  Any,
+  {
+    decode: (fromA, _, ast) =>
+      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"))
+        ),
+      ),
+    encode: (toI) => Effect.succeed(toI.address),
+  },
+)
+export type TokenFromString = typeof TokenFromString.Type

ts-sdk/src/TxIncomingMessage.ts

@@ -1,5 +1,9 @@
-import { Data, Stream } from "effect"
+import { Data, Effect, Stream } from "effect"
 
+/**
+ * NOTE: don't assume exhaustion
+ * - consider documenting per ecosystem states ? 
+ */
 type LifecycleEvent = Data.TaggedEnum<{
   // | { _tag: "SwitchChainStart" ; target: UniversalChainId }
   // | { _tag: "SwitchChainDone"  ; success: boolean }
@@ -11,14 +15,20 @@ type LifecycleEvent = Data.TaggedEnum<{
   // | { _tag: "Confirmed"        ; block: bigint }
   // | { _tag: "Finalised"        ; height: bigint ; success: boolean }
   // | { _tag: "Failed"           ; reason: string }
-  WriteTxStart: {}
-  Success: {}
-  Failure: {}
+  Receipt: {}
+  Indexed: {}
+  Finalized: {}
 }>
 
 export const LifecycleEvent = Data.taggedEnum<LifecycleEvent>()
 
 export interface TxIncomingMessage<E> {
   /** lifecycle and chain events in temporal order */
-  readonly events: Stream.Stream<unknown, E>
+  readonly stream: Stream.Stream<LifecycleEvent, E>
+  /**
+   * - add default ucompletion handler (index)
+   * - allow pred fn
+   */
+  readonly waitFor: (pred: (a: LifecycleEvent['_tag']) => Effect.Effect<{ readonly txHash: string }, E>
+
 }

ts-sdk/src/index.ts

@@ -114,3 +114,10 @@ export * as ClientRequest from "./ClientRequest.js"
  * @since 2.0.0
  */
 export * as ChannelRegistry from "./ChannelRegistry.js"
+
+/**
+ * TODO
+ *
+ * @since 2.0.0
+ */
+export * as Token from "./Token.js"

ts-sdk/test/Client.test.ts

@@ -11,6 +11,7 @@ describe("Client", () => {
         ClientRequest.send("0x123", "bbn1abc", {
           batch: true,
         }),
+        ClientRequest.withTokenBy(x => x.name === "WBTC"),
       )
 
       const result = yield* client.execute(transfer)

ts-sdk/test/Token.test.ts

@@ -0,0 +1,37 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as Token from "@unionlabs/sdk/Token"
+import { Effect, Schema as S } from "effect"
+
+describe("Token", () => {
+  describe("Erc20", () => {
+    it("scratch", () => {
+      const a = Token.Erc20.make({ address: "0xA0b86991C6218b36c1d19D4a2e9Eb0cE3606eB48" })
+      assert.ok(true)
+    })
+  })
+  describe("TokenFromString", () => {
+    it.effect("transforms ERC20", () =>
+      Effect.gen(function*() {
+        const a = yield* S.decode(Token.TokenFromString)(
+          "0xA0b86991C6218b36c1d19D4a2e9Eb0cE3606eB48",
+        )
+        assert.equal(a._tag, "Erc20")
+      }))
+
+    it.effect("transforms Cosmos Bank", () =>
+      Effect.gen(function*() {
+        const a = yield* S.decode(Token.TokenFromString)(
+          "uatom",
+        )
+        assert.equal(a._tag, "CosmosBank")
+      }))
+
+    it.effect("transforms IBC (classic)", () =>
+      Effect.gen(function*() {
+        const a = yield* S.decode(Token.TokenFromString)(
+          "ibc/B3504F0B84FEF5D8817A5196E19A886F81606DCD9D9FCA2E01B7F38379F94303",
+        )
+        assert.equal(a._tag, "CosmosBank")
+      }))
+  })
+})