ox 1.7.4 → 1.8.0

package/src/zod/_test/Frame.test.ts

@@ -0,0 +1,54 @@
+import { Frame } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+
+describe('Frame', () => {
+  test('decodes RPC budgets and encodes named flags', () => {
+    const frame = Frame.from({
+      flags: 'approveExecutionAndPayment',
+      gas: 50_000n,
+      mode: 'verify',
+    })
+    const rpc = z.encode(z.Frame.Frame, frame)
+    expect(rpc).toEqual({
+      data: '0x',
+      executionGasLimit: '0xc350',
+      flags: 3,
+      mode: 1,
+      stateGasLimit: '0x0',
+      value: '0x0',
+    })
+    expect(z.decode(z.Frame.Frame, rpc)).toEqual({
+      data: '0x',
+      flags: 3,
+      gas: 50_000n,
+      mode: 1,
+      stateGas: 0n,
+      value: 0n,
+    })
+  })
+  test('rejects invalid mode and budget', () => {
+    expect(z.safeParse(z.Frame.Decoded, { mode: 3 }).success).toBe(false)
+    expect(z.safeParse(z.Frame.Decoded, { gas: -1n }).success).toBe(false)
+  })
+  test('encodes numberish values', () => {
+    expect(
+      z.encode(z.Frame.FrameToRpc, { gas: '0xc350', stateGas: 0 })
+        .executionGasLimit,
+    ).toBe('0xc350')
+  })
+})
+
+describe('FrameToRpc validation', () => {
+  test.each([
+    { mode: 3 },
+    { flags: 8 },
+    { gas: 2n ** 64n },
+    { stateGas: -1 },
+    { gas: '0x10000000000000000' },
+  ])('rejects invalid frame %#', (frame) => {
+    expect(
+      z.safeEncode(z.Frame.FrameToRpc, frame as Frame.toRpc.Input).success,
+    ).toBe(false)
+  })
+})

package/src/zod/_test/FrameReceipt.test.ts

