feat: add fromHex to MultisigRune

fluent/CodecRune.ts

@@ -2,6 +2,10 @@ import * as $ from "../deps/scale.ts"
 import { Rune, RunicArgs } from "../rune/mod.ts"
 
 export class CodecRune<in out T, out U> extends Rune<$.Codec<T>, U> {
+  static from<X, T>(...[codec]: RunicArgs<X, [codec: $.Codec<T>]>) {
+    return Rune.resolve(codec).into(CodecRune)
+  }
+
   // TODO: eventually, utilize `V` to toggle runtime validation
   encoded<X>(...[value]: RunicArgs<X, [value: T]>) {
     return Rune.tuple([this, value]).map(async ([codec, value]) => {

patterns/multisig/MultisigRune.ts

@@ -1,13 +1,28 @@
 import { MultiAddress } from "@capi/polkadot"
 import * as bytes from "../../deps/std/bytes.ts"
-import { $, Chain, ChainRune, PatternRune, Rune, RunicArgs, ValueRune } from "../../mod.ts"
+import {
+  $,
+  Chain,
+  ChainRune,
+  CodecRune,
+  hex,
+  PatternRune,
+  Rune,
+  RunicArgs,
+  ValueRune,
+} from "../../mod.ts"
 import { multisigAccountId } from "./multisigAccountId.ts"
 
 export interface Multisig {
   signatories: Uint8Array[]
   threshold?: number
 }
 
+export const $multisig: $.Codec<Multisig> = $.object(
+  $.field("signatories", $.array($.sizedUint8Array(32))),
+  $.optionalField("threshold", $.u8),
+)
+
 // TODO: swap out `Chain` constraints upon subset gen issue resolution... same for other patterns
 export class MultisigRune<out C extends Chain, out U> extends PatternRune<Multisig, C, U> {
   static from<C extends Chain, U, X>(
@@ -22,6 +37,8 @@ export class MultisigRune<out C extends Chain, out U> extends PatternRune<Multis
   threshold = this.value.map(({ threshold, signatories }) => threshold ?? signatories.length - 1)
   accountId = Rune.fn(multisigAccountId).call(this.value.access("signatories"), this.threshold)
   address = MultiAddress.Id(this.accountId)
+  encoded = CodecRune.from($multisig).encoded(this.as(MultisigRune))
+  hex = this.encoded.map(hex.encode)
 
   otherSignatories<X>(...[sender]: RunicArgs<X, [sender: MultiAddress]>) {
     return Rune
@@ -150,6 +167,15 @@ export class MultisigRune<out C extends Chain, out U> extends PatternRune<Multis
       )
       .map((entry) => entry !== null)
   }
+
+  static fromHex<C extends Chain, U, X>(
+    chain: ChainRune<C, U>,
+    ...[state]: RunicArgs<X, [state: string]>
+  ) {
+    return CodecRune.from($multisig)
+      .decoded(Rune.resolve(state).into(ValueRune).map(hex.decode))
+      .into(MultisigRune, chain)
+  }
 }
 
 export class NoProposalError extends Error {

patterns/multisig/VirtualMultisigRune.ts

@@ -4,6 +4,7 @@ import {
   $,
   Chain,
   ChainRune,
+  CodecRune,
   hex,
   MetaRune,
   PatternRune,
@@ -38,7 +39,7 @@ export class VirtualMultisigRune<out C extends Chain, out U>
     signatories: this.value.access("members").map((arr) => arr.map((a) => a[1])),
     threshold: this.value.access("threshold"),
   }).into(MultisigRune, this.chain)
-  encoded = this.value.map((m) => $virtualMultisig.encode(m))
+  encoded = CodecRune.from($virtualMultisig).encoded(this.as(VirtualMultisigRune))
   hex = this.encoded.map(hex.encode)
 
   senderProxyId<X>(...[senderAccountId]: RunicArgs<X, [senderAccountId: Uint8Array]>) {
@@ -107,9 +108,8 @@ export class VirtualMultisigRune<out C extends Chain, out U>
     chain: ChainRune<C, U>,
     ...[state]: RunicArgs<X, [state: string]>
   ) {
-    return Rune
-      .resolve(state)
-      .map((s) => $virtualMultisig.decode(hex.decode(s)))
+    return CodecRune.from($virtualMultisig)
+      .decoded(Rune.resolve(state).into(ValueRune).map(hex.decode))
       .into(VirtualMultisigRune, chain)
   }