hookit-mcp 0.5.0 → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +269 -229
- package/index.js +7430 -6791
- package/package.json +16 -16
package/README.md
CHANGED
|
@@ -1,229 +1,269 @@
|
|
|
1
|
-
# hookit-mcp
|
|
2
|
-
|
|
3
|
-
Lets an AI agent launch a coin on [hookit.fun](https://www.hookit.fun) (Ink) by itself, with its own Uniswap v4 hook modules; find coins; buy and sell them with ETH, USDG or tokenized stocks (including AI-agents-only coins, with a Hookit Agent Pass); redeem them at their Backed Floor or borrow against it; collect its creator fees;
|
|
4
|
-
|
|
5
|
-
## Setup
|
|
6
|
-
|
|
7
|
-
```json
|
|
8
|
-
{
|
|
9
|
-
"mcpServers": {
|
|
10
|
-
"hookit": {
|
|
11
|
-
"command": "npx",
|
|
12
|
-
"args": ["-y", "hookit-mcp"],
|
|
13
|
-
"env": { "HOOKIT_PRIVATE_KEY": "0x…" }
|
|
14
|
-
}
|
|
15
|
-
}
|
|
16
|
-
}
|
|
17
|
-
```
|
|
18
|
-
|
|
19
|
-
The key signs on this machine and is never sent anywhere. Give it a wallet funded for what the agent should do and nothing else.
|
|
20
|
-
|
|
21
|
-
Optional env: `HOOKIT_API_URL` (default `https://www.hookit.fun`), `HOOKIT_RPC_URL` (default Ink public RPC), `HOOKIT_MAX_BUY_ETH` (largest single `buy_token` paid in ETH, default `0.5`), `HOOKIT_MAX_BUY_USD` (largest single `buy_token` paid in a token, in dollars, default `1000`), `HOOKIT_SEND_ETH_TO` (comma-separated addresses `send_eth` may pay, for example your Kraken deposit address on Ink; unset, any address), `HOOKIT_MEMORY_EVOLVE` / `HOOKIT_MEMORY_LENS` / `HOOKIT_MEMORY_FEE1` / `HOOKIT_MEMORY_FEE2` (override Memory on Evolve's pinned addresses), `HOOKIT_VELOCITY_FEE_PLUGIN` / `HOOKIT_VELOCITY_EVOLVE` / `HOOKIT_VELOCITY_EVOLVE_FEE1` / `HOOKIT_VELOCITY_EVOLVE_FEE2` (override Velocity Fee's pinned addresses).
|
|
22
|
-
|
|
23
|
-
Coin names, tickers and descriptions are written by whoever launched the coin. The server hands them to the agent as untrusted data: `coin_info` withholds a description that carries a link, a handle, an address or a tool name, names and tickers that read as instructions are replaced, and every tool that signs is annotated so your MCP client can ask you before each call. Keep that confirmation on for a funded wallet, and set `HOOKIT_SEND_ETH_TO` if the agent only ever cashes out to one place.
|
|
24
|
-
|
|
25
|
-
## Tools
|
|
26
|
-
|
|
27
|
-
| Tool | What it does |
|
|
28
|
-
| --- | --- |
|
|
29
|
-
| `list_presets` | Strategies by goal: clean, community, deflationary, floor, builder, dynamic. |
|
|
30
|
-
| `list_modules` | Every hook module, its settings and the rules a combination must follow. |
|
|
31
|
-
| `list_pairs` | What a coin can be priced in. |
|
|
32
|
-
| `
|
|
33
|
-
| `
|
|
34
|
-
| `
|
|
35
|
-
| `
|
|
36
|
-
| `
|
|
37
|
-
| `
|
|
38
|
-
| `
|
|
39
|
-
| `
|
|
40
|
-
| `
|
|
41
|
-
| `
|
|
42
|
-
| `
|
|
43
|
-
| `
|
|
44
|
-
| `
|
|
45
|
-
| `
|
|
46
|
-
| `
|
|
47
|
-
| `
|
|
48
|
-
| `
|
|
49
|
-
| `
|
|
50
|
-
| `
|
|
51
|
-
| `
|
|
52
|
-
| `
|
|
53
|
-
| `
|
|
54
|
-
| `
|
|
55
|
-
| `
|
|
56
|
-
| `
|
|
57
|
-
| `
|
|
58
|
-
| `
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
When
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
- `
|
|
134
|
-
-
|
|
135
|
-
-
|
|
136
|
-
-
|
|
137
|
-
-
|
|
138
|
-
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
velocity_set({ "token": "0x…", "
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
-
|
|
157
|
-
-
|
|
158
|
-
-
|
|
159
|
-
-
|
|
160
|
-
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
- The
|
|
175
|
-
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
```
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
}
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
1
|
+
# hookit-mcp
|
|
2
|
+
|
|
3
|
+
Lets an AI agent launch a coin on [hookit.fun](https://www.hookit.fun) (Ink) by itself, with its own Uniswap v4 hook modules; find coins; buy and sell them with ETH, USDG or tokenized stocks (including AI-agents-only coins, with a Hookit Agent Pass); redeem them at their Backed Floor or borrow against it; collect its creator fees; steer the Evolve coins it launches (their fee, their fee split and their later hooks); and deploy a hook it wrote with hookit's Plugin SDK, submit it to the Workshop and launch with it once Hookit registers it.
|
|
4
|
+
|
|
5
|
+
## Setup
|
|
6
|
+
|
|
7
|
+
```json
|
|
8
|
+
{
|
|
9
|
+
"mcpServers": {
|
|
10
|
+
"hookit": {
|
|
11
|
+
"command": "npx",
|
|
12
|
+
"args": ["-y", "hookit-mcp"],
|
|
13
|
+
"env": { "HOOKIT_PRIVATE_KEY": "0x…" }
|
|
14
|
+
}
|
|
15
|
+
}
|
|
16
|
+
}
|
|
17
|
+
```
|
|
18
|
+
|
|
19
|
+
The key signs on this machine and is never sent anywhere. Give it a wallet funded for what the agent should do and nothing else.
|
|
20
|
+
|
|
21
|
+
Optional env: `HOOKIT_API_URL` (default `https://www.hookit.fun`), `HOOKIT_RPC_URL` (default Ink public RPC), `HOOKIT_MAX_BUY_ETH` (largest single `buy_token` paid in ETH, default `0.5`), `HOOKIT_MAX_BUY_USD` (largest single `buy_token` paid in a token, in dollars, default `1000`), `HOOKIT_SEND_ETH_TO` (comma-separated addresses `send_eth` may pay, for example your Kraken deposit address on Ink; unset, any address), `HOOKIT_MEMORY_EVOLVE` / `HOOKIT_MEMORY_LENS` / `HOOKIT_MEMORY_FEE1` / `HOOKIT_MEMORY_FEE2` (override Memory on Evolve's pinned addresses), `HOOKIT_VELOCITY_FEE_PLUGIN` / `HOOKIT_VELOCITY_EVOLVE` / `HOOKIT_VELOCITY_EVOLVE_FEE1` / `HOOKIT_VELOCITY_EVOLVE_FEE2` (override Velocity Fee's pinned addresses).
|
|
22
|
+
|
|
23
|
+
Coin names, tickers and descriptions are written by whoever launched the coin. The server hands them to the agent as untrusted data: `coin_info` withholds a description that carries a link, a handle, an address or a tool name, names and tickers that read as instructions are replaced, and every tool that signs is annotated so your MCP client can ask you before each call. Keep that confirmation on for a funded wallet, and set `HOOKIT_SEND_ETH_TO` if the agent only ever cashes out to one place.
|
|
24
|
+
|
|
25
|
+
## Tools
|
|
26
|
+
|
|
27
|
+
| Tool | What it does |
|
|
28
|
+
| --- | --- |
|
|
29
|
+
| `list_presets` | Strategies by goal: clean, community, deflationary, floor, builder, dynamic. |
|
|
30
|
+
| `list_modules` | Every hook module, its settings and the rules a combination must follow. |
|
|
31
|
+
| `list_pairs` | What a coin can be priced in. |
|
|
32
|
+
| `list_builder_hooks` | Builder hooks a launch can add: Workshop hooks written by outside builders, reviewed by Hookit and registered on chain. For each: what it does, the most it adds on a trade, the most of the hook pot it takes, where it spends it and its builder's cut. |
|
|
33
|
+
| `deploy_hook` | Deploys a hook written with hookit's Plugin SDK from this wallet on Ink, with the live ModuleRegistry as its constructor argument. Takes the Foundry artifact. `dryRun` is on unless `false`: it checks the code and prices the deployment. Workshop, below. |
|
|
34
|
+
| `submit_hook` | Submits that hook to the Workshop for Hookit's review (manifest, public repo, name, tagline, description), signed by this wallet: a message, no transaction, no fee. `dryRun` is on unless `false`. |
|
|
35
|
+
| `hook_status` | Where a submitted hook stands in the review, Hookit's note and checks, its module id once live, and what to do next. Needs no key. |
|
|
36
|
+
| `wallet_status` | The wallet's ETH and USDG, the hookit.fun coins it holds with their value, its open floor loans, and whether it can launch. |
|
|
37
|
+
| `launch_token` | Launches in one call, with an optional `devBuyPct`, `payout`, `evolve` (`{ feePct?, maxFeePct?, potPct? }`: this wallet becomes the coin's Evolve decider, below) `velocity` (`{ preset?, malusPct }`: Velocity Fee, below) and `builderHooks` (`[{ hook, pct?, initData? }]`: builder hooks, below). `dryRun: true` checks and simulates without signing. |
|
|
38
|
+
| `claim_fees` | Collects the creator fees the wallet earned on coins it launched. |
|
|
39
|
+
| `send_eth` | Sends ETH from the wallet, for example back to a Kraken deposit address on Ink. Refuses less than 0.001 ETH, Kraken's minimum deposit (`belowKrakenMinimum: true` for an address that is not Kraken). `dryRun: true` checks only. With `HOOKIT_SEND_ETH_TO` set, it refuses any other address. |
|
|
40
|
+
| `agent_pass_challenge` | Step 1 for AI-agents-only coins: five short tasks for the Hookit Agent Pass check (or "already a holder"). `{ agentId? }` for an ERC-8004 validation (below). |
|
|
41
|
+
| `claim_agent_pass` | Step 2: `{ id, answers, agentId?, requestHash? }` within 30 seconds; signs the answers with the wallet and claims the pass on chain. With `agentId`, gets Hookit's ERC-8004 validation instead (below). |
|
|
42
|
+
| `list_coins` | Coins to trade: newest, top market cap, volume or 24h gainers; filters for AI-agents-only, launched by agents, Backed Floor and Boss Raid coins, a pair, or a name. |
|
|
43
|
+
| `coin_info` | One coin: market data, what it trades in, hooks, Backed Floor price and reserve, loans, launch gate, and the wallet's balance and loans on it. |
|
|
44
|
+
| `buy_token` | Step 3 (or any time): buys a coin, `{ token, amount, payWith?, slippageBps?, dryRun? }`. Pays with ETH, USDG, kBTC or a tokenized stock such as wNVDAx. USDG reaches v2 coins priced in a stock in one transaction (bridged on chain); anything else the coin does not trade in is swapped through Relay first (USDG for a coin priced in ETH, ETH for a coin priced in a stock), then the coin is bought: two transactions. On a coin with several markets the Relay swap lands where the coin is cheapest, and a buy is refused when the market of the asset paid with prices the coin far above its other markets. Checks the coin's launch gate first and sends nothing when the wallet is not allowed yet. Always an exact-input buy, the only kind a capped gate window accepts. |
|
|
45
|
+
| `sell_token` | Sells a coin, `{ token, amount, receive?, slippageBps?, dryRun? }`, `amount` in coins, `"max"` or `"50%"`. Receives the coin's pair, USDG through the same on-chain bridges, or anything else through Relay after the sale (two transactions). A multi-pair coin sells by default in the market that pays the most (most of its markets only pay out what their buyers paid in); when the market of the asset asked for cannot pay, it sells in the best one and swaps through Relay. Says when the Backed Floor pays more. |
|
|
46
|
+
| `redeem_floor` | Burns coins for their Backed Floor value from the floor reserve, `{ token, amount, dryRun? }`: exact payout, no slippage. Compares with selling. |
|
|
47
|
+
| `borrow_against_floor` | Locks coins and borrows their floor value, `{ token, amount, days?, dryRun? }` (7, 14, 30, 60 or 90 days, fee 1% to 7% upfront). v2 coins launched with loans. |
|
|
48
|
+
| `repay_loan` | Repays a floor loan before expiry and gets the coins back, `{ loanId?, dryRun? }`. |
|
|
49
|
+
| `evolve_status` | An Evolve coin's decider and whether it is this wallet, the live setting (split of Evolve's fees and Evolve's fee), an announced setting and when it applies, the caps and notice, what Evolve has spent so far, and the hooks plugged into its 8 slots with the room left. |
|
|
50
|
+
| `evolve_decide` | As the decider of an Evolve coin: `{ token, burnPct?, deepenPct?, holdersPct?, creatorPct?, feePct?, reason?, dryRun? }` sets the next setting (omitted values keep the live ones, the split totals 100), or `cancel: true` drops the announced one. `dryRun` says whether it applies now or after the notice. |
|
|
51
|
+
| `evolve_hooks` | The hooks Hookit listed for Evolve coins: id, name, what each does with its share (burn, deepen LP, holders, its own pot, sell rebates), its fee cap, gas and status. |
|
|
52
|
+
| `evolve_plug` | As the decider of an Evolve coin: `{ token, slot (1-8), hookId, sharePct, config?, dryRun? }` plugs a listed hook in or replaces a slot's hook; `unplug: true` empties a slot; `cancel: true` drops a slot's announced change. Applies after the coin's notice. |
|
|
53
|
+
| `evolve_nft_strategy` | NFT Strategy on Evolve: the collections it can be plugged with and its hook id; with `{ token }`, the coin's live and announced plug-in (collection, burn or raffle, share), its pot (ETH waiting), each of its vaults (ETH in it, spent, NFTs bought, burned or raffled) and the raffles of the NFTs held. |
|
|
54
|
+
| `evolve_nft_strategy_plug` | As the decider of an ETH Evolve coin: `{ token, collection, outcome: "burn" \| "raffle", sharePct, slot?, dryRun? }` plugs NFT Strategy (collection by address or OpenSea slug), or replaces its collection, outcome or share in its slot; `unplug: true` unplugs it; `cancel: true` drops its announced change. Builds the config and checks it on chain. Applies after the coin's notice. |
|
|
55
|
+
| `memory_status` | Memory on an Evolve coin, `{ token }`: each Memory plug-in (slot, key, share, live or announced), its live rules in plain words with the moments running now and until when, an announced setup and when it goes live, its allies, fee cap and bot threshold; its fee companions and the plug-in each follows (companions ask while Memory runs the plug-in they follow); how far the fee can reach on the next trade; the cashback ledger (booked per plug-in, released to Memory, claimed, still waiting in Evolve); the plug-in Memory runs, the newest, the one pardons and registrations act on, and whether the one Memory runs retired. Each rule comes with its `memory_set` input. |
|
|
56
|
+
| `memory_set` | As the decider of an Evolve coin that is an AI agent: `{ token, rules, allies?, feeCapPct?, botTrades?, reason?, sharePct?, slot?, dryRun? }` writes the coin's Memory setup (at most 8 rules, 3 allies). Plugs Memory first when it is not on the coin (lowest free slot, all the share left by default, after the notice) with the 0 to 2 fee companions its fee needs; otherwise edits the plug-in in Memory's slot (the newest one there) with the whole new setup, live at once when it is a cut, else after the notice, and plugs or unplugs companions to match. `cancel: true` drops an announced setup. Several transactions may be needed: `dryRun` (on unless `false`) lists and simulates them all. |
|
|
57
|
+
| `memory_wallet` | What Memory knows of a wallet on a coin (on the plug-in Memory runs, else the newest), `{ token, wallet? }`: friend or enemy and until when, neutral (a shared signer: no give-back) or not, trades today, holding clock, open buys, cashback to claim, and which live rules apply to it now. |
|
|
58
|
+
| `memory_pardon` | As the decider of a coin that runs or ran Memory: `{ token, wallets (at most 100), dryRun? }` clears the running enemy status of those wallets at once, whichever plug-in gave it (the others are left out). `dryRun` is on unless `false`. |
|
|
59
|
+
| `velocity_set` | As the decider of an Evolve coin: `{ token, preset?, malusPct?, cashback?, cashbackPct?, sharePct?, slot?, dryRun? }` plugs Velocity (lowest free slot) with the 0 to 2 fee companions its malus needs in free slots above it, or re-plugs it with new settings; `unplug: true` unplugs Velocity and its companions together; `cancel: true` drops their announced changes. Refuses a wallet that is not the decider and a coin whose swap gas has no room; warns when the coin's fee cap leaves less room than the malus. `dryRun` is on unless `false`. |
|
|
60
|
+
| `velocity_status` | Velocity on an Evolve coin, `{ token, sellAmount?, sellCoins? }`: each plug-in (slot, live or announced with its countdown, share, settings in words), its 4 h average against the price, the malus a sell would pay now, the companions and the plug-in each follows, the fee room and the cashback ledger. |
|
|
61
|
+
| `velocity_cashback` | The Velocity cashback a wallet earned on an Evolve coin, `{ token, wallet? }`. |
|
|
62
|
+
| `velocity_claim` | Claims this wallet's Velocity cashback, `{ token, to?, dryRun? }`, paid in the coin's quote. `dryRun` is on unless `false`. |
|
|
63
|
+
|
|
64
|
+
Paying or receiving a token approves exactly that amount to the contract that trades it first (HookitSwapRouter, the Hookit aggregator for USDG on v2 coins, Relay, the floor vault or the loan plugin). A coin with anti-MEV allows one trade per wallet per block, so a buy right after a sale may wait a second.
|
|
65
|
+
|
|
66
|
+
### Paying with something the coin does not trade in (Relay)
|
|
67
|
+
|
|
68
|
+
`coin_info` lists what a coin trades in (`tradeIn`). When `payWith` or `receive` is not one of them, the server swaps through [Relay](https://relay.link) on Ink, the same route hookit.fun's own swap box uses: it asks `https://www.hookit.fun/api/relay/quote` for the swap (Relay's API key stays on that server), then signs Relay's transactions itself. A buy swaps first and buys with what Relay returned; a sale sells for the coin's pair first, then swaps the proceeds. `dryRun` shows both legs.
|
|
69
|
+
|
|
70
|
+
Before signing, Relay's transactions are checked twice. First their shape: Ink only, calls only to Relay's Ink contracts (router, approval proxy, receiver, multicaller, depository), an approval only of Relay's approval proxy (replaced by an exact approval of the amount), and no more ETH than the amount. Then their effect: the approval and every call run together in one `eth_simulateV1` from the wallet, and the swap is refused unless the wallet would give at most the amount, get at least Relay's own minimum, and lose nothing else. Anything else is refused and nothing is sent. No allowance to Relay is left behind, even when a swap fails. One Relay swap converts at most the per-buy cap (`HOOKIT_MAX_BUY_ETH` / `HOOKIT_MAX_BUY_USD`), with at most 3% slippage. Relay swaps ETH or USDG with each other, kBTC and the tokenized stocks. The RPC in `HOOKIT_RPC_URL` must support `eth_simulateV1` (Ink's public RPC does).
|
|
71
|
+
|
|
72
|
+
When the first leg went through and the second did not, the reply is `partial: true` with what the wallet now holds: do not retry the call, or the first leg runs twice.
|
|
73
|
+
|
|
74
|
+
### What the server trusts
|
|
75
|
+
|
|
76
|
+
The contracts it approves, pays or quotes from (Factory C and the Master factories, CreatorPayoutRouterC, HookitSwapRouter, the aggregator's RouteConfigC, Uniswap's V4Quoter, USDG, FloorLoanPlugin, the Gated Buy plugin, the Evolve plugin, NFT Strategy and Memory on Evolve, ModuleRegistry, Velocity Fee and Velocity on Evolve, and the Agent Pass) are pinned in the server, not read from hookit.fun: a Hookit redeploy needs a new hookit-mcp release. A launch prepared by hookit.fun is only signed when it goes to Factory C or its payout router with at most the launch fee plus `HOOKIT_MAX_BUY_ETH`. Tools that sign run one at a time, even when an agent calls several at once.
|
|
77
|
+
|
|
78
|
+
## Evolve: the wallet that launches decides
|
|
79
|
+
|
|
80
|
+
`launch_token` with `evolve` launches a coin whose fee strategy moves after launch. This server's wallet becomes the coin's decider, for good: it alone moves the coin, with `evolve_decide`, and pays its own inference (Hookit runs nothing for it and the coin pays it nothing). A coin launched on hookit.fun with Evolve is decided by the wallet that launched it there.
|
|
81
|
+
|
|
82
|
+
```
|
|
83
|
+
launch_token({ "name": "Evolving Kitty", "symbol": "EVO", "evolve": { "feePct": 1, "maxFeePct": 3 }, "dryRun": true })
|
|
84
|
+
evolve_decide({ "token": "0x…", "feePct": 2, "reason": "Heavy selling: a higher fee deepens the LP faster.", "dryRun": true })
|
|
85
|
+
```
|
|
86
|
+
|
|
87
|
+
- Evolve carries the coin's whole hook fee: its fee on every swap comes on top of the 1% base, from `feePct` at launch (default 1%) up to `maxFeePct` (default 3%, at most 9%). There is no hook tax and no dynamic fee on an Evolve coin, and one pair only.
|
|
88
|
+
- The decider sets the split of Evolve's fees between burn, deepen LP, holders and creator (total 100%, the creator share at most 20%) and Evolve's fee, inside the caps fixed at launch. Every coin starts on "LP first": 20% burn, 80% deepen LP. Omitted values keep the live setting, so `{ token, feePct: 2 }` only moves the fee.
|
|
89
|
+
- A setting that raises neither the fee nor the creator share applies at once. A raise is announced on the coin page and applies after the launch's notice (1 h); a new decision replaces it, `cancel: true` drops it.
|
|
90
|
+
- The reason is optional and public on chain: plain text, no links, e-mails, domains or @handles (refused before sending).
|
|
91
|
+
- The decider cannot change the code, the liquidity or the name, and cannot redirect money: the caps and the sinks are fixed at launch. A lost key leaves the coin on its live setting.
|
|
92
|
+
|
|
93
|
+
## Evolve: hooks added later
|
|
94
|
+
|
|
95
|
+
Hookit reviews new hooks for Evolve coins and lists them on chain (`evolve_hooks`). The coin's decider can plug up to 8 at once with `evolve_plug`, unplug one to plug another, or cancel an announced change.
|
|
96
|
+
|
|
97
|
+
- Money only: a hook spends its share of Evolve's fees on burns, deeper LP, holders, its own pot or sell rebates, and may ask a fee. It can never block or change a trade; a hook that fails is skipped and its share follows the coin's split.
|
|
98
|
+
- Shares of all slots total at most 100%. Hooks that run in every swap share a fixed swap gas budget (`evolve_status` shows the room left); a passive hook (`passive: true` in `evolve_hooks`) runs outside the swap, credited its whole share, and takes none of that gas, so its own work has no gas limit. One slot per hook.
|
|
99
|
+
- Every plug-in, replacement or unplug applies after the coin's notice (1 h). The decider's own fee comes first in the coin's fee cap; hooks share what is left.
|
|
100
|
+
- Hookit can halt a listed hook at once if its review finds a problem; a halted hook stops running on every coin.
|
|
101
|
+
- Boss Raid (Evolve version) is the first hook listed. Its `config`: `0x` = the default boss for an ETH or USDG coin; `abi.encode(uint8 hp, uint8 round)` = a preset (hp 0/1/2 = 0.5/1/3 ETH or 1,000/2,500/7,500 USDG; round 0/1/2 = no timeout, 24 h, 7 days). It takes no fee: its slot's share fills the boss's loot, a kill pays at most 0.6% of the boss's HP, and players claim on the coin's page. When it is unplugged, anyone can `retire` the raid: the last round's fair share is paid and the rest waits for the coin's next Boss Raid.
|
|
102
|
+
|
|
103
|
+
### NFT Strategy on Evolve
|
|
104
|
+
|
|
105
|
+
NFT Strategy is listed as a passive Evolve hook for ETH coins. Its slot's share buys floor NFTs of one collection Hookit lists, and each NFT bought is burned or raffled to the coin's holders.
|
|
106
|
+
|
|
107
|
+
```
|
|
108
|
+
evolve_nft_strategy({})
|
|
109
|
+
evolve_nft_strategy_plug({ "token": "0x…", "collection": "pudgy-penguins", "outcome": "raffle", "sharePct": 50, "dryRun": true })
|
|
110
|
+
```
|
|
111
|
+
|
|
112
|
+
- Its `config` is `abi.encode(address collection, uint8 outcome)`, with outcome 0 = raffle and 1 = burn. `evolve_nft_strategy_plug` builds it, checks it with the hook's `checkConfig` and finds the slot (the first free one, or NFT Strategy's own slot when it is already plugged).
|
|
113
|
+
- It never runs in the swap and takes no fee and no swap gas. Each swap credits its share; Hookit's keeper moves part of the coin's pot into the coin's vault for that collection and outcome (at most 3 NFTs' worth at the collection's price ceiling) and buys floor NFTs there in its own transactions, at Hookit's price cap. The coin's decider is never a seller.
|
|
114
|
+
- Each (coin, collection, outcome) has its own vault. Replacing the collection or the outcome applies after the notice; NFTs already bought keep their outcome, and ETH not spent stays with the coin for its next NFT Strategy plug-in, even after an unplug.
|
|
115
|
+
- Burn-outcome NFTs go to the dead address (anyone can send them). A raffle snapshots the coin's holders, opens to checks for 15 minutes, then draws from a future block hash; the keeper sends the NFT to the winner, and the coin page lets anyone do it.
|
|
116
|
+
- Until NFT Strategy on Evolve is deployed and pinned in a hookit-mcp release, both tools answer that it is not live yet.
|
|
117
|
+
|
|
118
|
+
### Memory on Evolve
|
|
119
|
+
|
|
120
|
+
Memory is an Evolve hook for coins run by an AI agent: the coin's decider must own an ERC-8004 identity or hold the Hookit Agent Pass (checked at plug-in). The decider writes up to 8 rules, "for [who], when [moment], then [actions], for [duration]", and Memory applies them inside every trade, without the agent. It remembers the market, every wallet that trades the coin (the transaction's signer) and the agent's ally coins.
|
|
121
|
+
|
|
122
|
+
```
|
|
123
|
+
memory_set({ "token": "0x…", "rules": [
|
|
124
|
+
{ "when": "sell_impact", "side": "sells", "thresholdPct": 4, "route": "burn", "mark": "enemy", "markMinutes": 1440 },
|
|
125
|
+
{ "who": "enemies", "feePct": 3 },
|
|
126
|
+
{ "who": "holders", "heldMinutes": 10080, "givebackPct": 2 },
|
|
127
|
+
{ "who": "flippers", "resoldPct": 50, "withinMinutes": 10, "feePct": 2 }
|
|
128
|
+
], "feeCapPct": 3 })
|
|
129
|
+
memory_status({ "token": "0x…" })
|
|
130
|
+
memory_wallet({ "token": "0x…", "wallet": "0x…" })
|
|
131
|
+
```
|
|
132
|
+
|
|
133
|
+
- Who: `anyone`, `friends` (a friend status from the rules, or holding an ally coin's `minBalance`), `enemies` (an enemy status from the rules), `flippers` (a sell that resells `resoldPct` of the wallet's open buys within `withinMinutes` of its last buy; sells only), `holders` (held the coin `heldMinutes`, 60 to 43,200; the clock starts at the first buy, or with "Start my holding clock" on the coin page), `non_enemies`. `side` is `buys`, `sells` or `both`; `minAmount` skips smaller trades.
|
|
134
|
+
- When: `always` (every trade), `sell_impact`, `big_buy`, `price_drop`, `volume`, `silence`, `while_active` (Reflex's moments: `thresholdPct`, `amount`, `windowMinutes`, `whileRule`), in effect from the trade that triggers it to `durationMinutes` after (0 to 60; 0: that trade only).
|
|
135
|
+
- Then: `feePct` (anyone, enemies or flippers only, at most 4 rules with a fee), `givebackPct` (0.01 to 10, never for enemies or flippers: a rebate inside an exact-input sell, else cashback the wallet claims on the coin page), `route` (Memory's share of the trade to `burn`, `lp` or `holders`), `mark` (`enemy` for 1 to 1,440 minutes, `friend` for 60 to 43,200). Statuses come only from the rules; the decider can only pardon (`memory_pardon`).
|
|
136
|
+
- `feeCapPct` (0 to 3) caps the rules' fees added up on one trade. Evolve caps each hook's fee at 1%, so a cap above 1% runs Memory plus one or two fee companions (MemoryFee rank 1 asks the 2nd percent, rank 2 the 3rd), each fee-only, with share 0, in its own slot above Memory's. A companion follows the Memory plug-in in a slot below its own when it is plugged (the announced one if that slot has a change pending, else the live one), so `memory_set` plugs, re-plugs or unplugs them with Memory: one setup can take up to 3 transactions. Companions ask while Memory runs the plug-in they follow: the one Memory ran the coin's last trade for (before any trade, the newest). So during a re-plug's notice the old plug-in and its companions keep charging, the new plug-in's companions ask from its first trade, and after a cancelled re-plug Memory keeps running the live one. Once the plug-in Memory runs has left the slots, its companions keep asking until they are unplugged too (`evolve_plug` says so when Memory leaves), until another Memory plug-in trades, or until anyone calls `retire(token)` on Memory; `memory_status` warns when this happens.
|
|
137
|
+
- `botTrades` (5 to 1,000, default 100): a wallet trading more than that in a UTC day becomes neutral for good (a shared signer: solvers, bundlers). A neutral wallet gets no give-back (no rebate, no cashback) and no new status; it meets the `anyone` and `non_enemies` rules (fees and routes), and the `enemies` ones while a grudge it had before turning neutral runs out (at most 24 h).
|
|
138
|
+
- Holding clock: it starts at a wallet's first buy (or with "Start my holding clock", `register(token)`, for a wallet that holds the coin), stops when a sell leaves it under one unit (0.0001 of the quote, at that trade's price), and a clock started on less restarts at the wallet's next buy.
|
|
139
|
+
- Pardons, registrations and `memory_wallet` act on the plug-in Memory runs (unless it retired, then on the newest); `memory_pardon` clears any running grudge on the coin, whichever plug-in gave it.
|
|
140
|
+
- Editing: `memory_set` sends the whole setup (`memory_status` gives the live one as input). A cut is live at once and keeps the running moments: the same allies and `botTrades`, a cap no higher, and in place a fee lowered, a give-back raised, a route switched, an enemy mark shortened or dropped; rules without a route, give-back or friend mark dropped from the end; rules without a fee or mark appended. Anything else waits the coin's notice and restarts every moment. `dryRun` says which, before anything is sent.
|
|
141
|
+
- Its `config` for `evolve_plug` is `abi.encode(Setup)`, `Setup = (Rule[] rules, (address coin, uint96 minBalance)[] allies, uint16 feeCap, uint16 botTrades)` with `Rule = (uint8 who, uint8 side, uint16 whoBps, uint32 whoWindow, uint128 minNotional, uint8 condition, uint32 window, uint128 threshold, uint16 duration, uint8 route, uint16 feeBps, uint16 perkBps, uint8 mark, uint32 markFor)`; its companions take `0x`. `memory_set` builds it, checks the bounds and the allies, and refuses a decider that is not an agent before anything is sent.
|
|
142
|
+
- Memory's predicted addresses are pinned (list `c-evolve-memory`); until its contracts are deployed there, the four tools answer that it is not live yet. `HOOKIT_MEMORY_EVOLVE`, `HOOKIT_MEMORY_LENS`, `HOOKIT_MEMORY_FEE1` and `HOOKIT_MEMORY_FEE2` override them; nothing is used until code is there and the contracts point at each other.
|
|
143
|
+
|
|
144
|
+
### Velocity on Evolve
|
|
145
|
+
|
|
146
|
+
Velocity keeps a slow moving average of the coin's price (the mean: half-life 4 h, in the coin's own orientation). A sell whose price path runs below it, past a deadband, pays a malus on top of the coin's fee, growing with the depth up to the chosen malus and averaged over the sell's own path: a big dump pays more than a small sell, and splitting it saves almost nothing. A buy below the mean that brings the price back toward it earns cashback. Any decider can plug it (creator or agent), on new and existing Evolve coins.
|
|
147
|
+
|
|
148
|
+
```
|
|
149
|
+
velocity_set({ "token": "0x…", "preset": "balanced", "malusPct": 3, "dryRun": true })
|
|
150
|
+
velocity_status({ "token": "0x…", "sellAmount": "0.5" })
|
|
151
|
+
velocity_cashback({ "token": "0x…" })
|
|
152
|
+
velocity_claim({ "token": "0x…", "dryRun": false })
|
|
153
|
+
velocity_set({ "token": "0x…", "unplug": true, "dryRun": true })
|
|
154
|
+
```
|
|
155
|
+
|
|
156
|
+
- Presets (`halfLife` 4 h for all): `gentle` (deadband 1,500 ticks, about 14% below the mean), `balanced` (default, 1,000 ticks, about 10%), `strong` (500 ticks, about 5%). The malus is full 1,000 ticks beyond the deadband per 1% of malus (`balanced` at 3%: 3,000 ticks beyond the deadband, so the full malus from about 33% below the mean); `gentle` doubles that depth (at most 20,000 ticks), `strong` halves it (at least 100). A tick is 0.01%.
|
|
157
|
+
- `malusPct` 0 to 3 (default 3). Evolve caps each hook's fee at 1%, so Velocity asks the 1st percent and up to two fee companions (VelocityEvolveFee rank 1 and 2) the 2nd and 3rd: none up to 1%, one up to 2%, two up to 3%, each fee-only (share 0, config `0x`) in a free slot above Velocity's. A companion follows the Velocity plug-in in a lower slot when it is plugged, so a re-plug re-plugs them too; `velocity_set` does all of it, one transaction each.
|
|
158
|
+
- Cashback (on by default): `cashbackBps` 100% of the Evolve fee a dip buy paid (`cashbackPct` lowers it), times how well it closes the gap (most when it ends at the mean). It is paid from Velocity's share of Evolve's fees (`sharePct`, default 20%); on Evolve it is always on, because the catalog requires Velocity to take a share and a share pays cashback (`cashback: false` is refused). The 1% base fee is never given back. Each wallet claims its own (`velocity_claim`), also after an unplug.
|
|
159
|
+
- Swap gas: Velocity takes 38,000 of the coin's 120,000 and each companion 41,000, so Velocity with both companions takes it all. `velocity_set` refuses when Memory (or another hook that runs in every swap) leaves too little, and says which malus still fits.
|
|
160
|
+
- Fee room: Evolve adds the malus to its own fee and clamps the sum to the coin's fee cap. `velocity_set` warns when the cap minus Evolve's fee is below the malus (e.g. a 4% cap with a 3% fee leaves 1%); lower Evolve's fee with `evolve_decide` to leave it room.
|
|
161
|
+
- A plug-in's settings never change: new settings re-plug Velocity in its slot after the notice, and its mean restarts at its first trade. Every plug-in, re-plug and unplug applies after the coin's notice.
|
|
162
|
+
- Unplug with `velocity_set { unplug: true }`: it empties Velocity's slot and its companions' slots together (announces hook `0xFFFF`, none). A companion left alone keeps reading Velocity's last mean and asks a malus that fades out within a few half-lives.
|
|
163
|
+
- Its `config` for `evolve_plug` is `abi.encode(Setup)`, `Setup = (uint32 halfLife, uint16 deadbandTicks, uint16 fullDepthTicks, uint16 malusBps, uint16 cashbackBps)`; its companions take `0x`. The catalog ids are found by scanning EvolveExtensions' list for the pinned addresses.
|
|
164
|
+
- Live on Ink since hookit-mcp 0.5.0: VelocityEvolve `0xA76B2081A521AD03d773B7A4EB38088DAcaDA628`, its companions `0xebA39A6E554580f8F4c0aEB9B58Ead323D34eC95` (rank 1) and `0x90ffeF641eBAdea46Fb2Ae94e64e94aF7F9e2f7F` (rank 2). `HOOKIT_VELOCITY_EVOLVE`, `HOOKIT_VELOCITY_EVOLVE_FEE1` and `HOOKIT_VELOCITY_EVOLVE_FEE2` override them; nothing is used unless code is there and the contracts point at each other.
|
|
165
|
+
|
|
166
|
+
## Velocity Fee at launch
|
|
167
|
+
|
|
168
|
+
A coin without Evolve gets Velocity Fee at launch: `launch_token` with `velocity`.
|
|
169
|
+
|
|
170
|
+
```
|
|
171
|
+
launch_token({ "name": "Calm Kitty", "symbol": "CALM", "hookTaxPct": 5, "modules": { "autoBurn": true, "autoBurnPct": 90 }, "velocity": { "preset": "balanced", "malusPct": 3 }, "dryRun": true })
|
|
172
|
+
```
|
|
173
|
+
|
|
174
|
+
- The same curves as on Evolve (`preset`), and `malusPct` 1 to 9. The plugin is registered in ModuleRegistry once per malus tier (0%, 1%, … 9%): the malus counts as its tier, rounded up to a whole percent, and **1% base + hook tax + tier must stay at most 10%** (a 6% hook tax leaves a 3% malus; no hook tax leaves 9%). With dynamic fees the hook tax is the top of the range minus the base. The server finds the tier's module id by scanning the registry for the pinned plugin with that ceiling; ids are never hard-coded.
|
|
175
|
+
- Rebates: only when buys pay a hook tax (a static hook tax above 0, or dynamic fees whose minimum total is above 1%). Then a buy below the mean gets back up to all of the hook tax on the part of the buy that closes the gap, paid from Velocity's 10% share of the hook pot, and the coin's other destinations take the other 90% (the pot routes still total 100%). Otherwise Velocity runs the malus alone, with no pot share, and the dry run says so. The 1% base fee is always paid.
|
|
176
|
+
- Its malus goes into the hook pot and is split like the hook tax; the coin's pot needs destinations.
|
|
177
|
+
- Refused with Evolve (plug Velocity on Evolve instead) and with NFT Strategy.
|
|
178
|
+
- The launch is prepared by hookit.fun; before signing, the server decodes the transaction and checks it carries exactly Velocity's slot: the tier's module, the init data `abi.encode(Params)` with `Params = (uint32 halfLife, uint16 deadbandTicks, uint16 fullDepthTicks, uint16 maxSurchargeBps, uint16 rebateBps)` built from the preset and the launch's own fees, the pot share, and the 10% rule. Anything else is refused and nothing is sent.
|
|
179
|
+
- Live on Ink since hookit-mcp 0.5.0: VelocityFeePlugin `0x99772E2199da48e0d1388A3776F96b4257A49E8E`, registered for the 0% to 9% tiers. `HOOKIT_VELOCITY_FEE_PLUGIN` overrides it.
|
|
180
|
+
|
|
181
|
+
## Builder hooks at launch
|
|
182
|
+
|
|
183
|
+
Builder hooks are hooks written by outside builders in hookit.fun's Workshop. Hookit reviews each one and registers it in ModuleRegistry; `list_builder_hooks` shows the live ones, and `launch_token` adds them with `builderHooks`.
|
|
184
|
+
|
|
185
|
+
```
|
|
186
|
+
list_builder_hooks()
|
|
187
|
+
launch_token({ "name": "Burny", "symbol": "BRN", "hookTaxPct": 3, "builderHooks": [{ "hook": 21, "pct": 20 }], "dryRun": true })
|
|
188
|
+
```
|
|
189
|
+
|
|
190
|
+
- `hook` is the moduleId from `list_builder_hooks`, its plugin address or its exact name. `pct` is the whole percent of the hook pot it takes, up to its `maxPct` (hooks that take a share only); left out, hookit.fun picks the launch wizard's default. The coin's built-in pot destinations are rebalanced to leave it.
|
|
191
|
+
- A hook with a share needs something to fill the hook pot: a hook tax, Creator → Hook, or a builder hook that adds its own fee (`fillsHookPot`). `maxFeePct` is the most a hook adds on a trade, and it counts in the 10% cap with the 1% base and the hook tax.
|
|
192
|
+
- Names, taglines and descriptions are the builders' own words: the server filters them like a launcher's text and the agent treats them as data. The module, its plugin, its pot and fee caps and whether it is halted are read from ModuleRegistry, and a hook whose module holds another plugin or is deprecated is not listed.
|
|
193
|
+
- Up to 8 per launch. Refused with Evolve and with Velocity Fee for now.
|
|
194
|
+
- `initData` is the hook's launch settings, what its `onLaunch` reads: `0x` hex in whole bytes, up to 1,024. Left out, it is empty, as from hookit.fun's launch form.
|
|
195
|
+
- Before signing, the server decodes the transaction hookit.fun prepared and checks it carries one slot per hook asked and nothing else: its module, exactly the launch settings asked (none when left out), the share asked and never more than the module's registered cap. A launch asked without plugins is refused if a plugin slot appears. Anything else is refused and nothing is sent.
|
|
196
|
+
- A builder hook can be halted by Hookit at any time; the coin keeps trading without it.
|
|
197
|
+
|
|
198
|
+
## Workshop: write a hook, deploy it, submit it, launch with it
|
|
199
|
+
|
|
200
|
+
An agent writes a hook with [hookit's Plugin SDK](https://github.com/SDKHookit/SDKHookit) (its AGENTS.md holds every rule Hookit's review checks), runs the SDK's tests, then deploys and submits it from this wallet. The wallet that deploys is the one that submits.
|
|
201
|
+
|
|
202
|
+
```
|
|
203
|
+
deploy_hook({ "artifact": "out/MyHook.sol/MyHook.json" }) // checks it, gas and cost
|
|
204
|
+
deploy_hook({ "artifact": "out/MyHook.sol/MyHook.json", "dryRun": false }) // deploys it
|
|
205
|
+
// then, in the SDK folder: forge verify-contract … and forge script script/Manifest.s.sol … (the answer gives both)
|
|
206
|
+
submit_hook({ "manifest": "manifests/my-hook.json", "repo": "https://github.com/you/my-hook/tree/<commit>",
|
|
207
|
+
"name": "My Hook", "tagline": "…", "description": "…", "dryRun": false })
|
|
208
|
+
hook_status({ "plugin": "0x…" }) // the review, then the module id
|
|
209
|
+
launch_token({ "name": "…", "symbol": "…", "builderHooks": [{ "hook": 21, "initData": "0x…" }], "dryRun": true })
|
|
210
|
+
```
|
|
211
|
+
|
|
212
|
+
- `deploy_hook` takes the Foundry artifact (`out/<File>.sol/<Contract>.json` after `forge build`) and refuses anything that is not a deployable plugin: one `address` constructor, no linked libraries, code within Ink's limits. The constructor argument is always the ModuleRegistry pinned here, never one the agent or a website names.
|
|
213
|
+
- `submit_hook` sends the manifest as the SDK wrote it and cleans the card exactly as the Workshop's form does, then signs the Workshop's submit message. It says when the plugin already has a submission and warns when the explorer names another deployer.
|
|
214
|
+
- Nothing here is an audit: Hookit's review may ask for changes (a change is a new deployment and a new submission), and it can halt a plugin at any time.
|
|
215
|
+
- Both signing tools are dry runs unless `dryRun` is `false`: deploy or submit only once the user said to.
|
|
216
|
+
|
|
217
|
+
## Backed Floor: redeem and borrow
|
|
218
|
+
|
|
219
|
+
A coin launched with Backed Floor has a reserve that pays a floor price, reserve divided by circulating supply, which never goes down.
|
|
220
|
+
|
|
221
|
+
- `redeem_floor` burns coins and pays their floor value now. It is worth it when the market pays less than the floor.
|
|
222
|
+
- `borrow_against_floor` (v2 coins launched with loans) locks coins and pays their floor value minus an upfront fee. `repay_loan` before expiry pays their floor value then (at least what was borrowed) and returns the coins. Without repayment the coins are burned at expiry and the wallet keeps what it borrowed: nothing more is owed and nothing is liquidated before expiry.
|
|
223
|
+
|
|
224
|
+
`wallet_status` also reports `agentPass: { holder, via }`: `via` is `pass` for a Hookit Agent Pass holder, `erc8004` for the operating wallet of an ERC-8004 identity validated by Hookit (or by a validator hookit trusts), `null` otherwise.
|
|
225
|
+
|
|
226
|
+
## AI-agents-only coins
|
|
227
|
+
|
|
228
|
+
A creator can launch a coin with Gated Buy in "AI agents only" mode: during a window after launch (up to 24 hours), only wallets holding a Hookit Agent Pass can buy. The pass is non-transferable. A wallet gets it by solving a short agent check: five small tasks (arithmetic on word lengths, a reversed word, a letter count…), answered and signed by the wallet itself within 30 seconds.
|
|
229
|
+
|
|
230
|
+
1. `agent_pass_challenge`: the tasks, and the challenge id.
|
|
231
|
+
2. `claim_agent_pass({ id, answers })`: the answers, signed by the wallet's key; hookit checks them and returns a voucher, and the wallet sends `claim(deadline, signature)` to the pass contract itself (a little gas).
|
|
232
|
+
3. `buy_token({ token, amount })`: the wallet buys. The gate checks the wallet that signs the transaction, which is why the agent buys from its own wallet.
|
|
233
|
+
|
|
234
|
+
Ask in plain words: "Buy 0.01 ETH of 0x… on hookit." If the coin is AI-agents-only and the wallet has no pass, `buy_token` says so and the agent runs steps 1 and 2 first. One try per challenge; a pass is for good. A pass proves the wallet passed the agent check, not that no human is behind it.
|
|
235
|
+
|
|
236
|
+
### ERC-8004 agents
|
|
237
|
+
|
|
238
|
+
An agent with an ERC-8004 identity on Ink can get Hookit's validation instead of a pass, with the same check: `agent_pass_challenge({ agentId })` then `claim_agent_pass({ id, answers, agentId: "<identity id, digits>" })`, run with the identity's operating wallet (`agentWallet`) as `HOOKIT_PRIVATE_KEY`.
|
|
239
|
+
|
|
240
|
+
- If this wallet owns the identity or is its approved operator, and Hookit has not published yet, it sends two transactions: the validation request to the ERC-8004 ValidationRegistry, then `validate` on Hookit's validator, which links the wallet and publishes a 100/100 `hookit-agent` validation response anyone can read.
|
|
241
|
+
- Otherwise it sends `validate` without a request: the wallet is linked (it counts as an agent) but nothing is published. To publish later, the identity's owner sends `validationRequest(validator, agentId, "https://hookit.fun/agents", any new hash)` with its own wallet, then the agent runs the two tools again with `requestHash` set to that hash.
|
|
242
|
+
- Already linked (and published, or nothing to publish): it says so, and sends nothing.
|
|
243
|
+
|
|
244
|
+
The server checks every transaction hookit.fun returns against the pinned validator and the chain (the identity's owner and operators, the request's hash, URI and deadline) and simulates the voucher before sending anything. The validation follows the identity: transferring it clears its operating wallet, and the wallet stops counting. A wallet Hookit revoked, on the pass or on the validator, gets neither a pass nor a validation.
|
|
245
|
+
|
|
246
|
+
## With Kraken
|
|
247
|
+
|
|
248
|
+
Ink is Kraken's chain: Kraken moves ETH to and from Ink directly. Run the [Kraken CLI](https://github.com/krakenfx/kraken-cli) MCP next to this one and an agent can fund its wallet from Kraken, launch, collect its fees with `claim_fees`, and send them back to its Kraken deposit address on Ink with `send_eth`. Use only the address Kraken returns for the "ETH - Ink" deposit method, and send at least 0.001 ETH: Kraken marks smaller deposits as failed and the funds are lost.
|
|
249
|
+
|
|
250
|
+
```json
|
|
251
|
+
{
|
|
252
|
+
"mcpServers": {
|
|
253
|
+
"kraken": {
|
|
254
|
+
"command": "kraken",
|
|
255
|
+
"args": ["mcp", "-s", "market,account,funding"],
|
|
256
|
+
"env": { "KRAKEN_API_KEY": "…", "KRAKEN_API_SECRET": "…" }
|
|
257
|
+
},
|
|
258
|
+
"hookit": {
|
|
259
|
+
"command": "npx",
|
|
260
|
+
"args": ["-y", "hookit-mcp"],
|
|
261
|
+
"env": { "HOOKIT_PRIVATE_KEY": "0x…" }
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
}
|
|
265
|
+
```
|
|
266
|
+
|
|
267
|
+
Kraken withdraws only to saved addresses: save the agent's wallet in Kraken on the Ink network first.
|
|
268
|
+
|
|
269
|
+
Without MCP: `GET /api/agents/catalog` and `POST /api/agents/prepare-launch` on hookit.fun, and `GET` / `POST /api/agents/pass` for the Agent Pass (see `/llms.txt`).
|