@brninpay/sdk 0.1.0

package/src/erc4337/providers/kernel.ts

@@ -0,0 +1,136 @@
+import { ValidationError } from '@brninpay/core'
+import { encodeFunctionData } from 'viem'
+import { getUserOperationHash } from 'viem/account-abstraction'
+import type { ProviderBaseConfig, SmartAccountProvider } from './types.js'
+import { ACCOUNT_FACTORY_ABI, ENTRY_POINT_ABI } from './types.js'
+
+const KERNEL_ACCOUNT_ABI = [
+  {
+    type: 'function',
+    name: 'execute',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'to', type: 'address' },
+      { name: 'value', type: 'uint256' },
+      { name: 'data', type: 'bytes' },
+      { name: 'operation', type: 'uint8' },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'executeBatch',
+    stateMutability: 'nonpayable',
+    inputs: [
+      {
+        name: 'calls',
+        type: 'tuple[]',
+        components: [
+          { name: 'to', type: 'address' },
+          { name: 'value', type: 'uint256' },
+          { name: 'data', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [],
+  },
+] as const
+
+export class KernelAccountProvider implements SmartAccountProvider {
+  readonly kind = 'kernel' as const
+  readonly saltNonce: bigint
+
+  constructor(private readonly config: ProviderBaseConfig) {
+    this.saltNonce = config.saltNonce ?? 0n
+  }
+
+  get owner() {
+    return this.config.owner
+  }
+
+  get chainId() {
+    return this.config.chainId
+  }
+
+  get entryPointAddress() {
+    return this.config.entryPointAddress
+  }
+
+  get entryPointVersion() {
+    return this.config.entryPointVersion
+  }
+
+  get factoryAddress() {
+    return this.config.factoryAddress
+  }
+
+  async getCounterfactualAddress() {
+    return this.config.publicClient.readContract<`0x${string}`>({
+      address: this.config.factoryAddress,
+      abi: ACCOUNT_FACTORY_ABI,
+      functionName: 'getAddress',
+      args: [this.config.owner.address, this.saltNonce],
+    })
+  }
+
+  async getFactoryArgs() {
+    return {
+      factory: this.config.factoryAddress,
+      factoryData: encodeFunctionData({
+        abi: ACCOUNT_FACTORY_ABI,
+        functionName: 'createAccount',
+        args: [this.config.owner.address, this.saltNonce],
+      }),
+    }
+  }
+
+  async encodeCalls(calls: Parameters<SmartAccountProvider['encodeCalls']>[0]) {
+    if (calls.length === 0) {
+      throw new ValidationError('KernelAccountProvider requires at least one call')
+    }
+
+    if (calls.length === 1) {
+      const [call] = calls
+      return encodeFunctionData({
+        abi: KERNEL_ACCOUNT_ABI,
+        functionName: 'execute',
+        args: [call.to, call.value, call.data, 0],
+      })
+    }
+
+    return encodeFunctionData({
+      abi: KERNEL_ACCOUNT_ABI,
+      functionName: 'executeBatch',
+      args: [calls.map((call) => ({ to: call.to, value: call.value, data: call.data }))],
+    })
+  }
+
+  async getNonce(address: `0x${string}`, key = 0n) {
+    return this.config.publicClient.readContract<bigint>({
+      address: this.config.entryPointAddress,
+      abi: ENTRY_POINT_ABI,
+      functionName: 'getNonce',
+      args: [address, key],
+    })
+  }
+
+  async getStubSignature() {
+    return `0x${'00'.repeat(65)}` as `0x${string}`
+  }
+
+  async signUserOperation(userOperation: Parameters<SmartAccountProvider['signUserOperation']>[0]) {
+    const hash = getUserOperationHash({
+      chainId: this.config.chainId,
+      entryPointAddress: this.config.entryPointAddress,
+      entryPointVersion: this.config.entryPointVersion === 'v0.6' ? '0.6' : '0.7',
+      userOperation: userOperation as never,
+    })
+
+    return this.config.owner.signMessage({ message: { raw: hash } })
+  }
+
+  async isDeployed(address: `0x${string}`) {
+    const code = await this.config.publicClient.getCode({ address })
+    return Boolean(code && code !== '0x')
+  }
+}

package/src/erc4337/providers/safe.ts

@@ -0,0 +1,133 @@
+import { ValidationError } from '@brninpay/core'
+import { encodeFunctionData } from 'viem'
+import { getUserOperationHash } from 'viem/account-abstraction'
+import type { SmartAccountProvider, ProviderBaseConfig } from './types.js'
+import { ACCOUNT_FACTORY_ABI, ENTRY_POINT_ABI } from './types.js'
+
+const SAFE_ACCOUNT_ABI = [
+  {
+    type: 'function',
+    name: 'execute',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'to', type: 'address' },
+      { name: 'value', type: 'uint256' },
+      { name: 'data', type: 'bytes' },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'executeBatch',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'to', type: 'address[]' },
+      { name: 'value', type: 'uint256[]' },
+      { name: 'data', type: 'bytes[]' },
+    ],
+    outputs: [],
+  },
+] as const
+
+export class SafeAccountProvider implements SmartAccountProvider {
+  readonly kind = 'safe' as const
+  readonly saltNonce: bigint
+
+  constructor(private readonly config: ProviderBaseConfig) {
+    this.saltNonce = config.saltNonce ?? 0n
+  }
+
+  get owner() {
+    return this.config.owner
+  }
+
+  get chainId() {
+    return this.config.chainId
+  }
+
+  get entryPointAddress() {
+    return this.config.entryPointAddress
+  }
+
+  get entryPointVersion() {
+    return this.config.entryPointVersion
+  }
+
+  get factoryAddress() {
+    return this.config.factoryAddress
+  }
+
+  async getCounterfactualAddress() {
+    return this.config.publicClient.readContract<`0x${string}`>({
+      address: this.config.factoryAddress,
+      abi: ACCOUNT_FACTORY_ABI,
+      functionName: 'getAddress',
+      args: [this.config.owner.address, this.saltNonce],
+    })
+  }
+
+  async getFactoryArgs() {
+    return {
+      factory: this.config.factoryAddress,
+      factoryData: encodeFunctionData({
+        abi: ACCOUNT_FACTORY_ABI,
+        functionName: 'createAccount',
+        args: [this.config.owner.address, this.saltNonce],
+      }),
+    }
+  }
+
+  async encodeCalls(calls: Parameters<SmartAccountProvider['encodeCalls']>[0]) {
+    if (calls.length === 0) {
+      throw new ValidationError('SafeAccountProvider requires at least one call')
+    }
+
+    if (calls.length === 1) {
+      const [call] = calls
+      return encodeFunctionData({
+        abi: SAFE_ACCOUNT_ABI,
+        functionName: 'execute',
+        args: [call.to, call.value, call.data],
+      })
+    }
+
+    return encodeFunctionData({
+      abi: SAFE_ACCOUNT_ABI,
+      functionName: 'executeBatch',
+      args: [
+        calls.map((call) => call.to),
+        calls.map((call) => call.value),
+        calls.map((call) => call.data),
+      ],
+    })
+  }
+
+  async getNonce(address: `0x${string}`, key = 0n) {
+    return this.config.publicClient.readContract<bigint>({
+      address: this.config.entryPointAddress,
+      abi: ENTRY_POINT_ABI,
+      functionName: 'getNonce',
+      args: [address, key],
+    })
+  }
+
+  async getStubSignature() {
+    return `0x${'00'.repeat(65)}` as `0x${string}`
+  }
+
+  async signUserOperation(userOperation: Parameters<SmartAccountProvider['signUserOperation']>[0]) {
+    const hash = getUserOperationHash({
+      chainId: this.config.chainId,
+      entryPointAddress: this.config.entryPointAddress,
+      entryPointVersion: this.config.entryPointVersion === 'v0.6' ? '0.6' : '0.7',
+      userOperation: userOperation as never,
+    })
+
+    return this.config.owner.signMessage({ message: { raw: hash } })
+  }
+
+  async isDeployed(address: `0x${string}`) {
+    const code = await this.config.publicClient.getCode({ address })
+    return Boolean(code && code !== '0x')
+  }
+}

