Generate a new random cryptographic seed for the Keeta Network.

This is the starting point for all Keeta operations. A seed can derive unlimited accounts via keeta_derive_account. Store the seed securely — it controls all derived accounts and their funds.

Returns: { seed: string }

Derive a Keeta account (public/private keypair) from a seed and index.

Each unique (seed, index, algorithm) combination produces a deterministic account. The returned address (keeta_...) is used in all other tools as account/token identifiers.

Supported algorithms:

• SECP256K1 (default) — most common, Ethereum-compatible

• SECP256R1 — WebAuthn/passkey compatible

• ED25519 — fast signatures

Returns: { address: string, algorithm: string, index: number }

Request free KTA tokens from the Keeta test network faucet.

Only works on the test network. Sends 5 KTA to the given address for development/testing. KTA is needed for transaction fees on the network.

Returns: { status, address, amountRequested, currentBalance }

Get the configuration for a Keeta network, including the network ID, base token address, and network account address.

This is useful for understanding the network you are operating on before making transactions.

Returns: { networkAlias, networkId, baseToken, networkAddress }

Discover available methods and properties on Keeta SDK objects at runtime. Use this FIRST to understand what operations are available before calling execute tools.

The "target" parameter accepts:

Core SDK (fixed): "Client" → read-only network queries "UserClient" → authenticated operations "Builder" → batch transaction builder "Account" → account utilities + enums "Block" → block types + operation enums "Permissions" → permission construction "Config" → network configuration

Anchor SDK (dynamic — auto-discovers new services): "AnchorCatalog" → list ALL available anchor services and lib modules (start here!) "AnchorService:" → methods on a specific anchor service client (e.g. "AnchorService:FX", "AnchorService:KYC", "AnchorService:AssetMovement", "AnchorService:Username", "AnchorService:Notification", or ANY new service the SDK adds) "AnchorLib:" → methods on a specific anchor lib module (e.g. "AnchorLib:Resolver", "AnchorLib:Certificates", "AnchorLib:EncryptedContainer", "AnchorLib:URI", or ANY new module)

When in doubt, start with "AnchorCatalog" to see everything available, then drill into specific services/modules.

Execute any method on the Keeta Client (read-only network operations).

Use keeta_list_sdk_methods with target "Client" to discover available methods.

Common methods: getAccountInfo, getBalance, getAllBalances, getHeadBlock, getBlock, getHistory, getTokenSupply, getNetworkStatus, getPeers, getVersion, getLedgerChecksum, getAllCertificates, getAllRepresentativeInfo.

Arguments are auto-resolved:

• Strings starting with "keeta_" become Account objects

• "BIGINT:123" becomes BigInt(123)

• "PERM:ACCESS,ADMIN" becomes a Permissions object

• "ALGO:TOKEN" becomes AccountKeyAlgorithm.TOKEN

• Plain strings, numbers, booleans, objects, arrays pass through as-is

Execute any method on the Keeta UserClient (authenticated operations requiring an account).

Use keeta_list_sdk_methods with target "UserClient" to discover available methods.

Common methods: allBalances, balance, head, chain, history, state, send, setInfo, generateIdentifier, updatePermissions, createSwapRequest, transmit, listACLsByPrincipal, getCertificates, modifyCertificate, sync.

Properties you can read (pass method "GET_PROPERTY" with args ["propertyName"]): baseToken, networkAddress, network, account, signer.

Arguments are auto-resolved (see keeta_client_execute for resolution rules).

Execute a sequence of operations using the UserClient Builder pattern, then optionally compute and publish.

The builder batches multiple operations into blocks for efficient on-chain execution. Each operation in the "operations" array is an object with "method" and "args".

Use keeta_list_sdk_methods with target "Builder" to discover available methods.

Common builder methods: send, setInfo, modifyTokenSupply, modifyTokenBalance, computeBlocks, receive.

The tool will:

1. Create a UserClient and initialize a builder

2. Call each operation in sequence

3. If autoPublish is true (default): call computeBlocks() then publish()

4. Return all computed block hashes

Example operations: [ { "method": "setInfo", "args": [{ "name": "TKNA", "description": "My Token" }], "options": { "account": "keeta_..." } }, { "method": "modifyTokenSupply", "args": ["BIGINT:50000000000"], "options": { "account": "keeta_..." } }, { "method": "send", "args": ["keeta_recipient...", "BIGINT:1000000", "keeta_token..."] } ]

Arguments are auto-resolved (see keeta_client_execute for resolution rules). The "options" field in each operation is passed as the last argument (common for { account: tokenAddress }).

Execute ANY anchor operation on the Keeta Network. Fully dynamic — auto-discovers services and lib modules from the SDK at runtime.

subtarget types:

• "service" → call a method on any anchor service client (FX, KYC, AssetMovement, Username, Notification, or ANY future service). Set serviceName to the service name.

• "lib" → call a method/function on any anchor lib module (Resolver, Certificates, EncryptedContainer, URI, or ANY future module). Set libModule to the module name.

• "metadata" → shortcut to call Resolver.Metadata static methods (formatMetadata, fullyResolveValuizable)

Use keeta_list_sdk_methods with target "AnchorCatalog" to discover all available services and lib modules. Use "AnchorService:" or "AnchorLib:" to drill into specific ones.

Arguments are auto-resolved (see keeta_client_execute for resolution rules).