@@ -0,0 +1,75 @@
+import { FrameReceipt } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+
+describe('FrameReceipt', () => {
+  test('safe codecs reject invalid gas without throwing', () => {
+    expect(
+      z.safeDecode(z.FrameReceipt.FrameReceipt, {
+        executionGasUsed: '0x',
+        logs: [],
+        stateGasUsed: '0x0',
+        status: 1,
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeEncode(z.FrameReceipt.FrameReceipt, {
+        gasUsed: -1n,
+        logs: [],
+        stateGasUsed: 0n,
+        status: 'success',
+      }).success,
+    ).toBe(false)
+    for (const gasUsed of [-1, Number.MAX_SAFE_INTEGER + 1, '0x'] as const)
+      expect(
+        z.safeEncode(z.FrameReceipt.FrameReceiptToRpc, {
+          gasUsed,
+          logs: [],
+          stateGasUsed: 0n,
+          status: 'success',
+        }).success,
+      ).toBe(false)
+  })
+
+  test('roundtrip', () => {
+    const rpc = {
+      executionGasUsed: '0x20000000000001',
+      logs: [],
+      stateGasUsed: '0x0',
+      status: 2,
+    } as const
+    const receipt = FrameReceipt.fromRpc(rpc)
+    expect(z.decode(z.FrameReceipt.FrameReceipt, rpc)).toEqual(receipt)
+    expect(z.encode(z.FrameReceipt.FrameReceipt, receipt)).toEqual(rpc)
+  })
+
+  test('invalid status', () => {
+    expect(
+      z.safeDecode(z.FrameReceipt.FrameReceipt, {
+        executionGasUsed: '0x0',
+        logs: [],
+        stateGasUsed: '0x0',
+        // @ts-expect-error Invalid RPC status.
+        status: 3,
+      }).success,
+    ).toBe(false)
+  })
+})
+
+describe('FrameReceiptToRpc', () => {
+  test('numberish gas', () => {
+    expect(
+      z.encode(z.FrameReceipt.FrameReceiptToRpc, {
+        gasUsed: 21000,
+        logs: [],
+        stateGasUsed: '0x0',
+        status: 'success',
+      }),
+    ).toEqual({
+      executionGasUsed: '0x5208',
+      logs: [],
+      stateGasUsed: '0x0',
+      status: 1,
+    })
+  })
+})

package/src/zod/_test/FrameSignature.test.ts

@@ -0,0 +1,94 @@
+import { FrameSignature, P256, Secp256k1, Hash } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+import { accounts } from '../../../test/constants/accounts.js'
+
+describe('FrameSignature', () => {
+  test('safeDecode rejects malformed protocol signatures without throwing', () => {
+    expect(
+      z.safeDecode(z.FrameSignature.FrameSignature, {
+        msg: '0x',
+        scheme: 1,
+        signature: '0x01',
+      }).success,
+    ).toBe(false)
+  })
+
+  test('encodes omitted payloads', () => {
+    expect(
+      z.encode(z.FrameSignature.FrameSignature, {
+        scheme: 'arbitrary',
+        signature: '0xaabb',
+      }),
+    ).toEqual({ msg: '0x', scheme: 0, signature: '0xaabb' })
+    expect(
+      z.encode(z.FrameSignature.FrameSignature, {
+        scheme: 'secp256k1',
+      }),
+    ).toEqual({ msg: '0x', scheme: 1, signature: '0x' })
+    expect(
+      z.encode(z.FrameSignature.FrameSignature, {
+        scheme: 'p256',
+      }),
+    ).toEqual({ msg: '0x', scheme: 2, signature: '0x' })
+  })
+
+  test('arbitrary bytes', () => {
+    expect(
+      z.encode(z.FrameSignature.FrameSignature, FrameSignature.from('0xaabb')),
+    ).toEqual({ msg: '0x', scheme: 0, signature: '0xaabb' })
+    expect(
+      z.decode(z.FrameSignature.FrameSignature, {
+        msg: '0x',
+        scheme: 0,
+        signature: '0xaabb',
+      }),
+    ).toEqual(FrameSignature.from('0xaabb'))
+  })
+  test('secp256k1 signature', () => {
+    const entry = FrameSignature.from({
+      scheme: 'secp256k1',
+      signature: Secp256k1.sign({
+        payload: Hash.keccak256('0xdeadbeef'),
+        privateKey: accounts[0].privateKey,
+      }),
+    })
+    const rpc = z.encode(z.FrameSignature.FrameSignature, entry)
+    expect(rpc.scheme).toBe(1)
+    expect(z.decode(z.FrameSignature.FrameSignature, rpc)).toEqual(entry)
+  })
+  test('P-256 signature', () => {
+    const privateKey = accounts[0].privateKey
+    const entry = FrameSignature.from({
+      publicKey: P256.getPublicKey({ privateKey }),
+      scheme: 'p256',
+      signature: P256.sign({
+        payload: Hash.keccak256('0xdeadbeef'),
+        privateKey,
+      }),
+    })
+    const rpc = z.encode(z.FrameSignature.FrameSignature, entry)
+    expect(rpc.scheme).toBe(2)
+    expect(z.decode(z.FrameSignature.FrameSignature, rpc)).toEqual({
+      ...entry,
+      signature: { r: entry.signature.r, s: entry.signature.s },
+    })
+  })
+  test('rejects missing P-256 public key and invalid arbitrary signer', () => {
+    expect(
+      z.safeParse(z.FrameSignature.Decoded, {
+        payload: '0x',
+        scheme: 'p256',
+        signature: { r: '0x01', s: '0x02' },
+      }).success,
+    ).toBe(false)
+    expect(
+      z.safeParse(z.FrameSignature.Decoded, {
+        payload: '0x',
+        scheme: 'arbitrary',
+        signature: '0x',
+        signer: accounts[0].address,
+      }).success,
+    ).toBe(false)
+  })
+})

package/src/zod/_test/TxEnvelopeEip8141.test.ts

@@ -0,0 +1,116 @@
+import {
+  Frame,
+  FrameSignature,
+  TransactionEnvelope,
+  TxEnvelopeEip8141,
+} from 'ox'
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+import { accounts } from '../../../test/constants/accounts.js'
+
+describe('TxEnvelopeEip8141', () => {
+  test('signed codecs reject protocol signature placeholders', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      chainId: 1,
+      frames: [{}],
+      sender: accounts[0].address,
+      signatures: [{ scheme: 'secp256k1' }],
+    })
+    expect(
+      z.safeDecode(
+        z.TransactionEnvelope.Signed,
+        TxEnvelopeEip8141.toRpc(envelope),
+      ).success,
+    ).toBe(false)
+    expect(z.safeEncode(z.TransactionEnvelope.Signed, envelope).success).toBe(
+      false,
+    )
+    expect(
+      z.safeEncode(z.TransactionEnvelope.SignedToRpc, envelope).success,
+    ).toBe(false)
+    expect(
+      z.safeParse(z.TransactionEnvelope.SignedDecoded, envelope).success,
+    ).toBe(false)
+  })
+
+  test('RPC codec preserves chain ID precision and signing payloads', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      chainId: 9007199254740993n,
+      frames: [Frame.from({})],
+      sender: accounts[0].address,
+      signatures: [FrameSignature.from({ scheme: 'secp256k1' })],
+    })
+    const rpc = z.encode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, envelope)
+    expect(rpc.chainId).toBe('0x20000000000001')
+    const decoded = z.decode(z.TransactionEnvelope.TransactionEnvelope, rpc)
+    expect(decoded.chainId).toBe(9007199254740993n)
+    expect(TransactionEnvelope.getSignPayload(decoded)).toBe(
+      TxEnvelopeEip8141.getSignPayload(envelope),
+    )
+  })
+  test('generic serialized codec supports unsigned frame entries', () => {
+    const envelope = TxEnvelopeEip8141.from({
+      chainId: 1,
+      frames: [Frame.from({})],
+      sender: '0x1111111111111111111111111111111111111111',
+    })
+    const serialized =
+      '0x06e70180941111111111111111111111111111111111111111c9c8808080c280808080c0c3808080c0'
+    expect(z.encode(z.TxEnvelopeEip8141.serialized, envelope)).toBe(serialized)
+    const decoded = z.decode(z.TransactionEnvelope.serialized, serialized)
+    expect(decoded.type).toBe('eip8141')
+    expect(z.encode(z.TransactionEnvelope.serialized, decoded)).toBe(serialized)
+  })
+  test('rejects invalid envelope constraints', () => {
+    expect(
+      z.safeParse(z.TxEnvelopeEip8141.Decoded, {
+        chainId: 1,
+        frames: [],
+        sender: accounts[0].address,
+        type: 'eip8141',
+      }).success,
+    ).toBe(false)
+  })
+  test('numberish encoder preserves defaults', () => {
+    expect(
+      z.encode(z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc, {
+        chainId: '0x1',
+        frames: [{ gas: 50_000 }],
+        sender: accounts[0].address,
+        type: 'eip8141',
+      }).frames[0]!.executionGasLimit,
+    ).toBe('0xc350')
+  })
+})
+
+describe('invalid envelopes', () => {
+  const envelope = TxEnvelopeEip8141.from({
+    chainId: 1,
+    frames: [Frame.from({})],
+    sender: accounts[0].address,
+  })
+  test.each([
+    { frames: [] },
+    { frames: Array.from({ length: 65 }, () => Frame.from({})) },
+    { maxFeePerBlobGas: 1n },
+    { maxFeePerGas: 1n, maxPriorityFeePerGas: 2n },
+  ])('rejects numberish envelope %#', (fields) => {
+    const invalid = { ...envelope, ...fields }
+    expect(
+      z.safeEncode(z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc, invalid).success,
+    ).toBe(false)
+    const rpc = TxEnvelopeEip8141.toRpc(invalid)
+    expect(
+      z.safeDecode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, rpc).success,
+    ).toBe(false)
+  })
+  test('rejects malformed nested RPC signatures without throwing', () => {
+    const rpc = {
+      ...TxEnvelopeEip8141.toRpc(envelope),
+      signatures: [{ msg: '0x', scheme: 1, signature: '0x01' }],
+    } as const
+    expect(
+      z.safeDecode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, rpc).success,
+    ).toBe(false)
+  })
+})

