refactor: decouple capi from presentation layer (#223)

Co-authored-by: Josep M Sobrepere <jm.sobrepere@gmail.com>

.vscode/settings.json

@@ -1,13 +1,4 @@
 {
-  "[css]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[html]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[yaml]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
   "css.lint.unknownAtRules": "ignore",
   "editor.defaultFormatter": "dprint.dprint",
   "editor.formatOnSave": true,

www/package.json

@@ -16,15 +16,13 @@
     "react-router-dom": "^6.12.1",
     "react-tooltip": "^5.13.2",
     "tailwind-merge": "^1.13.1",
-    "uuid": "^9.0.0",
     "vite-tsconfig-paths": "^4.2.0"
   },
   "devDependencies": {
     "@babel/core": ">=7.12.10 <8.0.0",
     "@babel/plugin-transform-react-jsx": "^7.22.5",
     "@preact/preset-vite": "^2.5.0",
     "@tailwindcss/forms": "^0.5.3",
-    "@types/uuid": "^9.0.2",
     "autoprefixer": "^10.4.14",
     "clsx": "^1.2.1",
     "postcss": "^8.4.24",

www/src/api/cancel.ts

@@ -0,0 +1,40 @@
+import { hex, Rune, RunicArgs } from "capi"
+import { signature } from "capi/patterns/signature/polkadot"
+import { Setup } from "common"
+import { defaultAccount } from "../signals/accounts.js"
+import { toMultiAddressIdRune, toMultisigRune } from "../util/capi-helpers.js"
+import { createSender } from "./createSender.js"
+import { Message } from "./notificationsCb.js"
+
+export async function cancel(
+  setup: Setup,
+  callHash: string,
+  cb: (value: Message) => void,
+) {
+  const account = defaultAccount.value
+  if (!account) throw new Error("No account connected!")
+
+  const multisig = toMultisigRune(setup)
+  const user = toMultiAddressIdRune(account.address)
+  const sender = createSender(account.address)
+
+  const cancelCall = multisig
+    .cancel(user, hex.decode(callHash))
+    .signed(signature({ sender }))
+    .sent()
+    .dbgStatus("Cancel")
+    .finalizedEvents()
+    .unhandleFailed()
+    .pipe(<X>(...[events]: RunicArgs<X, [any[]]>) => {
+      cb({ type: "loading" })
+      return Rune.resolve(events).map((events) => {
+        cb({ type: "success" })
+        const eventNames = events.map((e) =>
+          `${e.event.type}:${e.event.value.type}`
+        )
+        cb({ type: "info", events: eventNames })
+      })
+    })
+
+  await cancelCall.run()
+}

www/src/api/createSender.ts

@@ -0,0 +1,10 @@
+import { westend } from "@capi/westend"
+import { pjsSender } from "capi/patterns/compat/pjs_sender"
+import { defaultExtension } from "../signals/accounts.js"
+
+export function createSender(address: string) {
+  return pjsSender(
+    westend,
+    defaultExtension.value!.signer as any,
+  )(address)
+}

www/src/api/createStashCall.ts

@@ -0,0 +1,53 @@
+import { PalletProxyEvent, RuntimeEvent, westend } from "@capi/westend"
+import { Rune, RunicArgs, ss58 } from "capi"
+import { signature } from "capi/patterns/signature/polkadot"
+import { createSender } from "./createSender.js"
+import { Message } from "./notificationsCb.js"
+
+export async function createStashCall(
+  address: string,
+  cb: (value: Message) => void,
+): Promise<string> {
+  const sender = createSender(address)
+
+  const createStashCall = westend.Proxy.createPure({
+    proxyType: "Any",
+    delay: 0,
+    index: 0,
+  })
+    .signed(signature({ sender: sender }))
+    .sent()
+    .dbgStatus("Creating Pure Proxy:")
+    .inBlockEvents()
+    .unhandleFailed()
+    .pipe(<X>(...[events]: RunicArgs<X, [any[]]>) => {
+      cb({ type: "loading" })
+      return Rune.resolve(events).map((events) => {
+        cb({ type: "success" })
+        const eventNames = events.map((e) =>
+          `${e.event.type}:${e.event.value.type}`
+        )
+        cb({ type: "info", events: eventNames })
+
+        return events
+          .map((e) => e.event)
+          .filter((event): event is RuntimeEvent.Proxy =>
+            event.type === "Proxy"
+          )
+          .map((e) => e.value)
+          .filter((event): event is PalletProxyEvent.PureCreated =>
+            event.type === "PureCreated"
+          )
+      })
+    })
+    // TODO typing is broken in capi
+    .map((events: { pure: unknown }[]) => events.map(({ pure }) => pure))
+    .access(0)
+
+  const stashBytes = (await createStashCall.run()) as Uint8Array
+  const stashAddress = ss58.encode(
+    await westend.addressPrefix().run(),
+    stashBytes,
+  )
+  return stashAddress
+}

www/src/api/fundStash.ts

@@ -0,0 +1,39 @@
+import { westend } from "@capi/westend"
+import { Rune, RunicArgs } from "capi"
+import { signature } from "capi/patterns/signature/polkadot"
+import { defaultAccount } from "../signals/accounts.js"
+import { toBalance } from "../util/balance.js"
+import { toMultiAddressIdRune } from "../util/capi-helpers.js"
+import { createSender } from "./createSender.js"
+import { Message } from "./notificationsCb.js"
+
+export async function fundStash(
+  amount: number,
+  dest: string,
+  cb: (value: Message) => void,
+) {
+  const sender = createSender(defaultAccount.value!.address)
+
+  const fundStashCall = westend.Balances
+    .transfer({
+      value: toBalance(amount),
+      dest: toMultiAddressIdRune(dest),
+    })
+    .signed(signature({ sender }))
+    .sent()
+    .dbgStatus("Transfer:")
+    .inBlockEvents()
+    .unhandleFailed()
+    .pipe(<X>(...[events]: RunicArgs<X, [any[]]>) => {
+      cb({ type: "loading" })
+      return Rune.resolve(events).map((events) => {
+        cb({ type: "success" })
+        const eventNames = events.map((e) =>
+          `${e.event.type}:${e.event.value.type}`
+        )
+        cb({ type: "info", events: eventNames })
+      })
+    })
+
+  await fundStashCall.run()
+}

www/src/api/getMultisigAddress.ts

@@ -0,0 +1,18 @@
+import { Westend, westend } from "@capi/westend"
+import { ss58 } from "capi"
+import { MultisigRune } from "capi/patterns/multisig"
+import { toPubKey } from "../util/capi-helpers.js"
+
+export async function getMultisigAddress(members: string[], threshold: number) {
+  const signatories = members.map(toPubKey)
+  const multisig: MultisigRune<Westend, never> = MultisigRune.from(westend, {
+    signatories,
+    threshold,
+  })
+  const [prefix, accountId] = await Promise.all([
+    westend.addressPrefix().run(),
+    multisig.accountId.run(),
+  ])
+
+  return ss58.encode(prefix, accountId)
+}