feat: add call method to SignedExtrinsicRune

examples/sign/offline.eg.ts

@@ -5,7 +5,7 @@
  * Finally, rehydrate the extrinsic and submit it.
  */
 
-import { westendDev } from "@capi/westend-dev"
+import { $runtimeCall, westendDev } from "@capi/westend-dev"
 import { $, createDevUsers, SignedExtrinsicRune } from "capi"
 import { signature } from "capi/patterns/signature/polkadot.ts"
 
@@ -25,7 +25,17 @@ const hex = await westendDev.Balances
 /// writing to disk, etc.).
 save(hex)
 
-/// Hydrate the signed extrinsic, submit it and await finalization.
+/// Hydrate the signed extrinsic.
+const signedExtrinsic = SignedExtrinsicRune.fromHex(westendDev, hex)
+
+/// Get an `ExtrinsicRune` (resolves to call data) from the `SignedExtrinsicRune`.
+const call = await signedExtrinsic.call().run()
+
+/// Ensure the call data is what we expect.
+console.log(call)
+$.assert($runtimeCall, call)
+
+/// Submit it and await finalization.
 const hash = await SignedExtrinsicRune
   .fromHex(westendDev, hex)
   .sent()

fluent/BlockRune.ts

@@ -1,11 +1,9 @@
 import { hex } from "../crypto/mod.ts"
-import { $extrinsic } from "../frame_metadata/Extrinsic.ts"
 import { known } from "../rpc/mod.ts"
 import { ArrayRune, Rune } from "../rune/mod.ts"
 import { ValueRune } from "../rune/ValueRune.ts"
 import { BlockHashRune } from "./BlockHashRune.ts"
 import { Chain } from "./ChainRune.ts"
-import { CodecRune } from "./CodecRune.ts"
 import { EventsRune } from "./EventsRune.ts"
 import { PatternRune } from "./PatternRune.ts"
 
@@ -23,13 +21,10 @@ export class BlockRune<out C extends Chain, out U>
   }
 
   extrinsics() {
-    const $ext = Rune.fn($extrinsic)
-      .call(this.chain.metadata)
-      .into(CodecRune)
     return this
       .extrinsicsRaw()
       .into(ArrayRune)
-      .mapArray((h) => $ext.decoded(h.map(hex.decode)))
+      .mapArray((h) => this.chain.$extrinsic.decoded(h.map(hex.decode)))
   }
 
   events() {

fluent/ChainRune.ts

@@ -1,9 +1,10 @@
 import { hex } from "../crypto/mod.ts"
 import * as $ from "../deps/scale.ts"
-import { decodeMetadata, FrameMetadata } from "../frame_metadata/mod.ts"
+import { $extrinsic, decodeMetadata, FrameMetadata } from "../frame_metadata/mod.ts"
 import { Connection } from "../rpc/mod.ts"
 import { Rune, RunicArgs, ValueRune } from "../rune/mod.ts"
 import { BlockHashRune } from "./BlockHashRune.ts"
+import { CodecRune } from "./CodecRune.ts"
 import { ConnectionRune } from "./ConnectionRune.ts"
 import { ExtrinsicRune } from "./ExtrinsicRune.ts"
 import { PalletRune } from "./PalletRune.ts"
@@ -72,6 +73,8 @@ export class ChainRune<out C extends Chain, out U> extends Rune<C, U> {
 
   metadata = this.into(ValueRune).access("metadata")
 
+  $extrinsic = Rune.fn($extrinsic).call(this.metadata).into(CodecRune)
+
   latestBlockNum = this.connection
     .subscribe("chain_subscribeNewHeads", "chain_unsubscribeNewHeads")
     .access("number")

fluent/ExtrinsicRune.ts

@@ -1,7 +1,7 @@
 import { blake2_256, hex } from "../crypto/mod.ts"
 import * as $ from "../deps/scale.ts"
 import { concat } from "../deps/std/bytes.ts"
-import { $extrinsic, Signer } from "../frame_metadata/Extrinsic.ts"
+import { Signer } from "../frame_metadata/Extrinsic.ts"
 import { Rune, RunicArgs, ValueRune } from "../rune/mod.ts"
 import { Chain, ChainRune } from "./ChainRune.ts"
 import { CodecRune } from "./CodecRune.ts"
@@ -34,40 +34,30 @@ export class ExtrinsicRune<out C extends Chain, out U> extends PatternRune<Chain
   $callData = this.chain.into(ValueRune).access("metadata", "extrinsic", "call").into(CodecRune)
   callData = this.$callData.encoded(this)
 
-  $callHash = this.$callData.into(ValueRune).map((x) => blake2_256.$hash<any>(x)).into(CodecRune)
+  $callHash = Rune
+    .fn(($inner: $.Codec<unknown>) => blake2_256.$hash($inner))
+    .call(this.$callData)
+    .into(CodecRune)
   callHash = this.$callHash.encoded(this)
 
-  $extrinsic = Rune.fn($extrinsic).call(this.chain.metadata).into(CodecRune)
-  extrinsic = this.$extrinsic.encoded(Rune.object({
-    protocolVersion: 4,
-    call: this,
-  }))
-
   signed<SU>(signatureFactory: SignatureDataFactory<C, U, SU>) {
-    return this.$extrinsic
+    return this.chain.$extrinsic
       .encoded(Rune.object({
-        protocolVersion: 4,
+        protocolVersion: ExtrinsicRune.PROTOCOL_VERSION,
         call: this,
         signature: signatureFactory(this.chain),
       }))
       .into(SignedExtrinsicRune, this.chain)
   }
 
-  encoded() {
-    return Rune
-      .fn($extrinsic)
-      .call(this.chain.metadata)
-      .into(CodecRune)
-      .encoded(Rune.object({
-        protocolVersion: ExtrinsicRune.PROTOCOL_VERSION,
-        call: this,
-      }))
-  }
-
   feeEstimate() {
+    const extrinsic = this.chain.$extrinsic.encoded(Rune.object({
+      protocolVersion: ExtrinsicRune.PROTOCOL_VERSION,
+      call: this,
+    }))
     const arg = Rune
       .fn(concat)
-      .call(this.extrinsic, this.extrinsic.access("length").map((n) => $.u32.encode(n)))
+      .call(extrinsic, extrinsic.access("length").map((n) => $.u32.encode(n)))
       .map(hex.encodePrefixed)
     const data = this.chain.connection
       .call("state_call", "TransactionPaymentApi_query_info", arg)

fluent/SignedExtrinsicRune.ts

@@ -1,6 +1,7 @@
 import { hex } from "../crypto/mod.ts"
 import { Rune, RunicArgs, ValueRune } from "../rune/mod.ts"
 import { Chain, ChainRune } from "./ChainRune.ts"
+import { ExtrinsicRune } from "./ExtrinsicRune.ts"
 import { ExtrinsicStatusRune } from "./ExtrinsicStatusRune.ts"
 import { PatternRune } from "./PatternRune.ts"
 
@@ -19,6 +20,13 @@ export class SignedExtrinsicRune<out C extends Chain, out U> extends PatternRune
     return this.from(chain, Rune.resolve(value).map(hex.decode))
   }
 
+  call() {
+    return this.chain.$extrinsic
+      .decoded(this.as(SignedExtrinsicRune))
+      .access("call")
+      .into(ExtrinsicRune, this.chain)
+  }
+
   hex() {
     return this.into(ValueRune).map(hex.encode)
   }