package/src/zod/internal/Frame.ts

@@ -0,0 +1,26 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as Hex from '../../core/Hex.js'
+import * as Quantity from '../../core/internal/quantity.js'
+import { quantityHex, uintBigint, uintNumber } from './Integer.js'
+import * as z from 'zod/mini'
+
+export const chainId = z.codec(
+  quantityHex(),
+  z.union([uintNumber(), uintBigint()]),
+  {
+    decode(value) {
+      const id = Hex.toBigInt(value)
+      return id <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(id) : id
+    },
+    encode: (value) => Hex.fromNumber(value),
+  },
+)
+
+export const chainIdToRpc = z.codec(
+  quantityHex(),
+  z.union([quantityHex(), uintNumber(), uintBigint()]),
+  {
+    decode: (value) => z.decode(chainId, value),
+    encode: (value) => Quantity.fromNumberish(value),
+  },
+)

package/src/zod/tempo/KeyAuthorization.ts

@@ -9,16 +9,6 @@ import {
 import * as z from 'zod/mini'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
-const SignatureRpc = z.union([
-  z_SignatureEnvelope.PrimitiveRpc,
-  z_SignatureEnvelope.MultisigRpc,
-])
-
-const Signature = z.union([
-  z_SignatureEnvelope.Primitive,
-  z_SignatureEnvelope.Multisig,
-])
-
 /** RPC token spending limit schema. */
 export const RpcTokenLimit = z.object({
   limit: z_Hex.Hex,
@@ -39,18 +29,28 @@ export const RpcCallScope = z.object({
 })
 
 /** RPC key authorization schema. */
-export const Rpc = z.object({
-  account: z.optional(z.nullable(z_Address.Address)),
-  allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
-  chainId: z_Hex.Hex,
-  expiry: z.optional(z.nullable(z_Hex.Hex)),
-  isAdmin: z.optional(z.nullable(z.boolean())),
-  keyId: z_Address.Address,
-  keyType: z_SignatureEnvelope.Type,
-  limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
-  signature: SignatureRpc,
-  witness: z.optional(z.nullable(z_Hex.Hex)),
-})
+export const Rpc = z
+  .object({
+    account: z.optional(z.nullable(z_Address.Address)),
+    allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
+    chainId: z_Hex.Hex,
+    expiry: z.optional(z.nullable(z_Hex.Hex)),
+    isAdmin: z.optional(z.nullable(z.boolean())),
+    keyId: z_Address.Address,
+    keyType: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
+    limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
+    signature: z.union([
+      z_SignatureEnvelope.PrimitiveRpc,
+      z_SignatureEnvelope.MultisigRpc,
+    ]),
+    witness: z.optional(z.nullable(z_Hex.Hex)),
+  })
+  .check(
+    z.refine(
+      (value) => value.keyType !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 /** Token spending limit schema. */
 export const TokenLimit = z.object({
@@ -79,20 +79,27 @@ const domainShape = {
   expiry: z.optional(z.number()),
   limits: z.optional(z.readonly(z.array(TokenLimit))),
   scopes: z.optional(z.readonly(z.array(Scope))),
-  signature: Signature,
-  type: z_SignatureEnvelope.Type,
+  signature: z.union([
+    z_SignatureEnvelope.Primitive,
+    z_SignatureEnvelope.Multisig,
+  ]),
+  type: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
   witness: z.optional(z_Hex.Hex),
 }
 
-/** Decoded key authorization schema (TIP-1049 admin fields are paired: both or neither). */
-export const Domain = z.union([
-  z.object({
+/** Decoded key authorization schema. */
+export const Domain = z
+  .object({
     ...domainShape,
-    account: z_Address.Address,
-    isAdmin: z.boolean(),
-  }),
-  z.object(domainShape),
-])
+    account: z.optional(z_Address.Address),
+    isAdmin: z.optional(z.boolean()),
+  })
+  .check(
+    z.refine(
+      (value) => value.type !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 const domainToRpcShape = {
   ...domainShape,
@@ -102,14 +109,18 @@ const domainToRpcShape = {
 }
 
 /** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
-export const DomainToRpc = z.union([
-  z.object({
+export const DomainToRpc = z
+  .object({
     ...domainToRpcShape,
-    account: z_Address.Address,
-    isAdmin: z.boolean(),
-  }),
-  z.object(domainToRpcShape),
-])
+    account: z.optional(z_Address.Address),
+    isAdmin: z.optional(z.boolean()),
+  })
+  .check(
+    z.refine(
+      (value) => value.type !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 /** Codec decoding an RPC key authorization into a signed key authorization. */
 export const KeyAuthorization = z.codec(Rpc, Domain, {

package/src/zod/tempo/MultisigSimulation.ts

@@ -7,53 +7,17 @@ import * as z from 'zod/mini'
 import * as z_MultisigConfig from './MultisigConfig.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
-const NestedPrimitiveApproval = z.object({
+const PrimitiveApproval = z.strictObject({
   keyData: z.optional(z_Hex.Hex),
   keyType: z.optional(z_SignatureEnvelope.Type),
   owner: z_Address.Address,
 })
 
-const PrimitiveApproval = z.object({
-  keyData: z.optional(z_Hex.Hex),
-  keyType: z.optional(z_SignatureEnvelope.Type),
-  owner: z_Address.Address,
-  type: z.literal('primitive'),
-})
-
-const NestedSpec = z.object({
-  account: z_Address.Address,
-  approvals: z.readonly(
-    z
-      .array(NestedPrimitiveApproval)
-      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
-  ),
-  config: z_MultisigConfig.Config,
-})
-
-const NestedSpecRpc = z.object({
-  account: z_Address.Address,
-  approvals: z.readonly(
-    z
-      .array(NestedPrimitiveApproval)
-      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
-  ),
-  config: z_Hex.Hex,
-})
-
 /** Native multisig simulation spec schema. */
 export const Domain = z.object({
-  account: z_Address.Address,
   approvals: z.readonly(
     z
-      .array(
-        z.union([
-          PrimitiveApproval,
-          z.object({
-            spec: NestedSpec,
-            type: z.literal('multisig'),
-          }),
-        ]),
-      )
+      .array(PrimitiveApproval)
       .check(z.maxLength(core_MultisigConfig.maxSignatures)),
   ),
   config: z_MultisigConfig.Config,
@@ -61,18 +25,9 @@ export const Domain = z.object({
 
 const Rpc_ = z
   .object({
-    account: z_Address.Address,
     approvals: z.readonly(
       z
-        .array(
-          z.union([
-            PrimitiveApproval,
-            z.object({
-              spec: NestedSpecRpc,
-              type: z.literal('multisig'),
-            }),
-          ]),
-        )
+        .array(PrimitiveApproval)
         .check(z.maxLength(core_MultisigConfig.maxSignatures)),
     ),
     config: z_Hex.Hex,

package/src/zod/tempo/SignatureEnvelope.ts

@@ -72,23 +72,35 @@ export const WebAuthnRpc = z.object({
 export const PrimitiveRpc = z.union([Secp256k1Rpc, P256Rpc, WebAuthnRpc])
 
 /** RPC keychain signature envelope schema. */
-export const KeychainRpc = z.object({
-  keyId: z.optional(z_Address.Address),
-  // `signature` is recursive; type the getter concretely to break the cycle.
-  signature: z.lazy(
-    (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelopeRpc> =>
-      Rpc as never,
-  ),
-  type: z.literal('keychain'),
-  userAddress: z_Address.Address,
-  version: z.optional(KeychainVersion),
-})
+export const KeychainRpc = z
+  .object({
+    keyId: z.optional(z_Address.Address),
+    // `signature` is recursive; type the getter concretely to break the cycle.
+    signature: z.lazy(
+      (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelopeRpc> =>
+        Rpc as never,
+    ),
+    type: z.literal('keychain'),
+    userAddress: z_Address.Address,
+    version: z.optional(KeychainVersion),
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_SignatureEnvelope.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'multisig access keys require keychain V2'),
+  )
 
 /** RPC native multisig signature envelope schema. */
 export const MultisigRpc = z_Hex.Hex.check(
   z.refine((value) => {
     try {
-      return core_SignatureEnvelope.fromRpc(value).type === 'multisig'
+      core_SignatureEnvelope.fromRpc(value)
+      return true
     } catch {
       return false
     }
@@ -133,34 +145,34 @@ export const WebAuthn = z.object({
 export const Primitive = z.union([Secp256k1, P256, WebAuthn])
 
 /** Keychain signature envelope schema. */
-export const Keychain = z.object({
-  // `inner` is recursive; type the getter concretely to break the cycle.
-  inner: z.lazy(
-    (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelope> =>
-      Domain as never,
-  ),
-  keyId: z.optional(z_Address.Address),
-  type: z.literal('keychain'),
-  userAddress: z_Address.Address,
-  version: z.optional(KeychainVersion),
-})
+export const Keychain = z
+  .object({
+    // `inner` is recursive; type the getter concretely to break the cycle.
+    inner: z.lazy(
+      (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelope> =>
+        Domain as never,
+    ),
+    keyId: z.optional(z_Address.Address),
+    type: z.literal('keychain'),
+    userAddress: z_Address.Address,
+    version: z.optional(KeychainVersion),
+  })
+  .check(
+    z.refine(
+      (value) => core_SignatureEnvelope.validate(value),
+      'multisig access keys require keychain V2',
+    ),
+  )
 
 /** Native multisig signature envelope schema. */
 export const Multisig = z
   .object({
     account: z_Address.Address,
     config: z_MultisigConfig.Config,
-    // `signatures` is recursive; type the getter concretely to break the cycle.
-    signatures: z.lazy(
-      (): z.ZodMiniType<readonly core_SignatureEnvelope.SignatureEnvelope[]> =>
-        z.readonly(
-          z
-            .array(Domain)
-            .check(
-              z.minLength(1),
-              z.maxLength(core_MultisigConfig.maxSignatures),
-            ),
-        ) as never,
+    signatures: z.readonly(
+      z
+        .array(Primitive)
+        .check(z.minLength(1), z.maxLength(core_MultisigConfig.maxSignatures)),
     ),
     type: z.literal('multisig'),
   })
@@ -189,7 +201,6 @@ function fromRpc(
   value: core_SignatureEnvelope.SignatureEnvelopeRpc,
 ): core_SignatureEnvelope.SignatureEnvelope {
   if (typeof value === 'string') return core_SignatureEnvelope.fromRpc(value)
-
   if (value.type === 'secp256k1') {
     const secp256k1 = value as core_SignatureEnvelope.Secp256k1Rpc
     return {