ERC-7677 — Paymaster Web Service Capability

Back to Account & Authentication

ERC-7677: Paymaster Web Service Capability

ERC-7677 standardises the wallet ↔ paymaster handshake for ERC-4337 account abstraction. The wallet asks a paymaster service "will you sponsor this UserOperation?"; the paymaster returns sponsorship parameters (signature, deadline, fees) that the wallet then includes in the UserOp. Without 7677, every wallet had to know each paymaster's idiosyncratic API; with 7677, paymasters expose a standardised JSON-RPC method (pm_getPaymasterStubData / pm_getPaymasterData) that any 7677-compliant wallet can call.

This is the missing piece between the on-chain ERC-4337 paymaster contract and the off-chain wallet UX. It's not on-chain — the wallet queries the paymaster service over HTTPS, then submits a UserOp that the on-chain paymaster contract validates.

Required Methods (JSON-RPC, off-chain)

// Wallet → Paymaster Service
pm_getPaymasterStubData(userOp, entryPoint, chainId, context)
  → { paymaster, paymasterData, paymasterVerificationGasLimit, paymasterPostOpGasLimit }

pm_getPaymasterData(userOp, entryPoint, chainId, context)
  → { paymaster, paymasterData, paymasterVerificationGasLimit, paymasterPostOpGasLimit }

Stub returns enough fake data for the wallet to estimate gas; getPaymasterData returns the real signature for execution.

The on-chain paymaster contract (separate, not part of 7677) verifies the data when the bundler submits the UserOp.

Neo Equivalent: Sponsor Relayer + Signed Gas-Budget Pattern

Neo's account abstraction story is different from Ethereum's: every Neo account is already a contract (no UserOp shape), and gas sponsorship is just a different relayer signing the transaction. The wallet UX question is the same — "will you sponsor my transaction?" — but the mechanics map to Neo's witness model.

// Wallet → Sponsor Service
sponsor_quote(transactionScript, signers, requestedFee, expirySeconds)
  → { sponsor: address, signedScript: bytes, expiresAt: number, attribution: string }

sponsor_finalize(transactionScript, signers, sponsorshipQuoteId)
  → { signedTransaction: bytes }

ERC-7677 (Ethereum)	Neo Equivalent	Notes
pm_getPaymasterStubData (estimation)	sponsor_quote returning a price + sponsor address	Pre-signing handshake
pm_getPaymasterData (final signature)	sponsor_finalize returning the sponsor's tx witness	Bundles sponsor signature
paymaster contract address	Sponsor account that signs the tx as a co-signer	Sponsor's witness scope covers the system fee
paymasterData opaque blob	Sponsor's witness in the transaction's witness array	Same affordance, native shape
Bundler submits UserOp	Wallet (or sponsor) submits the signed transaction	No bundler needed
EntryPoint validates paymaster	Network validates witnesses (consensus rule)	No application-level validation

Why The Neo Story is Simpler

Ethereum's ERC-4337 separates "the user's signature" from "the paymaster's signature" because EOAs can only sign one transaction at a time. Neo transactions natively support multiple signers with different witness scopes, so adding a sponsor's signature is just "add another signer with a Global witness scope and let them sign". No EntryPoint contract, no bundler, no UserOp envelope.

The 7677 web-service surface still applies: sponsor services need a way to quote and sign sponsorships, and wallets need a uniform API to ask. The mirror page formalises that shape for Neo without inventing on-chain machinery.

Composition

• ERC-4337 — account abstraction. ERC-7677 fills in the paymaster handshake on top.
• ERC-2771 — trusted forwarder. Neo's witness model already covers the gasless meta-tx case; sponsorship is a strict superset (sponsor pays GAS, not just relays).
• ERC-3009 — transfer with authorization. Off-chain signed authorization for token transfers, often paired with sponsor- paid relays.

Reference Sponsor Service Shape

// HTTP POST /sponsor/quote
//   body: { script: hex, signers: [...], maxFee: int, expirySeconds: int }
//   response: { quoteId, sponsorAddress, sponsorWitness, totalFee }
//
// HTTP POST /sponsor/finalize
//   body: { quoteId, walletWitness }
//   response: { signedTransaction: hex }
//
// Wallet flow:
//   1. Build script for the user's intended action.
//   2. Compute attached signers (user + sponsor).
//   3. POST to /sponsor/quote → receive sponsor signature stub.
//   4. Sign the transaction with the user's key.
//   5. POST to /sponsor/finalize with the user signature.
//   6. Broadcast the fully-signed transaction.

The sponsor service is the off-chain equivalent of an Ethereum paymaster operator. The on-chain footprint is zero new contracts — sponsorship rides on Neo's native witness model.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

// On-chain ERC-4337 paymaster contract (separate from ERC-7677, but the
// receiving side of the off-chain handshake).

interface IEntryPoint { /* ERC-4337 spec */ }

interface IPaymaster {
    function validatePaymasterUserOp(
        bytes calldata userOp, bytes32 userOpHash, uint256 maxCost
    ) external returns (bytes memory context, uint256 validationData);

