@gelatocloud/gasless 0.0.0 → 0.0.3

package/bundler/actions/sendUserOperation.ts

@@ -1,64 +0,0 @@
-import type { BaseError, Chain, Client, Transport } from 'viem';
-import {
-  formatUserOperationRequest,
-  getUserOperationError,
-  type PrepareUserOperationParameters,
-  type SendUserOperationParameters,
-  type SendUserOperationReturnType,
-  type SmartAccount,
-  type UserOperation
-} from 'viem/account-abstraction';
-import { parseAccount } from 'viem/accounts';
-import type { CapabilitiesByChain } from '../../relayer/evm/actions/index.js';
-import { AccountNotFoundError, type Payment } from '../../types/index.js';
-import { prepareUserOperation } from './prepareUserOperation.js';
-
-export const sendUserOperation = async <account extends SmartAccount | undefined>(
-  client: Client<Transport, Chain | undefined, account>,
-  parameters: SendUserOperationParameters,
-  capabilities: CapabilitiesByChain,
-  payment?: Payment
-): Promise<SendUserOperationReturnType> => {
-  const { account: account_ = client.account, entryPointAddress } = parameters;
-
-  if (!account_ && !parameters.sender) throw new AccountNotFoundError();
-  const account = account_ ? parseAccount(account_) : undefined;
-
-  const request = account
-    ? await prepareUserOperation(
-        client,
-        parameters as unknown as PrepareUserOperationParameters,
-        capabilities,
-        payment,
-        true
-      )
-    : parameters;
-
-  // biome-ignore lint/style/noNonNullAssertion: copied from viem
-  const signature = (parameters.signature ||
-    (await account?.signUserOperation?.(request as UserOperation)))!;
-
-  const rpcParameters = formatUserOperationRequest({
-    ...request,
-    signature
-  } as UserOperation);
-
-  try {
-    return await client.request(
-      {
-        method: 'eth_sendUserOperation',
-        // biome-ignore lint/style/noNonNullAssertion: copied from viem
-        params: [rpcParameters, (entryPointAddress ?? account?.entryPoint?.address)!]
-      },
-      { retryCount: 0 }
-    );
-  } catch (error) {
-    // biome-ignore lint/suspicious/noExplicitAny: copied from viem
-    const calls = (parameters as any).calls;
-    throw getUserOperationError(error as BaseError, {
-      ...(request as UserOperation),
-      ...(calls ? { calls } : {}),
-      signature
-    });
-  }
-};

package/bundler/actions/sendUserOperationSync.ts

@@ -1,71 +0,0 @@
-import type { BaseError, Chain, Client, Transport } from 'viem';
-import {
-  formatUserOperationReceipt,
-  formatUserOperationRequest,
-  getUserOperationError,
-  type PrepareUserOperationParameters,
-  type SendUserOperationParameters,
-  type SmartAccount,
-  type UserOperation,
-  type UserOperationReceipt
-} from 'viem/account-abstraction';
-import { parseAccount } from 'viem/accounts';
-import type { CapabilitiesByChain } from '../../relayer/evm/actions/index.js';
-import { AccountNotFoundError, type Payment } from '../../types/index.js';
-import { prepareUserOperation } from './prepareUserOperation.js';
-
-export type SendUserOperationSyncParameters = SendUserOperationParameters & {
-  timeout: number;
-};
-
-export const sendUserOperationSync = async <account extends SmartAccount | undefined>(
-  client: Client<Transport, Chain | undefined, account>,
-  parameters: SendUserOperationSyncParameters,
-  capabilities: CapabilitiesByChain,
-  payment?: Payment
-): Promise<UserOperationReceipt> => {
-  const { account: account_ = client.account, entryPointAddress, timeout } = parameters;
-
-  if (!account_ && !parameters.sender) throw new AccountNotFoundError();
-  const account = account_ ? parseAccount(account_) : undefined;
-
-  const request = account
-    ? await prepareUserOperation(
-        client,
-        parameters as unknown as PrepareUserOperationParameters,
-        capabilities,
-        payment,
-        true
-      )
-    : parameters;
-
-  // biome-ignore lint/style/noNonNullAssertion: copied from viem
-  const signature = (parameters.signature ||
-    (await account?.signUserOperation?.(request as UserOperation)))!;
-
-  const rpcParameters = formatUserOperationRequest({
-    ...request,
-    signature
-  } as UserOperation);
-
-  try {
-    const receipt = await client.request(
-      {
-        method: 'eth_sendUserOperationSync',
-        // biome-ignore lint/style/noNonNullAssertion: copied from viem
-        params: [rpcParameters, (entryPointAddress ?? account?.entryPoint?.address)!, { timeout }]
-      } as never,
-      { retryCount: 0 }
-    );
-
-    return formatUserOperationReceipt(receipt);
-  } catch (error) {
-    // biome-ignore lint/suspicious/noExplicitAny: copied from viem
-    const calls = (parameters as any).calls;
-    throw getUserOperationError(error as BaseError, {
-      ...(request as UserOperation),
-      ...(calls ? { calls } : {}),
-      signature
-    });
-  }
-};

