@polkadot-api/cli 0.0.1-0a3edb2e805b29fa7d3ebb02c2084a125c4ee78b.1.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@polkadot-api/cli",
+  "version": "0.0.1-0a3edb2e805b29fa7d3ebb02c2084a125c4ee78b.1.0",
+  "license": "MIT",
+  "sideEffects": true,
+  "type": "module",
+  "prettier": {
+    "printWidth": 80,
+    "semi": false,
+    "trailingComma": "all"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^3.0.2",
+    "@substrate/connect": "^0.7.31",
+    "as-table": "^1.0.55",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "fp-ts": "^2.16.1",
+    "fs.promises.exists": "^1.1.4",
+    "ora": "^7.0.1",
+    "rxjs": "^7.8.1",
+    "type-fest": "^4.3.1",
+    "write-pkg": "^6.0.0",
+    "zod": "^3.22.2",
+    "@polkadot-api/sc-provider": "0.0.1-0a3edb2e805b29fa7d3ebb02c2084a125c4ee78b.1.0",
+    "@polkadot-api/substrate-bindings": "0.0.1-0a3edb2e805b29fa7d3ebb02c2084a125c4ee78b.1.0",
+    "@polkadot-api/substrate-client": "0.0.1-0a3edb2e805b29fa7d3ebb02c2084a125c4ee78b.1.0",
+    "@polkadot-api/substrate-codegen": "0.0.1-0a3edb2e805b29fa7d3ebb02c2084a125c4ee78b.1.0",
+    "@polkadot-api/utils": "0.0.1-0a3edb2e805b29fa7d3ebb02c2084a125c4ee78b.1.0"
+  },
+  "scripts": {
+    "build": "tsup-node src/main.ts --clean --out-dir build --sourcemap --platform node --format esm",
+    "start": "pnpm build && node --enable-source-maps build/main.js",
+    "start:interactive": "pnpm start -- -i",
+    "test": "echo 'no tests'",
+    "lint": "prettier --check README.md \"src/**/*.{js,jsx,ts,tsx,json,md}\"",
+    "format": "prettier --write README.md \"src/**/*.{js,jsx,ts,tsx,json,md}\""
+  }
+}

package/src/CheckboxData.ts

@@ -0,0 +1,38 @@
+import { checkbox } from "@inquirer/prompts"
+import { ReadonlyRecord } from "fp-ts/lib/ReadonlyRecord"
+import util from "util"
+
+export class CheckboxData {
+  #data: Record<string, bigint>
+
+  constructor(data?: Record<string, bigint>) {
+    this.#data = data ?? {}
+  }
+
+  get data(): ReadonlyRecord<string, bigint> {
+    return this.#data
+  }
+
+  async prompt(message: string, items: [string, bigint][]) {
+    const selected = await checkbox({
+      message,
+      choices: items.map(([s, checksum]) => ({
+        name: s,
+        value: [s, checksum] as const,
+        checked: s in this.#data,
+      })),
+    })
+
+    for (const [s, checksum] of selected) {
+      this.#data[s] = checksum
+    }
+  }
+
+  [util.inspect.custom]() {
+    return this.toJSON()
+  }
+
+  toJSON() {
+    return this.#data
+  }
+}

package/src/ExtrinsicData.ts

@@ -0,0 +1,119 @@
+import { select, checkbox, confirm } from "@inquirer/prompts"
+import type { ReadonlyRecord } from "fp-ts/lib/ReadonlyRecord"
+import util from "util"
+
+type Data = Record<
+  string,
+  {
+    checksum: bigint
+    events: Record<string, Set<string>>
+    errors: Record<string, Set<string>>
+  }
+>
+
+export class ExtrinsicData {
+  #data: Data
+
+  constructor(data?: Data) {
+    this.#data = data ?? {}
+  }
+
+  get data(): ReadonlyRecord<
+    string,
+    Readonly<{
+      events: ReadonlyRecord<string, ReadonlySet<string>>
+      errors: ReadonlyRecord<string, ReadonlySet<string>>
+    }>
+  > {
+    return this.#data
+  }
+
+  async prompt(
+    extrinsics: [name: string, checksum: bigint][],
+    events: ReadonlyArray<readonly [pallet: string, event: string]>,
+    errors: ReadonlyArray<readonly [pallet: string, event: string]>,
+  ) {
+    const [ext, checksum] = await select({
+      message: "Select an extrinsic",
+      choices: extrinsics.map(([s, checksum]) => ({
+        name: s,
+        value: [s, checksum],
+      })),
+    })
+
+    if (ext in this.#data) {
+      const deleteExt = await confirm({ message: "Delete extrinsic?" })
+      if (deleteExt) {
+        delete this.#data[ext]
+        return
+      }
+    }
+
+    if (!this.#data[ext]) {
+      this.#data[ext] = { events: {}, errors: {}, checksum }
+    }
+    for (const [pallet, _] of events) {
+      if (!this.#data[ext].events[pallet]) {
+        this.#data[ext].events[pallet] = new Set()
+      }
+    }
+    for (const [pallet, _] of errors) {
+      if (!this.#data[ext].errors[pallet]) {
+        this.#data[ext].errors[pallet] = new Set()
+      }
+    }
+    const selectedEvents = this.#data[ext].events
+    const selectedErrors = this.#data[ext].errors
+
+    const newSelectedEvents = await checkbox({
+      message: "Select Events for this extrinsic",
+      choices: events.map(([pallet, event]) => ({
+        name: `${pallet} - ${event}`,
+        value: [pallet, event] as [pallet: string, event: string],
+        checked: selectedEvents[pallet].has(event),
+      })),
+    })
+    const newSelectedErrors = await checkbox({
+      message: "Select Errors for this extrinsic",
+      choices: errors.map(([pallet, error]) => ({
+        name: `${pallet} - ${error}`,
+        value: [pallet, error] as [pallet: string, event: string],
+        checked: selectedErrors[pallet].has(error),
+      })),
+    })
+
+    for (const [pallet, _] of newSelectedEvents) {
+      this.#data[ext].events[pallet].clear()
+    }
+    for (const [pallet, _] of newSelectedErrors) {
+      this.#data[ext].errors[pallet].clear()
+    }
+    for (const [pallet, event] of newSelectedEvents) {
+      this.#data[ext].events[pallet].add(event)
+    }
+    for (const [pallet, error] of newSelectedErrors) {
+      this.#data[ext].errors[pallet].add(error)
+    }
+  }
+
+  [util.inspect.custom]() {
+    return this.toJSON()
+  }
+
+  toJSON() {
+    return Object.fromEntries(
+      Object.entries(this.#data).map(([k, v]) => [
+        k,
+        {
+          checksum: v.checksum,
+          events: Object.fromEntries(
+            Object.entries(v.events).map(([k, v]) => [k, Array.from(v)]),
+          ),
+          errors: Object.fromEntries(
+            Object.entries(v.errors).map(([k, v]) => [k, Array.from(v)]),
+          ),
+        },
+      ]),
+    )
+  }
+}

