viem 2.56.6 → 2.56.7

package/_types/tempo/multisig/Config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../tempo/multisig/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,YAAY,CAAA;AAErC,OAAO,KAAK,KAAK,GAAG,MAAM,QAAQ,CAAA;AAElC,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,KAAK,KAAK,KAAK,MAAM,aAAa,CAAA;AAQzC,sCAAsC;AACtC,wBAAsB,IAAI,CACxB,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,OAAO,EAAE,IAAI,CAAC,OAAO,GACpB,OAAO,CAAC,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,CAOvC;AAED,MAAM,CAAC,OAAO,WAAW,IAAI,CAAC;IAC5B,mCAAmC;IACnC,KAAY,OAAO,GAAG;QACpB,gCAAgC;QAChC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;QACxB,0CAA0C;QAC1C,UAAU,EAAE,GAAG,CAAC,GAAG,CAAA;KACpB,CAAA;CACF;AAED,0CAA0C;AAC1C,wBAAsB,KAAK,CACzB,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,OAAO,EAAE,KAAK,CAAC,OAAO,GACrB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B,oCAAoC;IACpC,KAAY,OAAO,GAAG;QACpB,gCAAgC;QAChC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;QACxB,yCAAyC;QACzC,UAAU,EAAE,GAAG,CAAC,GAAG,CAAA;QACnB,uBAAuB;QACvB,MAAM,EAAE,cAAc,CAAC,MAAM,CAAA;KAC9B,CAAA;CACF;AAuDD,uEAAuE;AACvE,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,4CAA4C;gBAChC,OAAO,GAAE,sBAAsB,CAAC,OAAY;CAMzD;AAED,MAAM,CAAC,OAAO,WAAW,sBAAsB,CAAC;IAC9C,kCAAkC;IAClC,KAAY,OAAO,GAAG;QACpB,wBAAwB;QACxB,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAC5B,CAAA;CACF"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../../tempo/multisig/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,YAAY,CAAA;AAErC,OAAO,KAAK,KAAK,GAAG,MAAM,QAAQ,CAAA;AAElC,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAEhD,OAAO,KAAK,KAAK,KAAK,MAAM,aAAa,CAAA;AAQzC,sCAAsC;AACtC,wBAAsB,IAAI,CACxB,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,OAAO,EAAE,IAAI,CAAC,OAAO,GACpB,OAAO,CAAC,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,CAOvC;AAED,MAAM,CAAC,OAAO,WAAW,IAAI,CAAC;IAC5B,mCAAmC;IACnC,KAAY,OAAO,GAAG;QACpB,gCAAgC;QAChC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;QACxB,0CAA0C;QAC1C,UAAU,EAAE,GAAG,CAAC,GAAG,CAAA;KACpB,CAAA;CACF;AAED,0CAA0C;AAC1C,wBAAsB,KAAK,CACzB,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,OAAO,EAAE,KAAK,CAAC,OAAO,GACrB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B,oCAAoC;IACpC,KAAY,OAAO,GAAG;QACpB,gCAAgC;QAChC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;QACxB,yCAAyC;QACzC,UAAU,EAAE,GAAG,CAAC,GAAG,CAAA;QACnB,uBAAuB;QACvB,MAAM,EAAE,cAAc,CAAC,MAAM,CAAA;KAC9B,CAAA;CACF;AAyDD,uEAAuE;AACvE,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,4CAA4C;gBAChC,OAAO,GAAE,sBAAsB,CAAC,OAAY;CAMzD;AAED,MAAM,CAAC,OAAO,WAAW,sBAAsB,CAAC;IAC9C,kCAAkC;IAClC,KAAY,OAAO,GAAG;QACpB,wBAAwB;QACxB,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAC5B,CAAA;CACF"}

package/_types/tempo/multisig/Signature.d.ts

@@ -0,0 +1,4 @@
+import { SignatureEnvelope } from 'ox/tempo';
+/** Parses a primitive multisig owner approval. */
+export declare function parseApproval(signature: SignatureEnvelope.Serialized): SignatureEnvelope.Primitive;
+//# sourceMappingURL=Signature.d.ts.map