    function postOp(uint8 mode, bytes calldata context, uint256 actualGasCost) external;
}

contract WhitelistPaymaster is IPaymaster {
    address public owner;
    mapping(address => bool) public allowedSenders;
    IEntryPoint public entryPoint;

    function validatePaymasterUserOp(bytes calldata userOp, bytes32 /*userOpHash*/, uint256 maxCost)
        external view returns (bytes memory, uint256)
    {
        // Decode sender from userOp; check whitelist; return validationData.
        // ERC-7677 hands the wallet the data needed to construct this userOp
        // off-chain so this validation will succeed.
        address sender; assembly { sender := calldataload(userOp.offset) }  // simplified
        require(allowedSenders[sender], "not allowed");
        return ("", 0);
    }

    function postOp(uint8, bytes calldata, uint256) external pure {}
}

The on-chain side stays the same as a vanilla ERC-4337 paymaster. ERC-7677 is purely about the off-chain RPC contract between wallets and the paymaster operator.

using System;
using System.ComponentModel;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

// Optional on-chain sponsor accounting contract — used when sponsors want
// to pre-fund GAS escrow on-chain instead of paying out-of-band.

[DisplayName("SponsorEscrow")]
[ContractPermission("*", "*")]
public class SponsorEscrow : SmartContract
{
    private const byte Prefix_Balance = 0x10;
    private const byte Prefix_Spent   = 0x11;

    [DisplayName("Deposited")]
    public static event Action<UInt160, BigInteger> OnDeposited;
    [DisplayName("Sponsored")]
    public static event Action<UInt160, UInt160, BigInteger> OnSponsored;

    [DisplayName("OnNEP17Payment")]
    public static void OnNEP17Payment(UInt160 from, BigInteger amount, object data)
    {
        if (Runtime.CallingScriptHash != GAS.Hash) throw new Exception("only GAS");
        var key = BalanceKey(from);
        var prev = (BigInteger)(Storage.Get(Storage.CurrentContext, key) ?? ByteString.Empty);
        Storage.Put(Storage.CurrentContext, key, prev + amount);
        OnDeposited(from, amount);
    }

    /// Sponsor records its commitment off-chain; on settlement, this
    /// contract debits the sponsor's escrow for the actual fee charged.
    public static void RecordSponsorship(UInt160 sponsor, UInt160 sponsoree, BigInteger fee)
    {
        if (!Runtime.CheckWitness(sponsor)) throw new Exception("SPONSOR:NotSelf");
        var bk = BalanceKey(sponsor);
        var prev = (BigInteger)(Storage.Get(Storage.CurrentContext, bk) ?? ByteString.Empty);
        if (prev < fee) throw new Exception("SPONSOR:Insufficient");
        Storage.Put(Storage.CurrentContext, bk, prev - fee);

        var sk = SpentKey(sponsor, sponsoree);
        var spent = (BigInteger)(Storage.Get(Storage.CurrentContext, sk) ?? ByteString.Empty);
        Storage.Put(Storage.CurrentContext, sk, spent + fee);

        OnSponsored(sponsor, sponsoree, fee);
    }

    public static BigInteger BalanceOf(UInt160 sponsor)
        => (BigInteger)(Storage.Get(Storage.CurrentContext, BalanceKey(sponsor)) ?? ByteString.Empty);

    private static byte[] BalanceKey(UInt160 a)
        => new byte[] { Prefix_Balance }.Concat(a);
    private static byte[] SpentKey(UInt160 sponsor, UInt160 sponsoree)
        => new byte[] { Prefix_Spent }.Concat(sponsor).Concat(sponsoree);
}

Production Sponsor Service Skeleton (Off-chain)

// Express-style endpoint, illustrative.
app.post('/sponsor/quote', async (req, res) => {
    const { script, signers, maxFee } = req.body;
    if (!isAllowedDApp(req.headers.authorization)) return res.status(403).send();
    const fee = await estimateFee(script, signers);
    if (fee > maxFee) return res.status(400).send({ error: 'too expensive' });

    const sponsorWitness = await neoWallet.signWitness({ script, signers, fee });
    const quoteId = newId();
    pendingQuotes.set(quoteId, { fee, sponsorWitness, expiresAt: Date.now() + 30000 });
    res.json({ quoteId, sponsorAddress: SPONSOR_ADDRESS, sponsorWitness, totalFee: fee });
});

app.post('/sponsor/finalize', async (req, res) => {
    const { quoteId, walletWitness } = req.body;
    const q = pendingQuotes.get(quoteId);
    if (!q || q.expiresAt < Date.now()) return res.status(400).send({ error: 'expired' });
    pendingQuotes.delete(quoteId);

    const tx = assembleTransaction(q.script, [walletWitness, q.sponsorWitness]);
    res.json({ signedTransaction: hex(tx) });
});

Adoption

The real value of the 7677 mirror is convention convergence. If every Neo wallet implements sponsor_quote / sponsor_finalize, any sponsor service can integrate by exposing those two endpoints, and any dApp can request sponsorship without per-wallet integrations.