Docs · 01 / 07 · Quickstart

Send a sponsored UserOperation from a key that never held ETH.

1. 01

   Install#

   shellCopy

   $ npm i @unlinked/sdk @unlinked/miner viem

   The SDK builds the UserOperation itself (fixed gas profiles, EntryPoint v0.9, nonce key 0) on top of viem. The miner runs keccak256 in Web Workers (WASM, with a JavaScript fallback) or Node worker threads.

2. 02

   Point it at the relay#

   There is no project id: the relay URL is the only setting. This deployment's relay is https://relay-testnet.example. The relay checks the proof, co-signs and forwards the op to its own bundler. It is the only endpoint that ever sees your address.

3. 03

   Send the op#

   sdk.tsnext.config.tscURL

   Copy

   import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
   import {
     claimCall, createRelayClient, deployments, freshAccountState,
     sendPowUserOperation, startEpochPolling, transferCall,
   } from '@unlinked/sdk'
   
   const relay = createRelayClient('https://relay-testnet.example')
   const epochs = startEpochPolling(relay)       // fixed 60 s background poll
   const owner = privateKeyToAccount(generatePrivateKey()) // never funded
   let state = freshAccountState(owner.address)  // known locally, no read
   const { faucet, tokens } = deployments[46630]!
   
   const claim = await sendPowUserOperation({
     relay, epochs, owner, state,
     call: claimCall(faucet!, tokens.mNVDA!),    // first op: 7702 + claim
     onProgress: (p) => p.stage === 'mining' && console.log(`${p.found}/8`),
   })
   state = claim.state                           // delegated, nonces advanced
   
   const to = privateKeyToAccount(generatePrivateKey()).address
   const call = transferCall(tokens.mNVDA!, to, 10n ** 18n)
   const sent = await sendPowUserOperation({ relay, epochs, owner, state, call })
   console.log(sent.receipt.success, sent.userOpHash)
   epochs.stop()

   Relay URL filled in from this deployment (Robinhood Chain testnet).

   The first op of a fresh key carries an EIP-7702 authorization for Simple7702Account v0.9. The bundler's own type-4 transaction applies it, so the key never needs ETH. Keep the returned state for the next op: the SDK never reads it from the chain before mining.

   Run on testnet

   No relay is configured for this deployment.

Show progress and let people stop#

Mining is memoryless: every hash has the same odds, so show the found sub-solutions (x/8) and an honest estimate, never a fake percentage. Pass an AbortSignal for a Stop button.

const res = await sendPowUserOperation({
  relay, epochs, owner, state, call,
  delaySec: 120,              // optional: the relay holds the op 2 min
  signal: controller.signal,  // your Stop button
  onProgress: (p) => {
    if (p.stage === 'waiting') show(`Next epoch in ${p.seconds} s`)
    if (p.stage === 'mining') show(`${p.found}/8 · ~${Math.ceil(p.eta)} s`)
    if (p.stage === 'included') show(p.success ? 'Sponsored' : 'Reverted')
  },
  onState: (s) => save(s),    // persist the state as it advances
})

Imported keys#

A fresh key starts at freshAccountState(address) with no read at all. A key that already has history (a stealth address that received tokens, say) needs its state once:

import { loadAccountState } from '@unlinked/sdk'

// An imported key may already have history: read its state once, through the relay only.
let state = await loadAccountState(relay, owner.address)

Handle failures#

A failed send never costs ETH: either the op was not sponsored, or it was included and only the call reverted. The SDK re-mines by itself, at most twice, when the epoch rolls or the bundler's quotes move while you mine.

Next steps#

• 01How it works →The wire format, the challenge and how much work an op costs.
• 02Live parameters →Difficulty, caps and budget right now, and the time per op on this device.
• 03Privacy guide →Relay delay, nonce key 0 and what never to do with a fresh key.