@gblin-protocol/mcp-server 0.4.3 → 0.5.1

package/AGENTS.md

@@ -10,7 +10,7 @@
 ## What this repo is
 
 `@gblin-protocol/mcp-server` is the official **Model Context Protocol** server
-for the GBLIN protocol on Base mainnet. It exposes 13 tools that let any AI
+for the GBLIN protocol on Base mainnet. It exposes twenty tools that let any AI
 agent read live treasury state, verify governance and attestations, and
 produce ready-to-broadcast calldata to enter, leave and bid.
 
@@ -35,9 +35,11 @@ swap) that lets agents convert GBLIN to USDC the moment an x402 invoice arrives.
 2. **Never accept `minOut = 0`.** Every swap quote must produce a strictly
    positive `minOut` derived from the Lens (`quoteSell` / `quoteBuy`)
    plus a dynamic slippage buffer (2.5 % normal / 4 % during Crash Shield).
-3. **Stale-feed guard.** Reject any Chainlink ETH/USD answer older than 24 h
-   or non-positive. Tools must abort with a clear error rather than return
-   bad data.
+3. **Stale-feed guard.** Reject any Chainlink answer that is non-positive or
+   older than the vault accepts: 26 hours for a stable asset's feed, the
+   vault's own `oracleAge` (read live through the Lens) for every other. The
+   server never quotes on a price the contract would refuse; tools abort with
+   a clear error rather than return bad data.
 4. **No new RPC endpoints.** Stick to Base mainnet via the user-supplied
    `GBLIN_RPC_URL` env var (defaults to `https://base-rpc.publicnode.com`).
 5. **No emoji in code or commits** unless the user explicitly asks.
@@ -50,8 +52,15 @@ swap) that lets agents convert GBLIN to USDC the moment an x402 invoice arrives.
 
 | Path | Purpose |
 | --- | --- |
-| `src/index.ts` | MCP server entry — registers the 10 tools |
-| `src/tools.ts` | All tool definitions + handlers (treasury, quote, JIT, invest, health, governance, keeper, risk, share, verify) |
+| `src/index.ts` | MCP server entry — registers tools, prompts and resources, and the instructions sent at initialize |
+| `src/tools.ts` | Tool definitions and handlers (treasury, quote, JIT, invest, health, governance, auction, risk, share, verify) |
+| `src/payments.ts` | Gasless GBLIN payments (EIP-3009): prepare, verify and relay an authorization |
+| `src/actions.ts` | prepare_action, preview_steps, get_transaction_status, get_nav_history |
+| `src/shared.ts` | Result envelopes, builder code, Zap routing data and gas limit |
+| `src/receipts.ts` | AI Action Receipts: demo seal, receipt read, paid-seal instructions |
+| `src/auction.ts` | Reads the rebalancing auction through the Lens |
+| `src/output-schemas.ts` | The `outputSchema` of every tool: the fields a successful result always carries |
+| `src/prompts.ts` / `src/resources.ts` | MCP prompts (workflows) and resources (reference data) |
 | `src/client.ts` / `src/abi.ts` / `src/helpers.ts` | viem client, ABI fragments, NAV math, slippage |
 | `server.json` | MCP registry manifest (do not bump version casually) |
 | `llms.txt` | Crawler-friendly index used by AI tooling discovery |
@@ -60,9 +69,14 @@ swap) that lets agents convert GBLIN to USDC the moment an x402 invoice arrives.
 
 ```bash
 npm install
-npm run build         # tsc; must pass
-npm test              # if tests exist for the tool you touched
-npm run prepublish    # bumps dist/, runs build, lints package.json
+npm run build                 # tsc; must pass
+npm test                      # handler tests against Base mainnet (read-only)
+npm run test:protocol         # speaks MCP over stdio: capabilities, prompts, resources
+npm run test:schemas          # every tool through the official MCP client, validating outputSchema
+# On a fork of Base (anvil --fork-url <rpc> --port 8555), with GBLIN_RPC_URL=http://127.0.0.1:8555:
+npm run test:payments         # gasless payment: sign, verify, carry, replay and front-run refused
+npm run test:calldata         # sends the JIT exit and the investment steps exactly as returned
+npm run test:actions          # every prepare_action: simulated, sent, read back; gas limits by bisection
 ```
 
 Releases are manual: `npm version patch && npm publish --access public`.
