@0xsequence/relayer 2.3.39 → 3.0.0-beta.10

package/dist/relayer/standard/pk-relayer.js

@@ -0,0 +1,112 @@
+import { Address, Hex, Secp256k1, TransactionEnvelopeEip1559, TransactionReceipt } from 'ox';
+import { LocalRelayer } from './local.js';
+export class PkRelayer {
+    provider;
+    kind = 'relayer';
+    type = 'pk';
+    id = 'pk';
+    relayer;
+    constructor(privateKey, provider) {
+        this.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, data: args.data };
+                // 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) => {
+                const balanceHex = await this.provider.request({
+                    method: 'eth_getBalance',
+                    params: [address, 'latest'],
+                });
+                return BigInt(balanceHex);
+            },
+            call: async (args) => {
+                const callArgs = { to: args.to, data: args.data };
+                return await this.provider.request({ method: 'eth_call', params: [callArgs, 'latest'] });
+            },
+            getTransactionReceipt: async (txHash, chainId) => {
+                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, chainId) {
+        const providerChainId = Number(await this.provider.request({ method: 'eth_chainId' }));
+        return providerChainId === chainId;
+    }
+    feeTokens() {
+        return this.relayer.feeTokens();
+    }
+    feeOptions(wallet, chainId, calls) {
+        return this.relayer.feeOptions(wallet, chainId, calls);
+    }
+    async relay(to, data, 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');
+        }
+        return this.relayer.relay(to, data, chainId);
+    }
+    status(opHash, chainId) {
+        return this.relayer.status(opHash, chainId);
+    }
+    async checkPrecondition(precondition) {
+        // TODO: Implement precondition check
+        return true;
+    }
+}

package/dist/relayer/standard/sequence.d.ts

@@ -0,0 +1,27 @@
+import { TransactionPrecondition, FeeToken } from '../rpc-relayer/relayer.gen.js';
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Address, Hex } from 'ox';
+import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js';
+export declare class SequenceRelayer implements Relayer {
+    readonly kind: 'relayer';
+    readonly type = "sequence";
+    readonly id = "sequence";
+    private readonly service;
+    constructor(host: string);
+    isAvailable(_wallet: Address.Address, _chainId: number): Promise<boolean>;
+    feeTokens(): Promise<{
+        isFeeRequired: boolean;
+        tokens?: FeeToken[];
+        paymentAddress?: Address.Address;
+    }>;
+    feeOptions(wallet: Address.Address, _chainId: number, calls: Payload.Call[]): Promise<{
+        options: FeeOption[];
+        quote?: FeeQuote;
+    }>;
+    checkPrecondition(precondition: TransactionPrecondition): Promise<boolean>;
+    relay(to: Address.Address, data: Hex.Hex, _chainId: number, quote?: FeeQuote): Promise<{
+        opHash: Hex.Hex;
+    }>;
+    status(opHash: Hex.Hex, _chainId: number): Promise<OperationStatus>;
+}
+//# sourceMappingURL=sequence.d.ts.map

package/dist/relayer/standard/sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../../../src/relayer/standard/sequence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,uBAAuB,EAAsB,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AACnH,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AACvD,OAAO,EAAe,OAAO,EAAS,GAAG,EAAE,MAAM,IAAI,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC3E,qBAAa,eAAgB,YAAW,OAAO;IAC7C,SAAgB,IAAI,EAAE,SAAS,CAAY;IAC3C,SAAgB,IAAI,cAAa;IACjC,QAAQ,CAAC,EAAE,cAAa;IAExB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,IAAI,EAAE,MAAM;IAIlB,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIzE,SAAS,IAAI,OAAO,CAAC;QAAE,aAAa,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAC,OAAO,CAAA;KAAE,CAAC;IAgBvG,UAAU,CACd,MAAM,EAAE,OAAO,CAAC,OAAO,EACvB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,GACpB,OAAO,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,QAAQ,CAAA;KAAE,CAAC;IAehD,iBAAiB,CAAC,YAAY,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAK1E,KAAK,CAAC,EAAE,EAAE,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,GAAG,CAAC,GAAG,CAAA;KAAE,CAAC;IAW3G,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAuC1E"}

