viem 2.51.3 → 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.51.3'
+export const version = '2.52.2'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.51.3",
+  "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.25",
+    "ox": "0.14.29",
     "ws": "8.20.1"
   },
   "license": "MIT",

package/tempo/Abis.ts

@@ -1294,6 +1294,28 @@ export const signatureVerifier = [
     ],
     outputs: [{ type: 'bool' }],
   },
+  {
+    name: 'verifyKeychain',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { type: 'address', name: 'account' },
+      { type: 'bytes32', name: 'hash' },
+      { type: 'bytes', name: 'signature' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
+  {
+    name: 'verifyKeychainAdmin',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { type: 'address', name: 'account' },
+      { type: 'bytes32', name: 'hash' },
+      { type: 'bytes', name: 'signature' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
   { name: 'InvalidFormat', type: 'error', inputs: [] },
   { name: 'InvalidSignature', type: 'error', inputs: [] },
 ] as const
@@ -1594,6 +1616,15 @@ export const stablecoinDex = [
       { type: 'int16', name: 'flipTick' },
     ],
   },
+  {
+    name: 'FlipFailed',
+    type: 'event',
+    inputs: [
+      { type: 'uint128', name: 'orderId', indexed: true },
+      { type: 'address', name: 'maker', indexed: true },
+      { type: 'bytes4', name: 'reason' },
+    ],
+  },
   {
     name: 'OrderCancelled',
     type: 'event',
@@ -1949,6 +1980,82 @@ export const feeAmm = [
   { name: 'InvalidSwapCalculation', type: 'error', inputs: [] },
 ] as const
 
+export const receivePolicyGuard = [
+  {
+    name: 'balanceOf',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ type: 'bytes', name: 'receipt' }],
+    outputs: [{ type: 'uint256', name: 'amount' }],
+  },
+  {
+    name: 'claim',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { type: 'address', name: 'to' },
+      { type: 'bytes', name: 'receipt' },
+    ],
+    outputs: [],
+  },
+  {
+    name: 'burnBlockedReceipt',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [{ type: 'bytes', name: 'receipt' }],
+    outputs: [],
+  },
+  {
+    name: 'TransferBlocked',
+    type: 'event',
+    inputs: [
+      { type: 'address', name: 'token', indexed: true },
+      { type: 'address', name: 'receiver', indexed: true },
+      { type: 'uint64', name: 'blockedNonce', indexed: true },
+      { type: 'uint256', name: 'amount' },
+      { type: 'uint8', name: 'receiptVersion' },
+      { type: 'bytes', name: 'receipt' },
+    ],
+  },
+  {
+    name: 'ReceiptClaimed',
+    type: 'event',
+    inputs: [
+      { type: 'address', name: 'token', indexed: true },
+      { type: 'address', name: 'receiver', indexed: true },
+      { type: 'uint64', name: 'blockedNonce', indexed: true },
+      { type: 'uint64', name: 'blockedAt' },
+      { type: 'uint8', name: 'receiptVersion' },
+      { type: 'address', name: 'originator' },
+      { type: 'address', name: 'recipient' },
+      { type: 'address', name: 'recoveryAuthority' },
+      { type: 'address', name: 'caller' },
+      { type: 'address', name: 'to' },
+      { type: 'uint256', name: 'amount' },
+    ],
+  },
+  {
+    name: 'ReceiptBurned',
+    type: 'event',
+    inputs: [
+      { type: 'address', name: 'token', indexed: true },
+      { type: 'address', name: 'receiver', indexed: true },
+      { type: 'uint64', name: 'blockedNonce', indexed: true },
+      { type: 'uint64', name: 'blockedAt' },
+      { type: 'uint8', name: 'receiptVersion' },
+      { type: 'address', name: 'originator' },
+      { type: 'address', name: 'recipient' },
+      { type: 'address', name: 'recoveryAuthority' },
+      { type: 'address', name: 'caller' },
+      { type: 'uint256', name: 'amount' },
+    ],
+  },
+  { name: 'InvalidReceipt', type: 'error', inputs: [] },
+  { name: 'InvalidClaimAddress', type: 'error', inputs: [] },
+  { name: 'UnauthorizedClaimer', type: 'error', inputs: [] },
+  { name: 'AddressReserved', type: 'error', inputs: [] },
+] as const
+
 export const accountKeychain = [
   {
     name: 'authorizeKey',
@@ -2057,6 +2164,17 @@ export const accountKeychain = [
     ],
     outputs: [],
   },
+  {
+    name: 'authorizeAdminKey',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { type: 'address', name: 'keyId' },
+      { type: 'uint8', name: 'signatureType' },
+      { type: 'bytes32', name: 'witness' },
+    ],
+    outputs: [],
+  },
   {
     name: 'burnKeyAuthorizationWitness',
     type: 'function',
@@ -2199,6 +2317,16 @@ export const accountKeychain = [
     ],
     outputs: [{ type: 'bool' }],
   },
