viem 2.52.0 → 2.52.2

package/chains/definitions/valygoSmartchain.ts

@@ -0,0 +1,34 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const valygoSmartchain = defineChain({
+  id: 7_771_777,
+  name: 'VALYGO Smartchain',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'VYO',
+    symbol: 'VYO',
+  },
+  rpcUrls: {
+    default: {
+      http: [
+        'https://rpc-gw-1.vyoscan.com/ext/bc/2t51dXsuxUvd9teY9TKEJmgxmxMk3CRF88UYTA4HQgjeYZqzSX/rpc',
+        'https://rpc-gw-2.vyoscan.com/ext/bc/2t51dXsuxUvd9teY9TKEJmgxmxMk3CRF88UYTA4HQgjeYZqzSX/rpc',
+      ],
+      webSocket: [
+        'wss://ws.vyoscan.com/ext/bc/2t51dXsuxUvd9teY9TKEJmgxmxMk3CRF88UYTA4HQgjeYZqzSX/ws',
+      ],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'VYOScan',
+      url: 'https://vyoscan.com',
+      apiUrl: 'https://vyoscan.com/api',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xeFa3c632BD275750597cE9ca2346A5becAA0F344',
+    },
+  },
+})

package/chains/index.ts

@@ -114,6 +114,7 @@ export { celoSepolia } from './definitions/celoSepolia.js'
 export { chang } from './definitions/chang.js'
 export { chiliz } from './definitions/chiliz.js'
 export { chips } from './definitions/chips.js'
+export { citrate } from './definitions/citrate.js'
 export { citrea } from './definitions/citrea.js'
 export { citreaTestnet } from './definitions/citreaTestnet.js'
 export { classic } from './definitions/classic.js'
@@ -251,6 +252,7 @@ export { godwoken } from './definitions/godwoken.js'
 export { goerli } from './definitions/goerli.js'
 export { graphite } from './definitions/graphite.js'
 export { graphiteTestnet } from './definitions/graphiteTestnet.js'
+export { grav } from './definitions/grav.js'
 export { gravity } from './definitions/gravity.js'
 export { gunz } from './definitions/gunz.js'
 export { guruNetwork } from './definitions/guruNetwork.js'
@@ -350,6 +352,7 @@ export { kromaSepolia } from './definitions/kromaSepolia.js'
 export { krown } from './definitions/krown.js'
 export { l3x } from './definitions/l3x.js'
 export { l3xTestnet } from './definitions/l3xTestnet.js'
+export { ladyChain } from './definitions/ladyChain.js'
 export { lavita } from './definitions/lavita.js'
 export { lens } from './definitions/lens.js'
 export { lensTestnet } from './definitions/lensTestnet.js'
@@ -675,6 +678,8 @@ export { unique } from './definitions/unique.js'
 export { uniqueOpal } from './definitions/uniqueOpal.js'
 export { uniqueQuartz } from './definitions/uniqueQuartz.js'
 export { unreal } from './definitions/unreal.js'
+export { valygoNft } from './definitions/valygoNft.js'
+export { valygoSmartchain } from './definitions/valygoSmartchain.js'
 export { vana } from './definitions/vana.js'
 export { vanaMoksha } from './definitions/vanaMoksha.js'
 export { vanar } from './definitions/vanar.js'

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.52.0'
+export const version = '2.52.2'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.52.0",
+  "version": "2.52.2",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -15,8 +15,7 @@
     "!**/*.test.ts.snap",
     "!**/*.test-d.ts",
     "!**/*.tsbuildinfo",
