@nodiusxyz/solana-agent-kit 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nodius Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,132 @@
-# Temporary Holding Version
+# @nodiusxyz/solana-agent-kit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An opt-in **Solana Agent Kit 2.0.10** plugin for nodius.xyz recent signals, bounded monitoring, buy/sell plans, guarded execution and persistent status recovery. Node.js **20.20.2+**, ESM. This is a library plugin, not a CLI trading pack. MIT licensed.
+
+## Install and drop in
+
+```sh
+npm install @nodiusxyz/solana-agent-kit solana-agent-kit@2.0.10
+```
+
+Use your existing `BaseWallet` implementation. No keypair files or secret-key retrieval are needed. This ten-line drop-in uses your existing `wallet`:
+
+```ts
+import { SolanaAgentKit } from "solana-agent-kit";
+import { createNodiusPlugin } from "@nodiusxyz/solana-agent-kit";
+const agent = new SolanaAgentKit(wallet, "https://rpc.nodius.xyz/rpc", {});
+const nodius = agent.use(
+  createNodiusPlugin({
+    apiKey: process.env.NODIUS_API_KEY,
+    endpoint: "https://rpc.nodius.xyz",
+    journalDir: "./.nodius-journal",
+    allowExecution: false,
+    ackIncompletePolicy: false,
+  }),
+);
+console.log(await nodius.methods.nodiusRecent({ limit: 5 }));
+```
+
+`apiKey` is an optional **host** credential; pass it explicitly (the factory never reads global environment variables). Authenticated calls require it. `endpoint` defaults to `https://rpc.nodius.xyz`, must be an HTTPS origin, without path/query/credentials; HTTP is accepted only for loopback. `journalDir` is required, host-owned and persistent. Both permissions default **false**, are copied/frozen at creation, and cannot be enabled by action arguments. A plugin instance binds to exactly one agent; create a new instance for each agent. The plugin does not alter `agent.connection` or `process.env`; its separate web3 Connection sends `X-Api-Key` headers.
+
+## Methods and actions
+
+All five names are registered identically in `agent.methods` and `agent.actions`:
+
+- `nodiusRecent({ limit?: number })`: default 20, integer 1–50. Locally limits returned events even when an older server returns a larger preview; returned `count` matches those events.
+- `nodiusMonitor({ maxFeeCredits: number, seconds?: number, maxEvents?: number, mint?: string, kinds?: SignalKind[] })`: defaults 30 seconds / 100 events; bounds 1–300 seconds / 1–1000 events. Kinds: `newPair`, `graduation`, `walletActivity`, `largeSwap`, no duplicates. Authenticated **paid** stream. Requires a nonnegative safe-integer admission budget: live `subscribe + maxEvents × notification + unsubscribe` estimate must fit **before WS opens**. For example `{ seconds: 3, maxEvents: 3, maxFeeCredits: 100 }`. Returns `{ state: "monitor-complete", events, subscription, notifications, estimated_stream_credits, note }`; closes/unsubscribes in finally. This never triggers trades. Duration is the stream deadline; HTTP pricing lookup can add up to its 10-second timeout and cleanup up to 500ms.
+- `nodiusTrade(input)`: buy or sell; defaults a **read-only plan**, only fetching pricing. No builder, signature, funding or submission by default.
+- `nodiusStatus({ operationId: string })`: reads the configured persistent journal and, if a signature exists, reconciles chain status. Never rebuilds, resumes or rebroadcasts. A missing signature is not permission to retry; inspect the billing ledger separately.
+- `nodiusSend({ signedTxBase64: string, maxFeeCredits: number, execute?: boolean, operationId?: string })`: defaults a plan for an **already signed, independently reviewed** transaction. Canonical base64, packet-size limit, all signatures verified, exactly one signer/payer matching this agent wallet. Both host permissions are required to submit. No wallet signing occurs. Unlike `nodiusTrade`, this does **not** validate instruction semantics; do not expose this action to untrusted workflows even with host permissions. There is no file-path input.
+
+All direct methods and action handlers parse strict inputs themselves, even when framework schema validation is bypassed. Unknown fields, keypair/tx-file paths, API keys, endpoint and journal overrides are rejected. Outputs are JSON-safe (bigints become decimal strings); the configured current credential is redacted recursively from string values, object keys and surfaced error messages. This does not make arbitrary third-party content safe to trust.
+
+### Exact trade options
+
+```ts
+const plan = await nodius.methods.nodiusTrade({
+  side: "buy",
+  mint: "<base58 mint>",
+  amountSol: "0.001",
+  maxSol: "0.01",
+  maxFeeCredits: 100000,
+  slippageBps: 100,
+  priorityFee: 0,
+  maxPriorityFee: 0,
+  maxPriorityLamports: 0,
+});
+```
+
+| Field                       | Type / constraint                                                                                                          |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `side`                      | Required `"buy"` or `"sell"`                                                                                               |
+| `mint`                      | Required valid Solana public key                                                                                           |
+| `amountSol`                 | **Buy only**, required positive plain SOL decimal string, ≤9 places                                                        |
+| `amountRaw`                 | **Sell only**, required positive raw integer string, ≤u64; never a JS number                                               |
+| `maxSol`                    | Required positive plain SOL decimal string, ≤9 places, safe-integer lamports; buy amount must fit                          |
+| `maxFeeCredits`             | Required nonnegative safe integer; estimated and returned builder + send credits checked                                   |
+| `slippageBps`               | Required integer 0–9999                                                                                                    |
+| `priorityFee`               | Required nonnegative safe integer, requested micro-lamports per CU                                                         |
+| `maxPriorityFee`            | Required nonnegative safe integer, maximum micro-lamports per CU                                                           |
+| `maxPriorityLamports`       | Nonnegative safe integer total priority fee cap; **required** when `priorityFee > 0`                                       |
+| `execute`                   | Optional boolean, default false. Requires host `allowExecution: true`                                                      |
+| `buildOnly`                 | Optional boolean, default false. Requires `execute: true`; charged unsigned construction/inspection, no signing/submission |
+| `operationId`               | Required for execute, 1–80 characters `[A-Za-z0-9_-]`; use durable unique IDs                                              |
+| `acceptUnquotedBuildCharge` | Optional boolean, default false; must be true for **sell execution**, including build-only                                 |
+
+Cross-side amount fields are rejected. No wallet override is accepted: payer is always `agent.wallet.publicKey`. There is deliberately no `ackIncompletePolicy` action field; configure that on the host factory. To execute a reviewed trade, create a fresh host-authorized plugin with both permissions true and supply `execute: true` plus an operation ID. `buildOnly` does not require the incomplete-policy acknowledgement because it does not authorize signing.
+
+## Signing, fees and limitations
+
+For executed trades, billing identity must match the wallet. The SDK uses `maxRetries: 0` and `autoPay: false`: no automatic wallet funding or SDK retry. Before `wallet.signTransaction` is invoked, the client checks the builder envelope, payer, signer, unsigned bytes, packet size, supported classic/current-v2 Pump layout, instruction allowlist, v2 derived accounts/ATAs, funding/refund order, buy/sell amounts, builder-reported bounds, compute-unit and priority caps, message fees and known ATA rent against the SOL budget. Address lookup tables and unknown instruction layouts fail closed. The approved message bytes are copied **before** calling the wallet, then compared byte-for-byte after it returns; all required Ed25519 signatures are verified before submission. The plugin never calls `wallet.signAndSendTransaction`, `sendTransaction`, batch signing or `signMessage`.
+
+This is a **partial policy**, not a complete on-chain proof: dynamic program state, fee-recipient governance, program upgrades, Token-2022 extensions and all CPI behavior/rent are not fully verified. `ackIncompletePolicy: true` explicitly accepts these limitations, not arbitrary instructions. Slippage arguments are forwarded and returned instruction bounds checked; they are not an independent market-price oracle. `maxSol` is not a guaranteed cap on every possible CPI effect.
+
+Pricing is fetched fresh from `/pricing`. Buy build fee is estimated from **`amountSol`**, not `maxSol`, with a SOL quote no older than 15 seconds. `maxSol` is the aggregate safety ceiling; raising it does not raise the requested trade size or its fee estimate. Before charged buy construction (including `buildOnly`), live mint/curve and buyer-associated account data plus live rent prices admit the slippage-bound trade, known missing/growing account rent, and a conservative network/priority allowance. Token-2022 account sizes use SPL extension sizing, including metadata-extended mints; v2 zero/WSOL quote layouts reserve the known WSOL and volume-associated accounts. Missing/unsupported curve layouts fail before construction. Admission failures report required lamports and trade/rent/network components; unsigned results include an `admission` breakdown. This is a conservative partial check, not an exact rent multiplier or complete CPI-spend guarantee. Send admission uses the live landed **total** rather than adding the base fee twice. Builder fees are charged **before** the response arrives. The estimated buy cap is **not a server-side billing cap**; the post-build check cannot undo a builder debit. Sell construction is unquoted and requires the explicit charge acknowledgement. Send failure does not automatically refund a successful build. Signals billing may include events queued beyond the locally received count; duration/event limits are **not** hard server billing caps. Keep account credit balances bounded and review ledger/transaction details.
+
+There is exactly one client `sendAndConfirm` invocation per submitted operation. The server can intentionally make bounded same-byte multi-leg resends; this is not an SDK retry. Journal logical economic intent is origin/wallet/side/mint/amount; changing slippage or priority cannot bypass an unresolved reservation (different amounts are different intents, not a global exactly-once guarantee). Operation/intent reservations precede charged construction, and signature reservations are permanent before submission. Transport failures produce `unknown`, never an automatic rebuild/rebroadcast. Preserve the journal across restarts; do not delete it or change directories to bypass guards. Prefer a private directory on durable local storage (created 0700, files 0600), never shared across unrelated wallets. Journal records store only allowlisted validated builder summaries, not arbitrary response fields or unsigned transaction payloads, and redact the current credential before writes. Journal records include intent/build details; protect them like financial records. Status reconciliation is observation, not an execution authorization. Reusing a transaction signature is always blocked, including after terminal outcomes.
+
+### Unsigned decoder and sell rent recovery
+
+`decodeBuilderUnsigned(unsignedTxBase64)` is exported from the package root. It accepts the canonical provider zero-signature envelope and returns a `VersionedTransaction` with an empty signing placeholder. This decoding does **not** authorize signing or validate trade instruction semantics; independently inspect/review the result. Signed-send validation remains strict and does not normalize zero signatures.
+
+Sell requests omit `closeAccount` and honor the server default: a full-balance sell can append own-base-ATA rent recovery; partial sells leave the account open. No close override is exposed. Classic and v2 signing policies permit only the expected derived base ATA, the correct token program, and exactly three close accounts (base ATA, wallet destination, wallet authority), with the close after the sell. Arbitrary accounts/destinations/authorities and reordered closes are rejected. Inventory eligibility is server/on-chain state, not an offline client proof.
+
+`nodiusStatus` reports a missing local ID as `Operation not found`, without filesystem paths. Malformed signed wire data reports `Malformed signed transaction` rather than parser internals. Signature-bound definitive `status: failed`/transaction errors are terminal failures; explicit `status: unknown` remains uncertain regardless of diagnostic details. Status recovery recognizes on-chain `err` as failed without sending again.
+
+## Framework tools without hosted LLM credentials
+
+Programmatic methods above need **no LLM API key**. If desired, convert registered actions offline using published framework helpers:
+
+```ts
+import {
+  createLangchainTools,
+  createVercelAITools,
+  createOpenAITools,
+} from "solana-agent-kit";
+const langchain = createLangchainTools(nodius, nodius.actions);
+const vercel = createVercelAITools(nodius, nodius.actions);
+const openai = createOpenAITools(nodius, nodius.actions);
+```
+
+The actual 2.0.10 converters are tested. Action schemas are Zod 3 **objects** for LangChain interoperability; the trade handler independently enforces the stricter side-discriminated schema. Select only the read-only actions for untrusted planners; host permissions are defense in depth, not a substitute for controlling tools. Calling an LLM is a separate application concern.
+
+## Read-only example and local development
+
+The included `examples/readonly.ts` constructs a public-key-only wallet whose signing/sending methods throw. It does not retrieve a secret key. From the source checkout:
+
+```sh
+npm ci --ignore-scripts
+NODIUS_API_KEY='your-key' npm run example:readonly
+npm run build
+npm run typecheck
+npm test
+npm pack --dry-run
+npm audit
+npm audit --omit=dev
+```
+
+`NODIUS_PUBLIC_KEY`, `NODIUS_ENDPOINT` and `NODIUS_JOURNAL` are optional example host variables. Never put API keys in prompts or checked-in files. Tests use real loopback HTTP/WS and the published framework, including current-v2 buy/sell signing and an unsigned public snapshot; they do not make mainnet calls or trades.
+
+### Dependency security
+
+Dependencies and lockfile are pinned: published SDK 0.2.15 (redirect rejection), web3.js 1.99.0, Zod 3.25.76 and framework 2.0.10. Full development audit currently reports 14 advisories (7 high / 3 moderate / 4 low); `--omit=dev` reports 4 high advisories through optional SDK SPL-token/bigint-buffer dependencies. These counts describe this lockfile, not a guarantee for consumers. Solana Agent Kit 2.0.10 brings transitive framework/LLM and SPL-token dependencies with outstanding npm audit advisories; this package does **not** claim a zero-advisory install. Review both full and production audits for your own dependency tree. The development tree's `jayson` override is root-local and is **not inherited** by consumer installations. Do not run blind `npm audit fix --force` or silently downgrade the tested framework. Optional native bigint bindings may fall back to pure JS; upstream `punycode` deprecation warnings can occur.