package/src/erc4337/providers/types.ts

@@ -0,0 +1,73 @@
+import type { Address, EntryPointVersion, Hex, UserOperation, UserOperationCall } from '@brninpay/core'
+import type { SmartAccountOwner } from '../../types.js'
+
+export const ENTRY_POINT_ABI = [
+  {
+    type: 'function',
+    name: 'getNonce',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'sender', type: 'address' },
+      { name: 'key', type: 'uint192' },
+    ],
+    outputs: [{ name: 'nonce', type: 'uint256' }],
+  },
+] as const
+
+export const ACCOUNT_FACTORY_ABI = [
+  {
+    type: 'function',
+    name: 'createAccount',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'owner', type: 'address' },
+      { name: 'saltNonce', type: 'uint256' },
+    ],
+    outputs: [{ name: 'account', type: 'address' }],
+  },
+  {
+    type: 'function',
+    name: 'getAddress',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'owner', type: 'address' },
+      { name: 'saltNonce', type: 'uint256' },
+    ],
+    outputs: [{ name: 'account', type: 'address' }],
+  },
+] as const
+
+export interface ProviderBaseConfig {
+  publicClient: {
+    readContract<T = unknown>(parameters: {
+      address: Address
+      abi: readonly unknown[]
+      functionName: string
+      args?: readonly unknown[]
+    }): Promise<T>
+    getCode(parameters: { address: Address }): Promise<Hex | undefined>
+  }
+  owner: SmartAccountOwner
+  entryPointAddress: Address
+  entryPointVersion: EntryPointVersion
+  factoryAddress: Address
+  chainId: number
+  saltNonce?: bigint
+}
+
+export interface SmartAccountProvider {
+  readonly kind: 'safe' | 'kernel' | 'circle'
+  readonly owner: SmartAccountOwner
+  readonly chainId: number
+  readonly entryPointAddress: Address
+  readonly entryPointVersion: EntryPointVersion
+  readonly factoryAddress: Address
+  readonly saltNonce: bigint
+  getCounterfactualAddress(): Promise<Address>
+  getFactoryArgs(): Promise<{ factory?: Address; factoryData?: Hex }>
+  encodeCalls(calls: readonly UserOperationCall[]): Promise<Hex>
+  getNonce(address: Address, key?: bigint): Promise<bigint>
+  getStubSignature(): Promise<Hex>
+  signUserOperation(userOperation: UserOperation): Promise<Hex>
+  isDeployed(address: Address): Promise<boolean>
+}

