feat: simplify dynamic dx (#774)

Co-authored-by: T6 <[email protected]>

codegen/FrameCodegen.ts

@@ -23,20 +23,19 @@ export class FrameCodegen {
       "chain.js",
       `
 import * as _codecs from "./codecs.js"
-import { connection } from "./connection.js"
+import { connectionCtor, discoveryValue } from "./connection.js"
 import * as C from "./capi.js"
 import * as t from "./types/mod.js"
 
 export const metadata = ${this.codecCodegen.print(this.metadata)}
 
-export const chain = C.Rune.rec({ metadata, connection }).into(C.ChainRune)
+export const chain = C.ChainRune.from(connectionCtor, discoveryValue, metadata)
 `,
     )
     files.set(
       "chain.d.ts",
       `
 import * as _codecs from "./codecs.js"
-import { connection } from "./connection.js"
 import * as C from "./capi.js"
 import * as t from "./types/mod.js"
 

examples/dynamic.ts

@@ -0,0 +1,11 @@
+import { ChainRune, WsConnection } from "capi"
+
+const chain = ChainRune.from(WsConnection, "wss://rpc.polkadot.io")
+
+const accountInfo = await chain
+  .pallet("System")
+  .storage("Account")
+  .entryPage(10, null)
+  .run()
+
+console.log(accountInfo)

fluent/ChainRune.ts

@@ -1,6 +1,7 @@
+import { hex } from "../crypto/mod.ts"
 import * as $ from "../deps/scale.ts"
-import { FrameMetadata } from "../frame_metadata/mod.ts"
-import { Connection } from "../rpc/mod.ts"
+import { decodeMetadata, FrameMetadata } from "../frame_metadata/mod.ts"
+import { Connection, ConnectionCtorLike } from "../rpc/mod.ts"
 import { Rune, RunicArgs, ValueRune } from "../rune/mod.ts"
 import { BlockRune } from "./BlockRune.ts"
 import { ConnectionRune } from "./ConnectionRune.ts"
@@ -50,6 +51,21 @@ export namespace Chain {
 
 // TODO: do we want to represent the discovery value and conn type within the type system?
 export class ChainRune<out C extends Chain, out U> extends Rune<C, U> {
+  static from<D, M extends FrameMetadata>(
+    connectionCtor: ConnectionCtorLike<D>,
+    discovery: D,
+    staticMetadata?: M,
+  ) {
+    const connection = ConnectionRune.from(async (signal) =>
+      connectionCtor.connect(discovery, signal)
+    )
+    const metadata = staticMetadata ?? Rune
+      .fn(hex.decode)
+      .call(connection.call("state_getMetadata"))
+      .map(decodeMetadata)
+    return Rune.rec({ connection, metadata }).into(this)
+  }
+
   connection = this.into(ValueRune<Chain, U>).access("connection").into(ConnectionRune)
 
   metadata = this.into(ValueRune).access("metadata")
@@ -76,12 +92,11 @@ export class ChainRune<out C extends Chain, out U> extends Rune<C, U> {
     return call.into(ExtrinsicRune, this.as(ChainRune))
   }
 
-  pallet<P extends Chain.PalletName<C>, X>(...args: RunicArgs<X, [palletName: P]>) {
-    const [palletName] = RunicArgs.resolve(args)
-    return this
-      .into(ValueRune)
-      .access("metadata", "pallets", palletName.as(Rune))
-      .into(PalletRune, this)
+  pallet<P extends Chain.PalletName<C>, X>(...[palletName]: RunicArgs<X, [P]>) {
+    return this.metadata
+      .access("pallets", palletName)
+      .unsafeAs<Chain.Pallet<C, P>>()
+      .into(PalletRune, this.as(ChainRune))
   }
 
   addressPrefix(this: ChainRune<AddressPrefixChain, U>) {

fluent/ConnectionRune.ts

@@ -13,11 +13,11 @@ class RunConnection extends Run<Connection, never> {
   }
 }
 
-export function connection(init: (signal: AbortSignal) => Promise<Connection>) {
-  return Rune.new(RunConnection, init).into(ConnectionRune)
-}
-
 export class ConnectionRune<U> extends Rune<Connection, U> {
+  static from(init: (signal: AbortSignal) => Promise<Connection>) {
+    return Rune.new(RunConnection, init).into(ConnectionRune)
+  }
+
   call<K extends keyof Calls, X>(
     callMethod: K,
     ...args: RunicArgs<X, [...Parameters<Calls[K]>]>

providers/frame/FrameProxyProvider.ts

@@ -66,13 +66,8 @@ export abstract class FrameProxyProvider extends FrameProvider {
     return `
 import * as C from "./capi.js"
 
+export const connectionCtor ${isTypes ? `: typeof C.WsConnection` : `= C.WsConnection`}
 export const discoveryValue ${isTypes ? ":" : "="} "${url}"
-
-export const connection ${
-      isTypes
-        ? ": C.ConnectionRune<never>"
-        : "= C.connection((signal) => C.WsConnection.connect(discoveryValue, signal))"
-    }
     `
   }
 }

rpc/Connection.ts

@@ -4,6 +4,11 @@ import { RpcCallMessage, RpcIngressMessage, RpcSubscriptionHandler } from "./rpc
 
 const connectionMemos = new Map<new(discovery: any) => Connection, Map<unknown, Connection>>()
 
+export interface ConnectionCtorLike<D> {
+  new(discovery: D): Connection
+  connect: (discovery: D, signal: AbortSignal) => Connection
+}
+
 export abstract class Connection {
   nextId = 0
   references = 0