Initialize wallet from WIF private key for blockchain operations.

This is the first step before creating inscriptions. The wallet will be used for:

• Creating and signing inscription transactions

• Paying service fees (396 sats across 11 outputs / 10 addresses)

• Receiving change from transactions

Security: WIF is held in memory only, not persisted. Use ordnet_wallet_init_env for production.

Args:

• wif (string): WIF private key (starts with 5, K, or L, 51-52 chars)

Returns: { address: string, publicKey: string, balanceSatoshis: number }

Example: ordnet_wallet_init({ wif: "L1a2b3c4d5..." }) → Wallet initialized at 1ABC...

Initialize wallet from environment variable (highest security tier).

Reads WIF from environment variable instead of passing it directly. Recommended for production use.

Args:

• envVarName (string): Environment variable name (default: ORDNET_WIF)

Returns: { address: string, balanceSatoshis: number }

Example: export ORDNET_WIF="L1a2b3c4..." ordnet_wallet_init_env({}) → Wallet initialized

Check current wallet initialization status and balance.

Returns wallet address and balance if initialized.

Returns: { initialized: boolean, address?: string, balanceSatoshis?: number }

Get balance for any BSV address.

Args:

• address (string, optional): BSV address. Uses wallet address if not provided.

Returns: { address: string, confirmed: number, unconfirmed: number, total: number }

Get unspent transaction outputs (UTXOs) for an address.

Args:

• address (string, optional): BSV address. Uses wallet address if not provided.

• limit (number): Maximum UTXOs to return (default: 5)

Returns: { utxos: [{ txid, vout, satoshis }], count: number }

Clear wallet from memory. Use when done with operations.

Returns: { cleared: true }

Calculate fee estimate for an inscription.

Service fees breakdown (per ordmail-v10-standalone-026.html):

• ordiBuilder / onnoBuilder / algoBuilder / colleagueI: 11 sats each

• protocol / colleagueD: 22 sats each

• monitor: 33 sats, indexer: 44 sats, partner: 66 sats

• founder: 77 sats, foundation: 88 sats

• Total: 396 sats across 10 distinct addresses

Args:

• contentSize (number): Size of content in bytes

• feePerByte (number): Fee per byte (default: 0.15 = 150 sats/KB, miner fee floor 200 sats)

Returns: { estimatedTxSize, minerFee, serviceFee, totalCost, breakdown }

Prepare an inscription transaction without broadcasting.

Creates a signed transaction ready for broadcast. Returns the raw hex and fee breakdown for review before broadcasting.

Args:

• content (string): Content to inscribe (HTML, text, JSON, etc.)

• contentType (string): MIME type (default: text/html;charset=utf8)

• feePerByte (number): Fee per byte (default: 0.2)

Returns: { rawHex, txid, feeEstimate, inscriptionId }

Requires: Wallet must be initialized first.

Broadcast a prepared inscription transaction to the BSV network.

WARNING: This action is IRREVERSIBLE. The transaction will be permanently recorded on the blockchain.

Args:

• rawHex (string): Raw transaction hex from ordnet_inscribe_prepare

Returns: { txid, inscriptionId, viewUrl, transactionUrl }

Create and broadcast an HTML inscription in one step.

Convenience tool that prepares and broadcasts an HTML inscription.

Args:

• content (string): HTML content to inscribe

• feePerByte (number): Fee per byte (default: 0.2)

Returns: { txid, inscriptionId, viewUrl }

Requires: Wallet must be initialized.

Create and broadcast a JSON inscription in one step.

Args:

• content (string): JSON content to inscribe

• feePerByte (number): Fee per byte (default: 0.2)

Returns: { txid, inscriptionId, viewUrl }

Create and broadcast a plain text inscription in one step.

Args:

• content (string): Text content to inscribe

• feePerByte (number): Fee per byte (default: 0.2)

Returns: { txid, inscriptionId, viewUrl }

Check if a domain name is available for registration.

Args:

• name (string): Domain name without extension (e.g., "myname")

• extension (string): Domain extension (default: .sats)

Returns: { available: boolean, owner?: string, inscriptionId?: string }

Get detailed information about a domain.

Args:

• fullName (string): Full domain name (e.g., "myname.sats")

Returns: { name, extension, owner, inscriptionId, genesisHeight, protocol }

Search for registered domains by name prefix.

Args:

• query (string): Search query

• limit (number): Maximum results (default: 20)

Returns: { domains: [{ name, owner, inscriptionId }], count }

Register a new SNS/OPNS domain on the blockchain.

Creates and broadcasts a domain registration inscription.

Args:

• name (string): Domain name without extension

• extension (string): Domain extension (default: .sats)

• protocol (string): Registration protocol: sns or opns (default: sns)

• feePerByte (number): Fee per byte (default: 0.2)

Returns: { txid, inscriptionId, domain }

