Send a sponsored transfer

Introduction

A sponsored transfer packages the wallet action as a signed UserOperation for a bundler and paymaster.

Use when: users should spend wallet assets without holding native currency in their signing EOA for gas.
For: apps with an already deployed Swig account and a compatible sponsorship provider.

How it works

Connect the role signer to toSwigSmartAccount with an explicit validity window.
Connect the bundler and ERC-7677 paymaster clients.
Send one call through the smart-account adapter; the selected role’s permissions still apply.
Check the UserOperation’s success result and containing transaction hash.

Requirements

Item	Requirement
Account	Already deployed and registered with a compatible bundler
EntryPoint	Canonical v0.9 configured on the wallet
Authority	Secp256k1 role or active Secp256k1 session
Sponsor	Paymaster endpoint supporting the account, chain, and EntryPoint
Transfer	One call; sufficient vault funds and role allowance

The current adapter requires sponsorship and does not deploy accounts inside the operation. Confirm bundler compatibility before using a hosted endpoint.

Flow

Role signs
   ↓
Bundler submits
   ↓
EntryPoint validates
├─ Paymaster pays gas
└─ Wallet executes

SDK example

After Environment setup, supply the chain, endpoints, role signer, and deployed account. The selected role must allow this native transfer to an EOA recipient with no code.

import {
  type Address,
  type Chain,
  type LocalAccount,
  createPublicClient,
  http,
} from "viem";
import { createBundlerClient, createPaymasterClient } from "viem/account-abstraction";
import { toSwigSmartAccount } from "../src/index.js";

export async function sendSponsoredTransfer(
  chain: Chain,
  rpcUrl: string,
  bundlerUrl: string,
  paymasterUrl: string,
  signer: LocalAccount,
  accountAddress: Address,
  roleId: number,
  recipient: Address,
  amount: bigint,
) {
  const client = createPublicClient({ chain, transport: http(rpcUrl) });
  const account = await toSwigSmartAccount({
    client,
    address: accountAddress,
    roleId,
    signer,
    validAfter: 0,
    validUntil: Number((await client.getBlock()).timestamp) + 600,
  });
  const bundler = createBundlerClient({
    account,
    client,
    transport: http(bundlerUrl),
    paymaster: createPaymasterClient({ transport: http(paymasterUrl) }),
  });
  const fees = await client.estimateFeesPerGas();
  const hash = await bundler.sendUserOperation({
    calls: [{ to: recipient, value: amount }],
    ...fees,
    verificationGasLimit: 200_000n,
  });
  const receipt = await bundler.waitForUserOperationReceipt({ hash });
  if (!receipt.success) throw new Error("UserOperation execution failed");
  return { userOperationHash: hash, transactionHash: receipt.receipt.transactionHash };
}

Size gas limits for your deployment and operation; this example uses the SDK example’s verification limit.
Inclusion does not guarantee execution success. A failed included operation can still consume a nonce and charge the sponsor.
Obtain fresh sponsorship and authorization when rebuilding an expired operation.
The Viem and permissionless.js example use the same Swig adapter.
The Rust and Python examples use a local fixture sponsor. Hosted use requires the provider’s fee and sponsorship data before signing.

Getting started

Guides

Reference