accounts 0.18.4 → 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

@@ -11,6 +11,9 @@ import {
 } from 'viem'
 import {
   getBalance,
+  getBlockNumber,
+  getLogs,
+  getTransactionReceipt,
   sendCalls,
   sendTransactionSync,
   signMessage,
@@ -1109,6 +1112,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
         {
           "contractAddress": null,
           "feeToken": "0x20c0000000000000000000000000000000000000",
+          "multisig": undefined,
           "status": "success",
           "to": "0x20c0000000000000000000000000000000000000",
           "type": "0x76",
@@ -1386,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]
       `)
     })
   })
@@ -2192,6 +2196,66 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
   })
 
   describe('wallet_revokeAccessKey', () => {
+    test('error: rejects an authorization for a different access key', async () => {
+      const provider = Provider.create({ adapter: adapter(), chains: [chain] })
+      await connect(provider)
+
+      const connected = (await provider.request({ method: 'eth_accounts' }))[0]!
+      const first = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+      const second = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+
+      await expect(
+        provider.request({
+          method: 'wallet_revokeAccessKey',
+          params: [
+            {
+              address: connected,
+              accessKeyAddress: first.keyAuthorization.address!,
+              keyAuthorization: second.keyAuthorization,
+            },
+          ],
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `[RpcResponse.InvalidParamsError: \`keyAuthorization\` must authorize \`accessKeyAddress\`.]`,
+      )
+    })
+
+    test('behavior: atomically authorizes and revokes an unpublished access key', async () => {
+      const provider = Provider.create({ adapter: adapter(), chains: [chain] })
+      await connect(provider)
+
+      const connected = (await provider.request({ method: 'eth_accounts' }))[0]!
+      await fund(connected)
+
+      const { keyAuthorization } = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+
+      await provider.request({
+        method: 'wallet_revokeAccessKey',
+        params: [
+          {
+            address: connected,
+            accessKeyAddress: keyAuthorization.address!,
+            keyAuthorization,
+          },
+        ],
+      })
+
+      const metadata = await Actions.accessKey.getMetadata(getClient(), {
+        account: connected,
+        accessKey: keyAuthorization.address!,
+      })
+      expect(metadata.isRevoked).toMatchInlineSnapshot(`true`)
+    })
+
     test('default: revokes a granted access key on-chain', async () => {
       const provider = Provider.create({ adapter: adapter(), chains: [chain] })
       await connect(provider)
@@ -3232,6 +3296,57 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
       expect((result.tx as { feePayerSignature?: unknown }).feePayerSignature).toBeDefined()
     })
 