+  {
+    name: 'isAdminKey',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { type: 'address', name: 'account' },
+      { type: 'address', name: 'keyId' },
+    ],
+    outputs: [{ type: 'bool' }],
+  },
   {
     name: 'getTransactionKey',
     type: 'function',
@@ -2216,6 +2344,14 @@ export const accountKeychain = [
       { type: 'uint64', name: 'expiry' },
     ],
   },
+  {
+    name: 'AdminKeyAuthorized',
+    type: 'event',
+    inputs: [
+      { type: 'address', name: 'account', indexed: true },
+      { type: 'address', name: 'publicKey', indexed: true },
+    ],
+  },
   {
     name: 'KeyRevoked',
     type: 'event',
@@ -2281,6 +2417,7 @@ export const accountKeychain = [
   },
   { name: 'CallNotAllowed', type: 'error', inputs: [] },
   { name: 'InvalidCallScope', type: 'error', inputs: [] },
+  { name: 'InvalidKeyId', type: 'error', inputs: [] },
   { name: 'InvalidKeyAuthorizationWitness', type: 'error', inputs: [] },
   { name: 'KeyAuthorizationWitnessAlreadyBurned', type: 'error', inputs: [] },
   {
@@ -2464,6 +2601,34 @@ export const tip403Registry = [
       { type: 'uint64', name: 'mintRecipientPolicyId' },
     ],
   },
+  {
+    name: 'receivePolicy',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ type: 'address', name: 'account' }],
+    outputs: [
+      { type: 'bool', name: 'hasReceivePolicy' },
+      { type: 'uint64', name: 'senderPolicyId' },
+      { type: 'uint8', name: 'senderPolicyType' },
+      { type: 'uint64', name: 'tokenFilterId' },
+      { type: 'uint8', name: 'tokenFilterType' },
+      { type: 'address', name: 'recoveryAuthority' },
+    ],
+  },
+  {
+    name: 'validateReceivePolicy',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { type: 'address', name: 'token' },
+      { type: 'address', name: 'sender' },
+      { type: 'address', name: 'receiver' },
+    ],
+    outputs: [
+      { type: 'bool', name: 'authorized' },
+      { type: 'uint8', name: 'blockedReason' },
+    ],
+  },
   {
     name: 'createPolicy',
     type: 'function',
@@ -2528,6 +2693,17 @@ export const tip403Registry = [
     ],
     outputs: [{ type: 'uint64' }],
   },
+  {
+    name: 'setReceivePolicy',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { type: 'uint64', name: 'senderPolicyId' },
+      { type: 'uint64', name: 'tokenFilterId' },
+      { type: 'address', name: 'recoveryAuthority' },
+    ],
+    outputs: [],
+  },
   {
     name: 'PolicyAdminUpdated',
     type: 'event',
@@ -2577,12 +2753,24 @@ export const tip403Registry = [
       { type: 'uint64', name: 'mintRecipientPolicyId' },
     ],
   },
+  {
+    name: 'ReceivePolicyUpdated',
+    type: 'event',
+    inputs: [
+      { type: 'address', name: 'account', indexed: true },
+      { type: 'uint64', name: 'senderPolicyId' },
+      { type: 'uint64', name: 'tokenFilterId' },
+      { type: 'address', name: 'recoveryAuthority' },
+    ],
+  },
   { name: 'Unauthorized', type: 'error', inputs: [] },
   { name: 'PolicyNotFound', type: 'error', inputs: [] },
   { name: 'PolicyNotSimple', type: 'error', inputs: [] },
   { name: 'InvalidPolicyType', type: 'error', inputs: [] },
   { name: 'IncompatiblePolicyType', type: 'error', inputs: [] },
   { name: 'VirtualAddressNotAllowed', type: 'error', inputs: [] },