-    "!tsconfig.build.json",
-    "!jsr.json"
+    "!tsconfig.build.json"
   ],
   "exports": {
     ".": {
@@ -230,7 +229,7 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "0.14.27",
+    "ox": "0.14.29",
     "ws": "8.20.1"
   },
   "license": "MIT",

package/tempo/Account.ts

@@ -4,7 +4,12 @@ import * as P256 from 'ox/P256'
 import * as PublicKey from 'ox/PublicKey'
 import * as Secp256k1 from 'ox/Secp256k1'
 import * as Signature from 'ox/Signature'
-import { Channel, KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
+import {
+  Channel,
+  KeyAuthorization,
+  MultisigConfig,
+  SignatureEnvelope,
+} from 'ox/tempo'
 import * as WebAuthnP256 from 'ox/WebAuthnP256'
 import * as WebCryptoP256 from 'ox/WebCryptoP256'
 import type {
@@ -269,6 +274,78 @@ export declare namespace fromSecp256k1 {
     from.ReturnValue<options>
 }
 
+/**
+ * Instantiates a synthetic Account for a native multisig (TIP-1061) config.
+ *
+ * The returned account does not hold a key. It is used purely to drive the
+ * standard `sendTransaction` flow: it derives the multisig address from the
+ * config and passes the prepared request (carrying the collected owner
+ * `signatures`) through to the chain serializer, which combines the approvals
+ * into the multisig signature envelope.
+ *
+ * Owner approvals are produced separately by signing with `multisig` request
+ * metadata (see `signTransaction`), and provided here via `signatures`.
+ *
+ * Accepts a raw config and normalizes it internally (via `MultisigConfig.from`),
+ * so callers don't need to call `MultisigConfig.from` themselves.
+ *
+ * @example
+ * ```ts
+ * import { Account } from 'viem/tempo'
+ *
+ * const account = Account.fromMultisig({
+ *   threshold: 2,
+ *   owners: [
+ *     { owner: owner_1.address, weight: 1 },
+ *     { owner: owner_2.address, weight: 1 },
+ *   ],
+ * })
+ *
+ * // Pass the account to `prepareTransactionRequest` — the multisig config is
+ * // inferred from it, so no `multisig` field is needed.
+ * const request = await client.prepareTransactionRequest({ account, ...rest })
+ *
+ * // The prepared request carries the multisig account as sender, so it doesn't
+ * // need to be re-passed to `sendTransaction`.
+ * const transaction = await client.sendTransaction({
+ *   ...request,
+ *   signatures: [signature_1, signature_2],
+ * })
+ * ```
+ *
+ * @param config Multisig config (raw or from `MultisigConfig.from`).
+ * @returns Multisig account.
+ */
+export function fromMultisig(config: MultisigConfig.Config): MultisigAccount {
+  const normalized = MultisigConfig.from(config)
+  const address = Address.checksum(MultisigConfig.getAddress(normalized))
+  return {
+    address,
+    config: normalized,
+    publicKey: '0x',
+    source: 'multisig',
+    type: 'local',
+    async sign() {
+      throw new Error('`sign` is not supported for multisig accounts.')
+    },
+    async signMessage() {
+      throw new Error('`signMessage` is not supported for multisig accounts.')
+    },
+    async signTransaction(transaction, options) {
+      const { serializer = Transaction.serialize } = options ?? {}
+      return (await serializer(transaction as never)) as Hex.Hex
+    },
+    async signTypedData() {
+      throw new Error('`signTypedData` is not supported for multisig accounts.')
+    },
+  }
+}
+
+export type MultisigAccount = LocalAccount<'multisig'> & {
+  /** Multisig config (from `MultisigConfig.from`). */
+  config: MultisigConfig.Config
+}
+
 /**
  * Instantiates an Account from a WebAuthn credential.
  *
@@ -594,9 +671,25 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
           return { ...transaction, feePayerSignature: null }
         return transaction
       })()
-      const signature = await sign({
-        hash: keccak256(await serializer(presign)),
-      })
+
+      const payload = keccak256(await serializer(presign))
+
+      // Native multisig (TIP-1061): return this owner's approval — a serialized
+      // primitive signature over the multisig owner approval digest — instead of
+      // a full serialized transaction. Approvals are combined later in
+      // `sendTransaction({ signatures })`.
+      const multisig = (
+        transaction as { multisig?: MultisigConfig.Config | undefined }
+      ).multisig
+      if (multisig) {
+        const digest = MultisigConfig.getSignPayload({
+          payload,
+          genesisConfig: multisig,
+        })
+        return await sign({ hash: digest, raw: true })
+      }
+
+      const signature = await sign({ hash: payload })
       const envelope = SignatureEnvelope.from(signature)
       return await serializer(transaction, envelope as never)
     },

package/tempo/Formatters.ts

@@ -79,6 +79,8 @@ export function formatTransactionRequest(
     keyData?: Hex.Hex | undefined
     keyId?: Address | undefined
     keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
+    multisig?: unknown
+    signatures?: unknown
   }
   const account = request.account
     ? parseAccount<Account | viem_Account | Address>(request.account)
@@ -116,8 +118,17 @@ export function formatTransactionRequest(
   if (request.feePayer === true && !request.feePayerSignature)
     delete request.feeToken
 
+  // `multisig` / `signatures` are client-side only (TIP-1061). They drive
+  // sender derivation, owner signing, and final envelope assembly, but are
+  // never sent as raw RPC fields — the wire payload is the serialized tx.
+  const {
+    multisig: _multisig,
+    signatures: _signatures,
+    ...rpcRequest
+  } = request
+
   const rpc = ox_TransactionRequest.toRpc({
-    ...request,
+    ...rpcRequest,
     type: 'tempo',
   } as never)
 

package/tempo/Transaction.ts

@@ -7,6 +7,7 @@ import * as Signature from 'ox/Signature'
 import {
   type AuthorizationTempo,
   type KeyAuthorization,
+  type MultisigConfig,
   type TransactionReceipt as ox_TransactionReceipt,
   SignatureEnvelope,
   type TempoAddress,
@@ -124,7 +125,9 @@ export type TransactionRequestTempo<
     feePayer?: Account | true | undefined
     feeToken?: TempoAddress.Address | bigint | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
+    multisig?: MultisigConfig.Config<index> | undefined
     nonceKey?: 'expiring' | quantity | undefined
+    signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined
     validAfter?: index | undefined
   }
@@ -145,8 +148,10 @@ export type TransactionSerializableTempo<
     feePayerSignature?: viem_Signature | null | undefined
     from?: Address | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
+    multisig?: MultisigConfig.Config<index> | undefined
     nonceKey?: quantity | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
+    signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined
     validAfter?: index | undefined
     type?: 'tempo' | undefined
@@ -170,12 +175,16 @@ export function getType(
   if (
     (account?.keyType && account.keyType !== 'secp256k1') ||
     account?.source === 'accessKey' ||
+    account?.source === 'multisig' ||
     typeof transaction.calls !== 'undefined' ||
     typeof transaction.feePayer !== 'undefined' ||
+    typeof transaction.feePayerSignature !== 'undefined' ||
     typeof transaction.feeToken !== 'undefined' ||
     typeof transaction.keyAuthorization !== 'undefined' ||
+    typeof transaction.multisig !== 'undefined' ||
     typeof transaction.nonceKey !== 'undefined' ||
     typeof transaction.signature !== 'undefined' ||
+    typeof transaction.signatures !== 'undefined' ||
     typeof transaction.validBefore !== 'undefined' ||
     typeof transaction.validAfter !== 'undefined'
   )
@@ -337,6 +346,39 @@ async function serializeTempo(
   // the fee payer.
   if (shouldStripFeeTokenForSponsorship) delete transaction_ox.feeToken
 
+  // Native multisig (TIP-1061): combine the collected owner approvals into the
+  // multisig signature envelope and serialize the broadcast transaction. The
+  // approvals are recovered against the multisig owner digest and ordered into
+  // the strictly-ascending owner address order the node requires.
+  //
+  // Bootstrap (`init`) is auto-detected from the nonce: the protocol requires
+  // (and consumes) nonce `0` for the first transaction from a derived account,
+  // so `nonce == 0` uniquely identifies a bootstrap. This matches the serialized
+  // nonce above (a falsy `nonce` serializes as `0`). The owner approval digest
+  // doesn't commit to `init`, so attaching it here (rather than at owner-signing)
+  // is safe.
+  // NOTE: fee-payer + multisig is handled in a later phase.
+  if (transaction.multisig && transaction.signatures && !feePayer) {
+    const payload = TxTempo.getSignPayload(TxTempo.from(transaction_ox))
+    const signatures = transaction.signatures.map((approval) =>
+      SignatureEnvelope.from(approval),
+    )
+    const sorted = SignatureEnvelope.sortMultisigApprovals({
+      payload,
+      signatures,
+      genesisConfig: transaction.multisig,
+    })
+    const signature = SignatureEnvelope.from({
+      genesisConfig: transaction.multisig,
+      signatures: sorted,
+      ...(nonce ? {} : { init: true }),
+    })
+    return TxTempo.serialize(transaction_ox, {
+      feePayerSignature: undefined,
+      signature,
+    })
+  }
+
   if (signature && typeof transaction.feePayer === 'object') {
     const tx = TxTempo.from(transaction_ox, {
       signature,

package/tempo/chainConfig.ts

@@ -1,5 +1,6 @@
+import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
-import { SignatureEnvelope, type TokenId } from 'ox/tempo'
+import { MultisigConfig, SignatureEnvelope, type TokenId } from 'ox/tempo'
 import { getCode } from '../actions/public/getCode.js'
 import { verifyHash } from '../actions/public/verifyHash.js'
 import { maxUint256 } from '../constants/number.js'
@@ -12,7 +13,7 @@ import { defineTransactionRequest } from '../utils/formatters/transactionRequest
 import { getAction } from '../utils/getAction.js'
 import { keccak256 } from '../utils/hash/keccak256.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
-import type { Account } from './Account.js'
+import type { Account, MultisigAccount } from './Account.js'
 import { getMetadata } from './actions/accessKey.js'
 import * as Formatters from './Formatters.js'
 import type { Hardfork } from './Hardfork.js'
@@ -42,13 +43,16 @@ export const chainConfig = {
   prepareTransactionRequest: [
     async (r, { client, phase }) => {
       const request = r as Transaction.TransactionRequest & {
-        account?: Account | undefined
+        account?: Account | MultisigAccount | undefined
         chainId?: number | undefined
         chain?:
           | (Chain & {
               feeToken?: TokenId.TokenIdOrAddress | undefined
             })
           | undefined
+        from?: Address | undefined
+        multisig?: MultisigConfig.Config | undefined
+        signatures?: readonly unknown[] | undefined
       }
 
       // FIXME: node estimates gas with secp256k1 dummy sig + null feePayerSignature.
@@ -60,9 +64,34 @@ export const chainConfig = {
           else if (request.account?.source === 'accessKey')
             request.gas = (request.gas ?? 0n) + 10_000n
         }
+
         return request as unknown as typeof r
       }
 
+      // Native multisig (TIP-1061). The transaction sender is the derived
+      // multisig account, not a signing account (owner accounts only contribute
+      // approvals later via `signTransaction`). Derive the sender from the
+      // config; core fills nonce/gas/fees for it via `request.from`, and the
+      // serializer auto-detects bootstrap (`init`) from `nonce == 0`.
+      //
+      // The config is taken from an explicit `multisig` field, or inferred from
+      // a multisig account (so callers can just pass `account` to
+      // `prepareTransactionRequest` without also passing `multisig`).
+      const multisig =
+        request.multisig ??
+        (request.account?.source === 'multisig'
+          ? (request.account as MultisigAccount).config
+          : undefined)
+      if (multisig) {
+        request.multisig = multisig
+        request.from = MultisigConfig.getAddress(multisig)
+        // A non-multisig `account` (e.g. the client's default) isn't the sender,
+        // so drop it: core then fills nonce/gas/fees for the multisig sender via
+        // `request.from`. A multisig account *is* the sender — keep it so the
+        // prepared request can be sent without re-passing `account`.
+        if (request.account?.source !== 'multisig') delete request.account
+      }
+
       if (
         !request.keyAuthorization &&
         request.account?.source === 'accessKey'

package/tempo/index.ts

@@ -13,6 +13,7 @@ export type {
 } from 'ox/tempo'
 export {
   Channel,
+  MultisigConfig,
   Period,
   ReceivePolicyReceipt,
   TempoAddress,