package/dist/relayer/standard/sequence.js

@@ -0,0 +1,84 @@
+import { ETHTxnStatus, Relayer as Service } from '../rpc-relayer/relayer.gen.js';
+import { Payload } from '@0xsequence/wallet-primitives';
+import { AbiFunction, Address, Bytes, Hex } from 'ox';
+export class SequenceRelayer {
+    kind = 'relayer';
+    type = 'sequence';
+    id = 'sequence';
+    service;
+    constructor(host) {
+        this.service = new Service(host, fetch);
+    }
+    async isAvailable(_wallet, _chainId) {
+        return true;
+    }
+    async feeTokens() {
+        const { isFeeRequired, tokens, paymentAddress } = await this.service.feeTokens();
+        if (isFeeRequired) {
+            Address.assert(paymentAddress);
+            return {
+                isFeeRequired,
+                tokens,
+                paymentAddress,
+            };
+        }
+        // Not required
+        return {
+            isFeeRequired,
+        };
+    }
+    async feeOptions(wallet, _chainId, calls) {
+        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) {
+        // TODO: implement
+        return false;
+    }
+    async relay(to, data, _chainId, quote) {
+        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,
+        });
+        return { opHash: `0x${txnHash}` };
+    }
+    async status(opHash, _chainId) {
+        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' };
+        }
+    }
+}

package/package.json