package/src/_polyfills.ts

@@ -0,0 +1,3 @@
+;(BigInt.prototype as any).toJSON = function () {
+  return this.toString()
+}

package/src/deferred.ts

@@ -0,0 +1,48 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+// TODO(ry) It'd be better to make Deferred a class that inherits from
+// Promise, rather than an interface. This is possible in ES2016, however
+// typescript produces broken code when targeting ES5 code.
+// See https://github.com/Microsoft/TypeScript/issues/15202
+// At the time of writing, the github issue is closed but the problem remains.
+export interface Deferred<T> extends Promise<T> {
+  readonly state: "pending" | "fulfilled" | "rejected"
+  resolve(value?: T | PromiseLike<T>): void
+  // deno-lint-ignore no-explicit-any
+  reject(reason?: any): void
+}
+
+/**
+ * Creates a Promise with the `reject` and `resolve` functions placed as methods
+ * on the promise object itself.
+ *
+ * @example
+ * ```typescript
+ * import { deferred } from "https://deno.land/std@$STD_VERSION/async/deferred.ts";
+ *
+ * const p = deferred<number>();
+ * // ...
+ * p.resolve(42);
+ * ```
+ */
+export function deferred<T>(): Deferred<T> {
+  let methods
+  let state = "pending"
+  const promise = new Promise<T>((resolve, reject) => {
+    methods = {
+      async resolve(value: T | PromiseLike<T>) {
+        await value
+        state = "fulfilled"
+        resolve(value)
+      },
+      // deno-lint-ignore no-explicit-any
+      reject(reason?: any) {
+        state = "rejected"
+        reject(reason)
+      },
+    }
+  })
+  Object.defineProperty(promise, "state", { get: () => state })
+  return Object.assign(promise, methods) as Deferred<T>
+}

package/src/descriptor-schema.ts

@@ -0,0 +1,19 @@
+import { z } from "zod"
+
+export default z.record(
+  z.object({
+    constants: z.record(z.coerce.bigint()).optional(),
+    storage: z.record(z.coerce.bigint()).optional(),
+    events: z.record(z.coerce.bigint()).optional(),
+    errors: z.record(z.coerce.bigint()).optional(),
+    extrinsics: z
+      .record(
+        z.object({
+          checksum: z.coerce.bigint(),
+          events: z.record(z.array(z.string()).transform((s) => new Set(s))),
+          errors: z.record(z.array(z.string()).transform((s) => new Set(s))),
+        }),
+      )
+      .optional(),
+  }),
+)

package/src/guards.ts

@@ -0,0 +1,20 @@
+import { LookupEntry } from "@polkadot-api/substrate-codegen"
+import { CodecType, metadata } from "@polkadot-api/substrate-bindings"
+
+type Metadata = CodecType<typeof metadata>["metadata"]
+
+export function assertMetadataIsv14(
+  metadata: Metadata,
+): asserts metadata is Metadata & { tag: "v14" } {
+  if (metadata.tag !== "v14") {
+    throw new Error("unreachable")
+  }
+}
+
+export function assertLookupEntryIsEnum(
+  lookupEntry: LookupEntry,
+): asserts lookupEntry is LookupEntry & { type: "enum" } {
+  if (lookupEntry.type !== "enum") {
+    throw new Error("not an enum")
+  }
+}