@depup/viem 2.56.3-depup.0 → 2.56.9-depup.0

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

@@ -12,8 +12,13 @@ export const accountImplementation =
 export const accountKeychain = '0xaAAAaaAA00000000000000000000000000000000'
 export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
 export const addressRegistry = '0xfdc0000000000000000000000000000000000000'
+/** Current consensus committee precompile address, used with `Abis.currentCommittee` to read committee members. */
+export const currentCommittee = '0xC077e00000000000000000000000000000000000'
 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/Decorator.ts

@@ -13,6 +13,7 @@ import * as feeActions from './actions/fee.js'
 import * as multisigActions from './actions/multisig.js'
 import * as nonceActions from './actions/nonce.js'
 import * as policyActions from './actions/policy.js'
+import * as propAmmActions from './actions/propAmm.js'
 import * as receivePolicyActions from './actions/receivePolicy.js'
 import * as rewardActions from './actions/reward.js'
 import * as simulateActions from './actions/simulate.js'
@@ -3015,6 +3016,228 @@ type DecoratorBase<
       parameters: policyActions.watchBlacklistUpdated.Parameters,
     ) => () => void
   }
+  propAmm: {
+    /**
+     * Reads the base token of a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const base = await client.propAmm.baseToken({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns The base token address.
+     */
+    baseToken: (
+      parameters: propAmmActions.baseToken.Parameters,
+    ) => Promise<propAmmActions.baseToken.ReturnValue>
+    /**
+     * Quotes an exact input or output for a caller, recipient, and customer route.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const { amountOut, price, updatedAt } = await client.propAmm.getSwapQuote({
+     *   amountIn: 1_000_000n,
+     *   mode: 'exactInput',
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     *   taker: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Route, swap mode, amount, and read options.
+     * @returns Quoted amount, oracle observation, rounding credit, and swap request.
+     */
+    getSwapQuote: <
+      const parameters extends propAmmActions.getSwapQuote.Parameters,
+    >(
+      parameters: parameters,
+    ) => Promise<propAmmActions.getSwapQuote.ReturnValue<parameters>>
+    /**
+     * Reads whether a propAMM pool is paused.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const paused = await client.propAmm.paused({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns Whether swaps are paused.
+     */
+    paused: (
+      parameters: propAmmActions.paused.Parameters,
+    ) => Promise<propAmmActions.paused.ReturnValue>
+    /**
+     * Reads whether a resolved address may receive swap output.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const allowed = await client.propAmm.recipientAllowed({
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, resolved recipient, and read options.
+     * @returns Whether the recipient is allowed.
+     */
+    recipientAllowed: (
+      parameters: propAmmActions.recipientAllowed.Parameters,
+    ) => Promise<propAmmActions.recipientAllowed.ReturnValue>
+    /**
+     * Resolves a Tempo recipient to the address checked by the pool's allowlist.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const resolved = await client.propAmm.resolveRecipient({
+     *   pool: '0x...',
+     *   recipient: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, recipient, and read options.
+     * @returns The resolved recipient address.
+     */
+    resolveRecipient: (
+      parameters: propAmmActions.resolveRecipient.Parameters,
+    ) => Promise<propAmmActions.resolveRecipient.ReturnValue>
+    /**
+     * Reads the quote token of a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const quote = await client.propAmm.quoteToken({ pool: '0x...' })
+     * ```
+     *
+     * @param parameters - Pool and read options.
+     * @returns The quote token address.
+     */
+    quoteToken: (
+      parameters: propAmmActions.quoteToken.Parameters,
+    ) => Promise<propAmmActions.quoteToken.ReturnValue>
+    /**
+     * Approves the input token and swaps an exact input or output in one transaction.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     * const hash = await client.propAmm.swap({
+     *   amountIn: 1_000_000n,
+     *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+     *   minAmountOut: 1_000_000n,
+     *   minimumOracleUpdatedAt: 1_799_999_000n,
+     *   mode: 'exactInput',
+     *   pool: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Swap and transaction options.
+     * @returns The transaction hash.
+     */
+    swap: (
+      parameters: propAmmActions.swap.Parameters<chain, account>,
+    ) => Promise<propAmmActions.swap.ReturnValue>
+    /**
+     * Approves the input token, swaps, and returns the confirmed trade and receipt.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   account: privateKeyToAccount('0x...'),
+     *   chain: tempo,
+     *   transport: http(),
+     * }).extend(tempoActions())
+     * const trade = await client.propAmm.swapSync({
+     *   amountOut: 1_000_000n,
+     *   baseToQuote: false,
+     *   expectedOraclePrice: 1_000_000_000_000_000_000n,
+     *   maxAmountIn: 1_010_000n,
+     *   minimumOracleUpdatedAt: 1_799_999_000n,
+     *   mode: 'exactOutput',
+     *   pool: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Swap and transaction options.
+     * @returns Confirmed trade data and receipt.
+     */
+    swapSync: (
+      parameters: propAmmActions.swapSync.Parameters<chain, account>,
+    ) => Promise<propAmmActions.swapSync.ReturnValue>
+    /**
+     * Reads whether an address may call swaps on a propAMM pool.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({ chain: tempo, transport: http() }).extend(tempoActions())
+     *
+     * const allowed = await client.propAmm.takerAllowed({
+     *   pool: '0x...',
+     *   taker: '0x...',
+     * })
+     * ```
+     *
+     * @param parameters - Pool, taker, and read options.
+     * @returns Whether the taker is allowed.
+     */
+    takerAllowed: (
+      parameters: propAmmActions.takerAllowed.Parameters,
+    ) => Promise<propAmmActions.takerAllowed.ReturnValue>
+  }
   receivePolicy: {
     /**
      * Burns the funds backing a blocked receipt.
@@ -5774,9 +5997,7 @@ type BoundHelper<helper> = helper extends (
     ? (args: args) => returnType
     : parameters extends [Client<any, any, any>]
       ? () => returnType
-      : parameters extends [infer args, ...unknown[]]
-        ? (args: args) => returnType
-        : () => returnType
+      : helper
   : never
 
 type BoundActionHelpers<action> = (action extends { call: infer helper }
@@ -5879,6 +6100,10 @@ export type Decorator<
     DecoratorBase<chain, account>['policy'],
     typeof policyActions
   >
+  propAmm: DecorateNamespace<
+    DecoratorBase<chain, account>['propAmm'],
+    typeof propAmmActions
+  >
   receivePolicy: DecorateNamespace<
     DecoratorBase<chain, account>['receivePolicy'],
     typeof receivePolicyActions
@@ -6075,6 +6300,17 @@ export function decorator() {
         'watchWhitelistUpdated',
         'watchBlacklistUpdated',
       ]),
+      propAmm: bindActions(client, propAmmActions, [
+        'baseToken',
+        'paused',
+        'getSwapQuote',
+        'quoteToken',
+        'recipientAllowed',
+        'resolveRecipient',
+        'swap',
+        'swapSync',
+        'takerAllowed',
+      ]),
       receivePolicy: bindActions(client, receivePolicyActions, [
         'burn',
         'burnSync',