package/bundler/index.ts

@@ -1,98 +0,0 @@
-import { type Chain, type Client, http, type Transport } from 'viem';
-import {
-  type BundlerActions,
-  type BundlerClient,
-  type BundlerClientConfig,
-  createBundlerClient,
-  type UserOperationReceipt
-} from 'viem/account-abstraction';
-import { GELATO_PROD_API, GELATO_STAGING_API } from '../relayer/constants/index.js';
-import { getCapabilities } from '../relayer/evm/actions/index.js';
-import { type Payment, PaymentType } from '../types/index.js';
-import {
-  estimateUserOperationGas,
-  type GetUserOperationGasPriceReturnType,
-  type GetUserOperationQuoteParameters,
-  type GetUserOperationQuoteReturnType,
-  getUserOperationGasPrice,
-  getUserOperationQuote,
-  prepareUserOperation,
-  type SendUserOperationSyncParameters,
-  sendUserOperation,
-  sendUserOperationSync
-} from './actions/index.js';
-
-export * from './actions/index.js';
-
-export type GelatoBundlerActions = Partial<BundlerActions> & {
-  sendUserOperationSync: (
-    parameters: SendUserOperationSyncParameters
-  ) => Promise<UserOperationReceipt>;
-  getUserOperationGasPrice: () => Promise<GetUserOperationGasPriceReturnType>;
-  getUserOperationQuote: (
-    parameters: GetUserOperationQuoteParameters
-  ) => Promise<GetUserOperationQuoteReturnType>;
-};
-
-export type GelatoBundlerClient = BundlerClient & GelatoBundlerActions;
-
-export type GelatoBundlerClientConfig = Omit<BundlerClientConfig, 'transport' | 'userOperation'> & {
-  client: Client<Transport, Chain>;
-  payment?: Payment;
-  apiKey: string;
-};
-
-export const createGelatoBundlerClient = async (
-  parameters: GelatoBundlerClientConfig
-): Promise<GelatoBundlerClient> => {
-  const { client: client_, payment, apiKey } = parameters;
-
-  // TODO: can just use prod endpoint in the future
-  const base = client_.chain.testnet ? GELATO_STAGING_API : GELATO_PROD_API;
-
-  let endpoint = `${base}/rpc/${client_.chain.id}`;
-
-  if (payment) {
-    endpoint += `?payment=${payment.type}`;
-
-    if (payment.type === PaymentType.Token) {
-      endpoint += `&address=${payment.address}`;
-    }
-  }
-
-  const transport = http(endpoint, {
-    fetchOptions: {
-      headers: {
-        'X-API-Key': apiKey
-      }
-    }
-  });
-
-  const client = createBundlerClient({
-    ...parameters,
-    transport
-  });
-
-  const capabilities = (await getCapabilities(transport({})))[client_.chain.id];
-
-  if (!capabilities) {
-    throw new Error(`Chain not supported: ${client_.chain.id}`);
-  }
-
-  return client.extend(
-    (client) =>
-      ({
-        estimateUserOperationGas: (parameters) =>
-          estimateUserOperationGas(client, parameters, capabilities, payment),
-        getUserOperationGasPrice: () => getUserOperationGasPrice(client, payment),
-        getUserOperationQuote: (parameters) =>
-          getUserOperationQuote(client, parameters, capabilities, payment),
-        prepareUserOperation: (parameters) =>
-          prepareUserOperation(client, parameters, capabilities, payment),
-        sendUserOperation: (parameters) =>
-          sendUserOperation(client, parameters, capabilities, payment),
-        sendUserOperationSync: (parameters) =>
-          sendUserOperationSync(client, parameters, capabilities, payment)
-      }) as GelatoBundlerActions
-  ) as unknown as GelatoBundlerClient;
-};

package/index.ts

@@ -1,4 +0,0 @@
-export * from './account/index.js';
-export * from './bundler/index.js';
-export * from './relayer/index.js';
-export * from './types/index.js';

package/relayer/constants/index.ts

@@ -1,2 +0,0 @@
-export const GELATO_PROD_API = 'https://api.gelato.cloud';
-export const GELATO_STAGING_API = 'https://api.t.gelato.cloud';

