@0xsequence/relayer 2.3.35 → 3.0.0-beta.2

package/src/relayer/standard/abi.ts

@@ -0,0 +1,13 @@
+import { AbiFunction } from 'ox'
+
+// ERC20 ABI functions
+export const erc20BalanceOf = AbiFunction.from('function balanceOf(address) returns (uint256)')
+export const erc20Allowance = AbiFunction.from('function allowance(address,address) returns (uint256)')
+
+// ERC721 ABI functions
+export const erc721OwnerOf = AbiFunction.from('function ownerOf(uint256) returns (address)')
+export const erc721GetApproved = AbiFunction.from('function getApproved(uint256) returns (address)')
+
+// ERC1155 ABI functions
+export const erc1155BalanceOf = AbiFunction.from('function balanceOf(address,uint256) returns (uint256)')
+export const erc1155IsApprovedForAll = AbiFunction.from('function isApprovedForAll(address,address) returns (bool)')

package/src/relayer/standard/eip6963.ts

@@ -0,0 +1,74 @@
+import { createStore, EIP6963ProviderInfo, EIP6963ProviderDetail } from 'mipd'
+import { EIP1193ProviderAdapter, LocalRelayer } from './local.js'
+import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js'
+import { Address, Hex } from 'ox'
+import { Payload } from '@0xsequence/wallet-primitives'
+import { FeeToken, TransactionPrecondition } from '../rpc-relayer/relayer.gen.js'
+
+export class EIP6963Relayer implements Relayer {
+  public readonly kind: 'relayer' = 'relayer'
+  public readonly type = 'eip6963'
+  public readonly id: string
+  public readonly info: EIP6963ProviderInfo
+  private readonly relayer: LocalRelayer
+
+  constructor(detail: EIP6963ProviderDetail) {
+    this.info = detail.info
+    this.id = detail.info.uuid
+
+    this.relayer = new LocalRelayer(new EIP1193ProviderAdapter(detail.provider))
+  }
+
+  isAvailable(wallet: Address.Address, chainId: number): Promise<boolean> {
+    return this.relayer.isAvailable(wallet, chainId)
+  }
+
+  feeTokens(): Promise<{ isFeeRequired: boolean; tokens?: FeeToken[]; paymentAddress?: Address.Address }> {
+    return this.relayer.feeTokens()
+  }
+
+  feeOptions(
+    wallet: Address.Address,
+    chainId: number,
+    calls: Payload.Call[],
+  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
+    return this.relayer.feeOptions(wallet, chainId, calls)
+  }
+
+  async relay(to: Address.Address, data: Hex.Hex, chainId: number, _?: FeeQuote): Promise<{ opHash: Hex.Hex }> {
+    return this.relayer.relay(to, data, chainId)
+  }
+
+  status(opHash: Hex.Hex, chainId: number): Promise<OperationStatus> {
+    return this.relayer.status(opHash, chainId)
+  }
+
+  async checkPrecondition(precondition: TransactionPrecondition): Promise<boolean> {
+    return this.relayer.checkPrecondition(precondition)
+  }
+}
+
+// Global store instance
+let store: ReturnType<typeof createStore> | undefined
+
+export function getEIP6963Store() {
+  if (!store) {
+    store = createStore()
+  }
+  return store
+}
+
+let relayers: Map<string, EIP6963Relayer> = new Map()
+
+export function getRelayers(): EIP6963Relayer[] {
+  const store = getEIP6963Store()
+  const providers = store.getProviders()
+
+  for (const detail of providers) {
+    if (!relayers.has(detail.info.uuid)) {
+      relayers.set(detail.info.uuid, new EIP6963Relayer(detail))
+    }
+  }
+
+  return Array.from(relayers.values())
+}

package/src/relayer/standard/index.ts

@@ -0,0 +1,4 @@
+export * from './local.js'
+export * from './pk-relayer.js'
+export * from './sequence.js'
+export * as EIP6963 from './eip6963.js'

package/src/relayer/standard/local.ts