@@ -1,36 +1,39 @@
 {
   "name": "@0xsequence/relayer",
-  "version": "2.3.39",
+  "version": "3.0.0-beta.10",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "description": "relayer sub-package for Sequence",
-  "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/relayer",
-  "source": "src/index.ts",
-  "main": "dist/0xsequence-relayer.cjs.js",
-  "module": "dist/0xsequence-relayer.esm.js",
-  "author": "Horizon Blockchain Games",
+  "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/services/relayer",
+  "author": "Sequence Platforms Inc.",
   "license": "Apache-2.0",
-  "peerDependencies": {
-    "ethers": ">=6"
-  },
-  "dependencies": {
-    "@0xsequence/abi": "2.3.39",
-    "@0xsequence/core": "2.3.39",
-    "@0xsequence/utils": "2.3.39"
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "devDependencies": {
-    "@0xsequence/wallet-contracts": "^3.0.1",
-    "ethers": "6.13.4",
-    "@0xsequence/signhub": "2.3.39",
-    "@0xsequence/tests": "2.3.39"
+    "@types/node": "^25.0.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15",
+    "@repo/typescript-config": "^0.0.1-beta.1"
+  },
+  "dependencies": {
+    "mipd": "^0.0.7",
+    "ox": "^0.9.17",
+    "viem": "^2.40.3",
+    "@0xsequence/wallet-primitives": "^3.0.0-beta.10"
   },
-  "files": [
-    "src",
-    "dist"
-  ],
   "scripts": {
-    "test": "pnpm test:concurrently 'pnpm test:run'",
-    "test:run": "pnpm test:file tests/**/*.spec.ts",
-    "test:file": "NODE_OPTIONS='--import tsx' mocha --timeout 60000",
-    "test:concurrently": "concurrently -k --success first 'pnpm start:hardhat > /dev/null' ",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "old-test": "pnpm test:concurrently 'pnpm test:run'",
+    "old-test:run": "pnpm test:file tests/**/*.spec.ts",
+    "old-test:file": "NODE_OPTIONS='--import tsx' mocha --timeout 60000",
+    "old-test:concurrently": "concurrently -k --success first 'pnpm start:hardhat > /dev/null' ",
     "start:hardhat": "pnpm hardhat node --port 9547",
     "typecheck": "tsc --noEmit"
   }

package/src/index.ts

@@ -1,111 +1,3 @@
-import { ethers } from 'ethers'
-import { proto } from './rpc-relayer'
-
-import { commons } from '@0xsequence/core'
-
-export interface Relayer {
-  // simulate returns the execution results for a list of transactions.
-  simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>
-
-  // getFeeOptions returns the fee options that the relayer will accept as payment.
-  // If a quote is returned, it may be passed back to the relayer for dispatch.
-  getFeeOptions(
-    address: string,
-    ...transactions: commons.transaction.Transaction[]
-  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }>
-
-  // getFeeOptionsRaw returns the fee options that the relayer will accept as payment.
-  // If a quote is returned, it may be passed back to the relayer for dispatch.
-  // It doesn't make any assumptions about the transaction format.
-  getFeeOptionsRaw(
-    entrypoint: string,
-    data: ethers.BytesLike,
-    options?: {
-      simulate?: boolean
-    }
-  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }>
-
-  // gasRefundOptions returns the transactions which can be included to refund a
-  // relayer for submitting your transaction to a network.
-  gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>
-
-  // Gas tank sponsorship management
-  listGasSponsors(args: proto.ListGasSponsorsArgs): Promise<proto.ListGasSponsorsReturn>
-  addGasSponsor(args: proto.AddGasSponsorArgs): Promise<proto.AddGasSponsorReturn>
-  updateGasSponsor(args: proto.UpdateGasSponsorArgs): Promise<proto.UpdateGasSponsorReturn>
-  removeGasSponsor(args: proto.RemoveGasSponsorArgs): Promise<proto.RemoveGasSponsorReturn>
-
-  // getNonce returns the transaction count/nonce for a wallet, encoded with nonce space.
-  // If space is undefined, the relayer can choose a nonce space to encode the result with.
-  // Otherwise, the relayer must return a nonce encoded for the given nonce space.
-  getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish>
-
-  // relayer will submit the transaction(s) to the network and return the transaction response.
-  // The quote should be the one returned from getFeeOptions, if any.
-  // waitForReceipt must default to true.
-  relay(
-    signedTxs: commons.transaction.IntendedTransactionBundle,
-    quote?: FeeQuote,
-    waitForReceipt?: boolean,
-    projectAccessKey?: string
-  ): Promise<commons.transaction.TransactionResponse>
-
-  // wait for transaction confirmation
-  // timeout is the maximum time to wait for the transaction response
-  // delay is the polling interval, i.e. the time to wait between requests
-  // maxFails is the maximum number of hard failures to tolerate before giving up
-  wait(
-    metaTxnId: string | commons.transaction.SignedTransactionBundle,
-    timeout?: number,
-    delay?: number,
-    maxFails?: number
-  ): Promise<commons.transaction.TransactionResponse>
-
-  // getMetaTransactions returns a list of meta transactions for a given project and gas tank
-  getMetaTransactions(
-    projectId: number,
-    page?: proto.Page
-  ): Promise<{
-    page: proto.Page
-    transactions: proto.MetaTxnLog[]
-  }>
-
-  // getTransactionCost returns the used fee cost for gas tank during a given period
-  getTransactionCost(
-    projectId: number,
-    from: string,
-    to: string
-  ): Promise<{
-    cost: number
-  }>
-}
-
-export * from './local-relayer'
-export * from './provider-relayer'
-export * from './rpc-relayer'
-export { proto as RpcRelayerProto } from './rpc-relayer'
-export type SimulateResult = proto.SimulateResult
-export type FeeOption = proto.FeeOption
-
-// A fee quote is simply an opaque value that can be obtained via Relayer.getFeeOptions(), and
-// returned back to the same relayer via Relayer.relay(). Fee quotes should be treated as an
-// implementation detail of the relayer that produces them.
-//
-// This interface exists for type-safety purposes to protect against passing non-FeeQuotes to
-// Relayer.relay(), or any other functions that call it indirectly (e.g. Account.sendTransaction).
-export interface FeeQuote {
-  _tag: 'FeeQuote'
-  _quote: unknown
-}
-
-export function isRelayer(cand: any): cand is Relayer {
-  return (
-    typeof cand === 'object' &&
-    typeof cand.simulate === 'function' &&
-    typeof cand.getFeeOptions === 'function' &&
-    typeof cand.gasRefundOptions === 'function' &&
-    typeof cand.getNonce === 'function' &&
-    typeof cand.relay === 'function' &&
-    typeof cand.wait === 'function'
-  )
-}
+export * as Relayer from './relayer/index.js'
+export * as RpcRelayerGen from './relayer/rpc-relayer/relayer.gen.js'
+export * as Preconditions from './preconditions/index.js'

package/src/preconditions/codec.ts

@@ -0,0 +1,190 @@
+import { Address } from 'ox'
+import {
+  Precondition,
+  NativeBalancePrecondition,
+  Erc20BalancePrecondition,
+  Erc20ApprovalPrecondition,
+  Erc721OwnershipPrecondition,
+  Erc721ApprovalPrecondition,
+  Erc1155BalancePrecondition,
+  Erc1155ApprovalPrecondition,
+} from './types.js'
+
+export interface TransactionPrecondition {
+  type: string
+  chainId: number
+  ownerAddress: string
+  tokenAddress: string
+  minAmount: bigint
+}
+
+export function decodePreconditions(preconditions: TransactionPrecondition[]): Precondition[] {
+  const decodedPreconditions: Precondition[] = []
+
+  for (const p of preconditions) {
+    const decoded = decodePrecondition(p)
+    if (decoded) {
+      decodedPreconditions.push(decoded)
+    }
+  }
+
+  return decodedPreconditions
+}
+
+export function decodePrecondition(p: TransactionPrecondition): Precondition | undefined {
+  if (!p) {
+    return undefined
+  }
+
+  let precondition: Precondition | undefined
+
+  try {
+    switch (p.type) {
+      case 'native-balance':
+        precondition = new NativeBalancePrecondition(Address.from(p.ownerAddress), p.minAmount, undefined)
+        break
+
+      case 'erc20-balance':
+        precondition = new Erc20BalancePrecondition(
+          Address.from(p.ownerAddress),
+          Address.from(p.tokenAddress),
+          p.minAmount,
+          undefined,
+        )
+        break
+
+      case 'erc20-approval':
+        precondition = new Erc20ApprovalPrecondition(
+          Address.from(p.ownerAddress),
+          Address.from(p.tokenAddress),
+          Address.from(p.ownerAddress),
+          p.minAmount,
+        )
+        break
+
+      case 'erc721-ownership':
+        precondition = new Erc721OwnershipPrecondition(
+          Address.from(p.ownerAddress),
+          Address.from(p.tokenAddress),
+          BigInt(0),
+          true,
+        )
+        break
+
+      case 'erc721-approval':
+        precondition = new Erc721ApprovalPrecondition(
+          Address.from(p.ownerAddress),
+          Address.from(p.tokenAddress),
+          BigInt(0),
+          Address.from(p.ownerAddress),
+        )
+        break
+
+      case 'erc1155-balance':
+        precondition = new Erc1155BalancePrecondition(
+          Address.from(p.ownerAddress),
+          Address.from(p.tokenAddress),
+          BigInt(0),
+          p.minAmount,
+          undefined,
+        )
+        break
+
+      case 'erc1155-approval':
+        precondition = new Erc1155ApprovalPrecondition(
+          Address.from(p.ownerAddress),
+          Address.from(p.tokenAddress),
+          BigInt(0),
+          Address.from(p.ownerAddress),
+          p.minAmount,
+        )
+        break
+
+      default:
+        return undefined
+    }
+
+    const error = precondition.isValid()
+    if (error) {
+      console.warn(`Invalid precondition: ${error.message}`)
+      return undefined
+    }
+
+    return precondition
+  } catch (e) {
+    console.warn(`Failed to decode precondition: ${e}`)
+    return undefined
+  }
+}
+
+export function encodePrecondition(p: Precondition): string {
+  const data: any = {}
+
+  switch (p.type()) {
+    case 'native-balance': {
+      const native = p as NativeBalancePrecondition
+      data.address = native.address.toString()
+      if (native.min !== undefined) data.min = native.min.toString()
+      if (native.max !== undefined) data.max = native.max.toString()
+      break
+    }
+
+    case 'erc20-balance': {
+      const erc20 = p as Erc20BalancePrecondition
+      data.address = erc20.address.toString()
+      data.token = erc20.token.toString()
+      if (erc20.min !== undefined) data.min = erc20.min.toString()
+      if (erc20.max !== undefined) data.max = erc20.max.toString()
+      break
+    }
+
+    case 'erc20-approval': {
+      const erc20 = p as Erc20ApprovalPrecondition
+      data.address = erc20.address.toString()
+      data.token = erc20.token.toString()
+      data.operator = erc20.operator.toString()
+      data.min = erc20.min.toString()
+      break
+    }
+
+    case 'erc721-ownership': {
+      const erc721 = p as Erc721OwnershipPrecondition
+      data.address = erc721.address.toString()
+      data.token = erc721.token.toString()
+      data.tokenId = erc721.tokenId.toString()
+      if (erc721.owned !== undefined) data.owned = erc721.owned
+      break
+    }
+
+    case 'erc721-approval': {
+      const erc721 = p as Erc721ApprovalPrecondition
+      data.address = erc721.address.toString()
+      data.token = erc721.token.toString()
+      data.tokenId = erc721.tokenId.toString()
+      data.operator = erc721.operator.toString()
+      break
+    }
+
+    case 'erc1155-balance': {
+      const erc1155 = p as Erc1155BalancePrecondition
+      data.address = erc1155.address.toString()
+      data.token = erc1155.token.toString()
+      data.tokenId = erc1155.tokenId.toString()
+      if (erc1155.min !== undefined) data.min = erc1155.min.toString()
+      if (erc1155.max !== undefined) data.max = erc1155.max.toString()
+      break
+    }
+
+    case 'erc1155-approval': {
+      const erc1155 = p as Erc1155ApprovalPrecondition
+      data.address = erc1155.address.toString()
+      data.token = erc1155.token.toString()
+      data.tokenId = erc1155.tokenId.toString()
+      data.operator = erc1155.operator.toString()
+      data.min = erc1155.min.toString()
+      break
+    }
+  }
+
+  return JSON.stringify(data)
+}

package/src/preconditions/index.ts

@@ -0,0 +1,3 @@
+export * from './types.js'
+export * from './codec.js'
+export * from './selectors.js'

package/src/preconditions/selectors.ts

@@ -0,0 +1,38 @@
+import { Precondition, NativeBalancePrecondition, Erc20BalancePrecondition } from './types.js'
+import { TransactionPrecondition, decodePreconditions } from './codec.js'
+
+export function extractChainID(precondition: TransactionPrecondition): number | undefined {
+  if (!precondition) {
+    return undefined
+  }
+
+  return precondition.chainId
+}
+
+export function extractSupportedPreconditions(preconditions: TransactionPrecondition[]): Precondition[] {
+  if (!preconditions || preconditions.length === 0) {
+    return []
+  }
+
+  return decodePreconditions(preconditions)
+}
+
+export function extractNativeBalancePreconditions(
+  preconditions: TransactionPrecondition[],
+): NativeBalancePrecondition[] {
+  if (!preconditions || preconditions.length === 0) {
+    return []
+  }
+
+  const decoded = decodePreconditions(preconditions)
+  return decoded.filter((p): p is NativeBalancePrecondition => p.type() === 'native-balance')
+}
+
+export function extractERC20BalancePreconditions(preconditions: TransactionPrecondition[]): Erc20BalancePrecondition[] {
+  if (!preconditions || preconditions.length === 0) {
+    return []
+  }
+
+  const decoded = decodePreconditions(preconditions)
+  return decoded.filter((p): p is Erc20BalancePrecondition => p.type() === 'erc20-balance')
+}