# glue

> Pay with USDC.e or pathUSD on Tempo mainnet to receive native ETH on Base, Ethereum, Arbitrum, Optimism or Robinhood, or native TRX on Tron. The first four also support Sepolia testnets. Glue uses Relay, with Gas.zip for testnet delivery. Agents pay through Machine Payments Protocol (MPP); no Glue account or API key is required.

Base URL: https://glue.figtracer.com
Payment endpoint: POST https://glue.figtracer.com/api/refuel
Payment method: tempo.charge (one-time MPP payment).
Source network: Tempo mainnet, chain ID 4217, even when receiving testnet ETH.

## Local services

The [Glue CLI](https://github.com/figtracer/glue) uses the same Tempo wallet and MPP refuel endpoint for scheduled funding. Tempo-token refills swap directly on Tempo. Checks run locally with launchd or systemd; no LLM, Glue account, subscription or app fee is needed.

Run `glue services --json` to discover the bundled catalog and `glue list --json` to find existing local jobs. Reuse saved jobs before creating another. Configure `glue init refill`, preview with `glue run --policy FILE`, then install it with a bounded Tempo passkey approval. Each named job retains its grant, budget and pending receipts across restarts.

- [Refill](https://github.com/figtracer/glue/blob/main/docs/services/refill.md): maintain one wallet, a fleet, prepared work or a pathUSD/USDC.e balance. The setup options select the mode; use `glue init refill --help`.
- [Agent instructions](https://github.com/figtracer/glue/blob/main/AGENTS.md): setup, authority and recovery rules.

The computer must stay awake and online. Reuse existing jobs and approvals; never reset state or create a new payment to recover from a delayed receipt. Network and provider fees still apply.

## One-off refuel

**Request**

Send JSON with these fields:

- `sender`: your actual Tempo paying wallet's nonzero EVM address.
- `recipient`: the destination address. EVM destinations use a nonzero EVM address; Tron uses its case-sensitive Base58Check address.
- `chainId`: destination chain ID from the list below (a JSON number).
- `amount`: gross spend in source tokens, as a positive decimal string with up to six decimal places. No $10 app cap; provider minimums and liquidity still apply.
- `token`: source token contract address. Defaults to USDC.e if omitted.

Both source tokens have six decimals:

- USDC.e: `0x20c000000000000000000000b9537d11c60e8b50`
- pathUSD: `0x20c0000000000000000000000000000000000000`

Destination chain IDs:

| Network | Mainnet | Sepolia |
| --- | --- | --- |
| Base | 8453 | 84532 |
| Ethereum | 1 | 11155111 |
| Arbitrum | 42161 | 421614 |
| Optimism | 10 | 11155420 |
| Robinhood | 4663 | — |
| Tron | 728126428 | — |

One request funds one destination. Output is native ETH (including Sepolia test ETH) or native TRX on Tron; there is no arbitrary output-token parameter. Tron output uses six decimals; ETH uses 18.

**Quote, then pay with Tempo CLI**

Use an existing funded Tempo wallet and the user's authorized budget. `tempo wallet whoami` identifies the payer. Replace BOTH placeholder addresses below with real addresses. Generate a unique order key once, and save it with the exact request body before paying. Keys must be 16–128 characters using letters, digits, underscores or hyphens.

```sh
tempo request --dry-run https://glue.figtracer.com/api/refuel \
  --network tempo \
  --max-spend 0.25 \
  --payment-token 0x20c0000000000000000000000000000000000000 \
  -H 'Idempotency-Key: YOUR_UNIQUE_ORDER_KEY' \
  --json '{"sender":"YOUR_TEMPO_ADDRESS","recipient":"YOUR_BASE_ADDRESS","chainId":8453,"amount":"0.25","token":"0x20c0000000000000000000000000000000000000"}'
```

This creates an unpaid offer without charging. Inspect the amount, token, destination, recipient, `minimumEth`, reserve and expiry. Remove ONLY `--dry-run` to pay the same offer before expiry, retaining the same key and body. The initial Tempo payment network fee is additional to the quoted token charge; budget for it separately.

For USDC.e, replace the token address in BOTH `--payment-token` and the JSON. For Sepolia, choose its chain ID and a sufficient amount: `"1.10"` is a starting point, subject to the live quote. Update `--max-spend` to your authorized amount too. Gas.zip requires $1 after Relay fees per destination. Glue never rounds the charge up to meet a minimum.

**MPP over HTTP**

1. POST the JSON with `Content-Type: application/json` and `Idempotency-Key`. An unpaid offer returns HTTP 402, a JSON quote and a `WWW-Authenticate: Payment ...` challenge. Reading an offer costs nothing.
2. Let an MPP-compatible client pay that exact `tempo.charge` challenge, then retry the same request with its `Authorization: Payment ...` credential. Both transaction-hash/push and signed-transaction/pull credentials are supported. Preserve the challenge and its memo; an ordinary transfer to an address is not a substitute for the MPP credential.
3. Save the response, payment credential and transaction hashes. A `Payment-Receipt` header confirms the Tempo payment, not destination delivery.
4. Resolve the returned `statusUrl` against the base URL and GET it to check delivery. Keep every returned query parameter. On Sepolia this checks the final testnet transfer, not just the intermediate Base transaction.

**Retries and delivery**

Reuse the EXACT key and request body for every retry of an order. Preserve the original credential if payment was submitted. Never generate another key or authorize another payment merely because a response timed out or a receipt is delayed.

- 402: unpaid offer; review before payment. Offers normally expire after 60 seconds; `expiresAt` is Unix milliseconds and is authoritative.
- 202: payment or settlement is being reconciled. Repeat the same POST/key/body without authorizing another payment.
- 200: inspect JSON `status`; it does not imply gas arrived. `submitted` means source settlement completed; follow `statusUrl` for delivery. `refunded` means settlement did not proceed and the spendable remainder was returned. `payment_failed` means the recorded payment failed verification or execution; investigate before starting anything new.
- 409: conflicting terms or an invalid/unverified credential. Do not pay again; recover the original order and credential.
- 410: the unpaid offer expired. Only use a fresh key if you know no payment was submitted for the old offer. Otherwise recover that order.
- 429: honor `Retry-After` (normally 60 seconds), keeping the same key/body. Background recovery continues.
- 400/413: invalid or oversized request. Correct an unpaid request; the JSON body limit is 2048 characters.
- 503 or a network timeout: retry the same order; do not create a replacement payment.

The POST response may also show `payment_pending`, `paid`, `swap_pending` or `refund_pending` while recovering. Repeating a known paid order returns its recorded progress without a new charge. The returned GET `statusUrl` reports `success` when delivery is confirmed; `refund`, `fallback` or `failure` require inspecting the receipt. Other statuses mean wait and check again. Poll gently, for example every five seconds.

`paymentHash` identifies the MPP source payment. `sourceHash`, when present, identifies the settlement transaction. `refundHash` and `refundAmount` describe a settlement/reserve return, which can occur even on a successful order. `trackUrl` opens the Relay order; for Sepolia it covers the intermediate bridge, so use `statusUrl` to determine final delivery. The compatibility fields `expectedEth` and `minimumEth` are decimal destination-native amounts; use `outputSymbol` and `outputDecimals` (TRX/6 or ETH/18) to interpret them. Order IDs are your idempotency keys; Relay request IDs are separate identifiers.

**Costs and settlement**

Glue charges no app fee; provider and network fees still apply. New MPP orders use an isolated server-controlled wallet per order for direct source contract execution, avoiding Relay's deposit-address collection step. Existing deposit-address orders retain their original route. For new orders, 0.01 source tokens are reserved FROM the requested amount, not added to it: a gross 0.25 pathUSD payment quotes 0.24 through Relay; a gross 1.10 Sepolia payment quotes 1.09. Orders must exceed 0.01 and meet the provider's route minimum.

The offer exposes `amount`, `relayAmount`, `executionReserve`, `expectedEth` and `minimumEth` before payment. Unused execution reserve returns to the payer less refund fees; unspendable dust can remain. A refreshed settlement route must meet the accepted minimum native output, otherwise Glue refunds the spendable remainder less network costs. Relay refunds are separate and may arrive in USDC.e or USDT0 on Tempo. Sepolia ETH is testnet currency for development, paid for using real Tempo mainnet tokens.

## Optional

- [Tempo agent documentation](https://tempo.xyz/developers/llms.txt): Wallet, network and developer documentation.
- [MPP documentation](https://mpp.dev/llms.txt): Protocol and client implementation guides.
- [llms.txt specification](https://llmstxt.org/): Format and discovery conventions for this file.