0xtrails 0.13.1 → 0.13.2

package/src/keymachine/index.ts

@@ -0,0 +1,175 @@
+import type {
+  Config,
+  Context,
+  GenericTree,
+} from "@0xsequence/wallet-primitives"
+import { Address, Hex } from "ox"
+import {
+  KeyMachine as KeyMachineService,
+  type Fetch,
+} from "./key-machine.gen.js"
+
+export class KeyMachine {
+  private readonly service: KeyMachineService
+
+  constructor(host = "https://keymachine.sequence.app", fetcher?: Fetch) {
+    const resolvedFetch = fetcher ?? (globalThis as any).fetch
+    if (!resolvedFetch) {
+      throw new Error("fetch is not available")
+    }
+    this.service = new KeyMachineService(host, resolvedFetch)
+  }
+
+  async getConfiguration(
+    imageHash: Hex.Hex,
+  ): Promise<Config.Config | undefined> {
+    const { version, config } = await this.service.config({ imageHash })
+
+    if (version !== 3) {
+      throw new Error(
+        `invalid configuration version ${version}, expected version 3`,
+      )
+    }
+
+    return fromServiceConfig(config)
+  }
+
+  async getDeploy(
+    wallet: Address.Address,
+  ): Promise<{ imageHash: Hex.Hex; context: Context.Context } | undefined> {
+    const { deployHash, context } = await this.service.deployHash({ wallet })
+
+    Hex.assert(deployHash)
+    Address.assert(context.factory)
+    Address.assert(context.mainModule)
+    Address.assert(context.mainModuleUpgradable)
+    Hex.assert(context.walletCreationCode)
+
+    return {
+      imageHash: deployHash,
+      context: {
+        factory: context.factory,
+        stage1: context.mainModule,
+        stage2: context.mainModuleUpgradable,
+        creationCode: context.walletCreationCode,
+      },
+    }
+  }
+
+  async getTree(rootHash: Hex.Hex): Promise<GenericTree.Tree | undefined> {
+    const { version, tree } = await this.service.tree({ imageHash: rootHash })
+
+    if (version !== 3) {
+      throw new Error(`invalid tree version ${version}, expected version 3`)
+    }
+
+    return fromServiceTree(tree)
+  }
+}
+
+type ServiceConfig = {
+  threshold: number | string
+  checkpoint: number | string
+  checkpointer?: string
+  tree: ServiceConfigTree
+}
+
+type ServiceConfigTree =
+  | [ServiceConfigTree, ServiceConfigTree]
+  | string
+  | { weight: number | string; address: string; imageHash?: string }
+  | {
+      weight: number | string
+      threshold: number | string
+      tree: ServiceConfigTree
+    }
+  | { subdigest: string; isAnyAddress?: boolean }
+
+type ServiceTree = string | { data: string } | ServiceTree[]
+
+function fromServiceConfig(config: ServiceConfig): Config.Config {
+  if (config.checkpointer !== undefined) {
+    Address.assert(config.checkpointer)
+  }
+
+  return {
+    threshold: BigInt(config.threshold),
+    checkpoint: BigInt(config.checkpoint),
+    checkpointer: config.checkpointer,
+    topology: fromServiceConfigTree(config.tree),
+  }
+}
+
+function fromServiceConfigTree(tree: ServiceConfigTree): Config.Topology {
+  switch (typeof tree) {
+    case "string":
+      Hex.assert(tree)
+      return tree
+
+    case "object":
+      if (Array.isArray(tree)) {
+        return [fromServiceConfigTree(tree[0]), fromServiceConfigTree(tree[1])]
+      }
+
+      if ("weight" in tree) {
+        if ("address" in tree) {
+          Address.assert(tree.address)
+
+          if (tree.imageHash) {
+            Hex.assert(tree.imageHash)
+            return {
+              type: "sapient-signer",
+              address: tree.address,
+              weight: BigInt(tree.weight),
+              imageHash: tree.imageHash,
+            }
+          } else {
+            return {
+              type: "signer",
+              address: tree.address,
+              weight: BigInt(tree.weight),
+            }
+          }
+        }
+
+        if ("tree" in tree) {
+          return {
+            type: "nested",
+            weight: BigInt(tree.weight),
+            threshold: BigInt(tree.threshold),
+            tree: fromServiceConfigTree(tree.tree),
+          }
+        }
+      }
+
+      if ("subdigest" in tree) {
+        Hex.assert(tree.subdigest)
+        return {
+          type: tree.isAnyAddress ? "any-address-subdigest" : "subdigest",
+          digest: tree.subdigest,
+        }
+      }
+  }
+
+  throw new Error(`unknown config tree '${JSON.stringify(tree)}'`)
+}
+
+function fromServiceTree(tree: ServiceTree): GenericTree.Tree {
+  switch (typeof tree) {
+    case "string":
+      Hex.assert(tree)
+      return tree
+
+    case "object":
+      if (Array.isArray(tree)) {
+        return tree.map(fromServiceTree) as GenericTree.Branch
+      }
+
+      if ("data" in tree) {
+        Hex.assert(tree.data)
+        return { type: "leaf", value: Hex.toBytes(tree.data) }
+      }
+  }
+
+  throw new Error(`unknown tree '${JSON.stringify(tree)}'`)
+}