move writer; add fao

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

Author: ehegnes

ts-sdk/src/FungibleAssetOrder.ts

@@ -0,0 +1,101 @@
+import { Effect, pipe } from "effect"
+import * as O from "effect/Option"
+import * as S from "effect/Schema"
+import * as Evm from "./Evm.js"
+import { graphqlQuoteTokenUnwrapQuery } from "./graphql/unwrapped-quote-token.js"
+import { UniversalChainId } from "./schema/chain.js"
+import { ChannelId } from "./schema/channel.js"
+import { Hex } from "./schema/hex.js"
+import { TokenRawDenom } from "./schema/token.js"
+import * as Ucs03 from "./Ucs03.js"
+import * as Ucs05 from "./Ucs05.js"
+import * as Utils from "./Utils.js"
+
+const BaseIntent = S.Struct({
+  baseAmount: S.BigIntFromSelf.pipe(
+    S.greaterThanBigInt(0n),
+  ),
+  quoteAmount: S.BigIntFromSelf,
+  sourceChainId: UniversalChainId,
+  sourceChannelId: ChannelId,
+})
+type BaseIntent = typeof BaseIntent.Type
+
+export const XAS = S.Struct({
+  sender: Ucs05.AddressEvmZkgm,
+  baseToken: TokenRawDenom,
+  sourceChainId: UniversalChainId,
+  sourceChannelId: ChannelId,
+})
+export type XAS = typeof XAS.Type
+
+export const YAS = S.Struct({
+  receiver: Ucs05.AddressEvmZkgm,
+})
+export type YAS = typeof YAS.Type
+
+const XA = (xas: XAS) => (base: BaseIntent) =>
+  Effect.gen(function*() {
+    const sourceClient = (yield* Evm.PublicClientSource).client
+    const tokenMeta = yield* Evm.readErc20Meta(
+      xas.baseToken as unknown as any,
+      xas.sourceChainId,
+    ).pipe(
+      Effect.provideService(Evm.PublicClient, { client: sourceClient }),
+    )
+
+    const graphqlDenom = yield* graphqlQuoteTokenUnwrapQuery({
+      baseToken: Utils.ensureHex(xas.baseToken),
+      sourceChainId: xas.sourceChainId,
+      sourceChannelId: xas.sourceChannelId,
+    })
+
+    const finalQuoteToken = yield* O.match(graphqlDenom, {
+      onNone: () => Evm.predictQuoteToken(xas.baseToken),
+      onSome: Effect.succeed,
+    })
+
+    const path = O.match(graphqlDenom, {
+      onNone: () => 0n,
+      onSome: () => xas.sourceChannelId,
+    })
+
+    return [
+      O.some(xas.sender),
+      O.none(), // receiver
+      O.some(Utils.ensureHex(xas.baseToken)),
+      O.some(base.baseAmount),
+      O.some(tokenMeta.symbol),
+      O.some(tokenMeta.name),
+      O.some(tokenMeta.decimals),
+      O.some(path), // path is source channel when unwrapping, else 0
+      O.some(finalQuoteToken),
+      O.some(base.quoteAmount),
+    ] as const
+  })
+
+const YA = (yas: YAS) => (base: BaseIntent) =>
+  Effect.succeed(
+    [
+      O.none(),
+      O.some(yas.receiver),
+      O.none(),
+      O.none(),
+      O.none(),
+      O.none(),
+      O.none(),
+      O.none(),
+      O.none(),
+      O.none(),
+    ] as const,
+  )
+
+const combine = (xas: XAS, yas: YAS) => (base: BaseIntent) =>
+  pipe(
+    Effect.all([
+      XA(xas)(base),
+      YA(yas)(base),
+    ]),
+    Effect.map([x, y] => O.all),
+    x => 
+  )

ts-sdk/src/typeclass/Writer.ts