+  { name: 'InvalidReceivePolicyType', type: 'error', inputs: [] },
+  { name: 'InvalidRecoveryAuthority', type: 'error', inputs: [] },
 ] as const
 
 export const validatorConfig = [
@@ -2745,6 +2933,7 @@ export const abis = [
   ...addressRegistry,
   ...feeManager,
   ...feeAmm,
+  ...receivePolicyGuard,
   ...accountKeychain,
   ...nonce,
   ...tip20Factory,

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 {
@@ -55,8 +60,11 @@ export type RootAccount = Account_base<'root'> & {
     key: resolveAccessKey.Parameters,
     parameters: Pick<
       KeyAuthorization.KeyAuthorization,
-      'chainId' | 'expiry' | 'limits' | 'scopes'
-    >,
+      'chainId' | 'expiry' | 'limits' | 'scopes' | 'witness'
+    > & {
+      /** Whether to authorize the key as an admin key (TIP-1049). */
+      admin?: boolean | undefined
+    },
   ) => Promise<KeyAuthorization.Signed>
 }
 
@@ -266,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.
  *
@@ -462,36 +542,58 @@ export async function signKeyAuthorization(
   account: LocalAccount,
   parameters: signKeyAuthorization.Parameters,
 ): Promise<signKeyAuthorization.ReturnValue> {
-  const { chainId, key, expiry, limits, scopes } = parameters
+  const { chainId, key, expiry, limits, scopes, witness, admin } = parameters
   const { accessKeyAddress, keyType: type } = resolveAccessKey(key)
 
-  const signature = await account.sign!({
-    hash: KeyAuthorization.getSignPayload({
-      address: accessKeyAddress,
-      chainId,
-      expiry,
-      limits,
-      scopes,
-      type,
-    }),
-  })
+  // When the signer is an admin access key, the authorization must be
+  // signed directly by that key and bound to the parent account it acts
+  // on behalf of, so the signed payload cannot be replayed against another
+  // account. [TIP-1049]
+  const isAccessKey = isAccessKeyAccount(account)
+  const boundFields = isAccessKey ? { account: account.address } : {}
+
+  // Admin key authorizations are unrestricted and must not carry expiry,
+  // limits, or call scopes (the protocol rejects them). [TIP-1049]
+  const restrictions = admin ? {} : { expiry, limits, scopes }
+
+  const hash = KeyAuthorization.getSignPayload({
+    address: accessKeyAddress,
+    chainId,
+    type,
+    witness,
+    ...(admin ? { isAdmin: true } : {}),
+    ...boundFields,
+    ...restrictions,
+  } as never)
+  const signature = isAccessKey
+    ? await account.sign({ hash, raw: true })
+    : await account.sign!({ hash })
   return KeyAuthorization.from({
     address: accessKeyAddress,
     chainId,
-    expiry,
-    limits,
-    scopes,
     signature: SignatureEnvelope.from(signature),
     type,
-  })
+    ...(witness ? { witness } : {}),
+    ...(admin ? { isAdmin: true } : {}),
+    ...boundFields,
+    ...restrictions,
+  } as never)
 }
 
 export declare namespace signKeyAuthorization {
   type Parameters = Pick<
     KeyAuthorization.KeyAuthorization,
-    'chainId' | 'expiry' | 'limits' | 'scopes'
+    'chainId' | 'expiry' | 'limits' | 'scopes' | 'witness'
   > & {
     key: resolveAccessKey.Parameters
+    /**
+     * Whether to authorize the key as an admin key. Admin keys are
+     * unrestricted and can manage the account's other access keys; `expiry`,
+     * `limits`, and `scopes` are ignored. Requires the T6 hardfork.
+     *
+     * [TIP-1049](https://tips.sh/1049)
+     */
+    admin?: boolean | undefined
   }
 
   type ReturnValue = KeyAuthorization.Signed
@@ -569,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)
     },
@@ -618,28 +736,32 @@ function fromRoot(parameters: fromRoot.Parameters): RootAccount {
     ...account,
     source: 'root',
     async signKeyAuthorization(key, parameters) {
-      const { chainId, expiry, limits, scopes } = parameters
+      const { chainId, expiry, limits, scopes, witness, admin } = parameters
       const { accessKeyAddress, keyType: type } = resolveAccessKey(key)
 
+      // Admin key authorizations are unrestricted and must not carry expiry,
+      // limits, or call scopes (the protocol rejects them). [TIP-1049]
+      const restrictions = admin ? {} : { expiry, limits, scopes }
+
       const signature = await account.sign({
         hash: KeyAuthorization.getSignPayload({
           address: accessKeyAddress,
           chainId,
-          expiry,
-          limits,
-          scopes,
           type,
-        }),
+          witness,
+          ...(admin ? { isAdmin: true } : {}),
+          ...restrictions,
+        } as never),
       })
       const keyAuthorization = KeyAuthorization.from({
         address: accessKeyAddress,
         chainId,
-        expiry,
-        limits,
-        scopes,
         signature: SignatureEnvelope.from(signature),
         type,
-      })
+        ...(witness ? { witness } : {}),
+        ...(admin ? { isAdmin: true } : {}),
+        ...restrictions,
+      } as never)
       return keyAuthorization
     },
   }

package/tempo/Addresses.ts

@@ -6,6 +6,8 @@ export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
 export const feeManager = '0xfeec000000000000000000000000000000000000'
 export const nonceManager = '0x4e4F4E4345000000000000000000000000000000'
 export const pathUsd = '0x20c0000000000000000000000000000000000000'
+export const receivePolicyGuard = '0xB10C000000000000000000000000000000000000'
+export const signatureVerifier = '0x5165300000000000000000000000000000000000'
 export const stablecoinDex = '0xdec0000000000000000000000000000000000000'
 export const tip20Factory = '0x20fc000000000000000000000000000000000000'
 export const tip403Registry = '0x403c000000000000000000000000000000000000'