package/src/erc4337/smart-wallet.ts

@@ -0,0 +1,115 @@
+import type { SmartWallet as CoreSmartWallet, UserOperationCall } from '@brninpay/core'
+import { UserOperationBuilder } from './builder.js'
+import type {
+  BatchOperationOptions,
+  SmartWalletConfig,
+  SmartWalletSendResult,
+} from '../types.js'
+
+export class SmartWallet {
+  private wallet?: CoreSmartWallet
+
+  constructor(private readonly config: SmartWalletConfig) {}
+
+  async createWallet(): Promise<CoreSmartWallet> {
+    const address = await this.config.provider.getCounterfactualAddress()
+    const deployed = await this.config.provider.isDeployed(address)
+
+    this.wallet = {
+      address,
+      ownerAddress: this.config.provider.owner.address,
+      chainId: this.config.chainId,
+      provider: this.config.provider.kind,
+      entryPointAddress: this.config.provider.entryPointAddress,
+      entryPointVersion: this.config.provider.entryPointVersion,
+      factoryAddress: this.config.provider.factoryAddress,
+      deployed,
+    }
+
+    return this.wallet
+  }
+
+  async sendUSDC(
+    parameters: { recipient: `0x${string}`; amount: bigint },
+    options?: BatchOperationOptions
+  ): Promise<SmartWalletSendResult> {
+    const call = this.config.builder.buildUSDCTransfer(parameters)
+    return this.batchOperations([call], options)
+  }
+
+  async batchOperations(
+    calls: readonly UserOperationCall[],
+    options: BatchOperationOptions = {}
+  ): Promise<SmartWalletSendResult> {
+    const wallet = this.wallet ?? (await this.createWallet())
+    const builder = this.config.builder instanceof UserOperationBuilder ? this.config.builder : this.config.builder
+
+    let userOperation = await builder.prepareUserOperation(this.config.provider, {
+      walletAddress: wallet.address,
+      walletDeployed: wallet.deployed,
+      calls,
+    })
+
+    if (this.config.paymasterClient) {
+      const sponsorship = await this.config.paymasterClient.requestSponsorship(
+        userOperation,
+        options.sponsorshipContext
+      )
+
+      userOperation = await builder.prepareUserOperation(this.config.provider, {
+        walletAddress: wallet.address,
+        walletDeployed: wallet.deployed,
+        calls,
+        sponsorship,
+      })
+    }
+
+    const signature = await this.config.provider.signUserOperation(userOperation)
+    const signedUserOperation = {
+      ...userOperation,
+      signature,
+    }
+
+    const userOperationHash = await this.config.bundlerClient.sendUserOperation(signedUserOperation)
+
+    if (!options.waitForReceipt) {
+      return {
+        wallet,
+        userOperation: signedUserOperation,
+        userOperationHash,
+      }
+    }
+
+    const receipt = await this.config.bundlerClient.getUserOperationReceipt(userOperationHash, {
+      pollingIntervalMs: options.pollingIntervalMs,
+      timeoutMs: options.timeoutMs,
+    })
+
+    this.wallet = {
+      ...wallet,
+      deployed: true,
+    }
+
+    return {
+      wallet: this.wallet,
+      userOperation: signedUserOperation,
+      userOperationHash,
+      receipt,
+    }
+  }
+
+  async isDeployed(): Promise<boolean> {
+    const wallet = this.wallet ?? (await this.createWallet())
+    const deployed = await this.config.provider.isDeployed(wallet.address)
+    this.wallet = {
+      ...wallet,
+      deployed,
+    }
+    return deployed
+  }
+
+  async getNonce(key = 0n): Promise<bigint> {
+    const wallet = this.wallet ?? (await this.createWallet())
+    return this.config.provider.getNonce(wallet.address, key)
+  }
+}