@@ -0,0 +1,64 @@
+import type * as covariant from "@effect/typeclass/Covariant"
+import type * as flatmap from "@effect/typeclass/FlatMap"
+import type * as monad from "@effect/typeclass/Monad"
+import type * as monoid from "@effect/typeclass/Monoid"
+import type * as of from "@effect/typeclass/Of"
+import { dual } from "effect/Function"
+import type { TypeLambda } from "effect/HKT"
+
+export type Writer<W, A> = readonly [A, W]
+
+interface WriterTypeLambda<W> extends TypeLambda {
+  readonly type: Writer<W, this["Target"]>
+}
+
+export const censor = dual(
+  2,
+  <A, W>(fa: readonly [A, W], f: (w: W) => W): [A, W] => [fa[0], f(fa[1])],
+)
+
+export const mapWriter: {
+  <W1, W2, A, B>(
+    f: (a: A, w: W1) => readonly [B, W2],
+  ): (writer: readonly [A, W1]) => readonly [B, W2]
+  <W1, W2, A, B>(
+    writer: readonly [A, W1],
+    f: (a: A, w: W1) => readonly [B, W2],
+  ): readonly [B, W2]
+} = dual(
+  2,
+  <W1, W2, A, B>(
+    writer: readonly [A, W1],
+    f: (a: A, w: W1) => readonly [B, W2],
+  ): readonly [B, W2] => f(writer[0], writer[1]),
+)
+
+export const getOf = <W>(M: monoid.Monoid<W>): of.Of<WriterTypeLambda<W>> => ({
+  of: <A>(a: A) => [a, M.empty],
+})
+
+export const getFlatMap = <W>(M: monoid.Monoid<W>): flatmap.FlatMap<WriterTypeLambda<W>> => ({
+  flatMap: dual(2, <A, B>(fa: Writer<W, A>, f: (a: A) => Writer<W, B>): Writer<W, B> => {
+    const [a, w1] = fa
+    const [b, w2] = f(a)
+    return [b, M.combine(w1, w2)]
+  }),
+})
+
+export const getCovariant = <W>(): covariant.Covariant<WriterTypeLambda<W>> => ({
+  map: dual(2, <A, B>(fa: Writer<W, A>, f: (a: A) => B): Writer<W, B> => [f(fa[0]), fa[1]]),
+  imap: dual(
+    3,
+    <A, B>(
+      fa: Writer<W, A>,
+      to: (a: A) => B,
+      _from: (b: B) => A,
+    ): Writer<W, B> => [to(fa[0]), fa[1]],
+  ),
+})
+
+export const getMonad = <W>(M: monoid.Monoid<W>): monad.Monad<WriterTypeLambda<W>> => ({
+  ...getOf(M),
+  ...getCovariant(),
+  ...getFlatMap(M),
+})

ts-sdk/test/typeclass/Writer.test.ts

@@ -0,0 +1,50 @@
+import * as Writer from "$lib/typeclass/Writer.js"
+import * as ArrayInstances from "@effect/typeclass/data/Array"
+import * as StringInstances from "@effect/typeclass/data/String"
+import * as FlatMap from "@effect/typeclass/FlatMap"
+import { assert, describe, it } from "@effect/vitest"
+import * as A from "effect/Array"
+import { pipe } from "effect/Function"
+
+describe.concurrent("Writer", () => {
+  describe("FlatMap", () => {
+    it.each([
+      [
+        "getMonad",
+        pipe(
+          StringInstances.Monoid,
+          Writer.getMonad,
+          FlatMap.composeK,
+        ),
+      ],
+      [
+        "getFlatMap",
+        pipe(
+          Writer.getFlatMap(StringInstances.Monoid),
+          FlatMap.composeK,
+        ),
+      ],
+    ])("composeK (%s)", (_, composeK) => {
+      const f = (s: string): [number, string] => [s.length, "[length]"]
+      const g = (n: number): [boolean, string] => [n > 3, `[(>) 3 ${n}]`]
+      const h = pipe(f, composeK(g))
+      assert.deepStrictEqual(h(""), [false, "[length][(>) 3 0]"])
+      assert.deepStrictEqual(h("abc"), [false, "[length][(>) 3 3]"])
+      assert.deepStrictEqual(h("abcd"), [true, "[length][(>) 3 4]"])
+    })
+
+    it("mapWriter", () => {
+      const composeK = pipe(
+        Writer.getFlatMap(ArrayInstances.getMonoid<string>()),
+        FlatMap.composeK,
+      )
+      const f = (s: string): [number, string[]] => [s.length, ["length"]]
+      const g = (n: number): [boolean, string[]] => [n > 3, [">", "3", `${n}`]]
+      const h = pipe(f, composeK(g))
+      const j = Writer.mapWriter(
+        (a: boolean, w: readonly string[]) => [a, pipe(w, A.reverse, A.join(" · "))],
+      )
+      assert.deepStrictEqual(j(h("a")), [false, "1 · 3 · > · length"])
+    })
+  })
+})