ox 0.14.56 → 0.14.57

package/tempo/AccountSimulation.ts

@@ -28,6 +28,8 @@ export type Rpc = Compute<{
   approvals: readonly ApprovalRpc[]
   /** Canonical RLP-encoded applicable configuration. */
   config: Hex.Hex
+  /** Account that signs the modeled key authorization. Omitted for a direct signature. */
+  signer?: Address.Address | undefined
 }>
 
 /** Account simulation spec used to construct an RPC simulation signature. */
@@ -36,6 +38,8 @@ export type Spec = Compute<{
   approvals: readonly Approval[]
   /** Complete applicable configuration. */
   config: AccountConfig.Config
+  /** Account that signs the modeled key authorization. Omitted for a direct signature. */
+  signer?: Address.Address | undefined
 }>
 
 /**
@@ -53,14 +57,20 @@ export type Spec = Compute<{
  * @returns The account simulation spec with decoded configurations.
  */
 export function fromRpc(spec: Rpc): Spec {
-  const { approvals, config } = spec
+  const { approvals, config, signer } = spec
   assertApprovals(approvals)
-  return { approvals, config: deserializeConfig(config) }
+  if (signer !== undefined) Address.assert(signer)
+  return {
+    approvals,
+    config: deserializeConfig(config),
+    ...(signer !== undefined ? { signer } : {}),
+  }
 }
 
 export declare namespace fromRpc {
   /** Error type for `fromRpc`. */
   export type ErrorType =
+    | Address.assert.ErrorType
     | Hex.isEqual.ErrorType
     | InvalidSimulationError
     | AccountConfig.assert.ErrorType
@@ -84,8 +94,9 @@ export declare namespace fromRpc {
  * @returns The JSON-RPC account simulation spec with encoded configurations.
  */
 export function toRpc(spec: Spec): Rpc {
-  const { approvals, config } = spec
+  const { approvals, config, signer } = spec
   assertApprovals(approvals)
+  if (signer !== undefined) Address.assert(signer)
   return {
     approvals: approvals.map(({ keyData, keyType, owner }) => ({
       ...(keyData !== undefined ? { keyData: shimKeyData(keyData) } : {}),
@@ -93,12 +104,14 @@ export function toRpc(spec: Spec): Rpc {
       owner,
     })),
     config: serializeConfig(config),
+    ...(signer !== undefined ? { signer } : {}),
   }
 }
 
 export declare namespace toRpc {
   /** Error type for `toRpc`. */
   export type ErrorType =
+    | Address.assert.ErrorType
     | Hex.fromNumber.ErrorType
     | InvalidSimulationError
     | AccountConfig.assert.ErrorType
@@ -164,12 +177,13 @@ function serializeConfig(config: AccountConfig.Input): Hex.Hex {
 }
 
 /**
- * Shims long key data into the length hint accepted by Tempo's gas estimator.
+ * Shims key data into the 1-, 2-, or 4-byte length hint accepted by Tempo's
+ * gas estimator. Other sizes are replaced by a 2-byte hint of their length.
  * @internal
  */
 function shimKeyData(data: Hex.Hex): Hex.Hex {
   const size = Hex.size(data)
-  if (size <= 4) return data
+  if (size === 1 || size === 2 || size === 4) return data
   return Hex.fromNumber(size, { size: 2 })
 }
 

package/tempo/KeyAuthorization.test-d.ts

@@ -51,37 +51,27 @@ test('accepts configurable signatures and account-bound grants', () => {
   ).toMatchTypeOf<KeyAuthorization.Rpc>()
 })
 
-test('requires an account for configurable grants', () => {
+test('allows configurable grants without an account', () => {
   type Configurable = Extract<KeyAuthorization.Input, { type: 'configurable' }>
-  expectTypeOf<Configurable['account']>().toEqualTypeOf<TempoAddress.Address>()
+  expectTypeOf<Configurable['account']>().toEqualTypeOf<
+    TempoAddress.Address | undefined
+  >()
   expectTypeOf<
     Extract<KeyAuthorization.Signed, { type: 'configurable' }>['account']
-  >().toEqualTypeOf<`0x${string}`>()
-  expectTypeOf<
-    Omit<Extract<KeyAuthorization.Rpc, { keyType: 'multisig' }>, 'account'>
-  >().not.toExtend<KeyAuthorization.Rpc>()
+  >().toEqualTypeOf<`0x${string}` | undefined>()
   expectTypeOf<{
     address: `0x${string}`
     chainId: bigint
     type: 'configurable'
-  }>().not.toExtend<KeyAuthorization.Input>()
-  expectTypeOf<{
-    account: undefined
-    address: `0x${string}`
-    chainId: bigint
-    type: 'configurable'
-  }>().not.toExtend<KeyAuthorization.Input>()
+  }>().toExtend<KeyAuthorization.Input>()
   expectTypeOf<{
     account: null
     chainId: '0x1'
     expiry: null
     keyId: `0x${string}`
-    keyType: 'multisig'
+    keyType: 'configurableAccount'
     signature: KeyAuthorization.SignatureRpc
-  }>().not.toExtend<KeyAuthorization.Rpc>()
-  expectTypeOf<
-    Extract<KeyAuthorization.Rpc, { keyType: 'multisig' }>['account']
-  >().toEqualTypeOf<`0x${string}`>()
+  }>().toExtend<KeyAuthorization.Rpc>()
 })
 
 test('rejects keychain signatures', () => {

package/tempo/KeyAuthorization.test.ts

@@ -117,49 +117,84 @@ describe('configurable account binding', () => {
     ).toMatchInlineSnapshot(`"0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c"`)
   })
 
-  test('rejects unbound grants before signing or encoding', () => {
-    const authorization = {
-      address,
-      chainId: 1n,
-      type: 'configurable',
-    } as const
-    const signed = {
-      ...authorization,
-      signature: SignatureEnvelope.from(signature_secp256k1),
-    }
-    for (const encode of [
-      // @ts-expect-error Deliberately unbound configurable grant.
-      () => KeyAuthorization.from(authorization),
-      // @ts-expect-error Deliberately unbound configurable grant.
-      () => KeyAuthorization.toTuple(authorization),
-      // @ts-expect-error Deliberately unbound configurable grant.
-      () => KeyAuthorization.getSignPayload(authorization),
-      // @ts-expect-error Deliberately unbound configurable grant.
-      () => KeyAuthorization.serialize(authorization),
-      // @ts-expect-error Deliberately unbound configurable grant.
-      () => KeyAuthorization.toRpc(signed),
-    ])
-      expect(encode).toThrowErrorMatchingInlineSnapshot(
-        `[KeyAuthorization.MissingAccountError: Configurable account key grants require a parent account binding.]`,
-      )
+  test('behavior: accepts unbound configurable grants', () => {
+    // The node binds a root-signed grant to its signer, so only admin-signed
+    // grants need `account` (TIP-1049).
+    const signed = KeyAuthorization.from(
+      { address, chainId: 1n, type: 'configurable' },
+      { signature: signature_secp256k1 },
+    )
+    const rpc = KeyAuthorization.toRpc(signed)
+    expect({
+      deserialized: KeyAuthorization.deserialize(
+        KeyAuthorization.serialize(signed),
+      ),
+      fromRpc: KeyAuthorization.fromRpc(rpc),
+      fromTuple: KeyAuthorization.fromTuple([['0x01', '0x03', address]]),
+      rpc,
+    }).toMatchInlineSnapshot(`
+      {
+        "deserialized": {
+          "account": undefined,
+          "address": "0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c",
+          "chainId": 1n,
+          "signature": {
+            "signature": {
+              "r": 113291597329930009559670063131885256927775966057121513567941051428123344285399n,
+              "s": 54293712598725100598138577281441749550405991478212695085505730636505228583888n,
+              "yParity": 1,
+            },
+            "type": "secp256k1",
+          },
+          "type": "configurable",
+        },
+        "fromRpc": {
+          "account": undefined,
+          "address": "0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c",
+          "chainId": 1n,
+          "limits": undefined,
+          "signature": {
+            "signature": {
+              "r": 113291597329930009559670063131885256927775966057121513567941051428123344285399n,
+              "s": 54293712598725100598138577281441749550405991478212695085505730636505228583888n,
+              "yParity": 1,
+            },
+            "type": "secp256k1",
+          },
+          "type": "configurable",
+        },
+        "fromTuple": {
+          "account": undefined,
+          "address": "0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c",
+          "chainId": 1n,
+          "type": "configurable",
+        },
+        "rpc": {
+          "account": undefined,
+          "chainId": "0x1",
+          "expiry": null,
+          "keyId": "0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c",
+          "keyType": "configurableAccount",
+          "limits": undefined,
+          "signature": {
+            "r": "0xfa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7",
+            "s": "0x780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d0",
+            "type": "secp256k1",
+            "yParity": "0x1",
+          },
+        },
+      }
+    `)
   })
 
-  test('rejects unbound RPC and RLP grants', () => {
+  test('behavior: preserves a bound account', () => {
     const signed = KeyAuthorization.from(
       { account: address, address, chainId: 1n, type: 'configurable' },
       { signature: signature_secp256k1 },
     )
-    const rpc = KeyAuthorization.toRpc(signed)
-    for (const account of [undefined, null]) {
-      // @ts-expect-error Deliberately unbound configurable grant.
-      expect(() => KeyAuthorization.fromRpc({ ...rpc, account })).toThrowError(
-        KeyAuthorization.MissingAccountError,
-      )
-    }
-    expect(() =>
-      KeyAuthorization.fromTuple([['0x01', '0x03', address]]),
-    ).toThrowError(KeyAuthorization.MissingAccountError)
-    expect(KeyAuthorization.fromRpc(rpc).account).toBe(address)
+    expect(
+      KeyAuthorization.fromRpc(KeyAuthorization.toRpc(signed)).account,
+    ).toBe(address)
     expect(
       KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)).account,
     ).toBe(address)
@@ -1512,13 +1547,13 @@ describe('serialize', () => {
 })
 
 describe('toRpc', () => {
-  test('behavior: configurable key type uses the RPC multisig key type', () => {
+  test('behavior: configurable key type uses the RPC configurableAccount key type', () => {
     const authorization = KeyAuthorization.from(
       { account: address, address, chainId: 1n, type: 'configurable' },
       { signature: signature_secp256k1 },
     )
     const rpc = KeyAuthorization.toRpc(authorization)
-    expect(rpc.keyType).toMatchInlineSnapshot(`"multisig"`)
+    expect(rpc.keyType).toMatchInlineSnapshot(`"configurableAccount"`)
     expect(KeyAuthorization.fromRpc(rpc).type).toMatchInlineSnapshot(
       `"configurable"`,
     )
@@ -2891,4 +2926,25 @@ describe('admin keys (TIP-1049)', () => {
     })
     expect(KeyAuthorization.hash(a)).not.toBe(KeyAuthorization.hash(b))
   })
+
+  describe('configurable admin keys', () => {
+    test('behavior: a configurable account may sign or be granted an admin key', () => {
+      const signed = KeyAuthorization.from(
+        {
+          account: signature_configurable.account,
+          address,
+          chainId: 1n,
+          isAdmin: true,
+          type: 'configurable',
+        },
+        { signature: signature_configurable },
+      )
+      expect(
+        KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)),
+      ).toEqual(signed)
+      expect(
+        KeyAuthorization.fromRpc(KeyAuthorization.toRpc(signed)),
+      ).toMatchObject({ isAdmin: true, type: 'configurable' })
+    })
+  })
 })

package/tempo/KeyAuthorization.ts

@@ -77,14 +77,14 @@ export type KeyAuthorization<
   witness?: Hex.Hex | undefined
 } & (
   | {
-      /** Optional account address binding. */
+      /** Account address this authorization is bound to. Required when an admin access key signs the grant (TIP-1049). */
       account?: addressType | undefined
       /** Primitive key type. */
       type: SignatureEnvelope.Type
     }
   | {
-      /** Required parent account binding for a configurable account grant. */
-      account: addressType
+      /** Account address this authorization is bound to. Required when an admin access key signs the grant (TIP-1049). */
+      account?: addressType | undefined
       /** Configurable account key type. */
       type: 'configurable'
     }
@@ -146,10 +146,10 @@ export type Rpc = {
       keyType: SignatureEnvelope.Type
     }
   | {
-      /** Required parent account binding for a configurable account grant. */
-      account: Address.Address
-      /** Configurable account key type, named `multisig` by the node. */
-      keyType: 'multisig'
+      /** Optional account address binding (TIP-1049). */
+      account?: Address.Address | null | undefined
+      /** Configurable account key type, named `configurableAccount` by the node. */
+      keyType: 'configurableAccount'
     }
 )
 
@@ -449,7 +449,6 @@ export function from<
   options: from.Options<signature> = {},
 ): from.ReturnType<authorization, signature> {
   if ('keyId' in authorization) return fromRpc(authorization as Rpc) as never
-  assertAccountBinding(authorization.type, authorization.account)
   const auth = authorization as KeyAuthorization & {
     limits?: readonly { token: TempoAddress.Address; limit: bigint }[]
     scopes?: readonly {
@@ -535,10 +534,7 @@ export declare namespace from {
         >
   >
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -572,8 +568,7 @@ export function fromRpc(authorization: Rpc): Signed {
   const witness = authorization.witness ?? undefined
   const isAdmin = authorization.isAdmin ?? undefined
   const account = authorization.account ?? undefined
-  const type = keyType === 'multisig' ? 'configurable' : keyType
-  assertAccountBinding(type, account)
+  const type = keyType === 'configurableAccount' ? 'configurable' : keyType
   const signature = SignatureEnvelope.fromRpc(authorization.signature)
   assertSignature(signature)
   if (witness !== undefined) assertWitness(witness)
@@ -616,10 +611,7 @@ export function fromRpc(authorization: Rpc): Signed {
 }
 
 export declare namespace fromRpc {
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -739,7 +731,6 @@ export function fromTuple<const tuple extends Tuple>(
   const account = isAbsent(rawAccount)
     ? undefined
     : (rawAccount as Address.Address)
-  assertAccountBinding(keyType, account)
   const args: KeyAuthorization = {
     address: keyId,
     chainId: chainId === '0x' ? 0n : Hex.toBigInt(chainId),
@@ -766,10 +757,7 @@ export declare namespace fromTuple {
     KeyAuthorization<authorization extends Tuple<true> ? true : false>
   >
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -961,7 +949,6 @@ export declare namespace serialize {
  * @returns An RPC-formatted Key Authorization.
  */
 export function toRpc(authorization: Signed): Rpc {
-  assertAccountBinding(authorization.type, authorization.account)
   const {
     address,
     scopes,
@@ -1006,7 +993,7 @@ export function toRpc(authorization: Signed): Rpc {
     expiry: typeof expiry === 'number' ? Hex.fromNumber(expiry) : null,
     keyId: TempoAddress.resolve(address),
     ...(type === 'configurable'
-      ? { account, keyType: 'multisig' as const }
+      ? { account, keyType: 'configurableAccount' as const }
       : { keyType: type }),
     limits: limits?.map(({ token, limit, period }) => ({
       token,
@@ -1024,10 +1011,7 @@ export function toRpc(authorization: Signed): Rpc {
 }
 
 export declare namespace toRpc {
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -1064,7 +1048,6 @@ export declare namespace toRpc {
 export function toTuple<const authorization extends KeyAuthorization>(
   authorization: authorization,
 ): toTuple.ReturnType<authorization> {
-  assertAccountBinding(authorization.type, authorization.account)
   const {
     address,
     chainId,
@@ -1173,10 +1156,7 @@ export declare namespace toTuple {
   type ReturnType<authorization extends KeyAuthorization = KeyAuthorization> =
     Compute<Tuple<authorization extends KeyAuthorization<true> ? true : false>>
 
-  type ErrorType =
-    | InvalidSignatureTypeError
-    | MissingAccountError
-    | Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 function bigintToHex(value: bigint): Hex.Hex {
@@ -1210,14 +1190,6 @@ function resolveSelector(
   return AbiItem.getSelector(selector)
 }
 
-function assertAccountBinding(
-  type: KeyAuthorization['type'],
-  account: TempoAddress.Address | null | undefined,
-): void {
-  if (type === 'configurable' && account == null)
-    throw new MissingAccountError()
-}
-
 function assertWitness(witness: Hex.Hex): void {
   if (Hex.size(witness) !== 32) throw new InvalidWitnessSizeError(witness)
 }
@@ -1263,7 +1235,12 @@ export class InvalidSignatureTypeError extends Error {
   }
 }
 
-/** Thrown when a configurable account key grant omits its parent account binding. */
+/**
+ * Thrown when a configurable account key grant omits its parent account binding.
+ *
+ * @deprecated No longer thrown. The Tempo node only requires `account` on grants
+ * signed by an admin access key, which it checks against the transaction sender.
+ */
 export class MissingAccountError extends Error {
   override readonly name = 'KeyAuthorization.MissingAccountError'
   constructor() {

package/tempo/RpcSchemaTempo.test-d.ts

@@ -17,7 +17,7 @@ declare const tempoProvider: Provider.Provider<{
 declare const address: Address.Address
 declare const hash: Hex.Hex
 declare const keyAuthorization: KeyAuthorization.Rpc
-declare const multisigSimulation: AccountSimulation.Rpc
+declare const configurableAccountSimulation: AccountSimulation.Rpc
 declare const serializedTransaction: Hex.Hex
 declare const signature: Hex.Hex
 
@@ -79,7 +79,7 @@ test('tempo simulation accepts account simulation specs', () => {
           {
             calls: [
               {
-                multisigSimulation,
+                configurableAccountSimulation,
               },
             ],
           },

package/tempo/TransactionRequest.test-d.ts

@@ -19,16 +19,16 @@ test('transaction requests use domain account simulation specs', () => {
 })
 
 test('RPC requests use encoded account configurations', () => {
-  expectTypeOf(rpc.multisigSimulation?.config).toEqualTypeOf<
+  expectTypeOf(rpc.configurableAccountSimulation?.config).toEqualTypeOf<
     `0x${string}` | undefined
   >()
 })
 
-test('maps the configurable key type to the RPC multisig key type', () => {
+test('maps the configurable key type to the RPC configurableAccount key type', () => {
   expectTypeOf(request.keyType).toEqualTypeOf<
     'configurable' | 'p256' | 'secp256k1' | 'webAuthn' | undefined
   >()
   expectTypeOf(rpc.keyType).toEqualTypeOf<
-    'multisig' | 'p256' | 'secp256k1' | 'webAuthn' | undefined
+    'configurableAccount' | 'p256' | 'secp256k1' | 'webAuthn' | undefined
   >()
 })

package/tempo/TransactionRequest.test.ts

@@ -109,9 +109,9 @@ describe('fromRpc', () => {
     expect(request.nonceKey).toBe(255n)
   })
 
-  test('behavior: multisig key type decodes as configurable', () => {
+  test('behavior: configurableAccount key type decodes as configurable', () => {
     const request = TransactionRequest.fromRpc({
-      keyType: 'multisig',
+      keyType: 'configurableAccount',
       type: '0x76',
     })
     expect(request.keyType).toMatchInlineSnapshot(`"configurable"`)
@@ -120,7 +120,7 @@ describe('fromRpc', () => {
   test('behavior: account simulation', () => {
     const request = TransactionRequest.fromRpc({
       from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      multisigSimulation: accountSimulationRpc,
+      configurableAccountSimulation: accountSimulationRpc,
       type: '0x76',
     })
 
@@ -214,8 +214,7 @@ describe('toRpc', () => {
 
     expect(request).toMatchInlineSnapshot(`
       {
-        "from": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-        "multisigSimulation": {
+        "configurableAccountSimulation": {
           "approvals": [
             {
               "keyData": "0x0005",
@@ -225,9 +224,10 @@ describe('toRpc', () => {
           ],
           "config": "0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01",
         },
+        "from": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         "type": "0x76",
       }
-      `)
+    `)
   })
 })
 
@@ -295,7 +295,7 @@ describe('roundtrip', () => {
       nonceKey: '0xff',
       gas: '0x186a0',
       keyAuthorizationSimulation: accountSimulationRpc,
-      multisigSimulation: accountSimulationRpc,
+      configurableAccountSimulation: accountSimulationRpc,
       type: '0x76',
     }
 
@@ -311,7 +311,9 @@ describe('roundtrip', () => {
     expect(rpc.keyAuthorizationSimulation).toEqual(
       original.keyAuthorizationSimulation,
     )
-    expect(rpc.multisigSimulation).toEqual(original.multisigSimulation)
+    expect(rpc.configurableAccountSimulation).toEqual(
+      original.configurableAccountSimulation,
+    )
     expect(rpc.type).toBe('0x76')
   })
 })

package/tempo/TransactionRequest.ts

@@ -62,9 +62,9 @@ export type Rpc = Omit<
   feeToken?: Hex.Hex | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
   keyAuthorizationSimulation?: AccountSimulation.Rpc | undefined
-  /** Key type. Configurable accounts use the node's `multisig` key type. */
-  keyType?: SignatureEnvelope.Type | 'multisig' | undefined
-  multisigSimulation?: AccountSimulation.Rpc | undefined
+  /** Key type. Configurable accounts use the node's `configurableAccount` key type. */
+  keyType?: SignatureEnvelope.Type | 'configurableAccount' | undefined
+  configurableAccountSimulation?: AccountSimulation.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
 }
 
@@ -93,7 +93,7 @@ export function fromRpc(request: Rpc): TransactionRequest {
     authorizationList: _,
     keyAuthorizationSimulation: __,
     keyType: ___,
-    multisigSimulation: ____,
+    configurableAccountSimulation: ____,
     ...rest
   } = request
   const request_ = ox_TransactionRequest.fromRpc(
@@ -132,10 +132,12 @@ export function fromRpc(request: Rpc): TransactionRequest {
     )
   if (typeof request.keyType !== 'undefined')
     request_.keyType =
-      request.keyType === 'multisig' ? 'configurable' : request.keyType
-  if (request.multisigSimulation)
+      request.keyType === 'configurableAccount'
+        ? 'configurable'
+        : request.keyType
+  if (request.configurableAccountSimulation)
     request_.accountSimulation = AccountSimulation.fromRpc(
-      request.multisigSimulation,
+      request.configurableAccountSimulation,
     )
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = Hex.toNumber(request.validBefore as Hex.Hex)
@@ -240,7 +242,7 @@ export function toRpc(request: TransactionRequest): Rpc {
       request.keyAuthorizationSimulation,
     )
   if (request.accountSimulation)
-    request_rpc.multisigSimulation = AccountSimulation.toRpc(
+    request_rpc.configurableAccountSimulation = AccountSimulation.toRpc(
       request.accountSimulation,
     )
   if (typeof request.validBefore !== 'undefined')

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.14.56'
+export const version = '0.14.57'