package/relayer/evm/actions/getCapabilities.ts

@@ -1,22 +0,0 @@
-import type { Transport } from 'viem';
-import { z } from 'zod';
-import { evmAddressSchema, evmTokenSchema } from '../../../types/index.js';
-
-const capabilitiesByChainSchema = z.object({
-  feeCollector: evmAddressSchema,
-  tokens: z.array(evmTokenSchema)
-});
-
-const capabilitiesSchema = z.record(z.string().pipe(z.coerce.number()), capabilitiesByChainSchema);
-
-export type CapabilitiesByChain = z.infer<typeof capabilitiesByChainSchema>;
-export type Capabilities = z.infer<typeof capabilitiesSchema>;
-
-export const getCapabilities = async (client: ReturnType<Transport>): Promise<Capabilities> => {
-  const result = await client.request({
-    method: 'relayer_getCapabilities',
-    params: []
-  });
-
-  return capabilitiesSchema.parse(result);
-};

package/relayer/evm/actions/getFeeData.ts

@@ -1,36 +0,0 @@
-import type { Address, Transport } from 'viem';
-import { z } from 'zod';
-import { evmTokenSchema } from '../../../types/index.js';
-
-const feeDataSchema = z.object({
-  chainId: z.coerce.number(),
-  context: z.unknown().optional(),
-  expiry: z.number(),
-  gasPrice: z.coerce.bigint(),
-  rate: z.number(),
-  token: evmTokenSchema
-});
-
-export type FeeData = z.infer<typeof feeDataSchema>;
-
-export type GetFeeDataParameters = {
-  chainId: number;
-  token: Address;
-};
-
-export const getFeeData = async (
-  client: ReturnType<Transport>,
-  parameters: GetFeeDataParameters
-): Promise<FeeData> => {
-  const { chainId, token } = parameters;
-
-  const result = await client.request({
-    method: 'relayer_getFeeData',
-    params: {
-      chainId: chainId.toString(),
-      token
-    }
-  });
-
-  return feeDataSchema.parse(result);
-};

package/relayer/evm/actions/getFeeQuote.ts

@@ -1,39 +0,0 @@
-import type { Address, Transport } from 'viem';
-import { z } from 'zod';
-import { evmTokenSchema } from '../../../types/index.js';
-
-const feeQuote = z.object({
-  chainId: z.coerce.number(),
-  context: z.unknown().optional(),
-  expiry: z.number(),
-  fee: z.coerce.bigint(),
-  token: evmTokenSchema
-});
-
-export type FeeQuote = z.infer<typeof feeQuote>;
-
-export type GetFeeQuoteParameters = {
-  chainId: number;
-  gas: bigint;
-  l1Fee?: bigint;
-  token: Address;
-};
-
-export const getFeeQuote = async (
-  client: ReturnType<Transport>,
-  parameters: GetFeeQuoteParameters
-): Promise<FeeQuote> => {
-  const { chainId, gas, l1Fee, token } = parameters;
-
-  const result = await client.request({
-    method: 'relayer_getFeeQuote',
-    params: {
-      chainId: chainId.toString(),
-      gas: gas.toString(),
-      l1Fee: l1Fee ? l1Fee.toString() : undefined,
-      token
-    }
-  });
-
-  return feeQuote.parse(result);
-};

package/relayer/evm/actions/getStatus.ts

