accounts 0.18.5 → 0.19.0

package/src/core/ExecutionError.ts

@@ -21,7 +21,6 @@ export type Rpc = UnionOmit<ExecutionError, 'args'>
 /** Human-readable messages keyed by ABI error name. */
 export const messages: Record<AbiErrorName, string> = {
   AbdicationAlreadyScheduled: 'Capability {0} abdication is already scheduled.',
-  AccountAlreadyInitialized: 'Account already initialized.',
   AccountNotAllowed: 'Account {0} is not allowed.',
   ActiveLeaderRemoved: 'The active leader cannot be removed.',
   ActiveSupplyWithoutBacking: 'Active supply has no backing.',
@@ -32,6 +31,7 @@ export const messages: Record<AbiErrorName, string> = {
   AlreadyInitialized: 'Already initialized.',
   AmountExceedsDeposit: 'Amount exceeds deposit.',
   AmountExceedsLimit: 'Amount exceeds limit.',
+  AmountIsZero: 'Amount cannot be zero.',
   AmountNotIncreasing: 'Amount is not increasing.',
   AmountOverflow: 'Amount overflow.',
   AssetsNotArrived: 'Assets for request {0} have not arrived.',
@@ -56,6 +56,8 @@ export const messages: Record<AbiErrorName, string> = {
   ContractPaused: 'Contract is paused.',
   CreditExceedsBalance:
     'Credit for asset {0} exceeds the balance. Available: {1}, requested total: {2}.',
+  CustomerIdIsZero: 'Customer ID cannot be zero.',
+  DeadlineExpired: 'Deadline {0} has expired at timestamp {1}.',
   DepositBlockCapacityExceeded: 'Deposit block capacity of {0} exceeded.',
   DepositOverflow: 'Deposit overflow.',
   DepositTooSmall: 'Deposit too small.',
@@ -76,6 +78,7 @@ export const messages: Record<AbiErrorName, string> = {
   EarnVaultNotSet: 'Earn vault is not set.',
   EmptyDeploymentId: 'Deployment ID cannot be empty.',
   EmptyEarnShareMetadata: 'Empty earn share metadata.',
+  EmptyInstallation: 'Installation cannot be empty.',
   EmptyMetadata: 'Empty metadata.',
   EmptyV1ValidatorSet: 'Validator set is empty.',
   EncryptionKeyExpired: 'Encryption key {0}, activated at block {1}, expired at block {2}.',
@@ -86,6 +89,7 @@ export const messages: Record<AbiErrorName, string> = {
   EngineEarnVaultMismatch: 'Engine earn vault mismatch.',
   EngineExitUnsupported: 'This engine does not support exits.',
   EngineSharesTooLarge: 'Engine share amount {0} is too large.',
+  ExactBalanceDeltaFailed: 'Balance change for {0} was {2}, expected {1}.',
   ExceedsMaxEarnShares: 'Maximum earn shares exceeded.',
   ExcessiveConversionLoss:
     'Conversion loss is excessive. Input shares: {0}, represented shares: {1}.',
@@ -99,6 +103,7 @@ export const messages: Record<AbiErrorName, string> = {
   FailedDeployment: 'Deployment failed.',
   FeeValuationStale: 'Fee valuation is stale.',
   FinalizedAssetMismatch: 'Finalized asset {0} does not match.',
+  FutureOracleTimestamp: 'Oracle timestamp {0} is after the current time ({1}).',
   GasFeeRateTooHigh: 'Gas fee rate too high.',
   GasLimitTooHigh: 'Gas limit too high.',
   GlobalFeeDisableUnavailable: 'Global fee disabling is unavailable.',
@@ -117,11 +122,13 @@ export const messages: Record<AbiErrorName, string> = {
     'Insufficient engine share surplus. Available: {0}, requested: {1}.',
   InsufficientFeeTokenBalance: 'Insufficient fee token balance.',
   InsufficientFunding: 'Insufficient funding. Required: {0}, actual: {1}.',
+  InsufficientInventory: 'Insufficient inventory for {0}: available {1}, required {2}.',
   InsufficientLiquidity: 'Not enough liquidity in the order book to fill this trade.',
   InsufficientOutput:
     'The output amount is below the slippage minimum — try increasing slippage tolerance.',
   InsufficientReserves: 'Insufficient reserves.',
   InvalidAccount: 'Invalid account.',
+  InvalidAddress: 'Invalid address.',
   InvalidAdmin: 'Invalid admin.',
   InvalidAmount: 'Invalid amount.',
   InvalidArrayLengths: 'Invalid array lengths.',
@@ -152,6 +159,7 @@ export const messages: Record<AbiErrorName, string> = {
   InvalidEngine: 'Invalid engine.',
   InvalidEngineShareScale: 'Invalid engine share scale.',
   InvalidEphemeralPubkey: 'Invalid ephemeral pubkey.',
+  InvalidExistingDeployment: 'Existing deployment {0} is invalid.',
   InvalidExpiringNonceExpiry: 'Invalid expiring nonce expiry.',
   InvalidFallbackRecipient: 'Invalid fallback recipient.',
   InvalidFeeClaimReceiver: 'Invalid fee claim receiver.',
@@ -163,16 +171,21 @@ export const messages: Record<AbiErrorName, string> = {
   InvalidLeader: 'Invalid leader.',
   InvalidLogoURI: 'Invalid logo URI.',
   InvalidMasterAddress: 'Invalid master address.',
+  InvalidMaxOracleAge: 'Invalid maximum oracle age.',
+  InvalidMaxPriceDeviationBps: 'Maximum price deviation {0} exceeds {1} basis points.',
   InvalidMaxRateAge: 'Invalid maximum rate age.',
   InvalidMigrationIndex: 'Invalid migration index.',
   InvalidMode: 'Invalid mode.',
   InvalidMultiproof: 'Invalid multiproof.',
+  InvalidMultisigOwner: 'Invalid multisig owner.',
   InvalidNonceKey: 'Invalid nonce key.',
+  InvalidOraclePriceToleranceBps: 'Oracle price tolerance {0} exceeds {1} basis points.',
   InvalidOwner: 'Invalid owner.',
   InvalidOwnerOrder: 'Invalid owner order.',
   InvalidPayee: 'Invalid payee.',
   InvalidPayload: 'Invalid payload.',
   InvalidPolicyType: 'Invalid policy type.',
+  InvalidPrice: 'Invalid price.',
   InvalidPrivateAsset: 'Invalid private asset.',
   InvalidProof: 'Invalid proof.',
   InvalidProofOfPossession: 'Invalid proof of possession.',
@@ -186,6 +199,7 @@ export const messages: Record<AbiErrorName, string> = {
   InvalidRecoveryAuthority: 'Invalid recovery authority.',
   InvalidReturnToken: 'Invalid return token.',
   InvalidRevealTo: 'Invalid reveal to.',
+  InvalidRewardConfiguration: 'Invalid reward configuration.',
   InvalidRoutePair: 'Invalid route pair.',
   InvalidSequencerSet: 'Invalid sequencer set.',
   InvalidSignature: 'Invalid signature.',
@@ -245,18 +259,21 @@ export const messages: Record<AbiErrorName, string> = {
   NotEmergencyGuardianOrOperator: 'Caller is not the emergency guardian or operator.',
   NotEngine: 'Not engine.',
   NotFactory: 'Not factory.',
+  NotGuardianOrOwner: 'Not the guardian or owner.',
   NotHostPort: '"{1}" is not a valid host:port for {0}.',
   NotInitialized: 'Not initialized.',
   NotIp: '"{0}" is not a valid IP address.',
   NotIpPort: '"{1}" is not a valid IP:port for {0}.',
-  NotMultisigAccount: 'Not multisig account.',
   NotOperator: 'Not operator.',
   NotOwner: 'Not owner.',
   NotPauseAuthority: 'Not pause authority.',
+  NotPaused: 'Not paused.',
   NotPayeeOrOperator: 'Not payee or operator.',
   NotPayer: 'Not payer.',
   NotPendingAdmin: 'Not pending admin.',
   NotPendingDistributor: 'Not pending distributor.',
+  NotPendingOperator: 'Not the pending operator.',
+  NotPendingOwner: 'Not the pending owner.',
   NotRequesterOrJanitor: 'Caller is not the requester or janitor.',
   NotSelf: 'Not self.',
   NotSequencer: 'Not sequencer.',
@@ -266,6 +283,10 @@ export const messages: Record<AbiErrorName, string> = {
   OnlySequencer: 'Only the sequencer may call this function.',
   OnlyZoneInbox: 'Only the zone inbox may call this function.',
   OperatorMigrationDisabled: 'Operator migration disabled.',
+  OperatorTransferNotPending: 'No operator transfer is pending.',
+  OracleDecimalsChanged: 'Oracle decimals changed from {0} to {1}.',
+  OraclePriceToleranceExceeded: 'Oracle price {1} differs from {0} by more than {2} basis points.',
+  OracleTimestampTooOld: 'Oracle timestamp {1} is before the minimum ({0}).',
   OrderDoesNotExist: 'No order exists with the given ID.',
   OrderNotStale: 'This order is not yet eligible for stale-cleanup.',
   OwnableInvalidOwner: 'Owner {0} is invalid.',
@@ -281,13 +302,18 @@ export const messages: Record<AbiErrorName, string> = {
   PolicyNotFound: 'Policy not found.',
   PolicyNotSimple: 'Policy is not a simple policy.',
   PortalIsPaused: 'Portal is paused.',
+  PriceAnchorNotInitialized: 'Price anchor is not initialized for direction {0}.',
+  PriceDeviationExceeded:
+    'Price {1} deviates from anchor {2} by more than {3} basis points for direction {0}.',
   ProofOfWorkFailed: 'Proof of work failed.',
   ProtectedAddress: 'Address is protected.',
   ProtocolNonceNotSupported: 'Protocol nonce is not supported.',
   PublicKeyAlreadyExists: 'Public key already exists.',
   QueueTrackingDisabled: 'Tracking is disabled for queue {0}.',
   QueueUnavailable: 'Queue unavailable.',
+  QueuedAssetsBelowMinimum: 'Queued assets ({1}) are below the minimum ({0}).',
   RateChangedWithinTransaction: 'Rate changed within the transaction. Expected {0}, got {1}.',
+  RecipientNotAllowed: 'Recipient {0} is not allowed.',
   ReentrancyGuardReentrantCall: 'Reentrant call blocked.',
   ReentrantCall: 'Reentrant call blocked.',
   ReentrantWithdrawal: 'Reentrant withdrawal blocked.',
@@ -299,18 +325,22 @@ export const messages: Record<AbiErrorName, string> = {
   RootTotalDecreased: 'Root total decreased from {0} to {1}.',
   RootTotalExceeded: 'Requested amount {0} exceeds the remaining entitlement {1}.',
   SameEngine: 'Same engine.',
-  SameTransactionUpdateNotAllowed: 'Same transaction update not allowed.',
+  SameToken: 'Tokens must be different.',
   SequencerConfigurationUnchanged: 'Sequencer configuration unchanged.',
+  SettlementAlreadyConsumed: 'Settlement {0} has already been consumed.',
   SignatureTypeMismatch: 'Signature type mismatch. Expected {0}, got {1}.',
+  SlippageExceeded: 'Amount {1} exceeds slippage limit {0}.',
   SolveUnderfunded: 'Solve for asset {0} is underfunded. Delivered: {1}, required: {2}.',
   SpendingLimitExceeded: 'Spending limit exceeded.',
   StaleAccountantRate: 'Accountant rate updated at {0} is stale at time {1}; maximum age is {2}.',
   StaleLeadershipEpoch: 'Stale leadership epoch. Expected {0}, got {1}.',
+  StaleOraclePrice: 'Oracle price timestamp {0} exceeds the maximum age ({1}).',
   StaleRootVersion: 'Stale root version. Expected {0}, got {1}.',
   StaticCallNotAllowed: 'Static call not allowed.',
   SupplyCapExceeded: 'Supply cap exceeded.',
   SweepExceedsAvailableBalance:
     'Sweep for token {0} exceeds the balance. Available: {1}, requested: {2}.',
+  TakerNotAllowed: 'Taker {0} is not allowed.',
   TickOutOfBounds: 'Price tick {0} is outside the allowed range.',
   TokenAlreadyEnabled: 'Token already enabled.',
   TokenAlreadyExists: 'Token {0} already exists.',
@@ -319,6 +349,7 @@ export const messages: Record<AbiErrorName, string> = {
   TokenEnablementBlockCapacityExceeded: 'Token enablement block capacity of {0} exceeded.',
   TokenMetadataTooLong: 'Token metadata too long.',
   TokenNotEnabled: 'Token not enabled.',
+  TokenTransferFailed: 'Transfer of token {0} failed.',
   TokenTransferPolicyNotSet: 'Token transfer policy not set.',
   TooManyOwners: 'Too many owners.',
   TooManyWithdrawalsThisBlock: 'Too many withdrawals this block.',
@@ -327,6 +358,7 @@ export const messages: Record<AbiErrorName, string> = {
   Unauthorized: 'Unauthorized.',
   UnauthorizedCaller: 'Unauthorized caller.',
   UnauthorizedClaimer: 'Unauthorized claimer.',
+  UnauthorizedMultisigCaller: 'Unauthorized multisig caller.',
   UnexpectedAssetsReceived: 'Unexpected assets received. Expected {0}, got {1}.',
   UnexpectedEarnShares: 'Unexpected earn shares. Reported: {0}, measured: {1}.',
   UnexpectedRetainedAssets: 'Unexpected assets retained. Balance before: {0}, after: {1}.',
@@ -334,6 +366,8 @@ export const messages: Record<AbiErrorName, string> = {
   UnexpectedVenueSharesQueued: 'Unexpected venue shares queued. Expected {0}, got {1}.',
   Uninitialized: 'Uninitialized.',
   UnsupportedAccountantFreshness: 'Accountant {0} does not support freshness checks.',
+  UnsupportedDecimals: 'Unsupported decimals: base {0}, quote {1}, oracle {2}.',
+  UnsupportedToken: 'Token {0} is not supported.',
   UnsupportedTransferPolicy: 'Transfer policy {0} has unsupported type {1}.',
   ValidatorAlreadyDeactivated: 'Validator is already deactivated.',
   ValidatorAlreadyExists: 'Validator already exists.',
@@ -352,8 +386,10 @@ export const messages: Record<AbiErrorName, string> = {
   ZeroMinimumAssets: 'Minimum assets cannot be zero.',
   ZeroMinimumEarnShares: 'Minimum earn shares cannot be zero.',
   ZeroMinimumEngineShares: 'Minimum engine shares cannot be zero.',
+  ZeroMinimumQueuedAssets: 'Minimum queued assets cannot be zero.',
   ZeroPublicKey: 'Public key cannot be zero.',
   ZeroRoot: 'Root cannot be zero.',
+  ZeroSettlementId: 'Settlement ID cannot be zero.',
   ZeroStatementHash: 'Statement hash cannot be zero.',
 }
 

package/src/core/Provider.localnet.test.ts

@@ -1112,6 +1112,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
         {
           "contractAddress": null,
           "feeToken": "0x20c0000000000000000000000000000000000000",
+          "multisig": undefined,
           "status": "success",
           "to": "0x20c0000000000000000000000000000000000000",
           "type": "0x76",
@@ -1389,7 +1390,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
           from:  0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
 
         Details: plain send failure
-        Version: viem@2.56.0]
+        Version: viem@2.56.9]
       `)
     })
   })

package/src/core/adapters/deviceCode/deviceCode.localnet.test.ts

@@ -1,4 +1,5 @@
 import { Hex } from 'ox'
+import { SignatureEnvelope } from 'ox/tempo'
 import { describe, expect, test } from 'vp/test'
 import type { DeviceCode } from 'wata'
 
@@ -61,7 +62,9 @@ describe('deviceCode', () => {
       const keyAuthorization = account.capabilities.keyAuthorization
         ? {
             ...account.capabilities.keyAuthorization,
-            signature: { type: account.capabilities.keyAuthorization.signature.type },
+            signature: {
+              type: SignatureEnvelope.fromRpc(account.capabilities.keyAuthorization.signature).type,
+            },
           }
         : undefined
 

package/src/core/adapters/privy.test.ts

@@ -402,7 +402,7 @@ describe('privy', () => {
 
       Docs: https://viem.sh/docs/contract/writeContract
       Details: execution reverted
-      Version: viem@2.56.0]
+      Version: viem@2.56.9]
     `)
 
     expect(store.getState().accessKeys).toMatchInlineSnapshot(`

package/src/core/zod/rpc.ts

@@ -51,6 +51,7 @@ type KeyAuthorizationRpcDecoded = Omit<KeyAuthorization.Rpc, 'chainId' | 'expiry
   address?: KeyAuthorization.Rpc['keyId'] | undefined
   chainId: bigint
   expiry: number | null | undefined
+  keyType: z.output<typeof keyType>
   limits?:
     | readonly {
         token: KeyAuthorization.RpcTokenLimit['token']
@@ -133,7 +134,7 @@ export const keyAuthorization = z.codec(keyAuthorizationRpc, z.custom<KeyAuthori
       chainId: keyAuthorization.chainId === '0x' ? 0n : Hex.toBigInt(keyAuthorization.chainId),
       expiry: keyAuthorization.expiry == null ? null : Hex.toNumber(keyAuthorization.expiry),
       keyId: keyAuthorization.keyId,
-      keyType: keyAuthorization.keyType,
+      keyType: z.parse(keyType, keyAuthorization.keyType),
       limits: keyAuthorization.limits?.map(({ limit, period, token }) => ({
         token,
         limit: Hex.toBigInt(limit),

package/src/server/CliAuth.test.ts

@@ -1,5 +1,5 @@
 import { Base64, Hex } from 'ox'
-import { KeyAuthorization } from 'ox/tempo'
+import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
 import { createClient, custom, encodeErrorResult, encodeFunctionResult } from 'viem'
 import { Abis, Account as TempoAccount } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
@@ -89,6 +89,7 @@ async function authorize(
     code,
     keyAuthorization: z.decode(CliAuth.keyAuthorization, {
       ...keyAuthorization,
+      keyType: key.keyType,
       address: keyAuthorization.keyId,
     }),
   } satisfies z.output<typeof CliAuth.authorizeRequest>
@@ -126,6 +127,7 @@ async function authorizeWebAuthn(
     code,
     keyAuthorization: z.decode(CliAuth.keyAuthorization, {
       ...keyAuthorization,
+      keyType: key.keyType,
       address: keyAuthorization.keyId,
     }),
   } satisfies z.output<typeof CliAuth.authorizeRequest>
@@ -1199,7 +1201,7 @@ describe('poll', () => {
             keyAuthorization: {
               ...first.keyAuthorization,
               signature: {
-                type: first.keyAuthorization.signature.type,
+                type: SignatureEnvelope.fromRpc(first.keyAuthorization.signature).type,
               },
             },
           }
@@ -1727,7 +1729,7 @@ describe('authorize', () => {
         ? {
             ...polled.keyAuthorization,
             signature: {
-              type: polled.keyAuthorization.signature.type,
+              type: SignatureEnvelope.fromRpc(polled.keyAuthorization.signature).type,
             },
           }
         : undefined

package/src/server/CliAuth.ts

@@ -765,11 +765,12 @@ export function from(options: from.Options = {}): CliAuth {
       })
 
       const client = options.client ?? cache.get(current.chainId)
+      const signature = SignatureEnvelope.fromRpc(actual.signature)
       const valid = await verifyHash(client, {
         address: options.request.accountAddress,
         hash: TempoKeyAuthorization.getSignPayload(signed),
-        signature: SignatureEnvelope.serialize(SignatureEnvelope.fromRpc(actual.signature), {
-          magic: actual.signature.type === 'webAuthn',
+        signature: SignatureEnvelope.serialize(signature, {
+          magic: signature.type === 'webAuthn',
         }),
       })
       if (!valid) throw new Error('Key authorization signature is invalid.')
@@ -1258,11 +1259,12 @@ async function verifyKeyAuthorizationSignature(options: {
     ...(actual.limits ? { limits: actual.limits } : {}),
     type: actual.keyType,
   })
+  const signature = SignatureEnvelope.fromRpc(actual.signature)
   const valid = await verifyHash(options.client, {
     address: options.account,
     hash: TempoKeyAuthorization.getSignPayload(unsigned),
-    signature: SignatureEnvelope.serialize(SignatureEnvelope.fromRpc(actual.signature), {
-      magic: actual.signature.type === 'webAuthn',
+    signature: SignatureEnvelope.serialize(signature, {
+      magic: signature.type === 'webAuthn',
     }),
   })
   if (!valid) throw new Error('Key authorization signature is invalid.')

package/src/server/internal/handlers/relay.ts

@@ -26,7 +26,6 @@ import { type Handler, from } from '../../Handler.js'
 import * as Kv from '../../Kv.js'
 import { cached } from '../kv.js'
 import * as Tokenlist from '../tokenlist.js'
-import * as Multisig from './multisig.js'
 import * as Sponsorship from './sponsorship.js'
 import * as Utils from './utils.js'
 
@@ -84,7 +83,6 @@ export function relay(options: relay.Options = {}): Handler {
     ...rest
   } = options
   const feePayerOptions = options.feePayer
-  const multisigOptions = options.multisig
 
   // Resolves the verified tokenlist for `chainId`, sharing the KV cache with
   // `Handler.exchange` so a single `kv: Kv.cloudflare(env.KV)` covers both.
@@ -519,33 +517,6 @@ export function relay(options: relay.Options = {}): Handler {
       case 'eth_sendRawTransactionSync': {
         try {
           const serialized = params[0]
-          if (
-            multisigOptions &&
-            (request.method === 'eth_sendRawTransaction' ||
-              request.method === 'eth_sendRawTransactionSync') &&
-            typeof serialized === 'string' &&
-            Multisig.isMultisigTransaction(serialized as Hex.Hex)
-          ) {
-            const result = await Multisig.handleRawTransaction({
-              claimTtl: multisigOptions.claimTtl,
-              finalize: multisigOptions.finalize,
-              getClient,
-              method: request.method,
-              request: { params: 'params' in request ? request.params : undefined },
-              resolveConfig: multisigOptions.resolveConfig,
-              sponsor: feePayerOptions
-                ? {
-                    account: feePayerOptions.account,
-                    feeToken: feePayerOptions.feeToken,
-                    resolveFeeToken: async (chainId) => (await getTokens(chainId))[0],
-                    validate: feePayerOptions.validate,
-                  }
-                : undefined,
-              store: multisigOptions.store,
-            })
-            return RpcResponse.from({ result } as never, { request } as never)
-          }
-
           if (!feePayerOptions) {
             // eth_signRawTransaction is a signing method that only the
             // relay can fulfill — forwarding it to the RPC node returns
@@ -590,27 +561,6 @@ export function relay(options: relay.Options = {}): Handler {
         }
       }
 
-      case 'eth_getTransactionByHash':
-      case 'eth_getTransactionReceipt': {
-        try {
-          if (multisigOptions) {
-            const aliased = await Multisig.handleGetTransaction({
-              getClient,
-              method: request.method,
-              request: { params: 'params' in request ? request.params : undefined },
-              store: multisigOptions.store,
-            })
-            if (aliased)
-              return RpcResponse.from({ result: aliased.result } as never, { request } as never)
-          }
-
-          const result = await client.request(request as never)
-          return RpcResponse.from({ result }, { request })
-        } catch (error) {
-          return Utils.rpcErrorJson(request, error)
-        }
-      }
-
       default: {
         try {
           const result = await client.request(request as never)
@@ -696,12 +646,6 @@ export namespace relay {
           url?: string | undefined
         }
       | undefined
-    /**
-     * Native multisig configuration. When provided, the relay collects owner
-     * approvals from multisig raw transaction submissions and broadcasts once
-     * collected owner weight meets the configured threshold.
-     */
-    multisig?: Multisig.Options | undefined
     /**
      * Relay features.
      *

package/src/server/internal/handlers/sponsorship.ts

@@ -121,8 +121,7 @@ export async function handleRawTransaction(options: handleRawTransaction.Options
     })
 
   const transaction = Transaction.deserialize(serialized)
-  // Prefer sender recovered from raw envelope; multisig finalize path supplies fallback sender.
-  const sender = transaction.from ?? options.sender
+  const sender = transaction.from
 
   // Sponsorship only applies after sender has signed original transaction.
   if (!transaction.signature || !sender)
@@ -178,8 +177,6 @@ export declare namespace handleRawTransaction {
     method: 'eth_signRawTransaction' | 'eth_sendRawTransaction' | 'eth_sendRawTransactionSync'
     /** Incoming JSON-RPC request. */
     request: { params?: readonly unknown[] | undefined }
-    /** Sender address to use if it cannot be recovered from the raw envelope. */
-    sender?: Address | undefined
     /** Optional sponsorship approval callback. */
     validate?: ((request: Transaction.TransactionRequest) => boolean | Promise<boolean>) | undefined
   }

package/dist/server/internal/handlers/multisig.d.ts

@@ -1,214 +0,0 @@
-import { Hex } from 'ox';
-import { MultisigConfig } from 'ox/tempo';
-import type { Address, Client } from 'viem';
-import type { LocalAccount } from 'viem/accounts';
-import * as Sponsorship from './sponsorship.js';
-/** Default submission-claim TTL in milliseconds. */
-export declare const defaultClaimTtl = 30000;
-/** Returns whether a raw transaction carries a native multisig signature. */
-export declare function isMultisigTransaction(serialized: Hex.Hex): boolean;
-/** Handles a native multisig raw transaction submission. */
-export declare function handleRawTransaction(options: handleRawTransaction.Options): Promise<handleRawTransaction.ReturnType>;
-export declare namespace handleRawTransaction {
-    /** Options for handling a raw multisig transaction submission. */
-    type Options = collect.Options;
-    /** Raw transaction handler return value. */
-    type ReturnType = Hex.Hex | unknown;
-}
-declare function collect(options: collect.Options): Promise<collect.ReturnType>;
-/** Resolves a multisig operation id for standard transaction lookup methods. */
-export declare function handleGetTransaction(options: handleGetTransaction.Options): Promise<handleGetTransaction.ReturnType>;
-export declare namespace handleGetTransaction {
-    /** Options for resolving a multisig operation id through transaction lookup methods. */
-    type Options = {
-        /** Client resolver keyed by transaction `chainId`. */
-        getClient: (chainId?: number | undefined) => Client;
-        /** Standard transaction lookup method to handle. */
-        method: 'eth_getTransactionByHash' | 'eth_getTransactionReceipt';
-        /** Incoming JSON-RPC request. */
-        request: {
-            params?: readonly unknown[] | undefined;
-        };
-        /** Pending multisig operation store. */
-        store: Store;
-    };
-    /** Transaction lookup result wrapper. */
-    type ReturnType = {
-        result: unknown;
-    } | undefined;
-}
-declare namespace collect {
-    type Options = {
-        /** Submission claim TTL in milliseconds. @default 30000 */
-        claimTtl?: number | undefined;
-        /** How to broadcast once quorum is met. @default 'sync' */
-        finalize?: 'submitted' | 'sync' | undefined;
-        /** Client resolver keyed by transaction `chainId`. */
-        getClient: (chainId?: number | undefined) => Client;
-        /** Raw transaction method to handle. */
-        method: 'eth_sendRawTransaction' | 'eth_sendRawTransactionSync';
-        /** Incoming JSON-RPC request. */
-        request: {
-            params?: readonly unknown[] | undefined;
-        };
-        /** Resolves the genesis multisig config for quorum checks. */
-        resolveConfig?: ResolveConfig | undefined;
-        /** Optional fee payer used to sponsor finalized multisig transactions. */
-        sponsor?: Sponsor | undefined;
-        /** Pending multisig operation store. */
-        store: Store;
-    };
-    type ReturnType = {
-        /** Raw broadcast result once quorum is met and this caller claimed submission. */
-        broadcastResult?: unknown;
-        /** Structured operation claim status. */
-        status: ClaimSubmissionResult | {
-            operation: Operation;
-            status: 'claimed';
-        };
-    };
-}
-/** Returns a stored native multisig operation status. */
-export declare function getStatus(options: getStatus.Options): Promise<Status | null>;
-export declare namespace getStatus {
-    /** Options for reading one multisig operation status. */
-    type Options = {
-        /** Operation id returned by a pending multisig submission. */
-        id: Hex.Hex;
-        /** Resolves the genesis multisig config for quorum status. */
-        resolveConfig?: ResolveConfig | undefined;
-        /** Pending multisig operation store. */
-        store: Store;
-    };
-}
-/** Returns pending native multisig operation statuses for an account. */
-export declare function listStatuses(options: listStatuses.Options): Promise<readonly Status[]>;
-export declare namespace listStatuses {
-    /** Options for listing multisig operation statuses. */
-    type Options = {
-        /** Native multisig account address. */
-        account: Address;
-        /** Resolves the genesis multisig config for quorum status. */
-        resolveConfig?: ResolveConfig | undefined;
-        /** Pending multisig operation store. */
-        store: Store;
-    };
-}
-/** Creates an in-memory multisig operation store for development and tests only. */
-export declare function memoryStore(): Store;
-/** Native multisig relay options. */
-export type Options = {
-    /** Submission claim TTL in milliseconds. @default 30000 */
-    claimTtl?: number | undefined;
-    /** How to broadcast once quorum is met. @default 'sync' */
-    finalize?: 'submitted' | 'sync' | undefined;
-    /** Resolves the genesis multisig config for quorum checks. */
-    resolveConfig?: ResolveConfig | undefined;
-    /** Pending multisig operation store. */
-    store: Store;
-};
-/** Resolves the genesis multisig config for quorum checks. */
-export type ResolveConfig = (request: {
-    /** Native multisig account address. */
-    account: Address;
-    /** Transaction chain id. */
-    chainId: number;
-    /** Bootstrap config carried by the transaction, when present. */
-    init?: MultisigConfig.Config | undefined;
-}) => MultisigConfig.Config | Promise<MultisigConfig.Config | undefined> | undefined;
-/** Optional fee payer used to sponsor finalized multisig transactions. */
-export type Sponsor = {
-    /** Account used as the fee payer. */
-    account: LocalAccount;
-    /** Fee token to set before fee payer signing. */
-    feeToken?: Address | undefined;
-    /** Resolves the default fee token for raw sponsorship. */
-    resolveFeeToken?: ((chainId: number) => Address | Promise<Address | undefined> | undefined) | undefined;
-    /** Optional sponsorship approval callback. */
-    validate?: Sponsorship.handleRawTransaction.Options['validate'];
-};
-/** Storage for native multisig operation approvals and submission claims. */
-export type Store = {
-    /** Atomically claims submission for a quorum-ready operation. Only a `claimed` result may broadcast. */
-    claimSubmission: (operation: Operation, options: claimSubmission.Options) => Promise<ClaimSubmissionResult>;
-    /** Reads a stored operation. */
-    get: (id: Hex.Hex) => Promise<Operation | undefined>;
-    /** Lists non-submitted operations for a native multisig account address. */
-    listPendingByAddress: (address: Address) => Promise<readonly Operation[]>;
-    /** Saves a pending operation, preserving already-stored approvals. */
-    savePending: (operation: Operation) => Promise<Operation>;
-    /** Marks a claimed operation submitted with its real transaction hash. */
-    setSubmitted: (id: Hex.Hex, submittedHash: Hex.Hex) => Promise<Operation>;
-};
-/** `Store.claimSubmission` types. */
-export declare namespace claimSubmission {
-    /** Options for claiming submission. */
-    type Options = {
-        /** Claim TTL in milliseconds. */
-        ttl: number;
-    };
-}
-/** Result of atomically claiming a multisig operation for submission. */
-export type ClaimSubmissionResult = {
-    /** Operation this caller may broadcast. */
-    operation: Operation;
-    /** Claim status. */
-    status: 'claimed';
-} | {
-    /** Current stored operation. */
-    operation: Operation;
-    /** Current non-claimed status. */
-    status: 'pending' | 'submitting' | 'submitted';
-};
-/** Stored native multisig operation. */
-export type Operation = {
-    /** Native multisig account address. */
-    account: Address;
-    /** Transaction chain id. */
-    chainId: number;
-    /** Submission claim expiry timestamp in milliseconds. */
-    claimExpiresAt?: number | undefined;
-    /** Resolved genesis config used for approval checks. */
-    config?: MultisigConfig.Config | undefined;
-    /** Creation timestamp in milliseconds. */
-    createdAt: number;
-    /** Deterministic operation id. */
-    id: Hex.Hex;
-    /** Whether the finalized transaction must carry the genesis init config. */
-    init?: boolean | undefined;
-    /** Genesis init config to attach when finalizing a bootstrap transaction. */
-    initConfig?: MultisigConfig.Config | undefined;
-    /** Unsigned Tempo transaction sign payload. */
-    payload: Hex.Hex;
-    /** Collected owner approval signatures. */
-    signatures: readonly Hex.Hex[];
-    /** Operation state. */
-    status: 'pending' | 'submitting' | 'submitted';
-    /** Transaction hash once submitted. */
-    submittedHash?: Hex.Hex | undefined;
-    /** Last submitted serialized transaction carrying this operation. */
-    transaction: Hex.Hex;
-    /** Last update timestamp in milliseconds. */
-    updatedAt: number;
-};
-/** Native multisig operation status. */
-export type Status = {
-    /** Native multisig account address. */
-    account: Address;
-    /** Transaction chain id. */
-    chainId: number;
-    /** Deterministic operation id. */
-    id: Hex.Hex;
-    /** Number of collected owner approvals. */
-    signatures: number;
-    /** Operation state. */
-    status: Operation['status'];
-    /** Submitted transaction hash. */
-    submittedHash?: Hex.Hex | undefined;
-    /** Required owner weight. */
-    threshold?: number | undefined;
-    /** Collected owner weight. */
-    weight?: number | undefined;
-};
-export {};
-//# sourceMappingURL=multisig.d.ts.map