@@ -0,0 +1,353 @@
+import { Constants, Payload } from '@0xsequence/wallet-primitives'
+import { EIP1193Provider } from 'mipd'
+import { AbiFunction, Address, Bytes, Hex, TransactionReceipt } from 'ox'
+import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js'
+import { FeeToken, TransactionPrecondition } from '../rpc-relayer/relayer.gen.js'
+import { decodePrecondition } from '../../preconditions/index.js'
+import {
+  erc20BalanceOf,
+  erc20Allowance,
+  erc721OwnerOf,
+  erc721GetApproved,
+  erc1155BalanceOf,
+  erc1155IsApprovedForAll,
+} from './abi.js'
+
+type GenericProviderTransactionReceipt = 'success' | 'failed' | 'unknown'
+
+export interface GenericProvider {
+  sendTransaction(args: { to: Address.Address; data: Hex.Hex }, chainId: number): Promise<string | undefined>
+  getBalance(address: Address.Address): Promise<bigint>
+  call(args: { to: Address.Address; data: Hex.Hex }): Promise<string>
+  getTransactionReceipt(txHash: Hex.Hex, chainId: number): Promise<GenericProviderTransactionReceipt>
+}
+
+export class LocalRelayer implements Relayer {
+  public readonly kind: 'relayer' = 'relayer'
+  public readonly type = 'local'
+  public readonly id = 'local'
+
+  constructor(public readonly provider: GenericProvider) {}
+
+  isAvailable(_wallet: Address.Address, _chainId: number): Promise<boolean> {
+    return Promise.resolve(true)
+  }
+
+  static createFromWindow(window: Window): LocalRelayer | undefined {
+    const eth = (window as any).ethereum
+    if (!eth) {
+      console.warn('Window.ethereum not found, skipping local relayer')
+      return undefined
+    }
+
+    return new LocalRelayer(new EIP1193ProviderAdapter(eth))
+  }
+
+  static createFromProvider(provider: EIP1193Provider): LocalRelayer {
+    return new LocalRelayer(new EIP1193ProviderAdapter(provider))
+  }
+
+  feeTokens(): Promise<{ isFeeRequired: boolean; tokens?: FeeToken[]; paymentAddress?: Address.Address }> {
+    return Promise.resolve({
+      isFeeRequired: false,
+    })
+  }
+
+  feeOptions(
+    wallet: Address.Address,
+    chainId: number,
+    calls: Payload.Call[],
+  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
+    return Promise.resolve({ options: [] })
+  }
+
+  private decodeCalls(data: Hex.Hex): Payload.Calls {
+    const executeSelector = AbiFunction.getSelector(Constants.EXECUTE)
+
+    let packedPayload
+    if (data.startsWith(executeSelector)) {
+      const decode = AbiFunction.decodeData(Constants.EXECUTE, data)
+      packedPayload = decode[0]
+    } else {
+      packedPayload = data
+    }
+
+    return Payload.decode(Bytes.fromHex(packedPayload))
+  }
+
+  async relay(
+    to: Address.Address,
+    data: Hex.Hex,
+    chainId: number,
+    quote?: FeeQuote,
+    preconditions?: TransactionPrecondition[],
+    checkInterval: number = 5000,
+  ): Promise<{ opHash: Hex.Hex }> {
+    // Helper function to check all preconditions
+    const checkAllPreconditions = async (): Promise<boolean> => {
+      if (!preconditions || preconditions.length === 0) {
+        return true
+      }
+
+      for (const precondition of preconditions) {
+        const isValid = await this.checkPrecondition(precondition)
+        if (!isValid) {
+          return false
+        }
+      }
+      return true
+    }
+
+    // Check preconditions immediately
+    if (await checkAllPreconditions()) {
+      // If all preconditions are met, relay the transaction
+      const txHash = await this.provider.sendTransaction(
+        {
+          to,
+          data,
+        },
+        chainId,
+      )
+
+      // TODO: Return the opHash instead, but solve the `status` function
+      // to properly fetch the receipt from an opHash instead of a txHash
+      return { opHash: txHash as Hex.Hex }
+    }
+
+    // If not all preconditions are met, set up event listeners and polling
+    return new Promise((resolve, reject) => {
+      let timeoutId: NodeJS.Timeout
+      let isResolved = false
+
+      // Function to check and relay
+      const checkAndRelay = async () => {
+        try {
+          if (isResolved) return
+
+          if (await checkAllPreconditions()) {
+            isResolved = true
+            clearTimeout(timeoutId)
+            const txHash = await this.provider.sendTransaction(
+              {
+                to,
+                data,
+              },
+              chainId,
+            )
+            resolve({ opHash: txHash as Hex.Hex })
+          } else {
+            // Schedule next check
+            timeoutId = setTimeout(checkAndRelay, checkInterval)
+          }
+        } catch (error) {
+          isResolved = true
+          clearTimeout(timeoutId)
+          reject(error)
+        }
+      }
+
+      // Start checking
+      timeoutId = setTimeout(checkAndRelay, checkInterval)
+
+      // Cleanup function
+      return () => {
+        isResolved = true
+        clearTimeout(timeoutId)
+      }
+    })
+  }
+
+  async status(opHash: Hex.Hex, chainId: number): Promise<OperationStatus> {
+    const receipt = await this.provider.getTransactionReceipt(opHash, chainId)
+    if (receipt === 'unknown') {
+      // Could be pending but we don't know
+      return { status: 'unknown' }
+    }
+    return receipt === 'success'
+      ? { status: 'confirmed', transactionHash: opHash }
+      : { status: 'failed', reason: 'failed' }
+  }
+
+  async checkPrecondition(precondition: TransactionPrecondition): Promise<boolean> {
+    const decoded = decodePrecondition(precondition)
+
+    if (!decoded) {
+      return false
+    }
+
+    switch (decoded.type()) {
+      case 'native-balance': {
+        const native = decoded as any
+        const balance = await this.provider.getBalance(native.address.toString())
+        if (native.min !== undefined && balance < native.min) {
+          return false
+        }
+        if (native.max !== undefined && balance > native.max) {
+          return false
+        }
+        return true
+      }
+
+      case 'erc20-balance': {
+        const erc20 = decoded as any
+        const data = AbiFunction.encodeData(erc20BalanceOf, [erc20.address.toString()])
+        const result = await this.provider.call({
+          to: erc20.token.toString(),
+          data,
+        })
+        const balance = BigInt(result)
+        if (erc20.min !== undefined && balance < erc20.min) {
+          return false
+        }
+        if (erc20.max !== undefined && balance > erc20.max) {
+          return false
+        }
+        return true
+      }
+
+      case 'erc20-approval': {
+        const erc20 = decoded as any
+        const data = AbiFunction.encodeData(erc20Allowance, [erc20.address.toString(), erc20.operator.toString()])
+        const result = await this.provider.call({
+          to: erc20.token.toString(),
+          data,
+        })
+        const allowance = BigInt(result)
+        return allowance >= erc20.min
+      }
+
+      case 'erc721-ownership': {
+        const erc721 = decoded as any
+        const data = AbiFunction.encodeData(erc721OwnerOf, [erc721.tokenId])
+        const result = await this.provider.call({
+          to: erc721.token.toString(),
+          data,
+        })
+        const owner = '0x' + result.slice(26)
+        const isOwner = owner.toLowerCase() === erc721.address.toString().toLowerCase()
+        return erc721.owned === undefined ? isOwner : erc721.owned === isOwner
+      }
+
+      case 'erc721-approval': {
+        const erc721 = decoded as any
+        const data = AbiFunction.encodeData(erc721GetApproved, [erc721.tokenId])
+        const result = await this.provider.call({
+          to: erc721.token.toString(),
+          data,
+        })
+        const approved = '0x' + result.slice(26)
+        return approved.toLowerCase() === erc721.operator.toString().toLowerCase()
+      }
+
+      case 'erc1155-balance': {
+        const erc1155 = decoded as any
+        const data = AbiFunction.encodeData(erc1155BalanceOf, [erc1155.address.toString(), erc1155.tokenId])
+        const result = await this.provider.call({
+          to: erc1155.token.toString(),
+          data,
+        })
+        const balance = BigInt(result)
+        if (erc1155.min !== undefined && balance < erc1155.min) {
+          return false
+        }
+        if (erc1155.max !== undefined && balance > erc1155.max) {
+          return false
+        }
+        return true
+      }
+
+      case 'erc1155-approval': {
+        const erc1155 = decoded as any
+        const data = AbiFunction.encodeData(erc1155IsApprovedForAll, [
+          erc1155.address.toString(),
+          erc1155.operator.toString(),
+        ])
+        const result = await this.provider.call({
+          to: erc1155.token.toString(),
+          data,
+        })
+        return BigInt(result) === 1n
+      }
+
+      default:
+        return false
+    }
+  }
+}
+
+export class EIP1193ProviderAdapter implements GenericProvider {
+  constructor(private readonly provider: EIP1193Provider) {}
+
+  private async trySwitchChain(chainId: number) {
+    try {
+      await this.provider.request({
+        method: 'wallet_switchEthereumChain',
+        params: [
+          {
+            chainId: `0x${chainId.toString(16)}`,
+          },
+        ],
+      })
+    } catch (error) {
+      // Log and continue
+      console.error('Error switching chain', error)
+    }
+  }
+
+  async sendTransaction(args: { to: Address.Address; data: Hex.Hex }, chainId: number) {
+    const accounts: Address.Address[] = await this.provider.request({ method: 'eth_requestAccounts' })
+    const from = accounts[0]
+
+    if (!from) {
+      console.warn('No account selected, skipping local relayer')
+      return undefined
+    }
+
+    await this.trySwitchChain(chainId)
+
+    const tx = await this.provider.request({
+      method: 'eth_sendTransaction',
+      params: [
+        {
+          from,
+          to: args.to,
+          data: args.data,
+        },
+      ],
+    })
+
+    return tx
+  }
+
+  async getBalance(address: Address.Address) {
+    const balance = await this.provider.request({
+      method: 'eth_getBalance',
+      params: [address, 'latest'],
+    })
+    return BigInt(balance)
+  }
+
+  async call(args: { to: Address.Address; data: Hex.Hex }) {
+    return await this.provider.request({
+      method: 'eth_call',
+      params: [args, 'latest'],
+    })
+  }
+
+  async getTransactionReceipt(txHash: Hex.Hex, chainId: number) {
+    await this.trySwitchChain(chainId)
+
+    const rpcReceipt = await this.provider.request({ method: 'eth_getTransactionReceipt', params: [txHash] })
+
+    if (rpcReceipt) {
+      const receipt = TransactionReceipt.fromRpc(rpcReceipt as any)
+      if (receipt?.status === 'success') {
+        return 'success'
+      } else if (receipt?.status === 'reverted') {
+        return 'failed'
+      }
+    }
+
+    return 'unknown'
+  }
+}

