@t402/wdk-gasless

pnpm add @t402/wdk-gasless

import { createWdkGaslessClient } from '@t402/wdk-gasless'
import { createPublicClient, http } from 'viem'
import { arbitrum } from 'viem/chains'
 
// Create public client
const publicClient = createPublicClient({
  chain: arbitrum,
  transport: http()
})
 
// Create gasless client
const client = await createWdkGaslessClient({
  wdkAccount: myWdkAccount, // From @tetherto/wdk
  publicClient,
  chainId: 42161, // Arbitrum
  bundler: {
    bundlerUrl: 'https://api.pimlico.io/v2/arbitrum/rpc?apikey=...',
    chainId: 42161
  },
  paymaster: {
    address: '0x...',
    url: 'https://api.pimlico.io/v2/arbitrum/rpc?apikey=...',
    type: 'sponsoring'
  }
})
 
// Check smart account
const accountAddress = await client.getAccountAddress()
console.log('Smart Account:', accountAddress)
 
// Check balance
const balance = await client.getFormattedBalance()
console.log('USDT0 Balance:', balance)
 
// Execute gasless payment
const result = await client.pay({
  to: '0x...',
  amount: 1000000n // 1 USDT0 (6 decimals)
})
 
console.log('UserOp Hash:', result.userOpHash)
console.log('Sponsored:', result.sponsored)
 
// Wait for confirmation
const receipt = await result.wait()
console.log('Transaction Hash:', receipt.txHash)

const result = await client.payBatch({
  payments: [
    { to: '0xAlice...', amount: 1000000n },  // 1 USDT0
    { to: '0xBob...', amount: 2000000n },    // 2 USDT0
    { to: '0xCharlie...', amount: 500000n }  // 0.5 USDT0
  ]
})
 
const receipt = await result.wait()
console.log('Batch payment confirmed:', receipt.txHash)

const sponsorInfo = await client.canSponsor({
  to: '0x...',
  amount: 1000000n
})
 
if (sponsorInfo.canSponsor) {
  console.log('Payment will be sponsored!')
} else {
  console.log('User must pay gas:', sponsorInfo.estimatedGas)
}

interface WdkGaslessClient {
  // Account
  getAccountAddress(): Promise<Address>
  isAccountDeployed(): Promise<boolean>
 
  // Balances
  getBalance(): Promise<bigint>
  getFormattedBalance(): Promise<string>
  getNativeBalance(): Promise<bigint>
 
  // Payments
  pay(params: PayParams): Promise<PayResult>
  payBatch(params: BatchPayParams): Promise<PayResult>
 
  // Sponsorship
  canSponsor(params: PayParams): Promise<SponsorInfo>
}
 
interface PayParams {
  to: Address
  amount: bigint
  token?: Address // Default: USDT0
}
 
interface PayResult {
  userOpHash: Hex
  sponsored: boolean
  wait(): Promise<PayReceipt>
}
 
interface PayReceipt {
  txHash: Hex
  success: boolean
  gasUsed: bigint
  actualGasCost: bigint
}