Requires: Wallet must be initialized.

Quick registration of an SNS domain (.sats, .btc, etc).

Args:

• name (string): Domain name without extension

• extension (string): Extension (default: .sats)

• feePerByte (number): Fee per byte (default: 0.2)

Returns: { txid, inscriptionId, domain }

Quick registration of an OPNS domain.

Args:

• name (string): Domain name without extension

• extension (string): Extension (default: .sats)

• feePerByte (number): Fee per byte (default: 0.2)

Returns: { txid, inscriptionId, domain }

Search for inscriptions on the BSV blockchain.

Args:

• query (string): Search query

• contentType (string, optional): Filter by content type

• limit (number): Maximum results (default: 20)

Returns: { inscriptions: [...], count }

Get detailed information about a specific inscription.

Args:

• inscriptionId (string): Inscription ID (format: txid_outputIndex)

Returns: { inscriptionId, contentType, contentSize, owner, ... }

Get the URL to view inscription content.

Args:

• inscriptionId (string): Inscription ID

Returns: { inscriptionId, contentUrl, viewUrl, transactionUrl }

Validate a BSV address format.

Args:

• address (string): BSV address to validate

Returns: { valid: boolean, address }

Encrypt a WIF private key with AES-256-GCM.

Use this to create an encrypted wallet that can be stored safely. The encrypted data can later be decrypted with ordnet_wallet_init with the password.

Args:

• wif (string): WIF private key to encrypt

• password (string): Strong password (min 12 chars)

Returns: { encrypted: { iv, data, tag, salt } }

Check the current wallet security tier.

Tiers (highest to lowest):

1. environment - WIF from environment variable

2. encrypted - WIF from encrypted store

3. plaintext - WIF provided directly (not recommended)

Returns: { tier, envVarSet, recommendation }

Check if a password meets security requirements.

Requirements:

• Minimum 12 characters

• At least one uppercase letter

• At least one lowercase letter

• At least one number

• At least one special character

Args:

• password (string): Password to validate

Returns: { valid: boolean, errors: string[] }

Generate a new random BSV wallet.

WARNING: Store the WIF securely! It cannot be recovered if lost.

Returns: { wif, address }

Get information about the ORDnet MCP server.

Returns server version, capabilities, and service fee information.

Get list of all supported content types for inscriptions.

Returns: { contentTypes: [...] }

Decode and inspect a raw transaction via ORDnet's OWN node WITHOUT broadcasting it.

Use this BEFORE ordnet_inscribe_broadcast to verify exactly what a transaction will do: destinations, amounts, and safety warnings (e.g. 1-satoshi outputs that are likely ordinals/inscriptions).

Args:

• rawHex (string): Raw transaction hex to simulate

Returns: { txid, sizeBytes, outputCount, totalOutputSats, outputs[], warnings[] }

Configure spend limits for this server session (agent safety layer).

When any limit is set, every broadcast is first simulated via ORDnet's own node and BLOCKED if it would exceed a limit (fail-closed). When no limits are set, broadcasts behave exactly as before.

Limits apply to the TOTAL output value of a transaction, including change back to the agent's own wallet (a conservative upper bound).

Args:

• maxSatsPerTx (number|null, optional): Max output sats per transaction; null removes the limit

• maxSatsPerSession (number|null, optional): Max cumulative output sats this session; null removes the limit

• resetSession (boolean, optional): Reset the session spend counter

Returns: The active policy after applying changes.

Show the active spend policy and session totals.

Returns: { maxSatsPerTx, maxSatsPerSession, spentThisSession, broadcastCount }

Check the health and sync status of ORDnet's own address/UTXO index (ordnet-utxo).

This index is the PRIMARY source for balance and UTXO lookups since v2.5 — every UTXO in it has been individually verified by ORDnet's own BSV node. WhatsOnChain is only used as a connectivity fallback.

Returns: { status, index_height, node_height, in_sync }

Register a BSV address in ORDnet's own UTXO index watchlist.