package/src/relayer/standard/pk-relayer.ts

@@ -0,0 +1,138 @@
+import { Payload, Precondition } from '@0xsequence/wallet-primitives'
+import { Address, Hex, Provider, Secp256k1, TransactionEnvelopeEip1559, TransactionReceipt } from 'ox'
+import { LocalRelayer } from './local.js'
+import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js'
+import { FeeToken } from '../rpc-relayer/relayer.gen.js'
+
+export class PkRelayer implements Relayer {
+  public readonly kind: 'relayer' = 'relayer'
+  public readonly type = 'pk'
+  public readonly id = 'pk'
+  private readonly relayer: LocalRelayer
+
+  constructor(
+    privateKey: Hex.Hex,
+    private readonly provider: Provider.Provider,
+  ) {
+    const relayerAddress = Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey }))
+    this.relayer = new LocalRelayer({
+      sendTransaction: async (args, chainId) => {
+        const providerChainId = Number(await this.provider.request({ method: 'eth_chainId' }))
+        if (providerChainId !== chainId) {
+          throw new Error('Provider chain id does not match relayer chain id')
+        }
+
+        const oxArgs = { ...args, to: args.to as `0x${string}`, data: args.data as `0x${string}` }
+        // Estimate gas with a safety buffer
+        const estimatedGas = BigInt(await this.provider.request({ method: 'eth_estimateGas', params: [oxArgs] }))
+        const safeGasLimit = estimatedGas > 21000n ? (estimatedGas * 12n) / 10n : 50000n
+
+        // Get base fee and priority fee
+        const baseFee = BigInt(await this.provider.request({ method: 'eth_gasPrice' }))
+        const priorityFee = 100000000n // 0.1 gwei priority fee
+        const maxFeePerGas = baseFee + priorityFee
+
+        // Check sender have enough balance
+        const senderBalance = BigInt(
+          await this.provider.request({ method: 'eth_getBalance', params: [relayerAddress, 'latest'] }),
+        )
+        if (senderBalance < maxFeePerGas * safeGasLimit) {
+          console.log('Sender balance:', senderBalance.toString(), 'wei')
+          throw new Error('Sender has insufficient balance to pay for gas')
+        }
+        const nonce = BigInt(
+          await this.provider.request({
+            method: 'eth_getTransactionCount',
+            params: [relayerAddress, 'latest'],
+          }),
+        )
+
+        // Build the relay envelope
+        const relayEnvelope = TransactionEnvelopeEip1559.from({
+          chainId: Number(chainId),
+          type: 'eip1559',
+          from: relayerAddress,
+          to: oxArgs.to,
+          data: oxArgs.data,
+          gas: safeGasLimit,
+          maxFeePerGas: maxFeePerGas,
+          maxPriorityFeePerGas: priorityFee,
+          nonce: nonce,
+          value: 0n,
+        })
+        const relayerSignature = Secp256k1.sign({
+          payload: TransactionEnvelopeEip1559.getSignPayload(relayEnvelope),
+          privateKey: privateKey,
+        })
+        const signedRelayEnvelope = TransactionEnvelopeEip1559.from(relayEnvelope, {
+          signature: relayerSignature,
+        })
+        const tx = await this.provider.request({
+          method: 'eth_sendRawTransaction',
+          params: [TransactionEnvelopeEip1559.serialize(signedRelayEnvelope)],
+        })
+        return tx
+      },
+      getBalance: async (address: string): Promise<bigint> => {
+        const balanceHex = await this.provider.request({
+          method: 'eth_getBalance',
+          params: [address as Address.Address, 'latest'],
+        })
+        return BigInt(balanceHex)
+      },
+      call: async (args: { to: string; data: string }): Promise<string> => {
+        const callArgs = { to: args.to as `0x${string}`, data: args.data as `0x${string}` }
+        return await this.provider.request({ method: 'eth_call', params: [callArgs, 'latest'] })
+      },
+      getTransactionReceipt: async (txHash: string, chainId: number) => {
+        Hex.assert(txHash)
+
+        const providerChainId = Number(await this.provider.request({ method: 'eth_chainId' }))
+        if (providerChainId !== chainId) {
+          throw new Error('Provider chain id does not match relayer chain id')
+        }
+
+        const rpcReceipt = await this.provider.request({ method: 'eth_getTransactionReceipt', params: [txHash] })
+        if (!rpcReceipt) {
+          return 'unknown'
+        }
+        const receipt = TransactionReceipt.fromRpc(rpcReceipt)
+        return receipt.status === 'success' ? 'success' : 'failed'
+      },
+    })
+  }
+
+  async isAvailable(_wallet: Address.Address, chainId: number): Promise<boolean> {
+    const providerChainId = Number(await this.provider.request({ method: 'eth_chainId' }))
+    return providerChainId === chainId
+  }
+
+  feeTokens(): Promise<{ isFeeRequired: boolean; tokens?: FeeToken[]; paymentAddress?: Address.Address }> {
+    return this.relayer.feeTokens()
+  }
+
+  feeOptions(
+    wallet: Address.Address,
+    chainId: number,
+    calls: Payload.Call[],
+  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
+    return this.relayer.feeOptions(wallet, chainId, calls)
+  }
+
+  async relay(to: Address.Address, data: Hex.Hex, chainId: number, _?: FeeQuote): Promise<{ opHash: Hex.Hex }> {
+    const providerChainId = Number(await this.provider.request({ method: 'eth_chainId' }))
+    if (providerChainId !== chainId) {
+      throw new Error('Provider chain id does not match relayer chain id')
+    }
+    return this.relayer.relay(to, data, chainId)
+  }
+
+  status(opHash: Hex.Hex, chainId: number): Promise<OperationStatus> {
+    return this.relayer.status(opHash, chainId)
+  }
+
+  async checkPrecondition(precondition: Precondition.Precondition): Promise<boolean> {
+    // TODO: Implement precondition check
+    return true
+  }
+}