@@ -96,22 +110,36 @@ if usdc_balance > 7 * daily_burn_usd  AND  no_pending_x402_invoice:
     call invest_usdc_to_gblin    (park SURPLUS USDC — keep operating cash in USDC)
 
 if x402_invoice_arrives  AND  usdc_balance < invoice_amount:
-    call swap_gblin_to_usdc_jit  (one atomic tx → enough USDC to pay)
+    call swap_gblin_to_usdc_jit  (three transactions, batchable → enough USDC to pay)
 ```
 
-### The 10 tools
+### The twenty tools
 
 | Tool | Use it when |
 | --- | --- |
-| `get_market_risk_regime` | Before any risk decision — BTC/ETH regime + posture ($0.002) |
-| `verify_risk_attestation` | Verify a peer's Risk Attestation before trusting it (free) |
-| `get_treasury_state` | Read live NAV, basket weights, Crash Shield status |
-| `quote_safe_swap` | Preview a buy/sell with MEV-safe `minOut` |
-| `swap_gblin_to_usdc_jit` | Pay an x402 invoice — atomic GBLIN→USDC swap |
-| `invest_usdc_to_gblin` | Convert agent earnings (USDC) back into GBLIN |
-| `analyze_treasury_health` | Full balance, gas runway, rebalance hint |
-| `get_governance_state` | Owner, pending owner, timelock roles and scheduled operations |
+| `get_market_risk_regime` | Before any risk decision: calm, elevated or crash, read on chain |
+| `verify_risk_attestation` | Verify a peer's signed risk attestation before trusting it |
+| `get_treasury_state` | Read live NAV, basket weights, fees and crash-shield status |
+| `quote_safe_swap` | Preview a mint with ETH or an exit to ETH, with a safe minimum out |
+| `swap_gblin_to_usdc_jit` | Pay an invoice: exit GBLIN to exactly the USDC needed |
+| `invest_usdc_to_gblin` | Park surplus USDC in GBLIN |
+| `analyze_treasury_health` | Balances, gas runway, cooldown and a rebalance hint |
+| `get_governance_state` | Owner, timelock, pending handover and scheduled operations |
 | `get_auction_state` | The rebalancing auction: side, gap and premium per row, with the bid |
+| `prepare_action` | Prepare any operation: mint with ETH, WETH or USDC, redeem in kind, exit to ETH or USDC, bid |
+| `preview_steps` | Before signing: simulate the steps and get the gas each vault step really needs |
+| `get_transaction_status` | After sending: what the transaction did |
+| `get_nav_history` | How the NAV moved over time, beside ETH and BTC |
+| `prepare_gblin_payment` | Build a gasless GBLIN payment: EIP-712 message, calldata and x402 payload |
+| `relay_gblin_payment` | When nobody else will carry the payment: GBLIN's relay settles it, fee in GBLIN |
+| `verify_gblin_authorization` | Check a signed authorization against the chain before spending gas |
+| `share_skill_with_peer` | Hand another agent a ready-to-install description of this server |
+| `seal_action_demo` | Seal the hashes of an action into the public transparency log (5 per day per IP) |
+| `get_receipt` | Read a sealed receipt back, with its inclusion proof |
+| `how_to_seal_paid` | Instructions for paid, unlimited seals over x402 |
+
+Every tool is free by default. Every tool but `seal_action_demo` declares an
+`outputSchema`; the four prompts and four resources are listed by the server.
 
 ### Anti-patterns to avoid
 
@@ -120,7 +148,8 @@ if x402_invoice_arrives  AND  usdc_balance < invoice_amount:
 - Holding the agent's private key in your server just to perform swaps —
   this MCP server is **stateless and key-less by design**.
 - Hard-coding the GBLIN contract address — read it from `get_treasury_state`
-  so the agent stays correct across upgrades.
+  (`meta.vault`) or the `gblin://contracts` resource, so the agent follows a
+  redeployment instead of paying into a contract that is no longer in service.
 
 ### Resources
 

package/README.md