The index seeds the address immediately (WhatsOnChain as outpoint hint, every UTXO verified by ORDnet's own node) and then tracks it in real time via the tip-follower. Unknown addresses are also auto-registered on their first balance/UTXO query; this tool lets an agent pre-register addresses so that first query is instant.

Args:

• address (string): BSV address to watch

• label (string, optional): label for the watchlist entry (default: "mcp")

Returns: Watchlist registration result from the index.

Send a plain BSV payment (P2PKH) from the initialized wallet.

THE core tool for agent payments: miner fee only (0.15 sat/byte, min 200 sats), NO service fees — micropayments stay lean. Optional OP_RETURN data lets you attach a payment reference (e.g. an x402 invoice ID).

Safety: spend policy (ordnet_policy_status) is enforced; 1-sat ordinal UTXOs are never used as funding.

Args:

• to (string): recipient BSV address

• satoshis (number): amount in satoshis

• opReturn (string, optional): OP_RETURN payload / payment reference

Returns: { txid, satoshis, minerFee, change, transactionUrl }

Transfer an inscription (ordinal, .web3/SNS/OPNS domain, BSVmap tile) to another address.

1SatOrdinals semantics: the inscription outpoint becomes input 0 and the 1-sat output to the recipient becomes output 0 — the sat carries the inscription. The outpoint is verified as unspent via ORDnet's own node before building. Miner fee only.

Args:

• inscriptionTxid (string): txid of the inscription outpoint

• inscriptionVout (number): output index (usually 0)

• to (string): recipient BSV address

Returns: { txid, transferred, to, minerFee, transactionUrl }

Claim a BSVmap tile by inscribing ".bsvmap" (text/plain), following the bitmap convention on BSV. Tiles 0-999999 map to the 1M-tile BSVmap grid.

Note: first-is-first — if the tile was already claimed on-chain, your inscription will not make you the owner. Check bsvmap.io first.

Args:

• tile (number): tile number 0-999999

• feePerByte (number, optional): default 0.15

Returns prepared inscription; broadcast with ordnet_inscribe_broadcast.

Prepare an inscription for BINARY content (images, audio, video, PDF) from base64.

Bytes are inscribed untouched — use this instead of ordnet_inscribe_prepare for anything that is not text. Supported: image/png, image/jpeg, image/gif, image/webp, image/svg+xml, audio/mpeg, video/mp4, application/pdf.

Args:

• contentBase64 (string): base64-encoded content

• contentType (string): MIME type, e.g. image/png

• feePerByte (number, optional): default 0.15

Returns prepared inscription; broadcast with ordnet_inscribe_broadcast.

Check the status and confirmations of a transaction via ORDnet's own node.

Essential after ordnet_send / ordnet_inscribe_broadcast / ordnet_transfer: poll this to see your transaction confirm.

Args:

• txid (string): transaction ID

Returns: { txid, found, confirmations, blockhash, blocktime }

Get the current BSV price in fiat, via ORDnet's own CoinGecko proxy.

Lets an agent convert satoshis to USD/EUR before spending.

Args:

• currencies (string, optional): comma-separated, default "usd,eur"

Returns: { bsv: { usd, eur, ... }, satsPerUsd }

Return the wallet's BRC-100 identity: its public key and address.

This is the agent's on-chain identity — counterparties can use the public key to verify signatures (ordnet_verify_message) and to confirm the agent controls the address. Requires an initialized wallet.

Returns: { publicKey, address }

Sign an arbitrary message with the wallet's private key (BRC-100 createSignature).

Use this to prove control of the identity key, authenticate to a service, or sign an x402 payment authorization off-chain. The private key never leaves the server. Requires an initialized wallet.

Args:

• message (string): the message to sign

Returns: { publicKey, signature, messageHash }

Verify a signature against a message and public key (BRC-100 verifySignature).

Does NOT require a wallet — anyone can verify. Use this to check that a counterparty's message (e.g. a payment authorization or a signed quote) really came from the holder of a given public key.

Args:

• message (string): the original message

• signature (string): signature hex from ordnet_sign_message

• publicKey (string): compressed public key hex of the claimed signer

Returns: { valid: boolean }

Derive a unique, deterministic payment address for a given invoice or reference string (BRC-42/29-style key derivation).

Each invoice number yields a different address controlled by the same wallet, so incoming payments for different invoices are unlinkable on-chain — the foundation for clean x402 payment flows. The same invoice always derives the same address, so a payer and payee can compute it independently. Requires an initialized wallet.

Args:

• invoiceNumber (string): invoice/reference string

Returns: { address, publicKey, invoiceNumber }

Inspect an x402-paywalled URL WITHOUT paying: returns the price, payTo address, and payment requirements from the HTTP 402 response.

Use this to check costs before committing. Free and read-only.

Args:

• url (string): resource URL

• method (string, optional): GET or POST (default GET)

Returns: { isPaywalled, priceSats?, network?, payTo?, description?, accepts }

Consume an x402-paywalled resource in one call: detect the 402, pay the quoted amount in native BSV sats from the loaded wallet, retry with proof, and return the resource plus the settlement receipt.

Safety:

• maxSats is REQUIRED: the tool refuses quotes above it (agent-set budget)

• the spend policy (ordnet_policy_status) is enforced on the payment

• only the 'exact' scheme on network 'bsv' is supported; other networks (e.g. USDC on Base) are reported honestly as unsupported

• non-paywalled URLs are fetched and returned without any payment

Args:

• url (string): resource URL

• method (string, optional): GET or POST (default GET)

• maxSats (number): spending guard in satoshis

Returns: { status, body, paid?: { txid, satoshis, payTo }, receipt? }