Server definition

Hash: sha256:d0e94b838ff526d51193e5f7a646d9f51e7377033a3592a3f0a49ec9316cbe60
What it is: What a remote MCP server returned when asked what it offers: 24 tools

The blob, as servednamed by its sha256

{
  "instructions": "GBLIN hosted MCP (stateless, no auth, 60 req/min/IP, everything here is free). THREE THINGS LIVE HERE. (1) AI ACTION RECEIPTS - a public append-only RFC 6962 transparency log for AI actions. receipts.seal appends the SHA-256 of your input (and optionally your output) plus a short public label, and returns a portable receipt: Ed25519 signature, inclusion proof, C2SP checkpoint, tree root anchored daily on Base. Minimal call: receipts.seal {action: \"what you did\", input_hash: \"<sha256 hex>\"} - demo mode, 5/day/IP, receipts marked demo:true. Then receipts.verify checks it with pure math, no trust in this server; receipts.get re-reads any receipt by index. A receipt proves the record existed here at this time - NOT that the action happened (provenance is self-reported). (2) MARKET RISK: risk.regime (live calm|elevated|crash from the on-chain Crash Shield), risk.attestation_sample, protocol.stats, protocol.info, coherence.report. Nothing is paid over MCP; unlimited seals and signed attestations are x402 HTTP endpoints - see resources gblin://howto/seal, gblin://howto/attestation, gblin://limits, gblin://keys. Ready-made prompts: seal_and_verify, risk_gate. (3) THE GBLIN VAULT, the same code as the npm package @gblin-protocol/mcp-server: treasury.state, treasury.quote, treasury.health, treasury.nav_history, governance.state, auction.state, attestation.verify; to act, actions.prepare (any operation) -> actions.preview (simulate before signing; finds the gas each vault step really needs) -> send from your own wallet -> actions.status; to pay in GBLIN with a signature and no ETH, payments.prepare -> payments.verify, or payments.relay when nobody else will carry it. This server holds no key and never signs. The npm package's snake_case tool names are accepted here as aliases. (4) DOCUMENTS: search (query) and fetch (id) return the protocol's documentation, one card per tool and the live vault state as documents, in the shape research clients read.",
  "tools": [
    {
      "description": "Build the unsigned transactions for any operation on the GBLIN vault, in the order to send them. Actions: mint_with_eth (amount in ETH), mint_with_weth (amount in WETH), mint_with_usdc (amount in USDC, through the Zap), redeem_in_kind (amount in shares; pro rata basket tokens, no fee, no price feed), exit_to_eth (amount in shares, through the Zap, all or nothing), exit_to_usdc (amount = the USDC you need), bid (trade with the rebalancing auction; row optional, the largest gap by default). Every output bound is non-zero and every step through the vault or the Zap carries its gas limit. Nothing is signed or sent: simulate the steps with preview_steps, then send them from the wallet.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "action": {
            "description": "The operation to prepare.",
            "enum": [
              "mint_with_eth",
              "mint_with_weth",
              "mint_with_usdc",
              "redeem_in_kind",
              "exit_to_eth",
              "exit_to_usdc",
              "bid"
            ],
            "type": "string"
          },
          "amount": {
            "description": "Decimal amount. Unit depends on the action (see the description). Not used by bid.",
            "pattern": "^\\d+(\\.\\d+)?$",
            "type": "string"
          },
          "row": {
            "description": "bid only: the basket row to bid on. Default: the row with the largest gap.",
            "minimum": 0,
            "type": "integer"
          },
          "wallet_address": {
            "description": "The wallet that will sign and receive.",
            "pattern": "^0x[a-fA-F0-9]{40}$",
            "type": "string"
          }
        },
        "required": [
          "action",
          "wallet_address"
        ],
        "type": "object"
      },
      "name": "actions.prepare",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "action": {
            "type": "string"
          },
          "expected": {
            "description": "What the operation should deliver, with the minimums applied.",
            "type": "object"
          },
          "next": {
            "type": "string"
          },
          "steps": {
            "description": "Transactions to send in order.",
            "items": {
              "description": "One transaction to send, in order: target, calldata, value in wei, and gas when the step needs an explicit limit. The same call is repeated as to, data and chainId (8453) for wallet batch APIs such as send_calls.",
              "type": "object"
            },
            "type": "array"
          },
          "wallet": {
            "type": "string"
          },
          "warnings": {
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "action",
          "steps"
        ],
        "type": "object"
      }
    },
    {
      "description": "Simulate a list of transactions in sequence against the latest Base block, as if the wallet sent them one after the other, before anything is signed. Each step sees the state the previous ones left (an approval before a mint works). Returns, per step, whether it would succeed, the gas it uses, whether the gas limit it carries is enough, and the decoded revert reason with a hint when it fails; and the net token and ETH movements for the wallet. Pass the steps exactly as prepare_action, invest_usdc_to_gblin or swap_gblin_to_usdc_jit return them. State can change before your transactions land: a successful preview is evidence, not a guarantee.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "from": {
            "description": "The wallet that will send the steps.",
            "pattern": "^0x[a-fA-F0-9]{40}$",
            "type": "string"
          },
          "steps": {
            "description": "The steps, in order: target and calldata (or their send_calls spellings, to and data), value in wei (optional), gas (optional).",
            "items": {
              "additionalProperties": true,
              "properties": {
                "calldata": {
                  "description": "ABI-encoded call. Alias: data.",
                  "pattern": "^0x([0-9a-fA-F]{2})*$",
                  "type": "string"
                },
                "data": {
                  "pattern": "^0x([0-9a-fA-F]{2})*$",
                  "type": "string"
                },
                "gas": {
                  "pattern": "^\\d+$",
                  "type": "string"
                },
                "target": {
                  "description": "Contract to call. Alias: to.",
                  "pattern": "^0x[a-fA-F0-9]{40}$",
                  "type": "string"
                },
                "to": {
                  "pattern": "^0x[a-fA-F0-9]{40}$",
                  "type": "string"
                },
                "value": {
                  "pattern": "^\\d+$",
                  "type": "string"
                }
              },
              "required": [],
              "type": "object"
            },
            "maxItems": 8,
            "minItems": 1,
            "type": "array"
          }
        },
        "required": [
          "from",
          "steps"
        ],
        "type": "object"
      },
      "name": "actions.preview",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "balance_changes": {
            "description": "Net token and ETH movements for the wallet.",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "block": {
            "description": "The block the simulation ran on.",
            "type": "number"
          },
          "first_failing_step": {
            "type": [
              "number",
              "null"
            ]
          },
          "from": {
            "type": "string"
          },
          "note": {
            "type": "string"
          },
          "steps": {
            "description": "Per step: success, gas used, whether the given limit is enough, recommended limit, revert reason.",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "would_succeed": {
            "description": "True only if every step succeeds in the simulation.",
            "type": "boolean"
          }
        },
        "required": [
          "would_succeed",
          "steps",
          "balance_changes"
        ],
        "type": "object"
      }
    },
    {
      "description": "Report what a sent Base transaction did: pending, succeeded, reverted or not found; its block and confirmations; the fee paid; the net token movements for the sender (GBLIN shares minted or redeemed, USDC, basket tokens); and, when it reverted, the decoded reason. Use it after sending the steps from prepare_action to confirm each one before the next.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "hash": {
            "description": "The transaction hash.",
            "pattern": "^0x[0-9a-fA-F]{64}$",
            "type": "string"
          }
        },
        "required": [
          "hash"
        ],
        "type": "object"
      },
      "name": "actions.status",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "balance_changes": {
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "block": {
            "type": "number"
          },
          "confirmations": {
            "type": [
              "number",
              "null"
            ]
          },
          "explorer": {
            "type": "string"
          },
          "fee_eth": {
            "type": "string"
          },
          "from": {
            "type": "string"
          },
          "gas_limit": {
            "type": [
              "number",
              "null"
            ]
          },
          "gas_used": {
            "type": "number"
          },
          "hash": {
            "type": "string"
          },
          "note": {
            "type": "string"
          },
          "revert": {
            "type": "object"
          },
          "status": {
            "enum": [
              "pending",
              "not_found",
              "success",
              "reverted"
            ],
            "type": "string"
          },
          "to": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "hash",
          "status"
        ],
        "type": "object"
      }
    },
    {
      "description": "Verify a GBLIN Risk Attestation — the object returned by GBLIN's /api/x402/attestation, or a proof-of-diligence a peer agent attached to its action. FREE, no payment. Runs four checks: (1) INTEGRITY — recomputes the EIP-712 attestation_id and detects tampering; (2) AUTHENTICITY — if a signature is present, recovers the signer and checks it is GBLIN's published attestor; (3) FRESHNESS — whether it expired (10-minute TTL), using on-chain time; (4) LIVE DRIFT — compares the attested regime to the CURRENT on-chain regime and flags if it changed. Use before you trust any counterparty/peer that claims it 'checked market risk via GBLIN'.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "attestation": {
            "description": "The full attestation object from /api/x402/attestation (must include `eip712`; `attestation_id`, `signature`, `attestor` are used when present). A JSON string of that object is also accepted.",
            "type": "object"
          },
          "expected_attestor": {
            "description": "Optional 0x address to check the signature against. Defaults to the GBLIN attestor address baked into this MCP build (GBLIN_ATTESTOR_ADDRESS env).",
            "pattern": "^0x[a-fA-F0-9]{40}$",
            "type": "string"
          }
        },
        "required": [
          "attestation"
        ],
        "type": "object"
      },
      "name": "attestation.verify",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "attested": {
            "type": "object"
          },
          "checks": {
            "description": "Each check by name, with its result.",
            "type": "object"
          },
          "guidance": {
            "type": "string"
          },
          "live": {
            "type": "object"
          },
          "recomputed_attestation_id": {
            "type": "string"
          },
          "source": {
            "type": "string"
          },
          "valid": {
            "description": "True only if every check passed.",
            "type": "boolean"
          }
        },
        "required": [
          "valid",
          "checks"
        ],
        "type": "object"
      }
    },
    {
      "description": "Read the GBLIN rebalancing auction on Base. The vault does not rebalance itself and pays nobody to do it: when a basket row drifts past its band it holds a Dutch auction, and whoever trades with it toward the target weights is the counterparty, at the oracle price adjusted by a premium that starts at a discount and rises to a cap over one ramp. Returns, per row, the side the vault takes, the gap in ETH, the token and amount the bidder hands over, and unsigned calldata (approval + bid). The premium is the whole reward; nothing is paid out of the vault.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "required": [],
        "type": "object"
      },
      "name": "auction.state",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "auctionOpen": {
            "type": "boolean"
          },
          "best": {
            "description": "The row with the largest gap, or null.",
            "type": [
              "object",
              "null"
            ]
          },
          "curve": {
            "type": "object"
          },
          "howToBid": {
            "type": "string"
          },
          "lens": {
            "type": "string"
          },
          "navReliable": {
            "type": "boolean"
          },
          "note": {
            "type": "string"
          },
          "openedAt": {
            "description": "When the auction opened, or null when closed.",
            "type": [
              "number",
              "string",
              "null"
            ]
          },
          "premiumBps": {
            "description": "Current premium over the oracle price, in basis points; negative is a discount.",
            "type": "number"
          },
          "rows": {
            "description": "One entry per basket asset: side, gap from target and amount a bidder can fill.",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "totalValueEth": {
            "type": "string"
          },
          "vault": {
            "type": "string"
          },
          "worstGapEth": {
            "type": "string"
          }
        },
        "required": [
          "vault",
          "navReliable",
          "auctionOpen",
          "premiumBps",
          "rows"
        ],
        "type": "object"
      }
    },
    {
      "description": "Kept/violated tallies for GBLIN's pre-registered, hash-pinned promises (attestation uptime, counter honesty), probed every 10 minutes; each closed UTC day is sealed on Base as an EAS attestation (schema 0x9f433a96…). Self-observation only in v0. Free.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "required": [],
        "type": "object"
      },
      "name": "coherence.report",
      "outputSchema": {
        "properties": {
          "method": {
            "type": "string"
          },
          "observing_since": {
            "type": "string"
          },
          "promises": {
            "items": {
              "properties": {
                "file": {
                  "description": "Public URL of the promise file",
                  "type": "string"
                },
                "id": {
                  "description": "Short promise id (P1, P2, ...)",
                  "type": "string"
                },
                "kept": {
                  "type": "integer"
                },
                "kept_bps": {
                  "description": "Kept ratio in basis points (10000 = 100%)",
                  "type": "integer"
                },
                "last_observation": {
                  "type": "string"
                },
                "last_status": {
                  "enum": [
                    "kept",
                    "violated"
                  ],
                  "type": "string"
                },
                "observations": {
                  "type": "integer"
                },
                "promiseId": {
                  "description": "keccak256 of the pre-registered promise file",
                  "type": "string"
                },
                "violations": {
                  "type": "integer"
                }
              },
              "type": "object"
            },
            "type": "array"
          },
          "subject": {
            "description": "Observed subject",
            "type": "string"
          }
        },
        "required": [
          "subject",
          "promises"
        ],
        "type": "object"
      }
    },
    {
      "description": "Return the full text of one document found with search: {id, title, text, url, metadata}. Documents are the protocol's public documentation, the tool cards and the live vault state. Read-only and free.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "id": {
            "description": "A document id returned by search.",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "name": "fetch",
      "outputSchema": {
        "properties": {
          "id": {
            "type": "string"
          },
          "metadata": {
            "type": "object"
          },
          "text": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "url": {
            "type": "string"
          }
        },
        "required": [
          "id",
          "title",
          "text",
          "url"
        ],
        "type": "object"
      }
    },
    {
      "description": "Verify GBLIN protocol governance state: confirms whether the GBLIN vault is owned by the 48h Timelock, reads the timelock's min delay and grace period, reports role member counts, and surfaces any pending asset-addition proposal on the index contract. If an operation_id is provided, also reports the status of that specific timelock operation. Read-only — use this to gate trust-sensitive agent actions.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "operation_id": {
            "description": "Optional 0x-prefixed 32-byte hex id of a specific timelock operation to inspect.",
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "governance.state",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "fee_recipient": {
            "type": "string"
          },
          "lens": {
            "type": "string"
          },
          "owner": {
            "type": "string"
          },
          "owner_is_renounced": {
            "type": "boolean"
          },
          "owner_is_timelock": {
            "type": "boolean"
          },
          "pending_handover": {
            "description": "A pending ownership transfer, or null.",
            "type": [
              "object",
              "null"
            ]
          },
          "pending_timelock_operation": {
            "description": "A scheduled timelock operation affecting ownership, or null.",
            "type": [
              "object",
              "null"
            ]
          },
          "timelock": {
            "description": "Address and minimum delay of the timelock, read on chain.",
            "type": "object"
          },
          "trust_summary": {
            "type": "string"
          },
          "vault": {
            "type": "string"
          },
          "verification": {
            "type": "object"
          }
        },
        "required": [
          "vault",
          "owner",
          "owner_is_timelock",
          "owner_is_renounced",
          "timelock"
        ],
        "type": "object"
      }
    },
    {
      "description": "Build a gasless GBLIN payment. The vault's share token implements EIP-3009, so the holder signs an authorization and anybody can carry it on chain: the payer needs no ETH. Returns the EIP-712 message to sign (its domain is read from the token, not assumed), the calldata that carries the signed authorization, and the x402 'exact' payload for paying an HTTP endpoint in GBLIN. Use method 'receive' when paying a known recipient: only that recipient can submit it, so nobody can front-run the transfer. Use 'transfer' for an x402 facilitator, which submits on the seller's behalf. With relay: true it also prepares the fee authorization for relay_gblin_payment, for when nobody else will carry the payment. No private key is requested, held or transmitted: the signature is produced by the caller's own wallet.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "amount_gblin": {
            "description": "Amount in GBLIN shares, e.g. '0.25'. Give this or amount_usd.",
            "type": "string"
          },
          "amount_usd": {
            "description": "Amount in USD, converted at the live NAV. Give this or amount_gblin.",
            "type": "string"
          },
          "from": {
            "description": "The payer's address: the wallet that will sign.",
            "type": "string"
          },
          "method": {
            "description": "'receive' (default) can be submitted only by the recipient; 'transfer' by anyone.",
            "enum": [
              "receive",
              "transfer"
            ],
            "type": "string"
          },
          "relay": {
            "description": "true when nobody else will carry the payment on chain: also prepares the relay fee authorization, paid in GBLIN at the live NAV, for relay_gblin_payment. Forces method 'transfer'.",
            "type": "boolean"
          },
          "to": {
            "description": "The recipient's address.",
            "type": "string"
          },
          "valid_for_seconds": {
            "description": "How long the authorization stays valid. Default 600, maximum 86400.",
            "type": "number"
          }
        },
        "required": [
          "from",
          "to"
        ],
        "type": "object"
      },
      "name": "payments.prepare",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "amount": {
            "type": "object"
          },
          "authorization": {
            "description": "from, to, value, validAfter, validBefore, nonce.",
            "type": "object"
          },
          "digest": {
            "description": "The EIP-712 digest of typed_data.",
            "type": "string"
          },
          "method": {
            "enum": [
              "receive",
              "transfer"
            ],
            "type": "string"
          },
          "next_steps": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "payer_balance": {
            "type": "object"
          },
          "relay": {
            "description": "With relay: true, the fee authorization to sign and where to send both.",
            "type": "object"
          },
          "submit": {
            "type": "object"
          },
          "typed_data": {
            "description": "The EIP-712 message to sign with eth_signTypedData_v4.",
            "type": "object"
          },
          "warnings": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "x402_accepts_for_sellers": {
            "type": "object"
          },
          "x402_payload": {
            "description": "The x402 exact-scheme payment payload, with the signature left to fill.",
            "type": "object"
          }
        },
        "required": [
          "authorization",
          "method",
          "typed_data",
          "digest",
          "x402_payload"
        ],
        "type": "object"
      }
    },
    {
      "description": "Have GBLIN's relay carry a signed GBLIN payment on chain for a payer that holds no ETH. Pass the payment and the relay fee, each as { authorization, signature }, both prepared by prepare_gblin_payment with relay: true and signed by the payer's wallet. The relay checks both against the chain, simulates them and submits them in one transaction through Multicall3: either both settle or neither does. The fee is paid in GBLIN at the live NAV. Returns the transaction hash and its outcome. This moves funds: run it only with authorizations the payer meant to sign.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "fee": {
            "description": "{ authorization, signature } of the relay fee, from prepare_gblin_payment's relay block.",
            "properties": {
              "authorization": {
                "type": "object"
              },
              "signature": {
                "pattern": "^0x[0-9a-fA-F]+$",
                "type": "string"
              }
            },
            "required": [
              "authorization",
              "signature"
            ],
            "type": "object"
          },
          "payment": {
            "description": "{ authorization, signature } of the payment, method 'transfer'.",
            "properties": {
              "authorization": {
                "type": "object"
              },
              "signature": {
                "pattern": "^0x[0-9a-fA-F]+$",
                "type": "string"
              }
            },
            "required": [
              "authorization",
              "signature"
            ],
            "type": "object"
          }
        },
        "required": [
          "payment",
          "fee"
        ],
        "type": "object"
      },
      "name": "payments.relay",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "block": {
            "type": "number"
          },
          "explorer": {
            "type": "string"
          },
          "fee": {
            "type": "object"
          },
          "note": {
            "type": "string"
          },
          "payment": {
            "type": "object"
          },
          "relay": {
            "description": "The relay that carried the payment.",
            "type": "string"
          },
          "status": {
            "enum": [
              "settled",
              "reverted",
              "submitted"
            ],
            "type": "string"
          },
          "transaction": {
            "description": "The transaction hash.",
            "type": "string"
          }
        },
        "required": [
          "relay",
          "status",
          "transaction"
        ],
        "type": "object"
      }
    },
    {
      "description": "Check a signed GBLIN authorization against the chain before spending gas on it. Recovers the signer from the EIP-712 digest (and 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 already been used or cancelled, and whether the payer still holds the amount. Returns a verdict and the ready calldata when it would settle, the failing reason when it would not. This is the same set of checks an x402 facilitator runs, so a 'would_settle' verdict here means the payment is good to carry.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "authorization": {
            "additionalProperties": true,
            "description": "The authorization object: from, to, value, validAfter, validBefore, nonce.",
            "type": "object"
          },
          "method": {
            "description": "Which method the signature was produced for. Default 'receive'.",
            "enum": [
              "receive",
              "transfer"
            ],
            "type": "string"
          },
          "signature": {
            "description": "The signature produced by the payer's wallet, 0x-prefixed.",
            "type": "string"
          }
        },
        "required": [
          "authorization",
          "signature"
        ],
        "type": "object"
      },
      "name": "payments.verify",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "amount": {
            "type": "object"
          },
          "checks": {
            "type": "object"
          },
          "digest": {
            "type": "string"
          },
          "failures": {
            "description": "Reasons it would not settle; empty when it would.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "method": {
            "enum": [
              "receive",
              "transfer"
            ],
            "type": "string"
          },
          "source": {
            "type": "string"
          },
          "submit": {
            "description": "Calldata and who may submit it, or null when it would not settle.",
            "type": [
              "object",
              "null"
            ]
          },
          "would_settle": {
            "description": "True only if the token would accept this authorization now.",
            "type": "boolean"
          }
        },
        "required": [
          "would_settle",
          "method",
          "checks",
          "failures"
        ],
        "type": "object"
      }
    },
    {
      "description": "GBLIN llms.txt as plain text: contract addresses, endpoints, prices, payment flow, field contract of the attestation.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "required": [],
        "type": "object"
      },
      "name": "protocol.info",
      "outputSchema": {
        "properties": {
          "llms_txt": {
            "description": "The full llms.txt document (plain text)",
            "type": "string"
          }
        },
        "required": [
          "llms_txt"
        ],
        "type": "object"
      }
    },
    {
      "description": "Cumulative public counters of GBLIN's x402 endpoints: paid calls, unique payer wallets, USDC earned, with methodology disclosure. Cached 5 min.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "required": [],
        "type": "object"
      },
      "name": "protocol.stats",
      "outputSchema": {
        "properties": {
          "_source": {
            "description": "Provenance and disclosure of the counters",
            "properties": {
              "data_endpoint": {
                "type": "string"
              },
              "disclosure": {
                "type": "string"
              },
              "docs": {
                "type": "string"
              },
              "license": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "url": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "total_paid_calls": {
            "description": "Settled x402 calls, cumulative",
            "type": "integer"
          },
          "total_unique_agents": {
            "description": "Distinct payer wallets, cumulative (our own wallets excluded)",
            "type": "integer"
          },
          "total_usdc_earned": {
            "description": "USDC received, cumulative",
            "type": "number"
          }
        },
        "required": [
          "total_paid_calls",
          "total_unique_agents",
          "total_usdc_earned"
        ],
        "type": "object"
      }
    },
    {
      "description": "Receipt #index from GBLIN's receipts log, re-signed (Ed25519 is deterministic) with a fresh inclusion proof, the current signed checkpoint and the latest on-chain anchor. Free.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "index": {
            "description": "Receipt index in the log (0-based; current size at GET /log/checkpoint)",
            "minimum": 0,
            "type": "integer"
          }
        },
        "required": [
          "index"
        ],
        "type": "object"
      },
      "name": "receipts.get",
      "outputSchema": {
        "properties": {
          "anchor": {
            "description": "Latest daily EAS anchor of the tree root on Base and whether it already covers this receipt",
            "properties": {
              "anchored_tree_size": {
                "type": [
                  "integer",
                  "null"
                ]
              },
              "chain": {
                "type": "string"
              },
              "covers_this_receipt": {
                "description": "deprecated alias of root_covers_this_receipt",
                "type": "boolean"
              },
              "eas_schema_uid": {
                "type": "string"
              },
              "explorer": {
                "type": "string"
              },
              "last_anchor": {
                "properties": {
                  "day": {
                    "type": "string"
                  },
                  "root": {
                    "type": "string"
                  },
                  "tree_size": {
                    "type": "integer"
                  },
                  "tx": {
                    "type": "string"
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "method": {
                "type": "string"
              },
              "promise_id": {
                "type": "string"
              },
              "root_covers_this_receipt": {
                "description": "true iff index < anchored_tree_size: the anchored ROOT commits to this leaf via the inclusion proof",
                "type": "boolean"
              },
              "what_is_anchored": {
                "type": "string"
              }
            },
            "required": [
              "root_covers_this_receipt",
              "anchored_tree_size",
              "what_is_anchored"
            ],
            "type": "object"
          },
          "canonicalization": {
            "description": "The serialisation rule these bytes were produced with, named in the receipt itself so a later verifier can recompute them without consulting our repository. Frozen as gblin-canonical-json/1.",
            "properties": {
              "frozen_since": {
                "type": "string"
              },
              "leaf": {
                "type": "string"
              },
              "node": {
                "type": "string"
              },
              "rule": {
                "const": "gblin-canonical-json/1",
                "type": "string"
              },
              "signed_message": {
                "type": "string"
              },
              "spec": {
                "type": "string"
              },
              "verifier": {
                "type": "string"
              }
            },
            "required": [
              "rule",
              "spec"
            ],
            "type": "object"
          },
          "checkpoint": {
            "description": "C2SP signed note (origin, size, root)",
            "type": "string"
          },
          "format": {
            "const": "gblin-receipt/v1",
            "type": "string"
          },
          "inclusion_proof": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "index": {
            "type": "integer"
          },
          "leaf": {
            "description": "base64 SHA256(0x00 || canonical)",
            "type": "string"
          },
          "payload": {
            "description": "The signed, canonicalized record (gblin-canonical-json/1)",
            "properties": {
              "action": {
                "type": "string"
              },
              "agent_id": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "by": {
                "description": "Present only when this server sealed its own action; set server-side, cannot be supplied by a caller",
                "enum": [
                  "operator"
                ],
                "type": "string"
              },
              "demo": {
                "type": "boolean"
              },
              "index": {
                "type": "integer"
              },
              "input_hash": {
                "type": "string"
              },
              "log": {
                "type": "string"
              },
              "meta": {},
              "output_hash": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "tool": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "ts": {
                "type": "string"
              },
              "v": {
                "type": "integer"
              }
            },
            "required": [
              "v",
              "log",
              "index",
              "ts",
              "action",
              "input_hash"
            ],
            "type": "object"
          },
          "provenance": {
            "description": "What the receipt does and does not prove",
            "properties": {
              "level": {
                "enum": [
                  "self-reported",
                  "server-observed",
                  "externally-verified"
                ],
                "type": "string"
              },
              "levels": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "levels_meaning": {
                "type": "object"
              },
              "meaning": {
                "type": "string"
              }
            },
            "required": [
              "level",
              "levels"
            ],
            "type": "object"
          },
          "root": {
            "description": "base64 Merkle root at tree_size",
            "type": "string"
          },
          "signature": {
            "description": "base64 Ed25519 over 'gblin-receipt/v1\\n' + canonical",
            "type": "string"
          },
          "tree_size": {
            "type": "integer"
          },
          "verifier_key": {
            "description": "C2SP note verifier key: origin+hash+base64(0x01||pub)",
            "type": "string"
          }
        },
        "required": [
          "format",
          "payload",
          "leaf",
          "index",
          "tree_size",
          "root",
          "signature",
          "verifier_key",
          "inclusion_proof",
          "checkpoint",
          "anchor",
          "provenance"
        ],
        "type": "object"
      }
    },
    {
      "description": "Append the HASHES of an AI action to GBLIN's public RFC 6962 transparency log and return a portable receipt: Ed25519 signature, inclusion proof, operator-signed C2SP checkpoint, plus the latest on-chain anchor (EAS on Base, daily). mode=demo (the only mode over MCP): 5 seals/day/IP, receipts marked demo:true. Unlimited seals are a paid x402 HTTP endpoint (resource gblin://howto/seal). Provenance is self-reported: the receipt proves existence and time of the record, not that the action happened. The action/agent_id/tool/meta strings are PUBLISHED in the log: identifiers only, never secrets. Fields not listed here are ignored and NOT recorded.",
      "inputSchema": {
        "additionalProperties": true,
        "properties": {
          "action": {
            "description": "What the AI did, short label. PUBLISHED in the log.",
            "maxLength": 128,
            "minLength": 1,
            "type": "string"
          },
          "agent_id": {
            "description": "Your agent identifier (optional). PUBLISHED.",
            "maxLength": 128,
            "type": "string"
          },
          "input_hash": {
            "description": "sha256 of the input/prompt, 64 hex chars (0x prefix optional)",
            "pattern": "^\\s*(0x)?[0-9a-fA-F]{64}\\s*$",
            "type": "string"
          },
          "meta": {
            "description": "Extra JSON object as a string (optional). PUBLISHED.",
            "maxLength": 512,
            "type": "string"
          },
          "mode": {
            "default": "demo",
            "description": "Only 'demo' is available over MCP (5/day/IP). Paid seals go through x402 HTTP.",
            "enum": [
              "demo"
            ],
            "type": "string"
          },
          "output_hash": {
            "description": "sha256 of the output, 64 hex chars (optional; empty or blank = omitted)",
            "pattern": "^\\s*((0x)?[0-9a-fA-F]{64})?\\s*$",
            "type": "string"
          },
          "tool": {
            "description": "Tool/model used (optional). PUBLISHED.",
            "maxLength": 128,
            "type": "string"
          }
        },
        "required": [
          "action",
          "input_hash"
        ],
        "type": "object"
      },
      "name": "receipts.seal",
      "outputSchema": {
        "properties": {
          "anchor": {
            "description": "Latest daily EAS anchor of the tree root on Base and whether it already covers this receipt",
            "properties": {
              "anchored_tree_size": {
                "type": [
                  "integer",
                  "null"
                ]
              },
              "chain": {
                "type": "string"
              },
              "covers_this_receipt": {
                "description": "deprecated alias of root_covers_this_receipt",
                "type": "boolean"
              },
              "eas_schema_uid": {
                "type": "string"
              },
              "explorer": {
                "type": "string"
              },
              "last_anchor": {
                "properties": {
                  "day": {
                    "type": "string"
                  },
                  "root": {
                    "type": "string"
                  },
                  "tree_size": {
                    "type": "integer"
                  },
                  "tx": {
                    "type": "string"
                  }
                },
                "type": [
                  "object",
                  "null"
                ]
              },
              "method": {
                "type": "string"
              },
              "promise_id": {
                "type": "string"
              },
              "root_covers_this_receipt": {
                "description": "true iff index < anchored_tree_size: the anchored ROOT commits to this leaf via the inclusion proof",
                "type": "boolean"
              },
              "what_is_anchored": {
                "type": "string"
              }
            },
            "required": [
              "root_covers_this_receipt",
              "anchored_tree_size",
              "what_is_anchored"
            ],
            "type": "object"
          },
          "canonicalization": {
            "description": "The serialisation rule these bytes were produced with, named in the receipt itself so a later verifier can recompute them without consulting our repository. Frozen as gblin-canonical-json/1.",
            "properties": {
              "frozen_since": {
                "type": "string"
              },
              "leaf": {
                "type": "string"
              },
              "node": {
                "type": "string"
              },
              "rule": {
                "const": "gblin-canonical-json/1",
                "type": "string"
              },
              "signed_message": {
                "type": "string"
              },
              "spec": {
                "type": "string"
              },
              "verifier": {
                "type": "string"
              }
            },
            "required": [
              "rule",
              "spec"
            ],
            "type": "object"
          },
          "checkpoint": {
            "description": "C2SP signed note (origin, size, root)",
            "type": "string"
          },
          "format": {
            "const": "gblin-receipt/v1",
            "type": "string"
          },
          "inclusion_proof": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "index": {
            "type": "integer"
          },
          "leaf": {
            "description": "base64 SHA256(0x00 || canonical)",
            "type": "string"
          },
          "payload": {
            "description": "The signed, canonicalized record (gblin-canonical-json/1)",
            "properties": {
              "action": {
                "type": "string"
              },
              "agent_id": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "by": {
                "description": "Present only when this server sealed its own action; set server-side, cannot be supplied by a caller",
                "enum": [
                  "operator"
                ],
                "type": "string"
              },
              "demo": {
                "type": "boolean"
              },
              "index": {
                "type": "integer"
              },
              "input_hash": {
                "type": "string"
              },
              "log": {
                "type": "string"
              },
              "meta": {},
              "output_hash": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "tool": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "ts": {
                "type": "string"
              },
              "v": {
                "type": "integer"
              }
            },
            "required": [
              "v",
              "log",
              "index",
              "ts",
              "action",
              "input_hash"
            ],
            "type": "object"
          },
          "provenance": {
            "description": "What the receipt does and does not prove",
            "properties": {
              "level": {
                "enum": [
                  "self-reported",
                  "server-observed",
                  "externally-verified"
                ],
                "type": "string"
              },
              "levels": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "levels_meaning": {
                "type": "object"
              },
              "meaning": {
                "type": "string"
              }
            },
            "required": [
              "level",
              "levels"
            ],
            "type": "object"
          },
          "root": {
            "description": "base64 Merkle root at tree_size",
            "type": "string"
          },
          "signature": {
            "description": "base64 Ed25519 over 'gblin-receipt/v1\\n' + canonical",
            "type": "string"
          },
          "tree_size": {
            "type": "integer"
          },
          "verifier_key": {
            "description": "C2SP note verifier key: origin+hash+base64(0x01||pub)",
            "type": "string"
          }
        },
        "required": [
          "format",
          "payload",
          "leaf",
          "index",
          "tree_size",
          "root",
          "signature",
          "verifier_key",
          "inclusion_proof",
          "checkpoint",
          "anchor",
          "provenance"
        ],
        "type": "object"
      }
    },
    {
      "description": "Verify a gblin-receipt/v1 JSON with pure math (no log lookup, no trust in this server): leaf hash, Ed25519 signature, RFC 6962 inclusion proof, C2SP checkpoint signature, verifier-key hash. Same checks as the zero-dependency verify-receipt.mjs you can run offline. For the extra on-chain-anchor consistency check use GET /v1/verify/:index.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "receipt": {
            "description": "The receipt JSON as returned by receipts.seal / receipts.get / GET /v1/receipt/:i (bare or wrapped in {receipt})",
            "type": "object"
          }
        },
        "required": [
          "receipt"
        ],
        "type": "object"
      },
      "name": "receipts.verify",
      "outputSchema": {
        "properties": {
          "checks": {
            "items": {
              "properties": {
                "detail": {
                  "type": "string"
                },
                "name": {
                  "type": "string"
                },
                "ok": {
                  "type": "boolean"
                }
              },
              "required": [
                "name",
                "ok"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "errors": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "format": {
            "type": "string"
          },
          "index": {
            "type": "integer"
          },
          "reminder": {
            "type": "string"
          },
          "tree_size": {
            "type": "integer"
          },
          "valid": {
            "type": "boolean"
          }
        },
        "required": [
          "valid",
          "checks",
          "errors"
        ],
        "type": "object"
      }
    },
    {
      "description": "Static, permanently expired sample of the signed Risk Attestation (sample:true), same fields and EIP-712 schema as the paid one. Use it to build and test a parser/verifier.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "required": [],
        "type": "object"
      },
      "name": "risk.attestation_sample",
      "outputSchema": {
        "properties": {
          "attestation": {
            "description": "Same field contract as the paid attestation (regime, shield_active, severity_pct, defensive_cash_pct, expires_at, ...)",
            "type": "object"
          },
          "attestation_id": {
            "description": "hashTypedData digest — recompute to verify",
            "type": "string"
          },
          "attestor": {
            "type": [
              "string",
              "null"
            ]
          },
          "eip712": {
            "description": "EIP-712 domain/types/message to recompute the digest",
            "type": "object"
          },
          "meta": {
            "type": "object"
          },
          "sample": {
            "description": "Always true — never a live signal",
            "type": "boolean"
          },
          "signature": {
            "type": [
              "string",
              "null"
            ]
          },
          "signed": {
            "type": "boolean"
          },
          "verify": {
            "type": "object"
          }
        },
        "required": [
          "sample",
          "attestation",
          "attestation_id",
          "signed"
        ],
        "type": "object"
      }
    },
    {
      "description": "Current BTC/ETH risk regime (calm | elevated | crash) with a suggested posture, read live from GBLIN's on-chain Crash Shield on Base (60s cache). Free and unsigned; a signed, verifiable-offline version is a paid x402 endpoint (resource gblin://howto/attestation).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "required": [],
        "type": "object"
      },
      "name": "risk.regime",
      "outputSchema": {
        "properties": {
          "assets": {
            "description": "Per-risk-asset shield state",
            "items": {
              "properties": {
                "base_weight_pct": {
                  "type": "number"
                },
                "dynamic_weight_pct": {
                  "type": "number"
                },
                "shielded": {
                  "type": "boolean"
                },
                "token": {
                  "description": "ERC-20 address",
                  "type": "string"
                },
                "weight_cut_pct": {
                  "type": "number"
                }
              },
              "required": [
                "token",
                "shielded",
                "weight_cut_pct"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "chain_id": {
            "type": "integer"
          },
          "contract": {
            "description": "GBLIN contract on Base",
            "type": "string"
          },
          "defensive_cash_pct": {
            "description": "USDC dynamic weight in the basket, percent",
            "type": "number"
          },
          "note": {
            "type": "string"
          },
          "regime": {
            "description": "Current risk regime",
            "enum": [
              "calm",
              "elevated",
              "crash"
            ],
            "type": "string"
          },
          "regime_code": {
            "description": "0 calm, 1 elevated, 2 crash",
            "type": "integer"
          },
          "risk_posture": {
            "description": "Suggested posture",
            "enum": [
              "risk_on",
              "reduce",
              "risk_off"
            ],
            "type": "string"
          },
          "severity_pct": {
            "description": "Max crash-shield weight cut across risk assets, percent",
            "type": "number"
          },
          "shield_active": {
            "description": "True when any risk asset is currently slashed",
            "type": "boolean"
          },
          "source": {
            "type": "string"
          }
        },
        "required": [
          "regime",
          "regime_code",
          "severity_pct",
          "defensive_cash_pct",
          "shield_active",
          "assets"
        ],
        "type": "object"
      }
    },
    {
      "description": "Search GBLIN's documentation and live state and return matching documents: the agent API summary, the protocol's README and documents (governance, deployments, review record), the MCP server and library READMEs, the public pages, one card per MCP tool, and a snapshot of the live vault state. Returns {results: [{id, title, url}]}; pass an id to fetch for the full text. Read-only and free.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "query": {
            "description": "What to look for, in plain words.",
            "type": "string"
          }
        },
        "required": [
          "query"
        ],
        "type": "object"
      },
      "name": "search",
      "outputSchema": {
        "properties": {
          "results": {
            "items": {
              "properties": {
                "id": {
                  "type": "string"
                },
                "title": {
                  "type": "string"
                },
                "url": {
                  "type": "string"
                }
              },
              "required": [
                "id",
                "title",
                "url"
              ],
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "results"
        ],
        "type": "object"
      }
    },
    {
      "description": "Analyze an agent wallet's treasury health: GBLIN/USDC/ETH balances, whether the ETH covers an exit at the live gas price, the redemption cooldown, and (if daily_burn_usd is provided) days of USDC runway plus a recommendation that keeps seven days of spend in USDC and treats only the surplus as a candidate for GBLIN. Free by default; metered at $0.003 USDC only when the operator sets MCP_PAYWALL=true.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "_payment": {
            "description": "Base64-encoded x402 PaymentProof JSON. Omit on first call to receive the 402 payment manifest.",
            "type": "string"
          },
          "daily_burn_usd": {
            "description": "Optional. Average daily spend in USD (e.g. 1.5).",
            "type": "number"
          },
          "wallet_address": {
            "description": "Agent's 0x address.",
            "type": "string"
          }
        },
        "required": [
          "wallet_address"
        ],
        "type": "object"
      },
      "name": "treasury.health",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "balances": {
            "type": "object"
          },
          "cooldown": {
            "description": "Whether the redemption cooldown is active and for how long.",
            "type": "object"
          },
          "gas_health": {
            "description": "Whether the wallet holds enough ETH for the next transactions.",
            "type": "object"
          },
          "ratios": {
            "type": "object"
          },
          "recommendation": {
            "description": "hold, rebalance_to_gblin or rebalance_to_usdc, with the reason.",
            "type": "object"
          },
          "wallet": {
            "type": "string"
          }
        },
        "required": [
          "wallet",
          "balances",
          "gas_health",
          "cooldown",
          "recommendation"
        ],
        "type": "object"
      }
    },
    {
      "description": "NAV per GBLIN share over time, read from the chain at past blocks, beside the ETH/USD and BTC/USD oracle prices the vault itself 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. Use it to judge how the index behaved against holding ETH or BTC over the same span.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "interval": {
            "description": "Spacing of the points. Default day.",
            "enum": [
              "hour",
              "day"
            ],
            "type": "string"
          },
          "points": {
            "description": "How many points, newest last. Default 30.",
            "maximum": 90,
            "minimum": 2,
            "type": "integer"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "treasury.nav_history",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "interval": {
            "enum": [
              "hour",
              "day"
            ],
            "type": "string"
          },
          "method": {
            "type": "string"
          },
          "note": {
            "type": "string"
          },
          "points": {
            "type": "number"
          },
          "series": {
            "description": "Oldest first: time, block, NAV in ETH and USD, ETH/USD and BTC/USD.",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "summary": {
            "description": "Change of NAV, ETH and BTC over the window, and the NAV's largest drawdown.",
            "type": [
              "object",
              "null"
            ]
          }
        },
        "required": [
          "interval",
          "points",
          "series"
        ],
        "type": "object"
      }
    },
    {
      "description": "Idle USDC to a reviewable plan in one call: operating cash = max(reserve_usd, daily_burn_usd × days), the surplus above it, a simulation of minting that surplus into GBLIN at NAV (fees read live from the vault, estimated exit value today, round-trip cost), the same simulation for a trial amount (100 USDC by default), the blockers (crash shield, redemption cooldown, ETH for the exit) and the tools to call after a human confirms. Reads only: nothing is executed and nothing is advised. GBLIN is crypto exposure (cbBTC, WETH, USDC), not cash and not yield.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "daily_burn_usd": {
            "description": "Average daily spend in USD. Operating cash = daily_burn_usd × days.",
            "type": "number"
          },
          "days": {
            "description": "Days of spend to keep liquid (default 7, max 365).",
            "type": "number"
          },
          "reserve_usd": {
            "description": "USD to keep liquid regardless of the burn rate; the larger of the two rules wins.",
            "type": "number"
          },
          "trial_usdc": {
            "description": "Trial amount to simulate beside the surplus (default 100).",
            "type": "number"
          },
          "wallet_address": {
            "description": "Agent's 0x address.",
            "type": "string"
          }
        },
        "required": [
          "wallet_address"
        ],
        "type": "object"
      },
      "name": "treasury.plan",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "as_of": {
            "description": "Block and time the reads were taken at.",
            "type": "object"
          },
          "blockers": {
            "description": "Reasons parking is not appropriate right now, if any.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "inputs": {
            "description": "The inputs as applied, with the defaults filled in.",
            "type": "object"
          },
          "market": {
            "description": "NAV, ETH price, risk regime and crash shield status.",
            "type": "object"
          },
          "next": {
            "description": "The tools to call after a human confirms.",
            "type": "object"
          },
          "notes": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "operating_cash": {
            "description": "USDC to keep liquid: max(reserve_usd, daily_burn_usd × days), with the runway in days.",
            "type": "object"
          },
          "park_candidate": {
            "description": "True when no blocker applies. Not a recommendation.",
            "type": "boolean"
          },
          "simulation": {
            "description": "Mint simulation for the surplus: shares, fees, exit value today, round-trip cost; or nothing_to_park.",
            "type": "object"
          },
          "surplus": {
            "description": "USDC above the operating cash.",
            "type": "object"
          },
          "trial": {
            "description": "The same simulation for the trial amount.",
            "type": "object"
          },
          "wallet": {
            "type": "string"
          },
          "wallet_state": {
            "description": "USDC, GBLIN and ETH balances, gas health, redemption cooldown.",
            "type": "object"
          }
        },
        "required": [
          "wallet",
          "market",
          "wallet_state",
          "operating_cash",
          "surplus",
          "park_candidate",
          "blockers",
          "simulation",
          "trial",
          "next"
        ],
        "type": "object"
      }
    },
    {
      "description": "Preview a buy (ETH→GBLIN) or sell (GBLIN→ETH) without executing. Returns expected output, safe minOut with dynamic slippage buffer (2.5% normal / 4% during Crash Shield), and fee breakdown. Read-only.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "amount_in": {
            "description": "Positive decimal. ETH for buy, GBLIN for sell.",
            "type": "string"
          },
          "direction": {
            "enum": [
              "buy",
              "sell"
            ],
            "type": "string"
          }
        },
        "required": [
          "direction",
          "amount_in"
        ],
        "type": "object"
      },
      "name": "treasury.quote",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "amount_in_eth": {
            "description": "Buy only.",
            "type": "string"
          },
          "amount_in_gblin": {
            "description": "Sell only.",
            "type": "string"
          },
          "cooldown_note": {
            "type": "string"
          },
          "direction": {
            "enum": [
              "buy",
              "sell"
            ],
            "type": "string"
          },
          "expected_eth_out": {
            "description": "Sell only.",
            "type": "string"
          },
          "expected_gblin_out": {
            "description": "Buy only.",
            "type": "string"
          },
          "fees": {
            "type": "object"
          },
          "next_step": {
            "type": "string"
          },
          "safe_min_eth_out": {
            "description": "Sell only. Pass as minEthOut.",
            "type": "string"
          },
          "safe_min_gblin_out": {
            "description": "Buy only. Pass as minOut.",
            "type": "string"
          },
          "slippage_buffer_bps": {
            "type": "number"
          },
          "slippage_reason": {
            "type": "string"
          },
          "will_revert_with_zero_tolerance": {
            "type": "boolean"
          }
        },
        "required": [
          "direction",
          "slippage_buffer_bps",
          "next_step"
        ],
        "type": "object"
      }
    },
    {
      "description": "Read the current GBLIN protocol state on Base mainnet: NAV in USD, basket composition with dynamic weights, and Crash Shield status. Use this BEFORE any swap to know the current price and risk regime.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "required": [],
        "type": "object"
      },
      "name": "treasury.state",
      "outputSchema": {
        "additionalProperties": true,
        "properties": {
          "auction_open": {
            "description": "True while a rebalancing auction is running.",
            "type": "boolean"
          },
          "basket": {
            "description": "Assets in the basket with base and dynamic weights.",
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "crash_shield_active": {
            "description": "True when the crash shield has cut the weight of a falling asset.",
            "type": "boolean"
          },
          "eth_price_usd": {
            "description": "ETH price in USD from the oracle.",
            "type": "number"
          },
          "management_fee_bps_per_year": {
            "description": "Management fee in basis points per year, read from the contract.",
            "type": "number"
          },
          "meta": {
            "type": "object"
          },
          "nav_reliable": {
            "description": "False when a price feed is stale or a basket asset cannot be read; do not trade on the NAV then.",
            "type": "boolean"
          },
          "nav_usd": {
            "description": "Net asset value of one GBLIN share in USD.",
            "type": "number"
          },
          "slippage_buffer_pct": {
            "type": "number"
          },
          "slippage_reason": {
            "type": "string"
          }
        },
        "required": [
          "nav_usd",
          "eth_price_usd",
          "nav_reliable",
          "management_fee_bps_per_year",
          "auction_open",
          "crash_shield_active",
          "basket"
        ],
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:d0e94b838ff526d51193e5f7a646d9f51e7377033a3592a3f0a49ec9316cbe60 | sha256sum