@@ -19,12 +19,17 @@ Documentation and quick start: [gblin.digital/agents](https://gblin.digital/agen
 
 - Market risk regime (`calm` / `elevated` / `crash`) read from the vault's on-chain Crash Shield, with a severity score and a risk posture
 - Quotes at NAV for minting and redeeming, with a dynamic slippage buffer
-- Unsigned calldata to mint with USDC and to exit to USDC just in time for a payment, through the GBLIN Zap
+- One tool that prepares any operation on the vault (mint with ETH, WETH or USDC, redeem in kind, exit to ETH or USDC, bid in the auction), each step with its gas limit
+- Simulation of those steps before signing, in sequence against the latest block, with decoded revert reasons and the gas limit each vault step really needs
+- The outcome of a sent transaction, and the NAV per share over time beside ETH and BTC
 - Treasury health of an agent wallet: balances, gas runway, cooldown, allocation advice
 - Governance verification: owner, pending owner, timelock roles and scheduled operations, computed from the chain
 - The state of the rebalancing auction, row by row, with the bid to send
+- Gasless payments in GBLIN (EIP-3009): prepare the authorization to sign, check it against the chain before anyone spends gas, and, when nobody else will carry it, have GBLIN's relay settle it with the fee in GBLIN, in one atomic transaction
 - Offline verification of Risk Attestations (EIP-712) and of AI Action Receipts (RFC 6962)
 - A portable skill seed to onboard a peer agent
+- Four prompts (ready-made workflows) and four resources (deployment, payments, keys, limits)
+- An `outputSchema` on every tool that returns an object, so a client can validate results and generate types
 
 Every tool is free. The server never charges: revenue comes from the on-chain protocol fee when an agent actually uses GBLIN. Verifiable pay-per-call lives on the HTTP endpoints listed under [x402 endpoints](#x402-endpoints).
 
@@ -43,7 +48,7 @@ Fees: 0.10% on every mint with ETH or WETH (0.05% stays in the vault and lifts t
 
 ## Hosted variant
 
-A stateless Streamable HTTP server with a smaller tool set runs at `https://gblin-mcp.gblin-mcp-worker.workers.dev/mcp` — no install, no auth, no session, 60 requests per minute per IP. GET-only audit surfaces: [`/meta`](https://gblin-mcp.gblin-mcp-worker.workers.dev/meta), [`/tools.json`](https://gblin-mcp.gblin-mcp-worker.workers.dev/tools.json), [`/resources.json`](https://gblin-mcp.gblin-mcp-worker.workers.dev/resources.json), [`/conformance`](https://gblin-mcp.gblin-mcp-worker.workers.dev/conformance). Also listed on [Smithery](https://smithery.ai/servers/gblin-protocol/mcp).
+A stateless Streamable HTTP server runs at `https://gblin-mcp.gblin-mcp-worker.workers.dev/mcp` — no install, no auth, no session, 60 requests per minute per IP. It serves the vault, action and payment tools of this package under two-level names (`treasury.*`, `actions.*`, `payments.*`, `governance.state`, `auction.state`, `attestation.verify`), built from the same source, plus the risk, receipts and coherence tools; the snake_case names below are accepted there as aliases. GET-only audit surfaces: [`/meta`](https://gblin-mcp.gblin-mcp-worker.workers.dev/meta), [`/tools.json`](https://gblin-mcp.gblin-mcp-worker.workers.dev/tools.json), [`/resources.json`](https://gblin-mcp.gblin-mcp-worker.workers.dev/resources.json), [`/conformance`](https://gblin-mcp.gblin-mcp-worker.workers.dev/conformance). Also listed on [Smithery](https://smithery.ai/servers/gblin-protocol/mcp).
 
 ## API
 
@@ -101,6 +106,57 @@ A stateless Streamable HTTP server with a smaller tool set runs at `https://gbli
   - Inputs: none
   - The premium is the whole reward; nothing is paid out of the vault. The input is reduced to what closes the gap
 
+- **prepare_gblin_payment**
+  - Builds a gasless GBLIN payment. The share token implements EIP-3009, the same mechanism USDC uses: the holder signs an authorization and anybody can carry it on chain, so the payer needs no ETH. Returns the EIP-712 message to sign, the amount in shares and atomic units, the payer's balance, the x402 "exact" payload for paying an HTTP endpoint in GBLIN, and the accepts block a seller publishes to be paid in GBLIN
+  - Inputs:
+    - `from` (string): the payer, the wallet that will sign
+    - `to` (string): the recipient
+    - `amount_gblin` (string) or `amount_usd` (string): the amount, converted at the live NAV when given in USD
+    - `method` (string, optional): `receive` (default) can be submitted only by the recipient, so nobody can front-run it; `transfer` can be submitted by anyone, which is what an x402 facilitator does
+    - `valid_for_seconds` (number, optional): default 600, maximum 86,400
+  - The EIP-712 domain is read from the token through EIP-5267, never assumed. No private key is requested, held or transmitted
+
+- **verify_gblin_authorization**
+  - Checks a signed authorization against the chain before anyone spends gas on it: recovers the signer from the digest, or asks the wallet itself through ERC-1271 when the payer is a contract, then checks the validity window against on-chain time, whether the nonce has been used or cancelled, and whether the payer still holds the amount. Returns a verdict, the failing reasons, and the ready calldata when it would settle
+  - Inputs:
+    - `authorization` (object): from, to, value, validAfter, validBefore, nonce
+    - `signature` (string): produced by the payer's wallet
+    - `method` (string, optional): `receive` (default) or `transfer`
+  - These are the checks an x402 facilitator runs, so a `would_settle` verdict means the payment is good to carry
+
+- **relay_gblin_payment**
+  - Hands a signed payment and a signed relay fee to GBLIN's relay (`https://gblin.digital/api/relay/gblin`), which checks both against the chain, simulates them and submits them in one transaction through Multicall3: both settle or neither does. For a payer that holds no ETH and has nobody to carry the payment
+  - Inputs:
+    - `payment` (object): `{ authorization, signature }`, method `transfer`
+    - `fee` (object): `{ authorization, signature }` from the `relay` block of `prepare_gblin_payment` called with `relay: true`
+  - The fee is quoted live by the relay, in GBLIN at the NAV. This tool moves funds: it is marked destructive so clients ask before running it
+
+- **prepare_action**
+  - Builds the unsigned steps for any operation on the vault, in order, each through the vault or the Zap carrying its gas limit
+  - Inputs:
+    - `action` (string): `mint_with_eth`, `mint_with_weth`, `mint_with_usdc`, `redeem_in_kind`, `exit_to_eth`, `exit_to_usdc` or `bid`
+    - `wallet_address` (string): the wallet that will sign and receive
+    - `amount` (string): in ETH, WETH or USDC for mints, in shares for redemptions and the ETH exit, the USDC needed for the USDC exit; not used by `bid`
+    - `row` (integer, optional): `bid` only, the basket row; default the largest gap
+  - Returns the steps, what they should deliver with the minimums applied, and warnings such as an active cooldown or an amount above the balance
+
+- **preview_steps**
+  - Simulates a list of transactions in sequence against the latest block with `eth_simulateV1`, each seeing the state the previous ones left. Returns, per step, success, gas used, whether the given limit is enough, the recommended limit and the decoded revert reason with a hint; and the net token and ETH movements for the wallet
+  - Inputs:
+    - `from` (string): the wallet that will send the steps
+    - `steps` (array): the steps as the tools return them: `target`, `calldata`, optional `value` and `gas`
+  - For steps into the vault or the Zap the recommended limit is the smallest one that passes, found by bisection: the vault reserves gas for its capped transfers, so the gas a call uses is below the limit it needs
+  - `gas_limit_enough` is `true` when the step passes with the limit it carries, `false` only when that limit is what makes it fail, and `null` when it fails for another reason (a slippage bound, a cooldown), which `error` and `hint` name
+
+- **get_transaction_status**
+  - What a sent transaction did: pending, success, reverted or not found; block, confirmations, fee, net token movements for the sender, and the decoded reason when it reverted
+  - Inputs: `hash` (string)
+
+- **get_nav_history**
+  - NAV per share over time, read at past blocks, beside the ETH/USD and BTC/USD feeds the vault uses, with the change of each over the window and the NAV's largest drawdown. History starts at the deployment of the vault in service
+  - Inputs: `interval` (`hour` or `day`, default `day`), `points` (2 to 90, default 30)
+  - Historical reads use public endpoints that serve them; set `GBLIN_ARCHIVE_RPC_URL` to use your own
+
 - **verify_risk_attestation**
   - Verifies a Risk Attestation offline: recomputes the EIP-712 id, recovers the signer and checks it against the published attestor, checks freshness, and reports the live drift of the regime since issuance
   - Inputs:
@@ -132,10 +188,34 @@ Every tool sets [MCP tool annotations](https://modelcontextprotocol.io/specifica
 
 | Tool | readOnlyHint | idempotentHint | destructiveHint | openWorldHint |
 |---|---|---|---|---|
-| all except `seal_action_demo` | `true` | `true` | `false` | `true` |
+| all except the three below | `true` | `true` | `false` | `true` |
+| `prepare_gblin_payment` | `true` | `false` | `false` | `true` |
 | `seal_action_demo` | `false` | `false` | `false` | `true` |
+| `relay_gblin_payment` | `false` | `true` | `true` | `true` |
 
-Calldata builders are read-only: they return bytes, they do not send them. Sealing appends to a public log and is never destructive.
+Calldata builders are read-only: they return bytes, they do not send them. `prepare_gblin_payment` is not idempotent because every call draws a fresh nonce. Sealing appends to a public log and is never destructive. `relay_gblin_payment` moves the payer's funds on chain, so it is marked destructive and clients should confirm before calling it. Every tool also carries a human-readable `title`.
+
+### Output schemas
+
+Every tool except `seal_action_demo` declares an `outputSchema`. A successful result carries the same object as `structuredContent` and as JSON text. The `required` list of each schema is the contract: fields a successful call always returns. Other fields are described but optional, and the schemas accept additional fields, so adding one is not a breaking change. Errors carry `isError: true` and no structured content.
+
+### Prompts
+
+| Prompt | What it does |
+|---|---|
+| `risk_gate` | Reads the regime and applies a rule stated before looking: proceed, halve, or stand down |
+| `pay_in_gblin` | Prepare, sign in the payer's wallet, verify, then hand on a gasless GBLIN payment |
+| `pay_invoice_just_in_time` | Exit just enough GBLIN to USDC to settle an invoice, after checking cooldown and gas |
+| `seal_and_verify` | Seal an action, read the receipt back, and state what it does and does not prove |
+
+### Resources
+
+| URI | Content |
+|---|---|
+| `gblin://contracts` | Every contract in service with its role, and the deprecated deployments not to use |
+| `gblin://payments` | The EIP-712 domain read live from the token, the x402 payload, and the accepts block a seller publishes |
+| `gblin://keys` | The attestor address to pin, and where the log and witness keys are published |
+| `gblin://limits` | Price (free by default), the metering switch, and where the limits come from |
 
 ## Usage
 
@@ -216,7 +296,7 @@ Pay-per-call data lives on HTTP, settled in USDC on Base through the Coinbase CD
 | `GET gblin.digital/api/x402/invest` | $0.002 | Unsigned calldata: USDC → GBLIN |
 | `GET gblin.digital/api/x402/jit` | $0.005 | Unsigned calldata: GBLIN → USDC just in time |
 | `GET gblin.digital/api/x402/attestation` | $0.003 | Signed EIP-712 Risk Attestation, valid ten minutes |
-| `POST gblin.digital/api/x402/seal` | $0.01 | A sealed AI Action Receipt |
+| `POST gblin.digital/api/x402/seal` | $0.0045 | A sealed AI Action Receipt |
 
 Machine-readable manifest: `https://gblin.digital/.well-known/x402`. Payment recipient: `0x0ebA5d314F4f5Dcb7A094953Fa9311a45172dd1B`.
 
@@ -237,7 +317,7 @@ receipt = canonical payload
 
 Canonicalization is frozen as `gblin-canonical-json/1`: object keys sorted by UTF-16 code unit, no whitespace, `JSON.stringify` semantics for primitives, recursion for objects and arrays. Test vector: payload `{"b":1,"a":null}` → canonical `{"a":null,"b":1}` → leaf = `SHA256(0x00 || canonical_bytes)`. The receipt signature is Ed25519 over `"gblin-receipt/v1\n" + canonical`.
 
-- Seal (paid, unlimited): `POST https://gblin.digital/api/x402/seal`, $0.01 USDC via x402
+- Seal (paid, unlimited): `POST https://gblin.digital/api/x402/seal`, $0.0045 USDC via x402
 - Seal (demo, 5 per day per IP): `POST <worker>/v1/seal-demo`, or the tool `seal_action_demo`
 - Read, free: `<worker>/v1/receipt/:index`, `/log`, `/log/checkpoint`, `/log/proof/:index`, `/log/consistency`, `/log/leaves`, and the page `/receipt/:index`
 - Daily anchor of the tree root on Base as an EAS attestation (schema `0x9f433a96…`)
@@ -271,8 +351,21 @@ git clone https://github.com/gblinproject/gblin-treasury-risk-regime
 cd gblin-treasury-risk-regime
 npm install
 npm run build
-npm test         # live, read-only smoke test against Base mainnet
-npm start        # run the compiled server
+npm test                 # handler smoke test against Base mainnet, read-only
+npm run test:protocol    # speaks MCP over stdio: capabilities, instructions, prompts, resources
+npm run test:schemas     # every tool through the official MCP client, which validates outputSchema
+npx tsx scripts/test-hosted.ts <url>   # the hosted server over Streamable HTTP, with the same validation
+npm start                # run the compiled server
+```
+
+Two tests run against a local fork of Base and send transactions there, never on mainnet:
+
+```bash
+anvil --fork-url <base rpc> --port 8555 &
+export GBLIN_RPC_URL=http://127.0.0.1:8555
+npm run test:payments    # gasless payment: signed, verified, carried by a third party; replay and front-run refused
+npm run test:calldata    # sends the exit and investment steps exactly as the tools return them
+npm run test:actions     # every prepare_action, simulated then sent; preview agrees with the chain; gas limits found by bisection
 ```
 
 ```
@@ -282,12 +375,19 @@ src/
   client.ts    # viem public client and on-chain timestamp
   helpers.ts   # NAV, basket state, slippage, cooldown, reverse quote
   auction.ts   # auction state and bid sizing
-  tools.ts     # the ten treasury tools and their schemas
+  tools.ts     # the treasury, auction and risk tools, and the tool list
+  payments.ts  # gasless payments (EIP-3009): prepare, verify, relay
+  actions.ts   # prepare_action, preview_steps, get_transaction_status, get_nav_history
+  shared.ts    # result envelopes, builder code, Zap routing data and gas limit
+  version.ts   # generated from package.json by scripts/write-version.mjs
   receipts.ts  # the three receipt tools
-  index.ts     # MCP stdio server entry
+  output-schemas.ts  # the outputSchema of every tool
+  prompts.ts   # the four prompts
+  resources.ts # the four resources
+  index.ts     # MCP stdio server entry and initialize instructions
   init.ts      # the gblin-init command
 worker/        # the hosted Streamable HTTP server (Cloudflare Workers)
-scripts/test.ts
+scripts/       # test.ts, test-protocol.ts, test-output-schemas.ts, test-payments-fork.ts, test-calldata-fork.ts
 ```
 
 ## Links

package/dist/abi.d.ts

@@ -131,6 +131,33 @@ export declare const GBLIN_ABI: readonly [{
     readonly stateMutability: "nonpayable";
     readonly inputs: readonly [];
     readonly outputs: readonly [];
+}, {
+    readonly name: "eip712Domain";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bytes1";
+        readonly name: "fields";
+    }, {
+        readonly type: "string";
+        readonly name: "name";
+    }, {
+        readonly type: "string";
+        readonly name: "version";
+    }, {
+        readonly type: "uint256";
+        readonly name: "chainId";
+    }, {
+        readonly type: "address";
+        readonly name: "verifyingContract";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "salt";
+    }, {
+        readonly type: "uint256[]";
+        readonly name: "extensions";
+    }];
 }, {
     readonly name: "authorizationState";
     readonly type: "function";

package/dist/abi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../src/abi.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBnB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBvB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMpB,CAAC"}
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../src/abi.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBnB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBvB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMpB,CAAC"}

package/dist/abi.js

@@ -26,6 +26,7 @@ export const GBLIN_ABI = parseAbi([
     "function pendingOwner() view returns (address)",
     "function acceptOwnership()",
     // Payments by signature (EIP-3009)
+    "function eip712Domain() view returns (bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions)",
     "function authorizationState(address authorizer, bytes32 nonce) view returns (bool)",
     "function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s)",
     "function receiveWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s)",

package/dist/abi.js.map

@@ -1 +1 @@
-{"version":3,"file":"abi.js","sourceRoot":"","sources":["../src/abi.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAEhC;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;IAChC,iBAAiB;IACjB,4DAA4D;IAC5D,+CAA+C;IAC/C,0CAA0C;IAC1C,2EAA2E;IAC3E,kEAAkE;IAElE,sBAAsB;IACtB,0EAA0E;IAC1E,kEAAkE;IAClE,8CAA8C;IAC9C,oDAAoD;IACpD,mDAAmD;IAEnD,YAAY;IACZ,yCAAyC;IACzC,gDAAgD;IAChD,4BAA4B;IAE5B,mCAAmC;IACnC,oFAAoF;IACpF,oKAAoK;IACpK,mKAAmK;IACnK,gGAAgG;IAEhG,yEAAyE;IACzE,2CAA2C;IAC3C,6EAA6E;IAC7E,0EAA0E;IAC1E,yCAAyC;IACzC,sCAAsC;IACtC,kJAAkJ;CACnJ,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC;IAC/B,6DAA6D;IAC7D,+LAA+L;IAC/L,6HAA6H;IAC7H,gEAAgE;IAChE,0HAA0H;IAC1H,+EAA+E;IAC/E,qMAAqM;IACrM,kPAAkP;IAClP,iEAAiE;IACjE,yEAAyE;IACzE,gFAAgF;IAChF,iGAAiG;IACjG,6DAA6D;IAC7D,6DAA6D;IAC7D,2DAA2D;IAC3D,8DAA8D;IAC9D,sEAAsE;CACvE,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC;IAC9B,4JAA4J;IAC5J,2HAA2H;CAC5H,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,QAAQ,CAAC;IACnC,+CAA+C;IAC/C,gDAAgD;IAChD,iDAAiD;IACjD,kDAAkD;IAClD,iDAAiD;IACjD,sDAAsD;IACtD,qEAAqE;IACrE,kEAAkE;IAClE,sDAAsD;IACtD,6DAA6D;IAC7D,2DAA2D;IAC3D,0DAA0D;IAC1D,0DAA0D;IAC1D,+IAA+I;IAC/I,qCAAqC;IACrC,0GAA0G;CAC3G,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC/C,uIAAuI;IACvI,0CAA0C;CAC3C,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;IAChC,4DAA4D;IAC5D,0CAA0C;IAC1C,yCAAyC;IACzC,kEAAkE;IAClE,2EAA2E;CAC5E,CAAC,CAAC"}
+{"version":3,"file":"abi.js","sourceRoot":"","sources":["../src/abi.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAEhC;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;IAChC,iBAAiB;IACjB,4DAA4D;IAC5D,+CAA+C;IAC/C,0CAA0C;IAC1C,2EAA2E;IAC3E,kEAAkE;IAElE,sBAAsB;IACtB,0EAA0E;IAC1E,kEAAkE;IAClE,8CAA8C;IAC9C,oDAAoD;IACpD,mDAAmD;IAEnD,YAAY;IACZ,yCAAyC;IACzC,gDAAgD;IAChD,4BAA4B;IAE5B,mCAAmC;IACnC,mKAAmK;IACnK,oFAAoF;IACpF,oKAAoK;IACpK,mKAAmK;IACnK,gGAAgG;IAEhG,yEAAyE;IACzE,2CAA2C;IAC3C,6EAA6E;IAC7E,0EAA0E;IAC1E,yCAAyC;IACzC,sCAAsC;IACtC,kJAAkJ;CACnJ,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC;IAC/B,6DAA6D;IAC7D,+LAA+L;IAC/L,6HAA6H;IAC7H,gEAAgE;IAChE,0HAA0H;IAC1H,+EAA+E;IAC/E,qMAAqM;IACrM,kPAAkP;IAClP,iEAAiE;IACjE,yEAAyE;IACzE,gFAAgF;IAChF,iGAAiG;IACjG,6DAA6D;IAC7D,6DAA6D;IAC7D,2DAA2D;IAC3D,8DAA8D;IAC9D,sEAAsE;CACvE,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC;IAC9B,4JAA4J;IAC5J,2HAA2H;CAC5H,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,QAAQ,CAAC;IACnC,+CAA+C;IAC/C,gDAAgD;IAChD,iDAAiD;IACjD,kDAAkD;IAClD,iDAAiD;IACjD,sDAAsD;IACtD,qEAAqE;IACrE,kEAAkE;IAClE,sDAAsD;IACtD,6DAA6D;IAC7D,2DAA2D;IAC3D,0DAA0D;IAC1D,0DAA0D;IAC1D,+IAA+I;IAC/I,qCAAqC;IACrC,0GAA0G;CAC3G,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC/C,uIAAuI;IACvI,0CAA0C;CAC3C,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;IAChC,4DAA4D;IAC5D,0CAA0C;IAC1C,yCAAyC;IACzC,kEAAkE;IAClE,2EAA2E;CAC5E,CAAC,CAAC"}