+    test('behavior: feePayer URL sponsors wallet_revokeAccessKey', async () => {
+      const provider = Provider.create({ adapter: adapter(), chains: [chain] })
+      const connected = await connect(provider)
+      await fund(connected)
+      const { keyAuthorization } = await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+      await provider.request({
+        method: 'eth_sendTransactionSync',
+        params: [{ calls: [transferCall] }],
+      })
+
+      const rpc = getClient()
+      const blockNumber = await getBlockNumber(rpc)
+
+      await provider.request({
+        method: 'wallet_revokeAccessKey',
+        params: [
+          {
+            accessKeyAddress: keyAuthorization.address!,
+            address: connected,
+            feePayer: server.url,
+          },
+        ],
+      })
+
+      const logs = await getLogs(rpc, {
+        address: Addresses.accountKeychain,
+        fromBlock: blockNumber,
+        toBlock: 'latest',
+      })
+      const event = Actions.accessKey.revoke.extractEvent(logs)
+      const receipt = await getTransactionReceipt(rpc, { hash: event.transactionHash })
+      const metadata = await Actions.accessKey.getMetadata(rpc, {
+        account: connected,
+        accessKey: keyAuthorization.address!,
+      })
+      expect({
+        feePayer: receipt.feePayer,
+        isRevoked: metadata.isRevoked,
+        status: receipt.status,
+      }).toMatchInlineSnapshot(`
+        {
+          "feePayer": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+          "isRevoked": true,
+          "status": "success",
+        }
+      `)
+    })
+
     test('behavior: feePayer: true uses default from Provider.create', async () => {
       const provider = Provider.create({
         adapter: adapter({ feePayer: server.url }),

package/src/core/Provider.ts

@@ -558,28 +558,29 @@ export function create(options: create.Options = {}): create.ReturnType {
     })
   }
 
-  async function revokeAccessKey(parameters: {
-    address: Address.Address
-    accessKeyAddress: Address.Address
-  }) {
+  async function revokeAccessKey(parameters: Adapter.revokeAccessKey.Parameters) {
     const selected = await getAdapterAccount({ address: parameters.address })
+    const feePayer = parameters.feePayer
     const client = getWalletClient({
       account: selected.account,
+      feePayer: feePayer === true ? undefined : feePayer,
       transport: selected.transport,
     })
     if (selected.account.type === 'json-rpc') {
       await client.request({
         method: 'wallet_revokeAccessKey' as never,
-        params: [parameters] as never,
+        params: [z.encode(Rpc.wallet_revokeAccessKey.parameters, parameters)] as never,
       })
     } else {
       try {
-        await Actions.accessKey.revokeSync(getClient(), {
+        await Actions.accessKey.revokeSync(client, {
           account: selected.account as TempoAccount.Account,
           accessKey: parameters.accessKeyAddress,
+          ...(feePayer ? { feePayer: true as never } : {}),
+          ...(parameters.keyAuthorization ? { keyAuthorization: parameters.keyAuthorization } : {}),
         })
       } catch (error) {
-        if (!AccessKey.isUnavailableError(error)) throw error
+        if (typeof feePayer === 'string' || !AccessKey.isUnavailableError(error)) throw error
       }
     }
     store.accessKeys.remove({
@@ -677,6 +678,13 @@ export function create(options: create.Options = {}): create.ReturnType {
     parameters: Adapter.revokeAccessKey.Parameters,
     request: Pick<Rpc.wallet_revokeAccessKey.Encoded, 'method' | 'params'>,
   ) {
+    if (
+      parameters.keyAuthorization &&
+      !AddressUtil.isEqual(parameters.keyAuthorization.address, parameters.accessKeyAddress)
+    )
+      throw new RpcResponse.InvalidParamsError({
+        message: '`keyAuthorization` must authorize `accessKeyAddress`.',
+      })
     if (actions.revokeAccessKey) return await actions.revokeAccessKey(parameters, request)
     if (instance.getAccount) return await revokeAccessKey(parameters)
     unsupported('revokeAccessKey')
@@ -713,6 +721,12 @@ export function create(options: create.Options = {}): create.ReturnType {
     return url
   }
 
+  function resolveRevocationFeePayer(
+    feePayer: string | boolean | undefined,
+  ): Adapter.revokeAccessKey.Parameters['feePayer'] {
+    return resolveFeePayer(feePayer) ?? (feePayer === true ? true : undefined)
+  }
+
   function stripAuthorizeAccessKey(
     parameters: create.AuthorizeAccessKeyParameters,
   ): Adapter.authorizeAccessKey.Parameters {
@@ -1608,7 +1622,10 @@ export function create(options: create.Options = {}): create.ReturnType {
                   case 'wallet_revokeAccessKey': {
                     assertConnected()
                     const [decoded] = request._decoded.params
-                    await revokeAccessKeyAction({ ...decoded }, request)
+                    await revokeAccessKeyAction(
+                      { ...decoded, feePayer: resolveRevocationFeePayer(decoded.feePayer) },
+                      request,
+                    )
                     return
                   }
 

package/src/core/Schema.test-d.ts

@@ -1,4 +1,5 @@
 import type { RpcSchema } from 'ox'
+import type { KeyAuthorization } from 'ox/tempo'
 import type { Hex } from 'viem'
 import { describe, expectTypeOf, test } from 'vp/test'
 
@@ -309,6 +310,19 @@ describe('Request', () => {
     expectTypeOf<SwitchChain['params']>().toEqualTypeOf<readonly [{ chainId: number }]>()
   })
 
+  test('wallet_revokeAccessKey supports app-provided fee sponsorship', () => {
+    expectTypeOf<Rpc.wallet_revokeAccessKey.Decoded['params']>().toEqualTypeOf<
+      readonly [
+        {
+          accessKeyAddress: Hex
+          address: Hex
+          feePayer?: boolean | string | undefined
+          keyAuthorization?: KeyAuthorization.Signed | undefined
+        },
+      ]
+    >()
+  })
+
   test('eth_accounts has no params', () => {
     type EthAccounts = Extract<Schema.Request, { method: 'eth_accounts' }>
     expectTypeOf<EthAccounts>().not.toHaveProperty('params')

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

@@ -1,5 +1,5 @@
 import { Address as core_Address, Hex, Secp256k1, Signature } from 'ox'
-import { decodeFunctionData } from 'viem'
+import { BaseError, decodeFunctionData } from 'viem'
 import type { Address } from 'viem/accounts'
 import { Abis } from 'viem/tempo'
 import { describe, expect, test } from 'vp/test'
@@ -323,6 +323,140 @@ describe('privy', () => {
     expect(store.getState().accessKeys).toMatchInlineSnapshot(`[]`)
   })
 
+  test('behavior: revokeAccessKey forwards a fee payer URL', async () => {
+    const { adapter, client, store } = setup()
+    store.setState({ accounts: [{ address }], activeAccount: 0 })
+
+    await adapter.actions.revokeAccessKey!(
+      { accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' },
+      {
+        method: 'wallet_revokeAccessKey',
+        params: [{ accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' }],
+      },
+    )
+
+    expect({
+      clientOptions: client.clientOptions,
+      transactions: client.transactions,
+    }).toMatchInlineSnapshot(`
+      {
+        "clientOptions": [
+          {
+            "feePayer": "https://example.com/fee-payer",
+          },
+        ],
+        "transactions": [
+          {
+            "account": {
+              "address": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+              "sign": [Function],
+              "signTransaction": [Function],
+              "source": "privy",
+              "type": "local",
+            },
+            "data": "0x5ae7ab320000000000000000000000002b5ad5c4795c026514f8317c7a215e218dccd6cf",
+            "feePayer": true,
+            "to": "0xaAAAaaAA00000000000000000000000000000000",
+          },
+        ],
+      }
+    `)
+  })
+
+  test('error: revokeAccessKey preserves local state on external fee payer errors', async () => {
+    const transactionError = new BaseError('revoke failed', {
+      cause: Object.assign(new Error('execution reverted'), {
+        data: { errorName: 'KeyAlreadyRevoked' },
+      }),
+    })
+    const { adapter, store } = setup({ transactionError })
+    store.setState({
+      accounts: [{ address }],
+      activeAccount: 0,
+      accessKeys: [
+        {
+          access: address,
+          address: other,
+          chainId: 1,
+          keyType: 'secp256k1',
+        } as never,
+      ],
+    })
+
+    await expect(
+      adapter.actions.revokeAccessKey!(
+        { accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' },
+        {
+          method: 'wallet_revokeAccessKey',
+          params: [{ accessKeyAddress: other, address, feePayer: 'https://example.com/fee-payer' }],
+        },
+      ),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      [ContractFunctionExecutionError: revoke failed
+
+      Contract Call:
+        address:   0xaAAAaaAA00000000000000000000000000000000
+        function:  revokeKey(address keyId)
+        args:               (0x2b5ad5c4795c026514f8317c7a215e218dccd6cf)
+        sender:    0x7e5f4552091a69125d5dfcb7b8c2659029395bdf
+
+      Docs: https://viem.sh/docs/contract/writeContract
+      Details: execution reverted
+      Version: viem@2.56.9]
+    `)
+
+    expect(store.getState().accessKeys).toMatchInlineSnapshot(`
+      [
+        {
+          "access": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+          "address": "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
+          "chainId": 1,
+          "keyType": "secp256k1",
+        },
+      ]
+    `)
+  })
+
+  test('behavior: revokeAccessKey forwards default fee sponsorship', async () => {
+    const { adapter, client, store } = setup()
+    store.setState({ accounts: [{ address }], activeAccount: 0 })
+
+    await adapter.actions.revokeAccessKey!(
+      { accessKeyAddress: other, address, feePayer: true },
+      {
+        method: 'wallet_revokeAccessKey',
+        params: [{ accessKeyAddress: other, address, feePayer: true }],
+      },
+    )
+
+    expect({
+      clientOptions: client.clientOptions,
+      transactions: client.transactions,
+    }).toMatchInlineSnapshot(`
+      {
+        "clientOptions": [
+          {
+            "feePayer": undefined,
+          },
+        ],
+        "transactions": [
+          {
+            "account": {
+              "address": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+              "sign": [Function],
+              "signTransaction": [Function],
+              "source": "privy",
+              "type": "local",
+            },
+            "data": "0x5ae7ab320000000000000000000000002b5ad5c4795c026514f8317c7a215e218dccd6cf",
+            "feePayer": true,
+            "to": "0xaAAAaaAA00000000000000000000000000000000",
+          },
+        ],
+      }
+    `)
+  })
+
   test('behavior: signing silently restores wallet accounts via the Privy SDK', async () => {
     const { adapter, client, store } = setup()
     store.setState({ accounts: [{ address }], activeAccount: 0 })
@@ -642,13 +776,17 @@ function setup(options: setup.Options = {}) {
     getAccount: (() => {
       throw new Error('not implemented')
     }) as never,
-    getClient: (() => ({
-      chain: { id: 1 },
-      sendTransaction: async (parameters: unknown) => {
-        client.transactions.push(parameters)
-        return Hex.padLeft('0x1', 32)
-      },
-    })) as never,
+    getClient: ((clientOptions: unknown) => {
+      client.clientOptions.push(clientOptions)
+      return {
+        chain: { id: 1 },
+        sendTransaction: async (parameters: unknown) => {
+          client.transactions.push(parameters)
+          if (options.transactionError) throw options.transactionError
+          return Hex.padLeft('0x1', 32)
+        },
+      }
+    }) as never,
     storage,
     store,
   })
@@ -675,6 +813,8 @@ declare namespace setup {
     restoreError?: unknown
     token?: string | null | undefined
     signError?: unknown
+    /** Make the mock wallet client transaction fail. */
+    transactionError?: unknown
     /** Override the value returned by the embedded provider's `secp256k1_sign`. */
     signResult?: unknown
     /** Force the test wallet to sign with this private key (for wrong-signer tests). */
@@ -683,6 +823,7 @@ declare namespace setup {
 }
 
 type MockClient = privy.Client & {
+  clientOptions: unknown[]
   createCalls: number
   initCalls: number
   loadCalls: number
@@ -699,6 +840,7 @@ type MockClient = privy.Client & {
 
 function createClient(options: setup.Options = {}) {
   const client: MockClient = {
+    clientOptions: [] as unknown[],
     createCalls: 0,
     initCalls: 0,
     loadCalls: 0,