package/src/index.ts

@@ -0,0 +1,60 @@
+export { BrninpayClient } from './client.js'
+export { Runtimee } from './runtimee.js'
+export { ActorClient } from './actor-client.js'
+export { PaymentIntentClient } from './modules/payment-intents.js'
+export { PolicyClient } from './modules/policies.js'
+export { BundlerClient } from './bundler/client.js'
+export { createPimlicoBundlerProvider } from './bundler/providers/pimlico.js'
+export { createAlchemyBundlerProvider } from './bundler/providers/alchemy.js'
+export { PaymasterClient } from './paymaster/client.js'
+export { UserOperationBuilder } from './erc4337/builder.js'
+export { SmartWallet } from './erc4337/smart-wallet.js'
+export { SafeAccountProvider } from './erc4337/providers/safe.js'
+export { KernelAccountProvider } from './erc4337/providers/kernel.js'
+export { parseUsdc, formatUsdc } from './conversion.js'
+export type {
+  Address,
+  ApiErrorPayload,
+  BatchOperationOptions,
+  BundlerClientConfig,
+  BundlerProviderConfig,
+  CancelPaymentIntentParams,
+  ClientRequestOptions,
+  ClientTransport,
+  CreateActorParams,
+  CreatePaymentIntentParams,
+  CreatePolicyParams,
+  PayParams,
+  PaginatedResult,
+  PaymentIntentPreview,
+  PaymentIntentPreviewParams,
+  PimlicoBundlerProviderParams,
+  PreviewPayParams,
+  PublicClientLike,
+  RequestContext,
+  ResponseContext,
+  RetryPolicy,
+  SmartAccountOwner,
+  SmartWalletConfig,
+  SmartWalletInstance,
+  SmartWalletSendResult,
+  SponsorshipContext,
+  SponsorshipData,
+  ActorStatus,
+  ActorSummary,
+  ExecutionReceipt,
+  AlchemyBundlerProviderParams,
+  GetPaymentIntentOptions,
+  ListPaymentIntentsParams,
+  ListPoliciesParams,
+  PaymasterClientConfig,
+  PolicyDecisionExplanation,
+  PreparedUserOperationContext,
+  SmartWalletAccountProvider,
+  SdkLogger,
+  UpdatePolicyParams,
+  UserOperationBuilderConfig,
+  UserOperationByHash,
+  UserOperationReceipt,
+  RuntimeeConfig,
+} from './types.js'

package/src/modules/payment-intents.ts

