Add local relayer with pk

Author: ScreamingHawk

packages/wallet/core/src/relayer/index.ts

@@ -1,2 +1,3 @@
 export * from './relayer'
 export * as Local from './local'
+export * as Pk from './pk-relayer'

packages/wallet/core/src/relayer/local.ts

@@ -1,6 +1,6 @@
+import { Constants, Payload } from '@0xsequence/wallet-primitives'
 import { AbiFunction, Address, Bytes, Hex } from 'ox'
 import { FeeOption, FeeQuote, OperationStatus, Relayer } from './relayer'
-import { Constants, Payload } from '@0xsequence/wallet-primitives'
 
 export interface GenericProvider {
   sendTransaction(args: { to: string; data: string }): Promise<string>

packages/wallet/core/src/relayer/pk-relayer.ts

@@ -0,0 +1,91 @@
+import { Payload } from '@0xsequence/wallet-primitives'
+import { Address, Hex, Provider, Secp256k1, TransactionEnvelopeEip1559 } from 'ox'
+import { LocalRelayer } from './local'
+import { FeeOption, FeeQuote, OperationStatus, Relayer } from './relayer'
+
+export class PkRelayer implements Relayer {
+  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) => {
+        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 chainId = BigInt(await this.provider.request({ method: 'eth_chainId' }))
+        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
+      },
+    })
+  }
+
+  feeOptions(
+    wallet: Address.Address,
+    chainId: bigint,
+    calls: Payload.Call[],
+  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
+    return this.relayer.feeOptions(wallet, chainId, calls)
+  }
+
+  async relay(to: Address.Address, data: Hex.Hex, chainId: bigint, _?: FeeQuote): Promise<{ opHash: Hex.Hex }> {
+    const providerChainId = BigInt(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: bigint): Promise<OperationStatus> {
+    return this.relayer.status(opHash, chainId)
+  }
+}

packages/wallet/core/src/relayer/relayer.ts

@@ -1,5 +1,5 @@
 import { Payload } from '@0xsequence/wallet-primitives'
-import { Address, Bytes, Hex } from 'ox'
+import { Address, Hex } from 'ox'
 
 export interface FeeOption {
   token: Address.Address