From 5ea718fb71e3a33af44d64424ead69588b9c375d Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Fri, 13 Nov 2026 21:48:35 -0600
Subject: [PATCH 1/9] docs: README with try-it steps, key limits and contract
check
---
README.md | 211 ++++++++++++++++++++++++++++++++++++++++++------------
1 file changed, 165 insertions(+), 46 deletions(-)
diff --git a/README.md b/README.md
index 135758e..33e3c7c 100644
--- a/README.md
+++ b/README.md
@@ -1,37 +1,117 @@
# Inti
-
+

-
+
Inti is an investment agent on NEAR. You say in plain words what to buy or sell, and it does it from your own wallet, within limits you sign.
+Live app: **https://getinti.xyz** (NEAR mainnet, real funds).
+
Giving an AI agent money usually means giving it your keys. With Inti your funds stay in your wallet. Inti gets a key that can only send orders, and a contract on your own account refuses any order above your limits.
---
## Table of Contents
-- [How It Works](#how-it-works)
-- [Run Your Own Server](#run-your-own-server)
-- [Project Structure](#project-structure)
-- [Tech Stack](#tech-stack)
-- [Contributing](#contributing)
-- [License](#license)
+1. [Why Inti exists](#why-inti-exists)
+2. [What an intent is, and why it matters here](#what-an-intent-is-and-why-it-matters-here)
+3. [Try it](#try-it)
+4. [How it works](#how-it-works)
+5. [Your limits and Inti's key](#your-limits-and-intis-key)
+6. [Check it yourself](#check-it-yourself)
+7. [Run your own server](#run-your-own-server)
+8. [Project structure](#project-structure)
+9. [Tech stack](#tech-stack)
+10. [Built during the NEAR hackathon](#built-during-the-near-hackathon)
+
+## Why Inti exists
+
+Every year there are fewer barriers to using a blockchain. The ones left are the ones that stop careful people:
+
+- **Signing what you cannot read.** A wallet asks you to approve a string of code.
+- **A mistake you cannot undo.** One wrong network or address and the money is gone.
+- **Handing an AI the keys to your money.** An agent that can trade for you can usually also empty your account.
+
+Inti removes those three. You sign in with email or Google, you type "buy $5 of bitcoin", and you read in plain words what you are about to sign. The agent never writes an address, and the limits you set are enforced by a contract on your own account, not by Inti's server.
+
+## What an intent is, and why it matters here
+
+An intent is a signed statement of what you want ("I want $5 of bitcoin, and I accept no less than this much"), not the steps to get it. Solvers compete to fill it, and the network checks that the result matches what you signed.
+
+That idea came with a promise: people would say what they want and the chain would stay out of sight. NEAR's co-founder Illia Polosukhin [wrote in 2023](https://www.coindesk.com/opinion/2023/12/20/the-rise-of-chain-abstraction-and-end-of-blockchain-factionalism): "hopefully, users won't have to manage or even know about the technical layers."
+
+Inti takes that promise literally. The words you type become an intent on [NEAR Intents](https://docs.near-intents.org), placed by your own agent through the [Agent API](https://docs.agentsonintents.com). What stays visible is what should: your limits, what each order spends, and where your money is at every step.
+
+## Try it
+
+Open **https://getinti.xyz** on a phone or a computer.
+
+**Without funds** (nothing moves):
+
+1. Sign in with email or Google. You see your dashboard and an empty NEAR wallet that [Privy](https://docs.privy.io) made for you. You never see a seed phrase.
+2. Next to the logo, a shield says **AI hardware verified**. Tap it to see each check on the AI model's hardware and run them again.
+3. In the chat, type `buy $5 of bitcoin`. Inti answers in plain words. Under the reply you see **Simulated portfolio, no real funds moved**: until you have an agent and a signed permission, every order runs on a practice portfolio.
+4. Under the same reply, tap **Signed by the verified AI model** to see the signature over that exact answer.
+
+**With real funds** (NEAR mainnet):
+
+5. Send NEAR to the wallet address shown in **Your wallet**.
+6. Open **Spending limits**, set how much one order and one day may spend, and sign. In one transaction the app installs the Spending Limits contract on your account and gives Inti a key that can only call `fund_agent`. Activation asks for about 1.88 NEAR: most of it pays for the contract's storage on your account and comes back when you **Turn off Inti**.
+7. Create your agent and sign a trading permission (a grant) for 7, 30 or 90 days.
+8. Type `buy $5 of gold`, `buy Zcash if it drops to $900`, or `sell half my bitcoin and buy euro with it`. The agent places each order, one after another, and tells you what it got and what it cost. The result appears in your portfolio. To ask the price without buying, type `how much bitcoin do I get for $5?`.
+9. Type an order above your daily limit. The contract refuses it and nothing moves.
+10. To stop Inti at once, tap **Pause Inti** (deletes Inti's key from your account) or freeze your agent (it can do nothing until you unfreeze it). Both are your signature, not Inti's.
+
+## How it works
+
+```mermaid
+sequenceDiagram
+ actor You
+ participant App as Inti app
+ participant Server as Inti server
+ participant Model as AI model (NEAR AI, TEE)
+ participant Limits as Spending Limits contract (your account)
+ participant Agent as Your agent (NEAR Intents)
+
+ You->>App: "buy $5 of bitcoin"
+ App->>Server: POST /api/chat
+ Server->>Model: your words and the 8 tools
+ Model-->>Server: buy_now(bitcoin, $5)
+ Server->>Limits: fund_agent(wNEAR, amount) with Inti's key
+ Limits->>Limits: within per-order and per-day limits?
+ Limits->>Agent: ft_transfer_call to intents.near, only to your agent
+ Agent->>Agent: swap NEAR for BTC, never below your minimum
+ Agent-->>You: BTC sent to your wallet
+ Server-->>App: reply, signed inside the TEE
+```
+
+1. **You write** what you want. The app sends it to Inti's server, which checks your Privy sign-in on every request.
+2. **The model decides.** It runs on [NEAR AI Cloud](https://docs.near.ai/cloud/quickstart) inside a TEE (private hardware) and picks one of eight tools. It names an asset and an amount in dollars; it never writes an address.
+3. **The contract checks.** Inti's key calls `fund_agent` on your account. The contract adds the order to what the last 24 hours already spent and refuses it if a limit would be passed.
+4. **Your agent trades.** The NEAR goes to your own agent on NEAR Intents, which swaps it with a minimum you accept, from its confidential balance.
+5. **The result comes home.** Bitcoin, ether and Zcash go to your wallet. Anything left with the agent is sent back to your wallet every 5 minutes.
-## How It Works
+### The agent
+
+The model decides; the code and the contract enforce the limits.
+
+- `agent/core/loop.ts`: the loop. A brain is any object with a `step()` method.
+- `agent/brains/nearai.ts`: the brain, model `deepseek-ai/DeepSeek-V4.1-Flash-1017` on NEAR AI Cloud, which runs inside NEAR AI's TEE.
+- `agent/server/realTools.ts`: the eight tools the model can call: `get_portfolio`, `get_quote`, `buy_now`, `buy_at_price`, `get_sell_quote`, `sell_now`, `send_near_to_wallet` and `ask_user`.
+
+```ts
+export const ASSETS = {
+ bitcoin: { name: "Bitcoin", symbol: "BTC", assetId: "nep141:nbtc.bridge.near", decimals: 8, kind: "crypto" },
+```
-1. **Sign in** with email or Google. [Privy](https://docs.privy.io) creates a NEAR wallet for you.
-2. **Set your limits**: how much one order may spend, and how much in a day. The app installs the Spending Limits contract on your account and adds Inti's key, which can call only `fund_agent` (`web/src/limits/client.ts`).
-3. **Create your agent** on the NEAR Intents [Agent API](https://docs.agentsonintents.com) and sign a trading permission (a grant) for 7, 30 or 90 days.
-4. **Chat**: "buy $5 of bitcoin", "sell half my ether", "buy Zcash if it drops to $900". The agent quotes, buys, sells or places an order that waits for a price.
-5. **Results go to your wallet**, except gold, euro and Solana, which your agent keeps (see below). Anything else left with the agent is sent back to your wallet every 5 minutes.
+`agent/policy/assets.ts`: the model chooses from a fixed list by name. The token address comes from this file, so a prompt hidden in a message cannot make the agent pay somewhere else.
-The agent buys and sells bitcoin (BTC), ether (ETH) and Zcash (ZEC), and pays with NEAR (`agent/policy/assets.ts`). Its trades run on the agent's confidential balance in NEAR Intents.
+### Where your assets sit
-### Gold, euro and Solana: kept by your agent
+The agent buys and sells bitcoin (BTC), ether (ETH) and Zcash (ZEC), and pays with NEAR. These go to your wallet.
-The agent also buys gold (XAUT), euro (EURe) and Solana (SOL) (`agent/policy/heldAssets.ts`). These stay in your agent's confidential balance on NEAR Intents instead of going to your wallet. The dashboard shows how much your agent holds of each, with its price. When you ask Inti to sell, the agent sells for NEAR and sends the NEAR to your wallet.
+It also buys gold (XAUT), euro (EURe) and Solana (SOL) (`agent/policy/heldAssets.ts`). These stay in your agent's confidential balance on NEAR Intents, and the dashboard shows how much your agent holds of each, with its price. When you ask Inti to sell, the agent sells for NEAR and sends the NEAR to your wallet.
Why they stay with the agent: since 12 November 2026 the Agent API trades only from the agent's confidential balance. From there it can send to a NEAR wallet only tokens that live on NEAR, and these three live on Ethereum, Gnosis and Solana.
@@ -47,19 +127,66 @@ Until 12 November 2026 Inti sent gold, euro and Solana to the user's NEAR wallet
3. [`2S16iWuB`](https://nearblocks.io/txns/2S16iWuBepvzSeoykpxMBV3z5CmfoV8cRvCfPbPRvjZw): the market maker gives 0.002874 SOL to the agent.
4. [`9N1LZEDu`](https://nearblocks.io/txns/9N1LZEDuh4STZYtx6QLbVtkmnXoGcb8H1U7uupWCbdDV): the SOL leaves NEAR Intents for the user's wallet.
-### The agent
+### Server and web app
-The model decides; the code and the contract enforce the limits.
+`agent/server/` is the API the web app calls: `POST /api/chat` runs the agent for the signed-in user, and the `/api/agent/*` routes create the user's agent and the grant the user signs. It checks the Privy access token on every request with Privy's public verification key, so it never needs the Privy app secret.
-- `agent/core/loop.ts`: the loop. A brain is any object with a `step()` method.
-- `agent/brains/nearai.ts`: the brain, on [NEAR AI Cloud](https://docs.near.ai/cloud/quickstart), model `deepseek-ai/DeepSeek-V4.1-Flash-1017`, which runs inside NEAR AI's TEE (private inference). Each step keeps its response id, which NEAR AI signs inside the TEE.
-- `agent/server/realTools.ts`: the seven tools the model can call: `get_portfolio`, `get_quote`, `buy_now`, `buy_at_price`, `get_sell_quote`, `sell_now` and `ask_user`. The model picks an asset by name and an amount in dollars; it never writes an address.
+`web/` is the app. `PrivyNearSigner` plugs the Privy wallet into the near-api-js `Signer`, so near-api-js builds and hashes NEP-413 messages and NEP-366 delegate actions, the two signatures the Agent API asks an owner for, and Privy signs the hash.
-Until you have an agent and a live grant, the chat runs on a simulated portfolio and no funds move.
+## Your limits and Inti's key
+
+```mermaid
+flowchart LR
+ You["You full-access key"] -->|set limits, remove Inti's key, freeze the agent| Account
+ Inti["Inti's server function-call key"] -->|fund_agent only| Account
+ subgraph Account["Your NEAR account"]
+ Contract["Spending Limits contract per order, per day, 24 orders a day"]
+ end
+ Contract -->|one order, only to your agent| Agent["Your agent NEAR Intents"]
+ Agent -->|results| Wallet["Your wallet"]
+```
-### The AI model's hardware, checked live
+You keep your full-access key, in your Privy wallet. Inti gets a NEAR function-call key that is scoped to one contract (your own account) and one method (`fund_agent`), with no deposit allowed.
-Next to the logo, a shield says whether the hardware of Inti's model is verified. Tap it to see each check and run them again.
+What Inti's key **can** do: send one order to your own agent, within your limits.
+
+What Inti's key **cannot** do, because the network or the contract refuses it:
+
+- send NEAR or tokens to anyone, including itself;
+- call any method other than `fund_agent`, or attach a deposit;
+- change your limits or your agent (`set_limit`, `remove_limit` and `set_agent` require 1 yoctoNEAR, which a function-call key cannot attach);
+- choose where an order goes: `fund_agent` takes no destination, it always pays your agent;
+- add or remove keys, or deploy code.
+
+```rust
+require!(new_spent <= limit.per_day.0, "over the daily limit");
+```
+
+`contracts/spending-limits/src/lib.rs`: before Inti's key sends an order, the contract adds it to what the last 24 hours already sent. If the total would pass your daily limit, the order is refused and nothing moves. Even with Inti's key, nobody can spend more than your limits.
+
+If Inti's key were stolen, the most it could do is send your limits to your own agent, and use up the 24 orders of a day. Deleting the key ends both. Because your account keeps its full-access key, it never depends on a function-call key's gas allowance and cannot be locked out by it.
+
+The Agent API adds a second layer: your agent runs under a policy you sign, which only lets it send to your wallet.
+
+Contract details, tests and formal proofs: [Spending Limits contract](contracts/spending-limits/README.md).
+
+## Check it yourself
+
+### The contract on mainnet is this code
+
+The contract is verified on [SourceScan](https://nearblocks.io/address/91e0e128471dd3633637fd82850489b14c84cf9d41f45e83f33e74e8e52880be) (verification transaction [`9spE94qW`](https://nearblocks.io/txns/9spE94qWajKdyTLbbZM5y1fWa2wGinkFj8AkeFVyrvby)). To rebuild it and compare the hash yourself, with [cargo-near](https://github.com/near/cargo-near) and Docker:
+
+```bash
+git clone https://github.com/JaDi03/inti.git
+cd inti/contracts/spending-limits
+cargo near build reproducible-wasm
+sha256sum target/near/inti_spending_limits.wasm
+# ec08c308af218f6d1273a1ae785617d67b9bb3fa3ed95f843a5e1a9c19c3d161
+```
+
+The same hash is in `web/src/limits/config.ts`, and it matches `web/public/inti-spending-limits.wasm`, the only build the app installs.
+
+### The AI model's hardware, checked live
```ts
if (reportData.slice(64) === nonce) passed.add("binds_nonce");
@@ -68,7 +195,7 @@ if (reportData.slice(0, 64) === signingAddress.slice(2).padEnd(64, "0")) passed.
`agent/server/attestation.ts`: Inti sends NEAR AI a new random challenge and gets back the hardware report of its model. It checks the Intel TDX quote against Intel's own certificates ([@phala/dcap-qvl](https://github.com/Phala-Network/dcap-qvl)), that the quote carries the challenge and the model's signing key, that the machine is not in debug mode, that its startup log and published setup match what the chip measured, and asks NVIDIA whether the GPU is genuine. The steps follow [NEAR AI's verification docs](https://docs.near.ai/cloud/verification). One recent result is shared by everyone who opens the app; "Verify again" runs a new one.
-Under each of Inti's replies, a line says whether it was signed by that chip's key:
+### Each reply, signed
```ts
if (sig.text !== `${model}:${call.requestHash}:${call.responseHash}`) return "other_bytes";
@@ -78,21 +205,7 @@ if (sig.text !== `${model}:${call.requestHash}:${call.responseHash}`) return "ot
Together they prove that a genuine, sealed Intel TDX machine with an NVIDIA GPU, running this model, signed each reply. They do not prove which of the model's machines served it (they share one key), which software runs inside beyond its own measurements, or that your messages are hidden: NEAR AI's gateway and Inti's server both see them.
-### The limits
-
-```rust
-require!(new_spent <= limit.per_day.0, "over the daily limit");
-```
-
-`contracts/spending-limits/src/lib.rs`: before Inti's key sends an order, the contract adds it to what the last 24 hours already sent. If the total would pass your daily limit, the order is refused and nothing moves. Even with Inti's key, nobody can spend more than your limits. To stop Inti at once, delete its key from your account. Details: [Spending Limits contract](contracts/spending-limits/README.md).
-
-### Server and web app
-
-`agent/server/` is the API the web app calls: `POST /api/chat` runs the agent for the signed-in user, and the `/api/agent/*` routes create the user's agent and the grant the user signs. It checks the Privy access token on every request with Privy's public verification key, so it never needs the Privy app secret.
-
-`web/` is the app. `PrivyNearSigner` plugs the Privy wallet into the near-api-js `Signer`, so near-api-js builds and hashes NEP-413 messages and NEP-366 delegate actions, the two signatures the Agent API asks an owner for, and Privy signs the hash.
-
-## Run Your Own Server
+## Run your own server
The app and its API on your own server, at `https://your-domain.com`. You need Ubuntu or Debian (x64, tested on Ubuntu 24.04), a user with `sudo`, and a domain pointing to the server with ports 80 and 443 open.
@@ -136,7 +249,9 @@ Each install is a new release. If the new one does not start, the previous one k
Users authorize Inti's key on their own account. Keep a copy of `/var/lib/inti/inti-key.json` and of `SERVER_GRANT_KEY` from `/etc/inti/inti.env`. To move to a new server without asking users to do it again, copy `inti-key.json` and `grants.json` to the new server's `/var/lib/inti/`, and put `SERVER_GRANT_KEY` in its `.env`, before you run the script. It keeps a key and grants that are already there.
-## Project Structure
+To run it on your computer or change the code, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Project structure
```
agent/ the investment agent (TypeScript)
@@ -151,11 +266,13 @@ web/ app: login, Spending Limits, chat (React)
deploy/ install.sh and the server files it sets up
```
-## Tech Stack
+## Tech stack
- **[NEAR Intents](https://docs.near-intents.org)**: the swaps and price orders behind every buy and sell
-- **[@near-intents-agent-api/sdk](https://docs.agentsonintents.com/integration/agent-api/sdk)**: official Agent API types
+- **[NEAR Intents Agent API](https://docs.agentsonintents.com)**: each user's own agent, its signed policy and its confidential balance; types from [@near-intents-agent-api/sdk](https://docs.agentsonintents.com/integration/agent-api/sdk)
- **[NEAR AI Cloud](https://docs.near.ai/cloud/quickstart)**: private inference in a TEE, through the [OpenAI SDK](https://github.com/openai/openai-node)
+- **NEAR function-call access keys**: Inti's key, limited to `fund_agent` on the user's account
+- **[near-sdk-rs](https://github.com/near/near-sdk-rs)** and **[cargo-near](https://github.com/near/cargo-near)**: the Spending Limits contract and its reproducible build
- **[Privy](https://docs.privy.io)**: email and Google login with an embedded NEAR wallet
- **[near-api-js](https://github.com/near/near-api-js)**: NEAR transactions, NEP-413 and NEP-366 encoding
- **[fastify](https://fastify.dev)**: the API server
@@ -163,9 +280,11 @@ deploy/ install.sh and the server files it sets up
- **[vitest](https://vitest.dev)**: tests
- **[TypeScript](https://www.typescriptlang.org)**: language
-## Contributing
+## Built during the NEAR hackathon
-To run it on your computer or change the code, see [CONTRIBUTING.md](CONTRIBUTING.md).
+Inti was written from scratch for the NEAR hackathon (build window 1 to 14 November 2026). The first commit is from 5 November 2026, and every change since is in the [commit history](https://github.com/JaDi03/inti/commits/main). No code from an earlier product is reused, and no other project of ours is entered in this hackathon. Open-source libraries are the ones listed under [Tech stack](#tech-stack).
+
+Tracks it is built for: **AI Security & Defense** (spending limits, a function-call key, TEE attestation), **Unstoppable DeFi** (trading through NEAR Intents with no custodian) and **Privacy & Private AI** (the model runs in a TEE, the agent trades from a confidential balance).
## License
From a47d5817f9e5f296e90da9ead6e620f7ad2df351 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Fri, 13 Nov 2026 22:00:39 -0600
Subject: [PATCH 2/9] docs: README steps follow the app's activation order
---
README.md | 42 +++++++++++++++++++++++++-----------------
1 file changed, 25 insertions(+), 17 deletions(-)
diff --git a/README.md b/README.md
index 33e3c7c..df72129 100644
--- a/README.md
+++ b/README.md
@@ -15,8 +15,8 @@ Giving an AI agent money usually means giving it your keys. With Inti your funds
## Table of Contents
1. [Why Inti exists](#why-inti-exists)
-2. [What an intent is, and why it matters here](#what-an-intent-is-and-why-it-matters-here)
-3. [Try it](#try-it)
+2. [Try it](#try-it)
+3. [What an intent is, and why it matters here](#what-an-intent-is-and-why-it-matters-here)
4. [How it works](#how-it-works)
5. [Your limits and Inti's key](#your-limits-and-intis-key)
6. [Check it yourself](#check-it-yourself)
@@ -35,14 +35,6 @@ Every year there are fewer barriers to using a blockchain. The ones left are the
Inti removes those three. You sign in with email or Google, you type "buy $5 of bitcoin", and you read in plain words what you are about to sign. The agent never writes an address, and the limits you set are enforced by a contract on your own account, not by Inti's server.
-## What an intent is, and why it matters here
-
-An intent is a signed statement of what you want ("I want $5 of bitcoin, and I accept no less than this much"), not the steps to get it. Solvers compete to fill it, and the network checks that the result matches what you signed.
-
-That idea came with a promise: people would say what they want and the chain would stay out of sight. NEAR's co-founder Illia Polosukhin [wrote in 2023](https://www.coindesk.com/opinion/2023/12/20/the-rise-of-chain-abstraction-and-end-of-blockchain-factionalism): "hopefully, users won't have to manage or even know about the technical layers."
-
-Inti takes that promise literally. The words you type become an intent on [NEAR Intents](https://docs.near-intents.org), placed by your own agent through the [Agent API](https://docs.agentsonintents.com). What stays visible is what should: your limits, what each order spends, and where your money is at every step.
-
## Try it
Open **https://getinti.xyz** on a phone or a computer.
@@ -56,12 +48,24 @@ Open **https://getinti.xyz** on a phone or a computer.
**With real funds** (NEAR mainnet):
-5. Send NEAR to the wallet address shown in **Your wallet**.
-6. Open **Spending limits**, set how much one order and one day may spend, and sign. In one transaction the app installs the Spending Limits contract on your account and gives Inti a key that can only call `fund_agent`. Activation asks for about 1.88 NEAR: most of it pays for the contract's storage on your account and comes back when you **Turn off Inti**.
-7. Create your agent and sign a trading permission (a grant) for 7, 30 or 90 days.
-8. Type `buy $5 of gold`, `buy Zcash if it drops to $900`, or `sell half my bitcoin and buy euro with it`. The agent places each order, one after another, and tells you what it got and what it cost. The result appears in your portfolio. To ask the price without buying, type `how much bitcoin do I get for $5?`.
-9. Type an order above your daily limit. The contract refuses it and nothing moves.
-10. To stop Inti at once, tap **Pause Inti** (deletes Inti's key from your account) or freeze your agent (it can do nothing until you unfreeze it). Both are your signature, not Inti's.
+5. Open **Spending limits** and follow its four steps in order:
+ - **Protect your account** with a passkey.
+ - **Add funds**: send NEAR to the address shown. The step tells you how much is needed (about 1.9 NEAR with 0.1 NEAR set aside for orders; it grows with what you set aside). About 1.7 NEAR of it pays for the contract's storage on your account and comes back when you **Turn off Inti**.
+ - **Create your agent**: your own agent on NEAR Intents, which can send only to you.
+ - **Set your spending limits** and tap **Activate Inti**. You sign two transactions. The first installs the Spending Limits contract on your account, sets your limits and gives Inti a key that can only call `fund_agent`. The second wraps the NEAR you set aside for orders.
+6. Sign a trading permission (a grant) for your agent, for 7, 30 or 90 days.
+7. Type `buy $5 of gold`, `buy Zcash if it drops to $900`, or `sell half my bitcoin and buy euro with it`. The agent places each order, one after another, and tells you what it got and what it cost. The result appears in your portfolio. To ask the price without buying, type `how much bitcoin do I get for $5?`.
+ One real order on mainnet: [`2g5VBGWH`](https://nearblocks.io/txns/2g5VBGWHZCAtQYM9S122tRNVYsvcqUkj3nPbCVfzECHk), Inti's key calling `fund_agent` with 0.0286 wNEAR on a user's account.
+8. Type an order above your limit. Inti says it is over your limit and nothing moves. The server checks your limits first (`agent/server/orders.ts`, `fund`); the contract checks them again on chain, so the refusal holds even if the server is wrong or compromised. The contract's own refusals are covered by its tests (`contracts/spending-limits/tests/`).
+9. To stop Inti at once, tap **Pause Inti** (deletes Inti's key from your account) or freeze your agent (it can do nothing until you unfreeze it). Both are your signature, not Inti's.
+
+## What an intent is, and why it matters here
+
+An intent is a signed statement of what you want ("I want $5 of bitcoin, and I accept no less than this much"), not the steps to get it. Solvers compete to fill it, and the network checks that the result matches what you signed.
+
+That idea came with a promise: people would say what they want and the chain would stay out of sight. NEAR's co-founder Illia Polosukhin [wrote in 2023](https://www.coindesk.com/opinion/2023/12/20/the-rise-of-chain-abstraction-and-end-of-blockchain-factionalism): "hopefully, users won't have to manage or even know about the technical layers."
+
+Inti takes that promise literally. The words you type become an intent on [NEAR Intents](https://docs.near-intents.org), placed by your own agent through the [Agent API](https://docs.agentsonintents.com). What stays visible is what should: your limits, what each order spends, and where your money is at every step.
## How it works
@@ -164,7 +168,9 @@ require!(new_spent <= limit.per_day.0, "over the daily limit");
`contracts/spending-limits/src/lib.rs`: before Inti's key sends an order, the contract adds it to what the last 24 hours already sent. If the total would pass your daily limit, the order is refused and nothing moves. Even with Inti's key, nobody can spend more than your limits.
-If Inti's key were stolen, the most it could do is send your limits to your own agent, and use up the 24 orders of a day. Deleting the key ends both. Because your account keeps its full-access key, it never depends on a function-call key's gas allowance and cannot be locked out by it.
+Inti's key also has a gas allowance of 0.25 NEAR (`web/src/limits/config.ts`), from which it pays each order's network fee. It is one total, not per day, and the dashboard shows what is left under **Fees left for Inti**. When it runs out, Inti cannot send orders; **Pause Inti** and then **Resume Inti** add the key again with a new allowance.
+
+If Inti's key were stolen, the most it could do is send your limits to your own agent, use up the 24 orders of a day, and spend its 0.25 NEAR allowance on fees. Deleting the key ends all three. Because your account keeps its full-access key, it never depends on that allowance and cannot be locked out by it.
The Agent API adds a second layer: your agent runs under a policy you sign, which only lets it send to your wallet.
@@ -223,6 +229,8 @@ sudo bash deploy/install.sh
| `NEAR_AI_API_KEY` | [cloud.near.ai](https://cloud.near.ai) |
| `PRIVY_APP_ID`, `PRIVY_VERIFICATION_KEY` | your app in the [Privy dashboard](https://dashboard.privy.io) |
+`.env.example` points the Agent API at `https://api.demo.agentsonintents.com`. NEAR Intents and the Agent API have no testnet, so orders through that host are real orders on NEAR mainnet.
+
The script checks `.env` before it installs anything and says what is missing. It installs Node, pnpm and Caddy, creates Inti's key and the key that encrypts the grants, builds the app, and starts the API behind HTTPS. It ends with `Done. Open https://your-domain.com`. In the Privy dashboard, add that domain to the app's allowed domains.
To update, or to apply a changed setting, run the same command from the same folder:
From ab06da28c5706a3adc39758888ba131afcca1b20 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Fri, 13 Nov 2026 22:08:12 -0600
Subject: [PATCH 3/9] docs: README shows both limit checks
---
README.md | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/README.md b/README.md
index df72129..868863d 100644
--- a/README.md
+++ b/README.md
@@ -56,7 +56,7 @@ Open **https://getinti.xyz** on a phone or a computer.
6. Sign a trading permission (a grant) for your agent, for 7, 30 or 90 days.
7. Type `buy $5 of gold`, `buy Zcash if it drops to $900`, or `sell half my bitcoin and buy euro with it`. The agent places each order, one after another, and tells you what it got and what it cost. The result appears in your portfolio. To ask the price without buying, type `how much bitcoin do I get for $5?`.
One real order on mainnet: [`2g5VBGWH`](https://nearblocks.io/txns/2g5VBGWHZCAtQYM9S122tRNVYsvcqUkj3nPbCVfzECHk), Inti's key calling `fund_agent` with 0.0286 wNEAR on a user's account.
-8. Type an order above your limit. Inti says it is over your limit and nothing moves. The server checks your limits first (`agent/server/orders.ts`, `fund`); the contract checks them again on chain, so the refusal holds even if the server is wrong or compromised. The contract's own refusals are covered by its tests (`contracts/spending-limits/tests/`).
+8. Type an order above your limit. Inti tells you it is over your limit, and no transaction is sent, so you pay no fee. Your limits are checked twice: first by Inti, which reads them from your contract before it signs anything (`agent/server/orders.ts`, `fund`), and then by the contract itself on chain. The second check holds even if Inti's server were wrong or compromised; its refusals are covered by the contract's tests (`contracts/spending-limits/tests/`).
9. To stop Inti at once, tap **Pause Inti** (deletes Inti's key from your account) or freeze your agent (it can do nothing until you unfreeze it). Both are your signature, not Inti's.
## What an intent is, and why it matters here
@@ -166,7 +166,14 @@ What Inti's key **cannot** do, because the network or the contract refuses it:
require!(new_spent <= limit.per_day.0, "over the daily limit");
```
-`contracts/spending-limits/src/lib.rs`: before Inti's key sends an order, the contract adds it to what the last 24 hours already sent. If the total would pass your daily limit, the order is refused and nothing moves. Even with Inti's key, nobody can spend more than your limits.
+```ts
+if (amount > limit.perOrder) return "over_order_limit";
+if ((await chain.spentLast24h(account.owner, token)) + amount > limit.perDay) return "over_daily_limit";
+```
+
+`agent/server/orders.ts`: before it signs an order, Inti reads your limits and what the last 24 hours spent from your own contract. An order over a limit is stopped here, so it never reaches the chain and costs you nothing.
+
+`contracts/spending-limits/src/lib.rs`: the contract checks again. Before Inti's key sends an order, the contract adds it to what the last 24 hours already sent. If the total would pass your daily limit, the order is refused and nothing moves. Even with Inti's key, nobody can spend more than your limits.
Inti's key also has a gas allowance of 0.25 NEAR (`web/src/limits/config.ts`), from which it pays each order's network fee. It is one total, not per day, and the dashboard shows what is left under **Fees left for Inti**. When it runs out, Inti cannot send orders; **Pause Inti** and then **Resume Inti** add the key again with a new allowance.
From 2e3c6bf095cb61ea944cb39988ed0b7923e7a1b0 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Fri, 13 Nov 2026 23:34:20 -0600
Subject: [PATCH 4/9] docs: rebuild steps name the deployed commit
---
README.md | 6 ++++--
contracts/spending-limits/README.md | 4 +++-
2 files changed, 7 insertions(+), 3 deletions(-)
diff --git a/README.md b/README.md
index 868863d..2e8d234 100644
--- a/README.md
+++ b/README.md
@@ -187,11 +187,13 @@ Contract details, tests and formal proofs: [Spending Limits contract](contracts/
### The contract on mainnet is this code
-The contract is verified on [SourceScan](https://nearblocks.io/address/91e0e128471dd3633637fd82850489b14c84cf9d41f45e83f33e74e8e52880be) (verification transaction [`9spE94qW`](https://nearblocks.io/txns/9spE94qWajKdyTLbbZM5y1fWa2wGinkFj8AkeFVyrvby)). To rebuild it and compare the hash yourself, with [cargo-near](https://github.com/near/cargo-near) and Docker:
+The contract is verified on [SourceScan](https://nearblocks.io/address/91e0e128471dd3633637fd82850489b14c84cf9d41f45e83f33e74e8e52880be) (verification transaction [`9spE94qW`](https://nearblocks.io/txns/9spE94qWajKdyTLbbZM5y1fWa2wGinkFj8AkeFVyrvby)). To rebuild it and compare the hash yourself, you need Linux, macOS or WSL, Docker running, and [cargo-near](https://github.com/near/cargo-near) (tested with 0.23.0; the build itself runs inside the pinned Docker image). The build writes its git commit into the wasm, so check out the commit that was deployed, `cb3fe63`, the one the contract's on-chain metadata names. It takes about 2 minutes.
```bash
git clone https://github.com/JaDi03/inti.git
-cd inti/contracts/spending-limits
+cd inti
+git checkout cb3fe63
+cd contracts/spending-limits
cargo near build reproducible-wasm
sha256sum target/near/inti_spending_limits.wasm
# ec08c308af218f6d1273a1ae785617d67b9bb3fa3ed95f843a5e1a9c19c3d161
diff --git a/contracts/spending-limits/README.md b/contracts/spending-limits/README.md
index 26b1e6d..bc4cdfc 100644
--- a/contracts/spending-limits/README.md
+++ b/contracts/spending-limits/README.md
@@ -63,8 +63,10 @@ Requires Rust 1.99.1 (the version CI uses) with the `wasm32-unknown-unknown` tar
[cargo-near](https://github.com/near/cargo-near) to build the wasm.
```bash
-# unit, actor and property tests
+# unit, actor and property tests (about 8 minutes; the property tests take most of it)
cargo test
+# on Windows, a test dependency builds aws-lc and needs:
+AWS_LC_SYS_PREBUILT_NASM=1 cargo test
# contract wasm: target/near/inti_spending_limits.wasm
cargo near build non-reproducible-wasm
From fb879ce3dffc6ce7307be5c880abd43d71600347 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Sat, 14 Nov 2026 01:25:55 -0600
Subject: [PATCH 5/9] docs: README shows a real gold, bitcoin and euro trade
---
README.md | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 2e8d234..1e748bd 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,11 @@ Open **https://getinti.xyz** on a phone or a computer.
- **Set your spending limits** and tap **Activate Inti**. You sign two transactions. The first installs the Spending Limits contract on your account, sets your limits and gives Inti a key that can only call `fund_agent`. The second wraps the NEAR you set aside for orders.
6. Sign a trading permission (a grant) for your agent, for 7, 30 or 90 days.
7. Type `buy $5 of gold`, `buy Zcash if it drops to $900`, or `sell half my bitcoin and buy euro with it`. The agent places each order, one after another, and tells you what it got and what it cost. The result appears in your portfolio. To ask the price without buying, type `how much bitcoin do I get for $5?`.
- One real order on mainnet: [`2g5VBGWH`](https://nearblocks.io/txns/2g5VBGWHZCAtQYM9S122tRNVYsvcqUkj3nPbCVfzECHk), Inti's key calling `fund_agent` with 0.0286 wNEAR on a user's account.
+ A real use on mainnet, 14 November 2026: `buy $5 of gold`, then `sell it, half for bitcoin and half for euro`. On chain you see only two transactions:
+ - [`C68paMYv`](https://nearblocks.io/txns/C68paMYvQmm9AWrfvErLXuEMNrcFQEsy4wmBRugaWhJh): the Spending Limits contract on the user's account sends 1.488 wNEAR to the user's agent in NEAR Intents, after checking the limits.
+ - [`5cr7nwxz`](https://nearblocks.io/txns/5cr7nwxzMiqmBeEHgN73v3vWs52E5HJ6Ad83SZAYhTLB): NEAR Intents sends 0.00003638 BTC to the user's wallet.
+
+ The gold purchase, its sale and the euro happened inside the agent's confidential balance, so no public transaction shows them. The euro stays with the agent (see [Where your assets sit](#where-your-assets-sit)).
8. Type an order above your limit. Inti tells you it is over your limit, and no transaction is sent, so you pay no fee. Your limits are checked twice: first by Inti, which reads them from your contract before it signs anything (`agent/server/orders.ts`, `fund`), and then by the contract itself on chain. The second check holds even if Inti's server were wrong or compromised; its refusals are covered by the contract's tests (`contracts/spending-limits/tests/`).
9. To stop Inti at once, tap **Pause Inti** (deletes Inti's key from your account) or freeze your agent (it can do nothing until you unfreeze it). Both are your signature, not Inti's.
From 6e87f6ae31342c510f5dd5424e5717bf3bb1d4e1 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Sat, 14 Nov 2026 04:35:46 -0600
Subject: [PATCH 6/9] docs: README diagrams for the buy flow and who decides
---
README.md | 38 +++++++-----------------------
docs/diagrams/buy-flow-dark.svg | 4 ++++
docs/diagrams/buy-flow.svg | 4 ++++
docs/diagrams/who-decides-dark.svg | 4 ++++
docs/diagrams/who-decides.svg | 4 ++++
5 files changed, 24 insertions(+), 30 deletions(-)
create mode 100644 docs/diagrams/buy-flow-dark.svg
create mode 100644 docs/diagrams/buy-flow.svg
create mode 100644 docs/diagrams/who-decides-dark.svg
create mode 100644 docs/diagrams/who-decides.svg
diff --git a/README.md b/README.md
index 1e748bd..efbdead 100644
--- a/README.md
+++ b/README.md
@@ -73,26 +73,10 @@ Inti takes that promise literally. The words you type become an intent on [NEAR
## How it works
-```mermaid
-sequenceDiagram
- actor You
- participant App as Inti app
- participant Server as Inti server
- participant Model as AI model (NEAR AI, TEE)
- participant Limits as Spending Limits contract (your account)
- participant Agent as Your agent (NEAR Intents)
-
- You->>App: "buy $5 of bitcoin"
- App->>Server: POST /api/chat
- Server->>Model: your words and the 8 tools
- Model-->>Server: buy_now(bitcoin, $5)
- Server->>Limits: fund_agent(wNEAR, amount) with Inti's key
- Limits->>Limits: within per-order and per-day limits?
- Limits->>Agent: ft_transfer_call to intents.near, only to your agent
- Agent->>Agent: swap NEAR for BTC, never below your minimum
- Agent-->>You: BTC sent to your wallet
- Server-->>App: reply, signed inside the TEE
-```
+
+
+
+
1. **You write** what you want. The app sends it to Inti's server, which checks your Privy sign-in on every request.
2. **The model decides.** It runs on [NEAR AI Cloud](https://docs.near.ai/cloud/quickstart) inside a TEE (private hardware) and picks one of eight tools. It names an asset and an amount in dollars; it never writes an address.
@@ -143,16 +127,10 @@ Until 12 November 2026 Inti sent gold, euro and Solana to the user's NEAR wallet
## Your limits and Inti's key
-```mermaid
-flowchart LR
- You["You full-access key"] -->|set limits, remove Inti's key, freeze the agent| Account
- Inti["Inti's server function-call key"] -->|fund_agent only| Account
- subgraph Account["Your NEAR account"]
- Contract["Spending Limits contract per order, per day, 24 orders a day"]
- end
- Contract -->|one order, only to your agent| Agent["Your agent NEAR Intents"]
- Agent -->|results| Wallet["Your wallet"]
-```
+
+
+
+
You keep your full-access key, in your Privy wallet. Inti gets a NEAR function-call key that is scoped to one contract (your own account) and one method (`fund_agent`), with no deposit allowed.
diff --git a/docs/diagrams/buy-flow-dark.svg b/docs/diagrams/buy-flow-dark.svg
new file mode 100644
index 0000000..ae30312
--- /dev/null
+++ b/docs/diagrams/buy-flow-dark.svg
@@ -0,0 +1,4 @@
+
+
+
\ No newline at end of file
diff --git a/docs/diagrams/buy-flow.svg b/docs/diagrams/buy-flow.svg
new file mode 100644
index 0000000..e977530
--- /dev/null
+++ b/docs/diagrams/buy-flow.svg
@@ -0,0 +1,4 @@
+
+
+
\ No newline at end of file
diff --git a/docs/diagrams/who-decides-dark.svg b/docs/diagrams/who-decides-dark.svg
new file mode 100644
index 0000000..d07c082
--- /dev/null
+++ b/docs/diagrams/who-decides-dark.svg
@@ -0,0 +1,4 @@
+
+
+
\ No newline at end of file
diff --git a/docs/diagrams/who-decides.svg b/docs/diagrams/who-decides.svg
new file mode 100644
index 0000000..cbb9fec
--- /dev/null
+++ b/docs/diagrams/who-decides.svg
@@ -0,0 +1,4 @@
+
+
+
\ No newline at end of file
From 047e7c6842e43cec6d517290d30927afc0797343 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Sat, 14 Nov 2026 04:38:03 -0600
Subject: [PATCH 7/9] docs: README opening, pause and asset locations match the
app
---
README.md | 18 ++++++++++--------
1 file changed, 10 insertions(+), 8 deletions(-)
diff --git a/README.md b/README.md
index efbdead..ee51c3d 100644
--- a/README.md
+++ b/README.md
@@ -4,11 +4,13 @@


-Inti is an investment agent on NEAR. You say in plain words what to buy or sell, and it does it from your own wallet, within limits you sign.
+Inti is an investment agent on NEAR. You type `buy $5 of bitcoin`, and your own agent on NEAR Intents buys it with NEAR from your wallet, within limits you set.
Live app: **https://getinti.xyz** (NEAR mainnet, real funds).
-Giving an AI agent money usually means giving it your keys. With Inti your funds stay in your wallet. Inti gets a key that can only send orders, and a contract on your own account refuses any order above your limits.
+Giving an AI agent money usually means giving it your keys. Inti never holds your money or your full-access key. It gets a key that can only send one order at a time to your own agent, and a contract on your own account refuses any order above your limits. Inti checks the same limits first, so an order over them never reaches the chain.
+
+You can check this yourself: the contract on mainnet rebuilds to the same hash from this repository ([how](#the-contract-on-mainnet-is-this-code)), every AI reply carries a signature from the model's hardware ([how](#each-reply-signed)), and the transactions of a real trade are linked under [Try it](#try-it).
---
@@ -33,7 +35,7 @@ Every year there are fewer barriers to using a blockchain. The ones left are the
- **A mistake you cannot undo.** One wrong network or address and the money is gone.
- **Handing an AI the keys to your money.** An agent that can trade for you can usually also empty your account.
-Inti removes those three. You sign in with email or Google, you type "buy $5 of bitcoin", and you read in plain words what you are about to sign. The agent never writes an address, and the limits you set are enforced by a contract on your own account, not by Inti's server.
+Inti works on all three. You sign in with email or Google, you type "buy $5 of bitcoin", and you read in plain words what you are about to sign. The agent never writes an address. Your limits live in a contract on your own account: Inti's server checks them first, and the contract refuses any order over them even if the server got it wrong.
## Try it
@@ -60,8 +62,8 @@ Open **https://getinti.xyz** on a phone or a computer.
- [`5cr7nwxz`](https://nearblocks.io/txns/5cr7nwxzMiqmBeEHgN73v3vWs52E5HJ6Ad83SZAYhTLB): NEAR Intents sends 0.00003638 BTC to the user's wallet.
The gold purchase, its sale and the euro happened inside the agent's confidential balance, so no public transaction shows them. The euro stays with the agent (see [Where your assets sit](#where-your-assets-sit)).
-8. Type an order above your limit. Inti tells you it is over your limit, and no transaction is sent, so you pay no fee. Your limits are checked twice: first by Inti, which reads them from your contract before it signs anything (`agent/server/orders.ts`, `fund`), and then by the contract itself on chain. The second check holds even if Inti's server were wrong or compromised; its refusals are covered by the contract's tests (`contracts/spending-limits/tests/`).
-9. To stop Inti at once, tap **Pause Inti** (deletes Inti's key from your account) or freeze your agent (it can do nothing until you unfreeze it). Both are your signature, not Inti's.
+8. Type an order above your limit. Inti tells you it is over your limit and sends no transaction, so you pay no fee. If Inti's check were ever wrong, the contract would refuse the order on chain (see [Your limits and Inti's key](#your-limits-and-intis-key)).
+9. To stop Inti you have two switches, both signed by you. **Pause Inti** deletes Inti's key from your account, so no more money leaves your wallet; your agent can still trade what it already holds while your grant lasts. Freezing your agent stops everything it does until you unfreeze it.
## What an intent is, and why it matters here
@@ -82,7 +84,7 @@ Inti takes that promise literally. The words you type become an intent on [NEAR
2. **The model decides.** It runs on [NEAR AI Cloud](https://docs.near.ai/cloud/quickstart) inside a TEE (private hardware) and picks one of eight tools. It names an asset and an amount in dollars; it never writes an address.
3. **The contract checks.** Inti's key calls `fund_agent` on your account. The contract adds the order to what the last 24 hours already spent and refuses it if a limit would be passed.
4. **Your agent trades.** The NEAR goes to your own agent on NEAR Intents, which swaps it with a minimum you accept, from its confidential balance.
-5. **The result comes home.** Bitcoin, ether and Zcash go to your wallet. Anything left with the agent is sent back to your wallet every 5 minutes.
+5. **The result comes home.** Bitcoin, ether and Zcash go to your wallet; if one could not be sent right away, Inti tries again every 5 minutes. Gold, euro, Solana and the NEAR from a sale stay with your agent (see [Where your assets sit](#where-your-assets-sit)).
### The agent
@@ -103,9 +105,9 @@ export const ASSETS = {
The agent buys and sells bitcoin (BTC), ether (ETH) and Zcash (ZEC), and pays with NEAR. These go to your wallet.
-It also buys gold (XAUT), euro (EURe) and Solana (SOL) (`agent/policy/heldAssets.ts`). These stay in your agent's confidential balance on NEAR Intents, and the dashboard shows how much your agent holds of each, with its price. When you ask Inti to sell, the agent sells for NEAR and sends the NEAR to your wallet.
+It also buys gold (XAUT), euro (EURe) and Solana (SOL) (`agent/policy/heldAssets.ts`). These stay in your agent's confidential balance on NEAR Intents, and the dashboard shows how much your agent holds of each, with its price. When you ask Inti to sell, the agent sells for NEAR and keeps that NEAR to pay for your next purchase. To bring it to your wallet, type `send my NEAR to my wallet` or use the send button next to your agent's NEAR on the dashboard.
-Why they stay with the agent: since 12 November 2026 the Agent API trades only from the agent's confidential balance. From there it can send to a NEAR wallet only tokens that live on NEAR, and these three live on Ethereum, Gnosis and Solana.
+Why they stay with the agent: since 12 November 2026 the Agent API trades only from the agent's confidential balance; the public balance can only send funds out (the API answers `public_balance_exit_only`). From the confidential balance it sends to a NEAR wallet only tokens that live on NEAR. Gold, euro and Solana live on Ethereum, Gnosis and Solana, so a withdrawal of them answers `unsupported_token` (`agent/server/orders.ts`).
What this means for you:
From f3f6fd3893a768f20650cb2a200cbbabb09a56c8 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Sat, 14 Nov 2026 04:50:29 -0600
Subject: [PATCH 8/9] docs: README lists the commands that build and test the
code
---
README.md | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/README.md b/README.md
index ee51c3d..76b3392 100644
--- a/README.md
+++ b/README.md
@@ -169,6 +169,17 @@ Contract details, tests and formal proofs: [Spending Limits contract](contracts/
## Check it yourself
+### The code builds and its tests pass
+
+With Node 24 and pnpm 11, on a fresh clone and with no `.env`:
+
+```bash
+pnpm install
+pnpm typecheck && pnpm lint && pnpm test && pnpm build && pnpm web:build
+```
+
+The contract has its own tests, property runs and formal proofs: see [Spending Limits contract](contracts/spending-limits/README.md#build-and-test).
+
### The contract on mainnet is this code
The contract is verified on [SourceScan](https://nearblocks.io/address/91e0e128471dd3633637fd82850489b14c84cf9d41f45e83f33e74e8e52880be) (verification transaction [`9spE94qW`](https://nearblocks.io/txns/9spE94qWajKdyTLbbZM5y1fWa2wGinkFj8AkeFVyrvby)). To rebuild it and compare the hash yourself, you need Linux, macOS or WSL, Docker running, and [cargo-near](https://github.com/near/cargo-near) (tested with 0.23.0; the build itself runs inside the pinned Docker image). The build writes its git commit into the wasm, so check out the commit that was deployed, `cb3fe63`, the one the contract's on-chain metadata names. It takes about 2 minutes.
From 5d005b089bfdd7337d56fd007b8a2fdb5c1fb9f1 Mon Sep 17 00:00:00 2001
From: JA VI <127710324+JaDi03@users.noreply.github.com>
Date: Sat, 14 Nov 2026 05:23:47 -0600
Subject: [PATCH 9/9] docs: README logo and badges
---
README.md | 10 +++++++++-
1 file changed, 9 insertions(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 76b3392..c5d37d0 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,14 @@
-# Inti
+