package/_types/tempo/multisig/Signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Signature.d.ts","sourceRoot":"","sources":["../../../tempo/multisig/Signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5C,kDAAkD;AAClD,wBAAgB,aAAa,CAC3B,SAAS,EAAE,iBAAiB,CAAC,UAAU,GACtC,iBAAiB,CAAC,SAAS,CAK7B"}

package/_types/tokens/definitions/cirbtc.d.ts

@@ -10,6 +10,7 @@ import { defineToken } from '../defineToken.js';
 export declare const cirbtc: defineToken.ReturnType<{
     readonly addresses: {
         readonly 1: "0x72DFB2E44f59C5AD2bAFE84314E5b99a7cd5075E";
+        readonly 5042: "0x171A4217b86A807A64eB94757Db6849fb4bDbAA0";
         readonly 5042002: "0xf0C4a4CE82A5746AbAAd9425360Ab04fbBA432BF";
         readonly 11155111: "0x3a3fe695F684Bf9b9e43CF43C2b895Ea5e392bB3";
     };

package/_types/tokens/definitions/cirbtc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cirbtc.d.ts","sourceRoot":"","sources":["../../../tokens/definitions/cirbtc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;EAUjB,CAAA"}
+{"version":3,"file":"cirbtc.d.ts","sourceRoot":"","sources":["../../../tokens/definitions/cirbtc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;EAWjB,CAAA"}

package/_types/tokens/definitions/eurc.d.ts

@@ -14,6 +14,7 @@ export declare const eurc: defineToken.ReturnType<{
         readonly 338: "0x31f7538adb53cF16350e6B0c89d03D91b7D12c46";
         readonly 480: "0x1C60ba0A0eD1019e8Eb035E6daF4155A5cE2380B";
         readonly 4801: "0xe479EcA5740Ac65d6E1823bea2f1C08Bc14e954F";
+        readonly 5042: "0xbEf5f6d51CB62b58e6A8f77868681825C6fe21c1";
         readonly 8453: "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42";
         readonly 43113: "0x5E44db7996c682E92a960b65AC713a54AD815c6B";
         readonly 43114: "0xC891EB4cbdEFf6e073e859e987815Ed1505c2ACD";

package/_types/tokens/definitions/eurc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eurc.d.ts","sourceRoot":"","sources":["../../../tokens/definitions/eurc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;EAkBf,CAAA"}
+{"version":3,"file":"eurc.d.ts","sourceRoot":"","sources":["../../../tokens/definitions/eurc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;EAmBf,CAAA"}

package/_types/tokens/sets.d.ts

@@ -43,6 +43,7 @@ export declare const tokens: {
     }>, import("./defineToken.js").defineToken.ReturnType<{
         readonly addresses: {
             readonly 1: "0x72DFB2E44f59C5AD2bAFE84314E5b99a7cd5075E";
+            readonly 5042: "0x171A4217b86A807A64eB94757Db6849fb4bDbAA0";
             readonly 5042002: "0xf0C4a4CE82A5746AbAAd9425360Ab04fbBA432BF";
             readonly 11155111: "0x3a3fe695F684Bf9b9e43CF43C2b895Ea5e392bB3";
         };
@@ -81,6 +82,7 @@ export declare const tokens: {
             readonly 338: "0x31f7538adb53cF16350e6B0c89d03D91b7D12c46";
             readonly 480: "0x1C60ba0A0eD1019e8Eb035E6daF4155A5cE2380B";
             readonly 4801: "0xe479EcA5740Ac65d6E1823bea2f1C08Bc14e954F";
+            readonly 5042: "0xbEf5f6d51CB62b58e6A8f77868681825C6fe21c1";
             readonly 8453: "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42";
             readonly 43113: "0x5E44db7996c682E92a960b65AC713a54AD815c6B";
             readonly 43114: "0xC891EB4cbdEFf6e073e859e987815Ed1505c2ACD";

package/_types/tokens/sets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sets.d.ts","sourceRoot":"","sources":["../../tokens/sets.ts"],"names":[],"mappings":"AA2GA,6EAA6E;AAC7E,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0B,CAAA"}
+{"version":3,"file":"sets.d.ts","sourceRoot":"","sources":["../../tokens/sets.ts"],"names":[],"mappings":"AA2GA,6EAA6E;AAC7E,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0B,CAAA"}

package/chains/definitions/eCanna.ts

@@ -0,0 +1,20 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const eCanna = /*#__PURE__*/ defineChain({
+  id: 4111,
+  name: 'E Canna Mainnet',
+  nativeCurrency: {
+    name: 'E Canna',
+    symbol: 'ECNA',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: { http: ['https://rpc.ecnascan.com'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'ECNA Scan',
+      url: 'https://explorer.ecnascan.com',
+    },
+  },
+})

package/chains/definitions/eCannaTestnet.ts

@@ -0,0 +1,21 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const eCannaTestnet = /*#__PURE__*/ defineChain({
+  id: 4112,
+  name: 'E Canna Testnet',
+  nativeCurrency: {
+    name: 'E Canna Testnet',
+    symbol: 'tECNA',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: { http: ['https://testnetrpc.ecnascan.com'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'ECNA Scan Testnet',
+      url: 'https://testnetexplorer.ecnascan.com',
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/robinhood.ts

@@ -7,7 +7,11 @@ export const robinhood = /*#__PURE__*/ defineChain({
   blockTime: 100,
   rpcUrls: {
     default: {
-      http: ['https://rpc.mainnet.chain.robinhood.com'],
+      http: [
+        'https://rpc.mainnet.chain.robinhood.com',
+        'https://rpc.ordofi.network',
+      ],
+      webSocket: ['wss://rpc.ordofi.network'],
     },
   },
   blockExplorers: {

package/chains/definitions/zagros.ts

@@ -0,0 +1,30 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const zagros = /*#__PURE__*/ defineChain({
+  id: 21072026,
+  name: 'Zagros',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Zagros',
+    symbol: 'ZAGROS',
+  },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.zagros.network', 'https://rpc.zagrosnetwork.com'],
+      webSocket: ['wss://rpc.zagros.network/ws'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'ZagrosRadar',
+      url: 'https://zagrosradar.com',
+      apiUrl: 'https://zagrosradar.com/api/v1',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 51,
+    },
+  },
+})

package/chains/index.ts

@@ -169,6 +169,8 @@ export { dreyerxMainnet } from './definitions/dreyerxMainnet.js'
 export { dreyerxTestnet } from './definitions/dreyerxTestnet.js'
 export { dustboyIoT } from './definitions/dustboyIoT.js'
 export { dymension } from './definitions/dymension.js'
+export { eCanna } from './definitions/eCanna.js'
+export { eCannaTestnet } from './definitions/eCannaTestnet.js'
 export { eden } from './definitions/eden.js'
 export { edexa } from './definitions/edexa.js'
 export { edexaTestnet } from './definitions/edexaTestnet.js'
@@ -738,6 +740,7 @@ export { xrSepolia } from './definitions/xrSepolia.js'
 export { ynxTestnet } from './definitions/ynxTestnet.js'
 export { yooldoVerse } from './definitions/yooldoVerse.js'
 export { yooldoVerseTestnet } from './definitions/yooldoVerseTestnet.js'
+export { zagros } from './definitions/zagros.js'
 export { zenchainTestnet } from './definitions/zenchainTestnet.js'
 export { zeniq } from './definitions/zeniq.js'
 export { zeroNetwork } from './definitions/zeroNetwork.js'

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.56.6'
+export const version = '2.56.7'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.56.6",
+  "version": "2.56.7",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -229,7 +229,7 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "0.14.44",
+    "ox": "0.14.45",
     "ws": "8.21.0"
   },
   "license": "MIT",

package/tempo/Account.ts

@@ -24,7 +24,9 @@ import { keccak256 } from '../utils/hash/keccak256.js'
 import { hashMessage } from '../utils/signature/hashMessage.js'
 import { hashTypedData } from '../utils/signature/hashTypedData.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
+import { nativeMultisigFactory } from './Addresses.js'
 import type { KeyAuthorizationManager } from './KeyAuthorizationManager.js'
+import { parseApproval } from './multisig/Signature.js'
 import * as Transaction from './Transaction.js'
 
 export type Account_base<source extends string = string> = RequiredBy<
@@ -284,7 +286,7 @@ export declare namespace fromSecp256k1 {
  *
  * Owners can be accounts or addresses directly, or weighted `{ owner, weight }`
  * entries. Direct owners default to weight `1`, and `threshold` defaults to `1`.
- * Local owner accounts are retained for signing, including nested multisigs.
+ * Local owner accounts are retained for signing, using primitive signatures.
  * Configs containing only owner addresses require external approvals through
  * `signatures`.
  *
@@ -359,11 +361,13 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
     (() => {
       if (typeof value === 'string') return value
       if (value.address === undefined || value.address === 'infer')
-        return MultisigConfig.getAddress(config!)
+        return MultisigConfig.getAddress(config!, {
+          factory: nativeMultisigFactory,
+        })
       return value.address
     })(),
   )
-  const ownerAccounts = (() => {
+  const ownerAccounts: LocalAccount[] = (() => {
     if (!configInput) return []
     return configInput.owners.flatMap((value) => {
       const owner =
@@ -371,6 +375,12 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
       return typeof owner === 'string' ? [] : [parseAccount(owner)]
     })
   })()
+  if (
+    ownerAccounts.some(
+      (owner) => owner.source === 'multisig' || isAccessKeyAccount(owner),
+    )
+  )
+    throw new Error('Multisig owners must use primitive signatures.')
   const owners =
     config?.owners.flatMap(({ owner }) => {
       const account = ownerAccounts.find((account) =>
@@ -403,7 +413,7 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
           throw new Error(
             'A local owner account is required to approve a multisig transaction.',
           )
-        if (owner.source !== 'root' && owner.source !== 'multisig')
+        if (owner.source !== 'root')
           throw new Error(
             'A Tempo owner account is required to approve a multisig transaction.',
           )
@@ -422,29 +432,16 @@ export function fromMultisig(value: fromMultisig.Parameters): MultisigAccount {
       }
       const payload = keccak256(await serializer(presign as never))
       const simulation = request.multisigSimulation
-      const requestAccount = simulation?.account ?? address
-
-      if (!Address.isEqual(requestAccount, address)) {
-        if (!simulation)
-          throw new Error('A multisig config is required for local signing.')
-        const parentConfig = MultisigConfig.from(simulation.config)
-        const parentDigest = MultisigConfig.getSignPayload({
-          account: requestAccount,
-          config: parentConfig,
-          payload,
-        })
-        return SignatureEnvelope.serialize(
-          await signMultisig(account, {
-            payload: parentDigest,
-          }),
+      if (request.from && !Address.isEqual(request.from, address))
+        throw new Error(
+          'Multisig account does not match the transaction sender.',
         )
-      }
 
       const signature = await signMultisig(account, {
         config: simulation?.config,
         payload,
         signatures: request.signatures?.map((signature) =>
-          SignatureEnvelope.from(signature),
+          parseApproval(signature),
         ),
       })
       return (await serializer(
@@ -494,9 +491,11 @@ export declare namespace fromMultisig {
   /** Multisig owner account or address, optionally with an explicit weight. */
   export type Owner =
     | Address.Address
-    | LocalAccount
+    | (LocalAccount & { accessKeyAddress?: never; owners?: never })
     | (Omit<MultisigConfig.Owner, 'owner'> & {
-        owner: Address.Address | LocalAccount
+        owner:
+          | Address.Address
+          | (LocalAccount & { accessKeyAddress?: never; owners?: never })
       })
 
   /** Parameters for {@link fromMultisig}. */
@@ -523,7 +522,7 @@ async function signMultisig(
   parameters: {
     config?: MultisigConfig.Config | undefined
     payload: Hex.Hex
-    signatures?: readonly SignatureEnvelope.SignatureEnvelope[] | undefined
+    signatures?: readonly SignatureEnvelope.Primitive[] | undefined
   },
 ): Promise<SignatureEnvelope.Multisig> {
   const { config, payload, signatures: providedSignatures = [] } = parameters
@@ -558,6 +557,7 @@ async function signMultisig(
       a.owner.toLowerCase().localeCompare(b.owner.toLowerCase()),
   )
   for (const owner of owners) {
+    if (weight >= Number(currentConfig.threshold)) break
     const address = owner.owner.toLowerCase() as Address.Address
     if (signedOwners.has(address)) continue
     const ownerAccount = account.owners.find((account) =>
@@ -565,19 +565,9 @@ async function signMultisig(
     )
     if (!ownerAccount) continue
 
-    if (isMultisigAccount(ownerAccount)) {
-      signatures.push(
-        await signMultisig(ownerAccount, {
-          payload: digest,
-        }),
-      )
-    } else {
-      if (!ownerAccount.sign)
-        throw new Error('Multisig owner account cannot sign.')
-      signatures.push(
-        SignatureEnvelope.from(await ownerAccount.sign({ hash: digest })),
-      )
-    }
+    if (!ownerAccount.sign)
+      throw new Error('Multisig owner account cannot sign.')
+    signatures.push(parseApproval(await ownerAccount.sign({ hash: digest })))
 
     signedOwners.add(address)
     weight += Number(owner.weight)
@@ -856,9 +846,7 @@ export async function signKeyAuthorization(
         await signMultisig(account, {
           config: multisigState.config,
           payload: hash,
-          signatures: signatures?.map((signature) =>
-            SignatureEnvelope.from(signature),
-          ),
+          signatures: signatures?.map((signature) => parseApproval(signature)),
         }),
       )
     }
@@ -982,16 +970,17 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
       // primitive signature over the multisig owner approval digest, instead of
       // a full serialized transaction. Approvals are combined later in
       // `sendTransaction({ signatures })`.
-      const { multisigSimulation } = transaction as {
+      const { multisigSimulation, from } = transaction as {
+        from?: Address.Address
         multisigSimulation?: {
-          account: Address.Address
           config: MultisigConfig.Config
         }
       }
       if (multisigSimulation) {
+        if (!from) throw new Error('A multisig sender is required for signing.')
         const config = MultisigConfig.from(multisigSimulation.config)
         const digest = MultisigConfig.getSignPayload({
-          account: multisigSimulation.account,
+          account: from,
           config,
           payload,
         })

package/tempo/Addresses.ts

@@ -14,6 +14,9 @@ export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
 export const nativeMultisig = '0xAACC000000000000000000000000000000000000'
+/** Temporary recovery factory until the production address is finalized. */
+export const nativeMultisigFactory =
+  '0x7171717171717171717171717171717171717171'
 export const nonceManager = '0x4e4F4E4345000000000000000000000000000000'
 export const pathUsd = '0x20c0000000000000000000000000000000000000'
 export const receivePolicyGuard = '0xB10C000000000000000000000000000000000000'

package/tempo/Multisig.ts

@@ -140,13 +140,12 @@ export function handleRequest(
         }
       }
       if (operation.status === 'pending')
-        return await toTransaction(client, operation, parameters.store)
+        return await toTransaction(client, operation)
       const transactionHash = await getSubmittedTransactionHash(
         parameters.store,
         operation,
       )
-      if (!transactionHash)
-        return await toTransaction(client, operation, parameters.store)
+      if (!transactionHash) return await toTransaction(client, operation)
       const transaction = await next(
         {
           ...request,
@@ -155,7 +154,7 @@ export function handleRequest(
         requestOptions,
       )
       if (!transaction || typeof transaction !== 'object')
-        return await toTransaction(client, operation, parameters.store)
+        return await toTransaction(client, operation)
       const success =
         operation.status === 'submitting'
           ? await completeSubmission(
@@ -306,23 +305,16 @@ async function submit(options: submit.Options) {
       const existingApprovals = existing
         ? await selectApprovals({
             account: signature.account,
-            client: options.client,
             config,
-            discardInvalidNested: true,
             hash: operationHash,
             approvals: existing.approvals,
-            blockNumber,
-            store: options.store,
           })
         : undefined
       const approvals = await selectApprovals({
         account: signature.account,
-        client: options.client,
         config,
         hash: operationHash,
         approvals: [...(existingApprovals?.approvals ?? []), ...incoming],
-        blockNumber,
-        store: options.store,
       })
       return MultisigOperation.from({
         account: signature.account,
@@ -427,12 +419,9 @@ async function submit(options: submit.Options) {
         })
         const finalApprovals = await selectApprovals({
           account: claim.account,
-          blockNumber,
-          client: options.client,
           config: claim.config,
           hash: claim.hash,
           approvals: claim.approvals,
-          store: options.store,
         })
         const final = MultisigOperation.serializeTransaction(claim, {
           approvals: finalApprovals.selectedApprovals,
@@ -703,12 +692,8 @@ async function approveKeyAuthorization(
         ? await selectApprovals({
             account: approval.account,
             approvals: existing.approvals,
-            blockNumber,
-            client: options.client,
             config: approval.config,
-            discardInvalidNested: true,
             hash: approval.hash,
-            store: options.store,
           })
         : undefined
       const approvals = await selectApprovals({
@@ -717,11 +702,8 @@ async function approveKeyAuthorization(
           ...(existingApprovals?.approvals ?? []),
           ...approval.approvals,
         ],
-        blockNumber,
-        client: options.client,
         config: approval.config,
         hash: approval.hash,
-        store: options.store,
       })
       if (
         existing &&
@@ -804,16 +786,18 @@ function assertConfig(options: {
   const { account, commitment, config } = options
   if (
     config.version === 0n &&
-    MultisigConfig.getAddress(config).toLowerCase() !== account.toLowerCase()
+    MultisigConfig.getAddress(config, {
+      factory: Addresses.nativeMultisigFactory,
+    }).toLowerCase() !== account.toLowerCase()
   )
     throw new RpcResponse.InvalidParamsError({
       message: 'Initial multisig config does not match the multisig account.',
     })
-  const expected = (() => {
-    if (config.version === 0n) return Hex.fromNumber(0, { size: 32 })
-    return MultisigConfig.getCommitment(config)
-  })()
-  if (commitment.toLowerCase() !== expected.toLowerCase())
+  if (config.version === 0n && Hex.toBigInt(commitment) === 0n) return
+  if (
+    commitment.toLowerCase() !==
+    MultisigConfig.getCommitment(config).toLowerCase()
+  )
     throw new RpcResponse.InvalidParamsError({
       message: `Multisig config does not match account ${account}.`,
     })
@@ -904,82 +888,12 @@ declare namespace cacheNextConfigs {
   }
 }
 
-/** Selects approvals after validating every nested config. */
-// biome-ignore lint/correctness/noUnusedVariables: _
-async function selectApprovals(options: selectApprovals.Options) {
-  const validation = new Map<string, Promise<Hex.Hex>>()
-  let validationCount = 0
-  const select = async (approvals: readonly SignatureEnvelope.Serialized[]) => {
-    const result = await MultisigOperation.selectApprovals({
-      account: options.account,
-      approvals,
-      config: options.config,
-      hash: options.hash,
-    })
-    const configs = new Map<
-      string,
-      { account: Address; config: MultisigConfig.Config }
-    >()
-    const visit = (signature: SignatureEnvelope.SignatureEnvelope) => {
-      if (signature.type !== 'multisig') return
-      const config = MultisigConfig.from(signature.config)
-      const key = signature.account.toLowerCase()
-      configs.set(key, { account: signature.account, config })
-      for (const approval of signature.signatures) visit(approval)
-    }
-    for (const approval of result.approvals)
-      visit(SignatureEnvelope.from(approval))
-
-    for (const { account, config } of configs.values()) {
-      const key = `${account.toLowerCase()}:${MultisigConfig.getCommitment(config)}`
-      const pending = (() => {
-        const existing = validation.get(key)
-        if (existing) return existing
-        validationCount++
-        if (validationCount > MultisigConfig.maxOwners)
-          throw new RpcResponse.InvalidParamsError({
-            message: 'Multisig approval validation exceeds the owner limit.',
-          })
-        const pending = validateConfig({
-          account,
-          blockNumber: options.blockNumber,
-          client: options.client,
-          config,
-        })
-        validation.set(key, pending)
-        return pending
-      })()
-      const commitment = await pending
-      await ConfigStore.write(options.store, {
-        address: account,
-        commitment,
-        config,
-      })
-    }
-    return result
-  }
+/** Validates primitive approvals and translates invalid input into an RPC error. */
+async function selectApprovals(
+  options: MultisigOperation.selectApprovals.Options,
+) {
   try {
-    if (!options.discardInvalidNested) return await select(options.approvals)
-
-    const approvals: SignatureEnvelope.Serialized[] = []
-    for (const approval of options.approvals) {
-      if (SignatureEnvelope.from(approval).type !== 'multisig') {
-        approvals.push(approval)
-        continue
-      }
-      try {
-        const retained = (await select([approval])).approvals[0]
-        if (retained) approvals.push(retained)
-      } catch (error) {
-        if (
-          error instanceof MultisigOperation.InvalidApprovalError ||
-          error instanceof RpcResponse.InvalidParamsError
-        )
-          continue
-        throw error
-      }
-    }
-    return await select(approvals)
+    return await MultisigOperation.selectApprovals(options)
   } catch (error) {
     if (error instanceof MultisigOperation.InvalidApprovalError)
       throw new RpcResponse.InvalidParamsError({ message: error.shortMessage })
@@ -987,20 +901,6 @@ async function selectApprovals(options: selectApprovals.Options) {
   }
 }
 
-declare namespace selectApprovals {
-  /** Options for {@link selectApprovals}. */
-  export type Options = MultisigOperation.selectApprovals.Options & {
-    /** Block used to validate every config. */
-    blockNumber: bigint
-    /** Client used to validate nested multisig configurations. */
-    client: ReturnType<typeof createClient>
-    /** Discards stored nested approvals invalidated by a child configuration change. */
-    discardInvalidNested?: boolean | undefined
-    /** Shared multisig store. */
-    store: Store.Store
-  }
-}
-
 /** Returns an existing successful operation through the requested send method. */
 async function submittedResult(
   options: submit.Options,
@@ -1186,7 +1086,6 @@ function mergeTransaction(existing: Hex.Hex | undefined, incoming: Hex.Hex) {
 async function toTransaction(
   client: ReturnType<typeof createClient>,
   operation: MultisigOperation.TransactionOperation,
-  store: Store.Store,
 ) {
   const approvals = await (async () => {
     if (operation.status !== 'pending')
@@ -1206,12 +1105,8 @@ async function toTransaction(
     return await selectApprovals({
       account: operation.account,
       approvals: operation.approvals,
-      blockNumber,
-      client,
       config: operation.config,
-      discardInvalidNested: true,
       hash: operation.hash,
-      store,
     })
   })()
   const current =
@@ -1224,17 +1119,9 @@ async function toTransaction(
           weight: approvals.weight,
         })
       : operation
-  const serialized = MultisigOperation.serializeTransaction(
-    approvals.approvals.length > 0 ? current : operation,
-    {
-      // Keep one stored approval in the synthetic envelope when every nested
-      // approval became stale. The next submission replaces it before broadcast.
-      approvals:
-        approvals.selectedApprovals.length > 0
-          ? approvals.selectedApprovals
-          : operation.approvals.slice(0, 1),
-    },
-  )
+  const serialized = MultisigOperation.serializeTransaction(current, {
+    approvals: approvals.selectedApprovals,
+  })
   const transaction = deserialize(serialized)
   return {
     ...ox_Transaction.toRpc(