Buyer protection for resale tickets.
Pay from any chain through NEAR Intents, into an escrow that holds the money until the show is over.
Try it: lummy.id/near →
Every order, on chain →
What we built this week →
| In 30 seconds | |
|---|---|
| The problem | A resale ticket from a stranger can be fake, sold twice or never sent, and a crypto payment cannot be taken back. |
| Lummy | A resale marketplace that holds the buyer's money in escrow until 48 hours after the show, and checks every ticket before it is listed. It existed before this hackathon. |
| New, on NEAR | Pay from any chain. NEAR Intents turns any of 15 assets on 9 chains into exactly the ticket's price and delivers it into the escrow. A ticket check you can verify. A model reads the ticket inside NEAR AI's TEE and signs its answer, and our contract on NEAR mainnet checks that signature again. |
| Proof | Real USDC from a wallet on Base, locked in the escrow 37 seconds later. Every order is public, and every check can be run from a terminal. |
Important
Status (November 2026): a working prototype, not launched. No users and no revenue yet. Real money moves only in the Lummy team's own demo payments on Arbitrum One, through contracts that are unaudited and capped at 25 USDC an order by the escrow (our admin key can change that cap). Everyone else pays in test mode: QRIS in Xendit's test mode, USDC on Arbitrum Sepolia.
Tracks: Real-World Money, Privacy & Private AI, and Open Innovation (there, for one idea: an order's terms are the address the money is sent to, so a payment from another chain can only end in that order's escrow or back with the buyer). Lummy existed before the hackathon, and only the NEAR work is new. All of it is in the diff since the tag pre-hackathon. What came before is listed at the end.
Jump to: What we built · Real payments · Screens · Try it in 2 minutes · Run the checks · Who can move the money · Contracts · Not done yet
Resale tickets change hands between strangers. The ticket can be fake, sold twice, or never sent. Paying in crypto makes this worse: a transfer cannot be taken back, and the buyer and the seller rarely hold the same coin on the same chain.
On Lummy the buyer's money is held until 48 hours after the show, and the seller is paid only if no claim stands. Every ticket is checked before it is listed. This week we brought both to NEAR: a buyer can pay from any chain into the escrow, and the ticket check runs in a TEE with a receipt anyone can verify.
Where NEAR is in it.
Where NEAR is in it.
- Every payment from another chain crosses NEAR. NEAR Intents swaps it on
intents.nearand delivers it to the escrow: five NEAR transactions for the order of 12 November, Base to escrow in 37 seconds. - The ticket check runs in NEAR AI Cloud's TEE (a trusted execution environment: hardware-isolated and attested) and is signed there, for every listing by the team and every check on lummy.id/near.
- Our contract on NEAR mainnet,
lummy-receipts.near, recovers the signer of each receipt again, on chain. - The escrow stays on Arbitrum One, where it was built and tested; NEAR Intents brings the money to it. Why.
A buyer pays for a ticket to a show abroad with any of 15 assets on 9 chains: USDC on Base, Solana, Ethereum, NEAR, Optimism, Polygon or Avalanche, USDT on Solana or Ethereum, ETH on Base, Arbitrum or Ethereum, SOL, BTC or wNEAR. NEAR Intents turns it into exactly the ticket's price in USDC and delivers it on Arbitrum One to a contract made for that one order. That contract can do only two things with the money: lock it in Lummy's escrow on the agreed terms, or send it back to the buyer.
sequenceDiagram
autonumber
actor B as Buyer (any wallet, any chain)
participant L as lummy.id
participant N as NEAR Intents (1Click)
participant R as Order receiver (Arbitrum One)
participant E as LummyEscrow (Arbitrum One)
B->>L: A ticket, an asset to pay with, a refund address
L->>L: Receiver address = CREATE2 of the order's terms
L->>N: Quote EXACT_OUTPUT: the price in USDC, to the receiver
N-->>B: A deposit address on the buyer's own chain
B->>N: Pay (USDC, USDT, ETH, SOL, BTC, wNEAR...)
N->>R: Exactly the price, in USDC on Arbitrum One
L->>R: deployAndFund (anyone may call it)
R->>E: fund the listing, on the terms in its own address
Note over E: Held until 48 hours after the show
E-->>R: On a claim upheld, the refund
R-->>B: sweep: to the refund address
- The terms are fixed before the buyer pays. The receiver's address is computed with CREATE2 from the listing, the seller, the price, when the show ends, the refund address and a deadline. 1Click delivers to that address, so paying it is agreeing to those terms. The checkout shows them.
- Before the money is locked in the escrow, no key controls it, ours included; after, no key can send it to anyone but this order's seller or buyer. Every function of the receiver except
raiseDisputeis open to anyone. Until the money is locked in the escrow it can only fund that listing on those terms or go back to the refund address, and if Lummy's servers were gone the buyer could deploy the receiver and take it back after the deadline. Once it is locked, Lummy's operator key decides: it can refund the buyer, or file the buyer's claim and rule on it, which can pay the seller early (today a team wallet). Without that key the escrow pays the seller 48 hours after the show, or holds the money while a claim is open. - Finished by the server, not by the buyer's tab. 1Click has no webhooks, so someone has to ask how the swap is going. The buyer's page asks while it is open, and a job on the server asks every minute (
api/cron/intents): once the USDC is at the receiver the escrow is funded and the order written, whether or not the page is still open, and an email says so. Both go through one lock, so an order is funded once. Until 11 November only the page asked; in our own run the buyer wondered what would happen if they closed it.
More on how the payment is built (the escrow is unchanged, overpayments, paying twice, reading the wallet, where the code lives)
- The escrow did not change. To
LummyEscrow, the receiver is a buyer with a contract wallet (EIP-1271). It approves only the escrow and USDC, and only while its ownfund()is running. - Too much, or too late. An overpayment goes back to the refund address in the same transaction. Money still at a receiver after its deadline is sent back by that same job within minutes, or by anyone.
- Paid by hand, so guarded against paying twice. A hold whose money is already on its way (1Click has seen a deposit, or USDC sits at the receiver) cannot be cancelled or replaced by a new payment, and a payment left open is shown again when the buyer comes back, with a warning not to send it twice.
- The wallet is read before the buyer chooses. With a browser wallet connected, the server reads what it holds of the nine EVM assets on six chains (one batched call a chain, about 3 seconds), asks 1Click what this order would take of each, and the checkout lists them: enough, how much is missing, or no gas on that chain. What can pay is picked, a stablecoin before a coin whose price moves and Ethereum last. The refund address is filled in from the wallet, and the buyer confirms one transfer there. The deposit address and its QR stay, for Solana, Bitcoin, NEAR and exchanges. We added this on 11 November after our own run, where the buyer picked ETH while holding USDC and pasted the address by hand (
held.ts,balances.ts). - Where it lives:
contracts/src/LummyIntentReceiver.sol,web/src/lib/near/oneclick.ts,web/src/lib/payments/intents.ts,web/src/components/checkout/IntentsPanel.tsx.
| Step | Where the money is | Who can move it | Where it can go |
|---|---|---|---|
| 1. Paying | At NEAR Intents, then at the order's receiver on Arbitrum One | Nobody can redirect it: every function of the receiver but raiseDispute is open to anyone |
Into the escrow on the order's terms, or back to the buyer's refund address |
| 2. Locked | LummyEscrow |
Lummy's operator key: refund, or rule on a claim (it can also file the buyer's claim for them) | This order's buyer or this order's seller, never anyone else |
| 3. Show over, no claim | LummyEscrow |
Anyone can release it 48 hours after the show, even with our servers gone | The seller (a team wallet today) |
| 4. A claim is open | LummyEscrow |
Only an operator can rule on it, and release is blocked until then | Split between this buyer and this seller |
The operator key is one key we hold, and the contracts are unaudited. No real seller has been paid yet.
All three were the team's own money, and each is a public record.
| When | Paid from | Amount | Locked in the escrow | Then | Record |
|---|---|---|---|---|---|
| 9 Nov 2026 | Base, by our test script | 1 USDC | about 20 seconds after NEAR Intents saw the deposit | refunded by the escrow | proof |
| 10 Nov 2026 | Ethereum, at the checkout | 9.50 USDC | under two minutes after the buyer sent it | a claim, ruled for the buyer, refunded | proof |
| 12 Nov 2026 | Base, a connected wallet, one confirmation | 9.50 USDC | 37 seconds after the transfer | held a day, then claimed by us and refunded | proof |
From the screen recording of that order: the wallet as Lummy read it, the panel after the one transfer, and the order page a minute later.
Every transaction of the three payments
On 9 November 2026 the team paid 1.0156 USDC from a wallet on Base. Each step is public:
- Paid on Base
- The swap on NEAR Intents. The 0.0078 USDC it did not need went back on Base.
- 1 USDC arrived at the order's receiver on Arbitrum One, about 20 seconds after NEAR Intents saw the deposit
- Locked in the escrow
- Refunded by the escrow
- Back at the buyer's refund address
The swap cost 0.0054 USDC. The four transactions on Arbitrum One cost about 0.000026 ETH in gas, paid by the operator.
Then the whole flow on lummy.id (10 November 2026). A team seller account listed a sample Binance Blockchain Week ticket at 9.50 USDC. NEAR AI's TEE read it (the receipt on NEAR's Verification Center), and it went to staff review because it is stamped SAMPLE; staff cleared it. A team buyer account paid for it from Ethereum at the checkout, filed the claim "ticket never handed over" to test the way back, the seller agreed, and staff ruled for the buyer. The whole order is on its public proof page, read from the contract:
- Paid 9.603158 USDC on Ethereum
- The swap on NEAR Intents
- 9.5 USDC at the order's receiver on Arbitrum One, and locked in the escrow under two minutes after the buyer sent it
- Refunded on staff's ruling
- Back at the buyer's refund address, the one locked in the order's terms before paying
NEAR Intents used 9.507126 USDC of what was sent. The other 0.096 USDC did not come back: returning it on Ethereum costs 0.30 USDC, more than it is worth, while on Base the same leftover did come back. Gas was about 0.000015 ETH on Ethereum for the buyer and 0.000026 ETH on Arbitrum One for the operator. The seller got emails when the listing went live, sold and was claimed; the buyer when the payment arrived and the claim was filed.
And from a connected wallet, in one confirmation (12 November 2026). The checkout as it is now. The buyer connected a wallet, Lummy read what it held on six chains and picked USDC on Base, and the buyer confirmed one transfer in the wallet. Nothing was copied by hand. The money was locked 37 seconds after that transfer:
- One transfer of 9.603158 USDC on Base, at 03:00:52 UTC
- The swap on NEAR Intents: 9.507126 USDC used, and the other 0.093632 sent back to the wallet on Base. Between Base and Arbitrum the money crossed NEAR itself, in five transactions on
omft.nearandintents.near(the first, the swap) - 9.5 USDC at the order's receiver on Arbitrum One, 27 seconds after the transfer
- Locked in the escrow at 03:01:29 UTC, and the handover recorded
- Its public proof page. The escrow held its 9.50 USDC for a day. On 13 November we claimed it ourselves, to use the money again: the claim, a person's ruling and the 9.50 USDC back at the buyer's refund address, 28 seconds apart. No real order is locked in the escrow right now; the list shows each one's state
The ticket was read in NEAR AI's TEE when it was listed, and the receipt kept with the listing carries NVIDIA's verdict on the GPU evidence: valid, for our nonce, signed by NVIDIA.
Check the terms yourself. The receiver of this payment, 0x903C…8f6A, shows its listing, seller, price, show end, refund address and deadline under Read Contract. Give them to the factory's receiverOf and it returns that same address. Change any one of them, the refund address included, and the address changes: the money could only go where those terms say.
Before a ticket is listed, a model reads the show, date, category and seat off its PDF. It fills the listing in and cross-checks what the seller picked. It decides nothing: anything that does not match goes to a person. This week that read moved into NEAR AI's TEE, and every read now comes back with a receipt anyone can check.
flowchart LR
P["Ticket PDF"] --> C["Lummy's server takes out names,<br/>booking codes, barcodes, ID numbers"]
C --> M["Qwen3.8-27B in NEAR AI's TEE"]
M --> F["Show, date, category, seat"]
M --> S["ECDSA signature over<br/>model : sha256(request) : sha256(reply)"]
S --> V["Signer checked against the key<br/>in the model's attestation report"]
V --> L["The listing links NEAR's<br/>Verification Center"]
- What leaves our server. Only the ticket's text, with names, booking codes, barcode contents, ID numbers, emails and phone numbers taken out (
clean.ts). If anything that looks personal is left, nothing is sent and the seller fills the form in by hand. - What the TEE adds. The text is read inside hardware-isolated, attested hardware: an Intel TDX machine whose NVIDIA GPUs run in confidential-computing mode. We say "hardware-isolated and attested", not "nobody can see it".
- The receipt. We hash the exact bytes sent and received, fetch the model's signature, recover its signer with viem, and require that signer to be a key named in the model's attestation report. The request names the model's canonical id with
x-no-aliasing, so NEAR's gateway forwards it unchanged and the signature comes from the model's TEE, not from the gateway. A listing links NEAR's Verification Center only when both checks pass. The receipt holds hashes, never the ticket's text. - The GPU, asked from our server. The attestation report carries the evidence each GPU produced for a nonce our server made up. The server sends it to NVIDIA's Remote Attestation Service and requires three things: NVIDIA's verdict, our nonce in NVIDIA's token (so the evidence is not a replay), and the token's ES384 signature by a key NVIDIA publishes (
gpu.ts). The Intel TDX quote of the machine around the GPU is not checked by us: NEAR's Verification Center checks it in the reader's browser, from the link on each receipt. - Checked by a contract on NEAR too.
lummy-receipts.nearon NEAR mainnet (source and tests) recovers a receipt's signer with its own arithmetic and keeps the receipts recorded in it. Every check on lummy.id/near is put to it through NEAR's public RPC, so the signature is checked three times: by our server, by NEAR's Verification Center, and by this contract, which any reader can ask directly. We still hold the account's key and could redeploy it, so compare the code hash60535f35…de31bwith a build from this repository. Change one character and the contract answers with another address. It went live on mainnet on 13 November 2026 after a day on testnet, paid for with USDC swapped to NEAR through NEAR Intents; the deploy and the first record. It is unaudited, and nothing that holds money depends on it. It proves who signed; that the key lives in a TEE is still the attestation report's to say. - What is kept. A listing keeps the facts that were read and the receipt: two hashes, the signature, the signer and NVIDIA's verdict. The text sent to the model is not kept. The ticket file is, in private storage, because the buyer has to receive it. The check on lummy.id/near writes nothing.
- Measured before it was switched on. On 33 made-up tickets, the cleaner rightly stopped 2 before anything was sent, and Qwen3.8-27B with thinking off read the other 31: every field right on 27, and on 4 it left the title blank rather than invent one. That is 182 of 186 fields (97.8%), with a median of 2.8 seconds and 31 of 31 receipts verified. Claude Haiku 5.5, which still reads other sellers' tickets, got every field right on the same set.
- Where it lives:
web/src/lib/tickets/near-ai.ts(the call and the receipt),web/src/lib/tickets/ai.ts,web/src/app/near/page.tsx.
NEAR's page checks NVIDIA's freshly issued GPU token with no allowance for clock difference. On a computer whose clock runs a few seconds slow it reports the GPU check as failed, while the same receipt passes in full once the clock is right. lummy.id/near says so next to the link.
When NEAR AI is down. On the morning of 10 November 2026 NEAR AI Cloud's API, its private models and its attestation service were all down for hours (status.near.ai), and the page could only show an HTTP 500. Now it says the live check failed and why, and shows the same check recorded from NEAR AI earlier (recorded.json, made by npm run near:record). The recording keeps the exact request and reply, so it is checked again rather than trusted: both hashes are worked out from those bytes, the signature is recovered, and the facts are read from the signed reply. The one-character test works the same. What a recording cannot show again is the attestation: that the signer was named in the model's attestation report is what our check found when it was recorded (recorded.ts).
![]() A marketplace, not a demo page. Shows, listings and prices next to face value. |
![]() Every ticket is checked first. An edited sample PDF is flagged for a person; a barcode already on sale is refused. |
![]() The money waits for the show. The order page shows where the money is, when it pays out, and the handover documents. |
![]() A person rules on claims. The evidence checks are signals for staff, not verdicts. |
![]() Every order, read from the contract. lummy.id/proof lists each order in the escrow with its state now. |
![]() One order, step by step. Each step links to its transaction; no personal data is on the page. |
| Do this | See this | |
|---|---|---|
| 1 | Open lummy.id/near and pick an asset under "Pay from any chain". With a browser wallet, press Connect a wallet | A live quote from NEAR Intents: what you would send on that chain for a 9.50 USDC ticket, and how long it usually takes. With a wallet: what it holds on six chains and which of it covers the ticket, the one that does already picked. Nothing is held, nothing is paid, and reading moves nothing |
| 2 | Under "A ticket check you can verify", press Check this ticket | A made-up ticket read in NEAR AI's TEE, "Signed by the model's TEE key", the signer named in the attestation report, and NVIDIA's attestation service confirming the GPU evidence for a nonce our server chose. If NEAR AI Cloud is not answering, the page says so and shows the same check recorded earlier, checked again (a recording carries no verdict from NVIDIA) |
| 3 | Press Check it on NEAR's Verification Center | NEAR's page verifies the same receipt and the hardware evidence in your browser |
| 4 | Press Change one character and check again | The changed receipt is refused |
| 5 | Open the six links under "On chain" | The first real payment, step by step, on Basescan, the NEAR Intents explorer and Arbiscan |
| 6 | Open that payment's receiver on Arbiscan, then the factory's receiverOf with the terms it shows |
The same address comes back: the terms the buyer paid against are fixed in the address itself |
Paying for real through NEAR Intents is open to the Lummy team's accounts only, so a visitor sees the quote but no deposit address.
For an agent, or anyone in a terminal. Every line reads public data; only the last needs a key, and that one is yours. AGENTS.md says the same for a coding agent in a few lines: what runs with no keys, what does not, and what may look wrong and is not. npm test runs the offline checks.
| Run this | See this | |
|---|---|---|
| A | curl -s https://lummy.id/api/near/options |
"assets" lists the 15 assets, "rail":true, and the two contracts on Arbitrum One: "escrow":"0x68d535494bf33a6F483A945683Ab629D036d3cb3" and "factory":"0x3dFc2bFFBfC17F1e5F741E0dCD04e8F24dd6b75C". "team":false: you may look, not pay |
| B | curl -s -X POST https://lummy.id/api/near/quote -H 'content-type: application/json' -d '{"originAsset":"nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near","amount":"9500000"}' |
A live quote from NEAR Intents for USDC on Base: "amountIn" near 9.60, "amountOut":"9.5", "etaSeconds". Nothing is held |
| C | curl -s -X POST https://lummy.id/api/near/ticket-check -H 'content-type: application/json' -d '{"sample":"concert"}' |
A made-up ticket read in NEAR AI's TEE, in 3 to 8 seconds: "facts", and a "receipt" with "verified":true, "attested":true and "gpu":{"ok":true,"fresh":true,"signed":true}. "verifyUrl" is NEAR's own page for that receipt. When NEAR AI is not answering, the reply carries "recordedAt" and "liveError" instead, and no "gpu". Six reads in ten minutes for each visitor |
| D | curl -s -X POST https://lummy.id/api/near/held -H 'content-type: application/json' -d '{"address":"0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045","amount":"9500000"}' |
"held": for each of the nine EVM assets, that wallet's "balance", what a 9.50 USDC ticket "needs" of it, and whether that is "enough" |
| E | curl -s https://rpc.mainnet.fastnear.com -H 'content-type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"query","params":{"request_type":"call_function","finality":"final","account_id":"lummy-receipts.near","method_name":"recent","args_base64":"e30="}}' |
NEAR's own RPC, not our server: the receipts recorded in our registry contract on NEAR mainnet, as the bytes of a JSON list. Each holds the signed text, the signature and the signer the contract recovered. |
| F | curl -s https://lummy.id/api/chain/recent |
Every order ever paid into the escrow on Arbitrum One, newest first, with its status now, read from the contract's events and not from our database. Three so far, all the team's own. The same list is the page lummy.id/proof. |
| G | curl -s https://lummy.id/api/chain/history/0x435ad32a3c0844c5562365f0a12ddcf4126d7eaecc0b67290d49120b9883b181 |
The team's real order of 10 November, read from the escrow's events on Arbitrum One: Listed, Funded, HandoverMarked, DisputeRaised, then Resolved with "toBuyer":"9500000", each with its transaction hash. The public proof page shows this same record. The same call with 0xcae8b654980f9b56ae6c63713f58cf0494bcbeb9ae71cd52b7a93bd63fa5c536 reads the order of 12 November, which was locked for a day and then claimed and refunded by the team on 13 November: Listed, Funded, HandoverMarked, DisputeRaised, Resolved with "toBuyer":"9500000", and "status":"Refunded" |
| H | git clone --recurse-submodules https://github.com/Lummy-Ticket/lummy && cd lummy/web && npm ci && npm run near:check (from here on, every row runs from the repository root lummy/) |
94/94 checks pass, offline, with no keys: the receipt, NVIDIA's verdict on the GPU evidence (its nonce and its signature), which asset a wallet is offered first, real receipts recorded from NEAR AI's TEE, what the page does when NEAR AI is down or flapping, paying the deposit from the buyer's own wallet, the Verification Center link, the 1Click request, and who may pay |
| I | cd web && npm run near:terms |
6/6 checks pass. It reads the terms that order's receiver carries from the contract itself, asks the factory which address those terms give (that very one), and shows that another refund address, price, deadline or seller each gives another address. A public RPC, no keys. npm run near:terms -- 0xC68d92284f6E226e1F190bFEe409dc49b10C5F8e does the same for the order of 12 November |
| J | cd web && npm run near:held -- 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 (or any address) |
What that wallet holds of the nine EVM assets, read from public RPCs, what a 9.50 USDC ticket would take of each, and which one the checkout would offer first. Dry quotes only: nothing is held or sent |
| K | cd contracts && forge test (needs Foundry) |
147 tests pass, 33 of them on the receiver and its factory |
| L | cd contracts/near-receipts && cargo test (needs Rust) |
8 tests pass on the NEAR contract: a real signature recovers its signer, one changed character gives another, and each refusal holds |
| M | cd web && npm run near:fork (Foundry again) |
13/13 checks pass in about a minute: both contracts deployed on a fork of Arbitrum One with Circle's real USDC, then a payment with too much, a release to the seller, a claim refunded through the receiver, and money with no order going back by itself. Nothing leaves your machine |
| N | cd web && NEAR_AI_API_KEY=your-key npm run near:prove (a key from cloud.near.ai; the hackathon's rules say NEAR Builders gives US$10 of credits) |
Two made-up tickets read in the TEE with your own key: the facts, "signature and text check out: true", "signer named in the model's attestation report: true", NVIDIA's verdict on the GPU evidence, and the link to NEAR's Verification Center. About US$0.001 |
Without a key, npm run dev still shows a real check on localhost:3000/near: the one recorded from NEAR AI, verified again from its bytes, and it says the server has no key.
Run the checks yourself. Needs Node 22 (20 and 24 also passed), plus Foundry (CI pins v1.8.3) for the contracts and Rust for the NEAR contract; no keys. Timings from a clean clone: npm ci about 70 s, near:check about 10 s, near:terms about 15 s, forge test about 90 s, cargo test about 2 min the first time (it fetches the pinned toolchain), near:fork about 50 s. The table of commands and what each prints · the same list for a coding agent.
| Check | What it covers | Result |
|---|---|---|
npm run near:check (in CI) |
Offline, no keys. A real ECDSA signature over model:request_hash:response_hash passes, and a changed hash, model, signer, text or kind of signature fails. The Verification Center link carries no ticket text. A listing links a receipt only when it was verified and attested. The 1Click request asks for the exact amount at the receiver, with refunds on the chain paid from. Only staff and the named team may pay, never a demo account. Real receipts recorded from NEAR AI's TEE: the exact request and reply kept in the repository hash to what the model's key signed, the signature recovers to that key, and one added character is refused. When NEAR AI answers with an HTTP 500, /near gets the recording, marked as one, and does not ask again for two minutes. NEAR's 400 "Provider failed", which it gives while a model is redeployed, is tried again; other 400s are not. Paying from the buyer's own wallet on an EVM chain sends the exact units: transfer to the deposit address on the token, or plain value for ETH. A wallet's balance is judged against a live quote and the gas to send it, and what can pay is offered a stablecoin first and Ethereum last. NVIDIA's verdict on the GPU evidence counts only with our nonce, unexpired, from NVIDIA's issuer and signed by a published key. A server with no NEAR AI key shows the recorded check and says so. Every error these routes send carries English. The minute cron runs for nobody without its secret |
94 of 94 |
npm run near:terms |
On Arbitrum One, through a public RPC: the receiver of the real order of 10 November carries its terms, the factory gives that very address for them, and a changed refund address, price, deadline or seller each gives another address | 6 of 6 |
forge test in contracts/ |
The new receiver and its factory (33 tests: the two exits, the terms checked against the escrow, overpayment, late money, EIP-1271 only inside fund, fuzzing), plus the escrow and ledger from before |
147 of 147. The receiver: 100% of lines and functions, 91.7% of branches |
RUN_FORK=1 forge test --match-contract Fork |
The receiver against Circle's real USDC on a fork of Arbitrum One | 2 of 2 |
npm run near:fork |
The chain side through the app's own code, on that fork: a payment with too much, a release to the seller, a claim refunded through the receiver, money with no order going back by itself | 13 of 13 |
npm run near:app |
The whole app flow: a local server, the real 1Click API, the database and the fork. A hold and a cancel, an overpayment, one order however often it is checked, a claim refunded to the refund address. Then a payment whose buyer never looks again: with part of the money delivered a second payment is refused and the hold cannot be cancelled, and with the rest delivered the minute cron alone writes the order and the buyer is told by email | 33 of 33 |
npm run near:pay |
One real payment from another chain into the escrow on Arbitrum One and back | Done 9 Nov 2026 |
npm run ai:eval -- --provider near |
33 made-up tickets, each through the same cleaning as a real upload, then the TEE model; every request checked for names, numbers and codes that should have been taken out | 29 of 33 tickets right (2 of them rightly never sent), 182 of 186 fields (97.8%), 31 of 31 receipts |
cargo test in contracts/near-receipts (in CI) |
The NEAR contract: a real TEE signature recovers its signer, one changed character gives another address, and it refuses a missing deposit, a second copy, text that is not a receipt, text too long for its deposit, and a short signature | 8 of 8 |
Slither (Trail of Bits), in our working repository's CI (the checks run on this public copy are forge test, cargo test and near:check) |
The new receiver triaged with the rest in contracts/SECURITY-ANALYSIS.md. CI fails on any untriaged medium or high finding |
21 new findings triaged, none a real issue |
Anyone can run near:check, near:terms, near:held and forge test with no keys, and near:fork with Foundry: on 11 November it passed in under a minute from an environment with nothing but Foundry and Node. The app and payment runs need our keys or the database, so the team runs them. The results above are from 9 to 12 November 2026.
On Arbitrum One (chain ID 42161), new this week
| Contract | Address | What it does |
|---|---|---|
LummyEscrow |
0x68d535494bf33a6F483A945683Ab629D036d3cb3 |
The same escrow as on Arbitrum Sepolia, deployed fresh: Circle's USDC, a 48-hour claim window after the show, at most 25 USDC an order (a cap our admin key can change) |
LummyIntentFactory |
0x3dFc2bFFBfC17F1e5F741E0dCD04e8F24dd6b75C |
Computes each order's LummyIntentReceiver address, and deploys and funds it |
Both have verified source on Arbiscan and are not proxies. Neither takes a fee. Money in the escrow can only go to a listing's buyer or seller, and money at a receiver only into its listing or back to its refund address.
On NEAR mainnet, new this week
| Contract | Account | What it does |
|---|---|---|
lummy-receipts (Rust) |
lummy-receipts.near |
Recovers the signer of a NEAR AI TEE receipt with its own ecrecover and keeps the receipts recorded in it; holds no money. Deployed with code hash 60535f35…de31b, the same as building contracts/near-receipts here |
On Arbitrum Sepolia (chain ID 421614), from before the hackathon: LummyEscrow with test USDC, and LummyLedger, the public record of QRIS orders. Details: contracts/README.md.
flowchart TB
subgraph Buyer["Buyer"]
W["Any wallet on any of 9 chains"]
UI["lummy.id pages"]
end
subgraph App["Next.js app on Vercel"]
API["Server routes<br/>web/src/app/api"]
OP["Operator key<br/>pays gas, never holds the buyer's money"]
end
subgraph NEAR["NEAR"]
NI["NEAR Intents<br/>1Click API"]
NA["NEAR AI Cloud<br/>a model in a TEE"]
RR["lummy-receipts.near<br/>re-checks each receipt"]
end
subgraph ARB["Arbitrum One"]
R["LummyIntentReceiver<br/>one per order"]
E["LummyEscrow"]
end
DB[("Supabase<br/>Postgres with RLS,<br/>email sign-in")]
UI -->|"sign in, list, buy, claim"| API
API -->|"quote: the exact USDC, to the receiver"| NI
W -->|"pays the deposit address"| NI
NI -->|"USDC"| R
API -->|"the cleaned ticket text"| NA
NA -->|"facts and a signed receipt"| API
API -->|"who signed this?"| RR
OP -->|"deployAndFund, refund, sweep"| R
R -->|"fund, on the agreed terms"| E
DB <--> API
The database decides; the chain holds the money. Tickets stay off chain: they are the organiser's PDFs, not NFTs.
Why the escrow stays on Arbitrum. It was already built and tested there: Circle's native USDC with ERC-3009, the escrow's own 76 tests with fuzzing and invariant runs, and a testnet deployment the app has used since October. NEAR Intents delivers to any chain, so it brings the money to the escrow from 9 chains, NEAR itself included, without moving the escrow. Rewriting it as a NEAR contract in Rust this week would have meant shipping an untested escrow.
stateDiagram-v2
state "Paid" as paid
state "In escrow" as escrow
state "Show over: claim window open" as window
state "Claim with proof" as claim
state "Seller paid" as released
state "Refunded" as refunded
[*] --> paid: from any chain, QRIS or USDC
paid --> escrow: held, not by the seller
escrow --> window: the show ends
window --> released: no claim within 48 h
window --> claim: turned away at the gate
escrow --> claim: ticket never handed over
claim --> refunded: a person rules for the buyer
claim --> released: a person rules for the seller
escrow --> refunded: show cancelled
released --> [*]
refunded --> [*]
A ruling can also split the money. The clock settles an order, not a button: there is no "I got in" confirmation to fake. A refund on an order paid from another chain goes to the refund address the buyer gave before paying, as USDC on Arbitrum One.
Everything before the tag pre-hackathon existed already and is not part of this entry. We set the tag on 9 November 2026, the day we entered; the hackathon opened on 1 November. In this public copy it sits on 8 November, 14:36 WIB: the commit we tagged on the 9th held only our plan for the week, and the plan is not published, so the tag lands on the last commit before it.
- Before Lummy, 2025 to early 2026: the team's first ticketing build was fully on-chain, made in a hackathon and an incubator in the Lisk ecosystem. It taught us that an ordinary fan will not install a wallet for a ticket, so we pivoted to a hybrid and narrowed to resale. None of that code is in this repository.
- Lummy, since July 2026: escrow for concert ticket resale in Indonesia. Rupiah by QRIS through Xendit in test mode: the licensed provider holds the money until the show (in test mode, no real money), and every paid order is recorded on
LummyLedger. Ticket checks: each barcode held by one listing only, edited PDFs sent to a person, the show and seat read by Claude after personal data is taken out. Claims ruled by a person. - Arbitrum Founder House Singapore, 23 to 25 October 2026: we added the checkout for shows abroad, in test USDC from the buyer's own wallet, into
LummyEscrowon Arbitrum Sepolia. We submitted it, and were not a finalist. The tagfounder-house-startmarks where that work began, and the demo video from then shows the product as it was.
- App: Next.js 16 and TypeScript on Vercel, Supabase (Postgres with row-level security, email sign-in), viem.
- Contracts: Solidity 0.8.28 with Foundry and OpenZeppelin, Circle's USDC, Slither in our working repository's CI.
- NEAR: NEAR Intents through the 1Click API (quote, deposit, status). NEAR AI Cloud: Qwen3.8-27B in a TEE, its signature endpoint and its attestation report. A contract in Rust with near-sdk 5.30 and cargo-near, on NEAR mainnet.
- AI tools: most of the code was written with Claude Code (Anthropic), directed and reviewed by the team, and Claude drafted this README. Claude Haiku 5.5 reads tickets for sellers outside the team.
Measured on the team's own orders above, not projected.
| For one order | Cost | Who pays it |
|---|---|---|
| Gas on Arbitrum One for its four transactions (create the listing, fund it, record the handover, settle) | about 0.000026 ETH | Lummy's operator |
| The swap through NEAR Intents | 0.0054 USDC on a 1 USDC order, 0.0071 USDC on a 9.50 USDC order, the same from Ethereum and from Base | The buyer, inside the quote |
| The ticket read in NEAR AI's TEE | about US$0.0005 | Lummy |
- How Lummy would earn. A service fee on each order. The rupiah checkout already adds 5% for the buyer, in test mode. The USDC rail takes none yet: the escrow has no fee path, on purpose, and adding one is a contract change we would make together with an audit.
- Before anyone but the team pays real money. An audit of
LummyEscrowandLummyIntentReceiver. A way for sellers to be paid in USDC, since they sign in with an email and have no wallet. Live mode with the rupiah payment provider. - Why NEAR stays in it. Fans buy tickets to shows abroad with whatever they hold. NEAR Intents lets the checkout take that without Lummy running a bridge or holding an exchange account, and the TEE read costs less than the fee on the cheapest ticket.
- Real payments through NEAR Intents are for the team's accounts only, at most 25 USDC an order. "Team only" is a rule of the app, not of the contracts: on chain anyone could pay, and our admin key can change the cap. The contracts are unaudited.
- No seller has been paid with real money yet: the release to a seller has run on a fork of Arbitrum One, not on the live escrow.
- Once money is in the escrow, our operator key decides: it can refund the buyer, or file the buyer's claim and rule on it, which can pay the seller early. It cannot send money to anyone else. Without that key the escrow pays the seller 48 hours after the show and holds the money while a claim is open; a refund on a timeout is not built.
- On Arbitrum One the seller's share goes to a team wallet: sellers sign in with an email and have no wallet yet.
- The listings on shows abroad are the team's samples.
- The TEE read runs for the team's accounts. Other sellers' tickets are still read by Claude Haiku, after the same cleaning.
- NEAR AI's response times vary: 1 to 8 seconds this week, with the odd stall of 20 to 30 seconds. A try is cut at 12 seconds and sent again.
- The escrow is not on NEAR. Every payment crosses NEAR through NEAR Intents (five NEAR transactions for the order of 12 November) and lands in the escrow on Arbitrum One; our one contract on NEAR,
lummy-receipts.near, checks ticket receipts and holds no money. The app asks it on every check on /near but does not yet record each listing's receipt in it. - USDC that is already on Arbitrum One cannot pay yet. NEAR Intents swaps other assets into it, and the direct path, sending it straight to the order's receiver, is not built.
- Paying from a connected wallet in one confirmation has carried one real payment: from Base, with the Rabby wallet, on 12 November. Other wallets and the other five chains are untried.
- We do not verify the Intel TDX quote ourselves. NEAR's Verification Center does, in the reader's browser.
Repo map
| Path | What it is |
|---|---|
web/ |
The Next.js app in TypeScript: buyer, seller and staff pages |
web/src/lib/near |
NEAR Intents (1Click), who may pay, the made-up tickets for /near |
web/src/lib/tickets |
The ticket checks: barcodes, the cleaner, the AI step, the NEAR AI call and its receipt |
web/src/lib/payments |
Payments from any chain, QRIS through Xendit, and the USDC checkout |
web/src/lib/chain |
Contract access with viem, on the server and in the browser |
web/src/app/api |
Server routes: listings, orders, payments, claims, the ticket checks, /near |
web/scripts |
The checks above, and the local and fork rehearsals |
contracts/ |
Solidity and Foundry: LummyEscrow, LummyLedger, LummyIntentReceiver, tests, deploy scripts |
contracts/near-receipts |
The receipt registry on NEAR, in Rust, with its tests and record.sh |
supabase/ |
The Postgres schema, row-level security and its tests, email templates |
Run it locally
Node 22 and Foundry. Each line runs from the repository root:
(cd web && npm ci && npm run near:check) # the NEAR checks, offline
(cd contracts && git submodule update --init --recursive && forge test)
(cd web && npm run dev) # the app on localhost:3000, on sample data
(cd web && npm run chain:local) # Anvil, a deploy, and four escrow cyclesWithout environment variables the app runs on its sample catalogue and sample accounts. web/.env.example lists what a deploy sets, the NEAR keys included. Code comments are in English and Indonesian.
Note
This repository is a public mirror of our working repository. It holds the app, the database schema and the contracts, with their full commit history. Internal notes, plans and partner documents stay private, so a few links in code comments and commit messages point to files that are not here.
- Zahra Sasongko, CEO
- Luthfi Hadi, CTO (@luthfidi)
- Joanita Timbin Panggalo, COO
Contact: team@lummy.id. More at github.com/Lummy-Ticket.
All rights reserved: see LICENSE. You may read the code and run its checks to judge this entry. For anything else, write to team@lummy.id.