package/src/relayer/standard/sequence.ts

@@ -0,0 +1,110 @@
+import { ETHTxnStatus, TransactionPrecondition, Relayer as Service, FeeToken } from '../rpc-relayer/relayer.gen.js'
+import { Payload } from '@0xsequence/wallet-primitives'
+import { AbiFunction, Address, Bytes, Hex } from 'ox'
+import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js'
+export class SequenceRelayer implements Relayer {
+  public readonly kind: 'relayer' = 'relayer'
+  public readonly type = 'sequence'
+  readonly id = 'sequence'
+
+  private readonly service: Service
+
+  constructor(host: string) {
+    this.service = new Service(host, fetch)
+  }
+
+  async isAvailable(_wallet: Address.Address, _chainId: number): Promise<boolean> {
+    return true
+  }
+
+  async feeTokens(): Promise<{ isFeeRequired: boolean; tokens?: FeeToken[]; paymentAddress?: Address.Address }> {
+    const { isFeeRequired, tokens, paymentAddress } = await this.service.feeTokens()
+    if (isFeeRequired) {
+      Address.assert(paymentAddress)
+      return {
+        isFeeRequired,
+        tokens,
+        paymentAddress,
+      }
+    }
+    // Not required
+    return {
+      isFeeRequired,
+    }
+  }
+
+  async feeOptions(
+    wallet: Address.Address,
+    _chainId: number,
+    calls: Payload.Call[],
+  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
+    const to = wallet // TODO: this might be the guest module
+    const execute = AbiFunction.from('function execute(bytes calldata _payload, bytes calldata _signature)')
+    const payload = Payload.encode({ type: 'call', space: 0n, nonce: 0n, calls }, to)
+    const signature = '0x0001' // TODO: use a stub signature
+    const data = AbiFunction.encodeData(execute, [Bytes.toHex(payload), signature])
+
+    const { options, quote } = await this.service.feeOptions({ wallet, to, data })
+
+    return {
+      options,
+      quote: quote ? { _tag: 'FeeQuote', _quote: quote } : undefined,
+    }
+  }
+
+  async checkPrecondition(precondition: TransactionPrecondition): Promise<boolean> {
+    // TODO: implement
+    return false
+  }
+
+  async relay(to: Address.Address, data: Hex.Hex, _chainId: number, quote?: FeeQuote): Promise<{ opHash: Hex.Hex }> {
+    const walletAddress = to // TODO: pass wallet address or stop requiring it
+
+    const { txnHash } = await this.service.sendMetaTxn({
+      call: { walletAddress, contract: to, input: data },
+      quote: quote && (quote._quote as string),
+    })
+
+    return { opHash: `0x${txnHash}` }
+  }
+
+  async status(opHash: Hex.Hex, _chainId: number): Promise<OperationStatus> {
+    try {
+      const {
+        receipt: { status, revertReason, txnReceipt },
+      } = await this.service.getMetaTxnReceipt({ metaTxID: opHash })
+
+      switch (status) {
+        case ETHTxnStatus.UNKNOWN:
+          return { status: 'unknown' }
+
+        case ETHTxnStatus.DROPPED:
+          return { status: 'failed', reason: revertReason ?? status }
+
+        case ETHTxnStatus.QUEUED:
+          return { status: 'pending' }
+
+        case ETHTxnStatus.SENT:
+          return { status: 'pending' }
+
+        case ETHTxnStatus.SUCCEEDED: {
+          const receipt = JSON.parse(txnReceipt)
+          const transactionHash = receipt.transactionHash
+          Hex.assert(transactionHash)
+          return { status: 'confirmed', transactionHash }
+        }
+
+        case ETHTxnStatus.PARTIALLY_FAILED:
+          return { status: 'failed', reason: revertReason ?? status }
+
+        case ETHTxnStatus.FAILED:
+          return { status: 'failed', reason: revertReason ?? status }
+
+        default:
+          throw new Error(`unknown transaction status '${status}'`)
+      }
+    } catch {
+      return { status: 'pending' }
+    }
+  }
+}