package/dist/index.d.ts

@@ -0,0 +1,281 @@
+import type { SolanaAgentKit } from "solana-agent-kit";
+import { z } from "zod";
+export { decodeBuilderUnsigned } from "./internal/safety.js";
+export interface NodiusOptions {
+    apiKey?: string;
+    endpoint?: string;
+    journalDir: string;
+    allowExecution?: boolean;
+    ackIncompletePolicy?: boolean;
+}
+export declare const tradeSchema: z.ZodDiscriminatedUnion<"side", [z.ZodObject<{
+    side: z.ZodLiteral<"buy">;
+    amountSol: z.ZodString;
+    mint: z.ZodString;
+    maxSol: z.ZodString;
+    maxFeeCredits: z.ZodNumber;
+    slippageBps: z.ZodNumber;
+    priorityFee: z.ZodNumber;
+    maxPriorityFee: z.ZodNumber;
+    maxPriorityLamports: z.ZodOptional<z.ZodNumber>;
+    execute: z.ZodDefault<z.ZodBoolean>;
+    buildOnly: z.ZodDefault<z.ZodBoolean>;
+    operationId: z.ZodOptional<z.ZodString>;
+    acceptUnquotedBuildCharge: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    mint: string;
+    execute: boolean;
+    side: "buy";
+    amountSol: string;
+    maxSol: string;
+    maxFeeCredits: number;
+    slippageBps: number;
+    priorityFee: number;
+    maxPriorityFee: number;
+    buildOnly: boolean;
+    acceptUnquotedBuildCharge: boolean;
+    maxPriorityLamports?: number | undefined;
+    operationId?: string | undefined;
+}, {
+    mint: string;
+    side: "buy";
+    amountSol: string;
+    maxSol: string;
+    maxFeeCredits: number;
+    slippageBps: number;
+    priorityFee: number;
+    maxPriorityFee: number;
+    execute?: boolean | undefined;
+    maxPriorityLamports?: number | undefined;
+    buildOnly?: boolean | undefined;
+    operationId?: string | undefined;
+    acceptUnquotedBuildCharge?: boolean | undefined;
+}>, z.ZodObject<{
+    side: z.ZodLiteral<"sell">;
+    amountRaw: z.ZodString;
+    mint: z.ZodString;
+    maxSol: z.ZodString;
+    maxFeeCredits: z.ZodNumber;
+    slippageBps: z.ZodNumber;
+    priorityFee: z.ZodNumber;
+    maxPriorityFee: z.ZodNumber;
+    maxPriorityLamports: z.ZodOptional<z.ZodNumber>;
+    execute: z.ZodDefault<z.ZodBoolean>;
+    buildOnly: z.ZodDefault<z.ZodBoolean>;
+    operationId: z.ZodOptional<z.ZodString>;
+    acceptUnquotedBuildCharge: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    mint: string;
+    execute: boolean;
+    side: "sell";
+    maxSol: string;
+    maxFeeCredits: number;
+    slippageBps: number;
+    priorityFee: number;
+    maxPriorityFee: number;
+    buildOnly: boolean;
+    acceptUnquotedBuildCharge: boolean;
+    amountRaw: string;
+    maxPriorityLamports?: number | undefined;
+    operationId?: string | undefined;
+}, {
+    mint: string;
+    side: "sell";
+    maxSol: string;
+    maxFeeCredits: number;
+    slippageBps: number;
+    priorityFee: number;
+    maxPriorityFee: number;
+    amountRaw: string;
+    execute?: boolean | undefined;
+    maxPriorityLamports?: number | undefined;
+    buildOnly?: boolean | undefined;
+    operationId?: string | undefined;
+    acceptUnquotedBuildCharge?: boolean | undefined;
+}>]>;
+export declare const monitorSchema: z.ZodObject<{
+    maxFeeCredits: z.ZodNumber;
+    seconds: z.ZodDefault<z.ZodNumber>;
+    maxEvents: z.ZodDefault<z.ZodNumber>;
+    mint: z.ZodOptional<z.ZodString>;
+    kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<["newPair", "graduation", "walletActivity", "largeSwap"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    seconds: number;
+    maxFeeCredits: number;
+    maxEvents: number;
+    mint?: string | undefined;
+    kinds?: ("newPair" | "graduation" | "walletActivity" | "largeSwap")[] | undefined;
+}, {
+    maxFeeCredits: number;
+    mint?: string | undefined;
+    seconds?: number | undefined;
+    kinds?: ("newPair" | "graduation" | "walletActivity" | "largeSwap")[] | undefined;
+    maxEvents?: number | undefined;
+}>;
+export declare const statusSchema: z.ZodObject<{
+    operationId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    operationId: string;
+}, {
+    operationId: string;
+}>;
+export declare const sendSchema: z.ZodObject<{
+    signedTxBase64: z.ZodString;
+    maxFeeCredits: z.ZodNumber;
+    execute: z.ZodDefault<z.ZodBoolean>;
+    operationId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    execute: boolean;
+    maxFeeCredits: number;
+    signedTxBase64: string;
+    operationId?: string | undefined;
+}, {
+    maxFeeCredits: number;
+    signedTxBase64: string;
+    execute?: boolean | undefined;
+    operationId?: string | undefined;
+}>;
+export type SendInput = z.input<typeof sendSchema>;
+export type StatusInput = z.input<typeof statusSchema>;
+export type MonitorInput = z.input<typeof monitorSchema>;
+export type TradeInput = z.input<typeof tradeSchema>;
+export type NodiusResult = Record<string, unknown>;
+export declare function createNodiusPlugin(options: NodiusOptions): {
+    name: string;
+    methods: {
+        nodiusSend: (input: SendInput) => Promise<NodiusResult>;
+        nodiusStatus: (input: StatusInput) => Promise<NodiusResult>;
+        nodiusMonitor: (input: MonitorInput) => Promise<NodiusResult>;
+        nodiusRecent: (input?: {
+            limit?: number;
+        }) => Promise<NodiusResult>;
+        nodiusTrade: (input: TradeInput) => Promise<NodiusResult>;
+    };
+    actions: ({
+        name: string;
+        similes: never[];
+        description: string;
+        examples: never[];
+        schema: z.ZodObject<{
+            signedTxBase64: z.ZodString;
+            maxFeeCredits: z.ZodNumber;
+            execute: z.ZodDefault<z.ZodBoolean>;
+            operationId: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            execute: boolean;
+            maxFeeCredits: number;
+            signedTxBase64: string;
+            operationId?: string | undefined;
+        }, {
+            maxFeeCredits: number;
+            signedTxBase64: string;
+            execute?: boolean | undefined;
+            operationId?: string | undefined;
+        }>;
+        handler: (a: SolanaAgentKit, i: unknown) => Promise<NodiusResult>;
+    } | {
+        name: string;
+        similes: never[];
+        description: string;
+        examples: never[];
+        schema: z.ZodObject<{
+            operationId: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            operationId: string;
+        }, {
+            operationId: string;
+        }>;
+        handler: (a: SolanaAgentKit, i: unknown) => Promise<NodiusResult>;
+    } | {
+        name: string;
+        similes: never[];
+        description: string;
+        examples: never[];
+        schema: z.ZodObject<{
+            maxFeeCredits: z.ZodNumber;
+            seconds: z.ZodDefault<z.ZodNumber>;
+            maxEvents: z.ZodDefault<z.ZodNumber>;
+            mint: z.ZodOptional<z.ZodString>;
+            kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<["newPair", "graduation", "walletActivity", "largeSwap"]>, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            seconds: number;
+            maxFeeCredits: number;
+            maxEvents: number;
+            mint?: string | undefined;
+            kinds?: ("newPair" | "graduation" | "walletActivity" | "largeSwap")[] | undefined;
+        }, {
+            maxFeeCredits: number;
+            mint?: string | undefined;
+            seconds?: number | undefined;
+            kinds?: ("newPair" | "graduation" | "walletActivity" | "largeSwap")[] | undefined;
+            maxEvents?: number | undefined;
+        }>;
+        handler: (a: SolanaAgentKit, i: unknown) => Promise<NodiusResult>;
+    } | {
+        name: string;
+        similes: never[];
+        description: string;
+        examples: never[];
+        schema: z.ZodObject<{
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            limit: number;
+        }, {
+            limit?: number | undefined;
+        }>;
+        handler: (a: SolanaAgentKit, i: unknown) => Promise<NodiusResult>;
+    } | {
+        name: string;
+        similes: never[];
+        description: string;
+        examples: never[];
+        schema: z.ZodObject<{
+            side: z.ZodEnum<["buy", "sell"]>;
+            amountSol: z.ZodOptional<z.ZodString>;
+            amountRaw: z.ZodOptional<z.ZodString>;
+            mint: z.ZodString;
+            maxSol: z.ZodString;
+            maxFeeCredits: z.ZodNumber;
+            slippageBps: z.ZodNumber;
+            priorityFee: z.ZodNumber;
+            maxPriorityFee: z.ZodNumber;
+            maxPriorityLamports: z.ZodOptional<z.ZodNumber>;
+            execute: z.ZodDefault<z.ZodBoolean>;
+            buildOnly: z.ZodDefault<z.ZodBoolean>;
+            operationId: z.ZodOptional<z.ZodString>;
+            acceptUnquotedBuildCharge: z.ZodDefault<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            mint: string;
+            execute: boolean;
+            side: "buy" | "sell";
+            maxSol: string;
+            maxFeeCredits: number;
+            slippageBps: number;
+            priorityFee: number;
+            maxPriorityFee: number;
+            buildOnly: boolean;
+            acceptUnquotedBuildCharge: boolean;
+            amountSol?: string | undefined;
+            maxPriorityLamports?: number | undefined;
+            operationId?: string | undefined;
+            amountRaw?: string | undefined;
+        }, {
+            mint: string;
+            side: "buy" | "sell";
+            maxSol: string;
+            maxFeeCredits: number;
+            slippageBps: number;
+            priorityFee: number;
+            maxPriorityFee: number;
+            execute?: boolean | undefined;
+            amountSol?: string | undefined;
+            maxPriorityLamports?: number | undefined;
+            buildOnly?: boolean | undefined;
+            operationId?: string | undefined;
+            acceptUnquotedBuildCharge?: boolean | undefined;
+            amountRaw?: string | undefined;
+        }>;
+        handler: (a: SolanaAgentKit, i: unknown) => Promise<NodiusResult>;
+    })[];
+    initialize(agent: SolanaAgentKit): void;
+};