@@ -0,0 +1,156 @@
+import {
+  deserializeBigInts,
+  parsePaymentIntent,
+  ValidationError,
+} from '@brninpay/core'
+import type {
+  CancelPaymentIntentParams,
+  ClientTransport,
+  CreatePaymentIntentParams,
+  GetPaymentIntentOptions,
+  ListPaymentIntentsParams,
+  PaginatedResult,
+  PaymentIntentPreview,
+  PaymentIntentPreviewParams,
+} from '../types.js'
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function normalizeAmount(amount: CreatePaymentIntentParams['amount']) {
+  return {
+    currency: amount.currency,
+    value: BigInt(amount.value).toString(),
+    decimals: amount.decimals ?? 6,
+  }
+}
+
+export class PaymentIntentClient {
+  constructor(private readonly transport: ClientTransport) {}
+
+  async createPaymentIntent(params: CreatePaymentIntentParams) {
+    if (!params.idempotencyKey?.trim()) {
+      throw new ValidationError('createPaymentIntent requires a non-empty idempotencyKey', {
+        field: 'idempotencyKey',
+      })
+    }
+
+    const response = await this.transport.request<unknown>({
+      path: '/v1/payment-intents',
+      method: 'POST',
+      headers: {
+        'Idempotency-Key': params.idempotencyKey,
+      },
+      body: {
+        ...params,
+        amount: normalizeAmount(params.amount),
+      },
+    })
+
+    return parsePaymentIntent(deserializeBigInts(response))
+  }
+
+  async getPaymentIntent(id: string, options: GetPaymentIntentOptions = {}) {
+    if (!id.trim()) {
+      throw new ValidationError('getPaymentIntent requires a payment intent id')
+    }
+
+    const loadOnce = async () => {
+      const response = await this.transport.request<unknown>({
+        path: `/v1/payment-intents/${encodeURIComponent(id)}`,
+        method: 'GET',
+      })
+
+      return parsePaymentIntent(deserializeBigInts(response))
+    }
+
+    if (!options.waitForTerminalState) {
+      return loadOnce()
+    }
+
+    const startedAt = Date.now()
+    const pollIntervalMs = options.pollIntervalMs ?? 2_000
+    const timeoutMs = options.timeoutMs ?? 60_000
+
+    while (true) {
+      const paymentIntent = await loadOnce()
+      if (['rejected', 'succeeded', 'failed', 'cancelled', 'expired'].includes(paymentIntent.status)) {
+        return paymentIntent
+      }
+
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new ValidationError('Timed out while waiting for payment intent to reach a terminal state', {
+          id,
+          timeoutMs,
+          currentStatus: paymentIntent.status,
+        })
+      }
+
+      await sleep(pollIntervalMs)
+    }
+  }
+
+  async cancelPaymentIntent(id: string, params: CancelPaymentIntentParams = {}) {
+    const current = await this.getPaymentIntent(id)
+    if (['submitted', 'confirming', 'succeeded', 'failed'].includes(current.status)) {
+      throw new ValidationError(`Payment intent ${id} can no longer be cancelled`, {
+        id,
+        status: current.status,
+      })
+    }
+
+    const response = await this.transport.request<unknown>({
+      path: `/v1/payment-intents/${encodeURIComponent(id)}/cancel`,
+      method: 'POST',
+      body: params,
+    })
+
+    return parsePaymentIntent(deserializeBigInts(response))
+  }
+
+  async previewPayment(params: PaymentIntentPreviewParams): Promise<PaymentIntentPreview> {
+    const response = await this.transport.request<PaymentIntentPreview>({
+      path: '/v1/payment-intents/preview',
+      method: 'POST',
+      body: {
+        ...params,
+        amount: normalizeAmount(params.amount),
+      },
+    })
+
+    return {
+      ...response,
+      estimatedGas:
+        response.estimatedGas !== undefined ? BigInt(response.estimatedGas) : undefined,
+      estimatedTotalCost:
+        response.estimatedTotalCost !== undefined
+          ? BigInt(response.estimatedTotalCost)
+          : undefined,
+    }
+  }
+
+  async listPaymentIntents(
+    params: ListPaymentIntentsParams = {}
+  ): Promise<PaginatedResult<ReturnType<typeof parsePaymentIntent>>> {
+    const response = await this.transport.request<{
+      items: unknown[]
+      nextCursor?: string | null
+    }>({
+      path: '/v1/payment-intents',
+      method: 'GET',
+      query: {
+        cursor: params.cursor,
+        limit: params.limit,
+        workspaceId: params.workspaceId,
+        actorId: params.actorId,
+        status: params.status,
+      },
+    })
+
+    return {
+      items: response.items.map((item) => parsePaymentIntent(deserializeBigInts(item))),
+      nextCursor: response.nextCursor ?? null,
+    }
+  }
+}