@@ -1,92 +0,0 @@
-import type { Transport } from 'viem';
-import { z } from 'zod';
-import { evmAddressSchema, hexData32Schema, hexDataSchema } from '../../../types/index.js';
-
-export enum StatusCode {
-  Pending = 100,
-  Submitted = 110,
-  Included = 200,
-  Rejected = 400,
-  Reverted = 500
-}
-
-const logSchema = z.object({
-  address: evmAddressSchema,
-  data: hexDataSchema,
-  topics: z.array(hexData32Schema)
-});
-
-const receiptSchema = z.object({
-  blockHash: hexData32Schema,
-  blockNumber: z.coerce.bigint(),
-  gasUsed: z.coerce.bigint(),
-  logs: z.array(logSchema).optional(),
-  transactionHash: hexData32Schema
-});
-
-const baseStatusSchema = z.object({
-  chainId: z.coerce.number(),
-  createdAt: z.number()
-});
-
-const pendingStatusSchema = baseStatusSchema.extend({
-  status: z.literal(StatusCode.Pending)
-});
-
-const submittedStatusSchema = baseStatusSchema.extend({
-  hash: hexData32Schema,
-  status: z.literal(StatusCode.Submitted)
-});
-
-const includedStatusSchema = baseStatusSchema.extend({
-  receipt: receiptSchema,
-  status: z.literal(StatusCode.Included)
-});
-
-const rejectedStatusSchema = baseStatusSchema.extend({
-  data: z.unknown().optional(),
-  message: z.string(),
-  status: z.literal(StatusCode.Rejected)
-});
-
-const revertedStatusSchema = baseStatusSchema.extend({
-  data: z.string(),
-  message: z.string().optional(),
-  status: z.literal(StatusCode.Reverted)
-});
-
-export const terminalStatusSchema = z.discriminatedUnion('status', [
-  includedStatusSchema,
-  rejectedStatusSchema,
-  revertedStatusSchema
-]);
-
-export const statusSchema = z.discriminatedUnion('status', [
-  pendingStatusSchema,
-  submittedStatusSchema,
-  includedStatusSchema,
-  rejectedStatusSchema,
-  revertedStatusSchema
-]);
-
-export type TerminalStatus = z.infer<typeof terminalStatusSchema>;
-
-export type Status = z.infer<typeof statusSchema>;
-
-export type GetStatusParameters = {
-  id: string;
-};
-
-export const getStatus = async (
-  client: ReturnType<Transport>,
-  parameters: GetStatusParameters
-): Promise<Status> => {
-  const { id } = parameters;
-
-  const result = await client.request({
-    method: 'relayer_getStatus',
-    params: { id }
-  });
-
-  return statusSchema.parse(result);
-};

package/relayer/evm/actions/index.ts

@@ -1,7 +0,0 @@
-export * from './getCapabilities.js';
-export * from './getFeeData.js';
-export * from './getFeeQuote.js';
-export * from './getStatus.js';
-export * from './sendTransaction.js';
-export * from './sendTransactionSync.js';
-export * from './waitForStatus.js';

package/relayer/evm/actions/sendTransaction.ts

@@ -1,33 +0,0 @@
-import type { Address, Hex, SignedAuthorizationList, Transport } from 'viem';
-import { hexData32Schema, type Payment } from '../../../types/index.js';
-import { formatAuthorization } from '../../../utils/index.js';
-
-export type SendTransactionParameters = {
-  authorizationList?: SignedAuthorizationList;
-  chainId: number;
-  context?: unknown;
-  data: Hex;
-  payment: Payment;
-  to: Address;
-};
-
-export const sendTransaction = async (
-  client: ReturnType<Transport>,
-  parameters: SendTransactionParameters
-): Promise<Hex> => {
-  const { chainId, data, to, payment, context, authorizationList } = parameters;
-
-  const result = await client.request({
-    method: 'relayer_sendTransaction',
-    params: {
-      authorizationList: authorizationList ? authorizationList.map(formatAuthorization) : undefined,
-      chainId: chainId.toString(),
-      context,
-      data,
-      payment,
-      to
-    }
-  });
-
-  return hexData32Schema.parse(result);
-};

package/relayer/evm/actions/sendTransactionSync.ts

@@ -1,30 +0,0 @@
-import type { Transport } from 'viem';
-import { formatAuthorization } from '../../../utils/index.js';
-import { type TerminalStatus, terminalStatusSchema } from './getStatus.js';
-import type { SendTransactionParameters } from './sendTransaction.js';
-
-export type SendTransactionSyncParameters = SendTransactionParameters & {
-  timeout?: number;
-};
-
-export const sendTransactionSync = async (
-  client: ReturnType<Transport>,
-  parameters: SendTransactionSyncParameters
-): Promise<TerminalStatus> => {
-  const { chainId, data, to, payment, context, authorizationList, timeout } = parameters;
-
-  const result = await client.request({
-    method: 'relayer_sendTransactionSync',
-    params: {
-      authorizationList: authorizationList ? authorizationList.map(formatAuthorization) : undefined,
-      chainId: chainId.toString(),
-      context,
-      data,
-      payment,
-      timeout,
-      to
-    }
-  });
-
-  return terminalStatusSchema.parse(result);
-};

package/relayer/evm/actions/waitForStatus.ts

@@ -1,24 +0,0 @@
-import type { Transport } from 'viem';
-import {
-  type GetStatusParameters,
-  getStatus,
-  StatusCode,
-  type TerminalStatus
-} from './getStatus.js';
-
-// TODO: use websockets
-// TODO: make polling interval configurable
-export const waitForStatus = async (
-  client: ReturnType<Transport>,
-  parameters: GetStatusParameters
-): Promise<TerminalStatus> => {
-  while (true) {
-    const status = await getStatus(client, parameters);
-
-    if (status.status !== StatusCode.Pending && status.status !== StatusCode.Submitted) {
-      return status;
-    }
-
-    await new Promise((r) => setTimeout(r, 100));
-  }
-};

package/relayer/evm/index.ts

@@ -1,68 +0,0 @@
-import { type Hex, type HttpTransportConfig, http } from 'viem';
-import { GELATO_PROD_API, GELATO_STAGING_API } from '../constants/index.js';
-import {
-  type Capabilities,
-  type FeeData,
-  type FeeQuote,
-  type GetFeeDataParameters,
-  type GetFeeQuoteParameters,
-  type GetStatusParameters,
-  getCapabilities,
-  getFeeData,
-  getFeeQuote,
-  getStatus,
-  type SendTransactionParameters,
-  type SendTransactionSyncParameters,
-  type Status,
-  sendTransaction,
-  sendTransactionSync,
-  type TerminalStatus,
-  waitForStatus
-} from './actions/index.js';
-
-export * from './actions/index.js';
-
-export type GelatoEvmRelayerClient = {
-  getCapabilities: () => Promise<Capabilities>;
-  getFeeData: (parameters: GetFeeDataParameters) => Promise<FeeData>;
-  getFeeQuote: (parameters: GetFeeQuoteParameters) => Promise<FeeQuote>;
-  getStatus: (parameters: GetStatusParameters) => Promise<Status>;
-  waitForStatus: (parameters: GetStatusParameters) => Promise<TerminalStatus>;
-  sendTransaction: (parameters: SendTransactionParameters) => Promise<Hex>;
-  sendTransactionSync: (parameters: SendTransactionSyncParameters) => Promise<TerminalStatus>;
-};
-
-export type GelatoEvmRelayerClientConfig = {
-  apiKey: string;
-  testnet: boolean;
-};
-
-// TODO: the testnet/mainnet separation won't be necessary in the future
-export const createGelatoEvmRelayerClient = (
-  parameters: GelatoEvmRelayerClientConfig
-): GelatoEvmRelayerClient => {
-  const { apiKey, testnet } = parameters;
-
-  const config: HttpTransportConfig = {
-    fetchOptions: {
-      headers: {
-        'X-API-Key': apiKey
-      }
-    }
-  };
-
-  // TODO: can just use prod endpoint in the future
-  const base = testnet ? GELATO_STAGING_API : GELATO_PROD_API;
-
-  const client = http(`${base}/rpc`, config)({});
-
-  return {
-    getCapabilities: () => getCapabilities(client),
-    getFeeData: (parameters) => getFeeData(client, parameters),
-    getFeeQuote: (parameters) => getFeeQuote(client, parameters),
-    getStatus: (parameters) => getStatus(client, parameters),
-    sendTransaction: (parameters) => sendTransaction(client, parameters),
-    sendTransactionSync: (parameters) => sendTransactionSync(client, parameters),
-    waitForStatus: (parameters) => waitForStatus(client, parameters)
-  };
-};

package/relayer/index.ts

@@ -1 +0,0 @@
-export * from './evm/index.js';

package/tsconfig.build.json

@@ -1,19 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "composite": true,
-    "noEmit": false,
-    "outDir": "./_dist"
-  },
-  "exclude": [
-    "node_modules",
-    "_dist",
-    "**/*.test.ts",
-    "**/*.spec.ts",
-    "**/*.test.tsx",
-    "**/*.spec.tsx"
-  ]
-}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "rootDir": "./"
-  }
-}

package/types/error.ts

@@ -1,38 +0,0 @@
-// Note: copied from viem since it doesn't export these
-
-import { BaseError } from 'viem';
-
-export class InvalidBytesLengthError extends BaseError {
-  constructor({
-    size,
-    targetSize,
-    type
-  }: {
-    size: number;
-    targetSize: number;
-    type: 'hex' | 'bytes';
-  }) {
-    super(
-      `${type.charAt(0).toUpperCase()}${type
-        .slice(1)
-        .toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size} ${type} long.`,
-      { name: 'InvalidBytesLengthError' }
-    );
-  }
-}
-
-export class AccountNotFoundError extends BaseError {
-  constructor({ docsPath }: { docsPath?: string | undefined } = {}) {
-    super(
-      [
-        'Could not find an Account to execute with this Action.',
-        'Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the Client.'
-      ].join('\n'),
-      {
-        docsPath,
-        docsSlug: 'account',
-        name: 'AccountNotFoundError'
-      }
-    );
-  }
-}

package/types/index.ts

@@ -1,3 +0,0 @@
-export * from './error.js';
-export * from './payment.js';
-export * from './schema.js';