@oobe-protocol-labs/synapse-sap-sdk 0.1.0

package/dist/esm/types/enums.js

@@ -0,0 +1,171 @@
+/**
+ * @module types/enums
+ * @description Anchor-compatible enum variant objects for SAP v2.
+ *
+ * Each enum mirrors the Rust discriminant format used by Anchor:
+ * `{ variant: {} }` — e.g. `{ sol: {} }` for `TokenType::Sol`.
+ *
+ * Use the `*Kind` types for function signatures.
+ *
+ * @category Types
+ * @since v0.1.0
+ * @see {@link https://solana.com/docs | Solana Docs}
+ */
+// ═══════════════════════════════════════════════════════════════════
+//  Token Type
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * @name TokenType
+ * @description Anchor-compatible enum variants for token types accepted by agent pricing and escrow.
+ *
+ * - `Sol` — Native SOL.
+ * - `Usdc` — USDC stablecoin.
+ * - `Spl` — Arbitrary SPL token (requires `tokenMint`).
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { TokenType } from "@synapse-sap/sdk";
+ *
+ * const tier = { tokenType: TokenType.Sol };
+ * ```
+ */
+export const TokenType = {
+    Sol: { sol: {} },
+    Usdc: { usdc: {} },
+    Spl: { spl: {} },
+};
+// ═══════════════════════════════════════════════════════════════════
+//  Plugin Type
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * @name PluginType
+ * @description Anchor-compatible enum variants for plugin extension types.
+ *
+ * Plugins extend agent functionality and are feature-gated on-chain.
+ *
+ * - `Memory` — Encrypted memory / vault storage.
+ * - `Validation` — Custom validation logic.
+ * - `Delegation` — Hot-wallet delegation.
+ * - `Analytics` — Metrics & analytics.
+ * - `Governance` — DAO / governance participation.
+ * - `Custom` — User-defined plugin type.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { PluginType } from "@synapse-sap/sdk";
+ *
+ * const ref = { pluginType: PluginType.Memory, pda: vaultPda };
+ * ```
+ */
+export const PluginType = {
+    Memory: { memory: {} },
+    Validation: { validation: {} },
+    Delegation: { delegation: {} },
+    Analytics: { analytics: {} },
+    Governance: { governance: {} },
+    Custom: { custom: {} },
+};
+// ═══════════════════════════════════════════════════════════════════
+//  Settlement Mode
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * @name SettlementMode
+ * @description Anchor-compatible enum variants for payment settlement strategies.
+ *
+ * - `Instant` — Pay-per-call, settled immediately on invocation.
+ * - `Escrow` — Pre-funded escrow account with per-call drawdown.
+ * - `Batched` — Aggregated settlement at fixed intervals.
+ * - `X402` — HTTP 402-based micropayment protocol settlement.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { SettlementMode } from "@synapse-sap/sdk";
+ *
+ * const tier = { settlementMode: SettlementMode.Escrow };
+ * ```
+ */
+export const SettlementMode = {
+    Instant: { instant: {} },
+    Escrow: { escrow: {} },
+    Batched: { batched: {} },
+    X402: { x402: {} },
+};
+// ═══════════════════════════════════════════════════════════════════
+//  Tool HTTP Method
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * @name ToolHttpMethod
+ * @description Anchor-compatible enum variants for the HTTP method exposed by a tool.
+ *
+ * - `Get` / `Post` / `Put` / `Delete` — Standard REST verbs.
+ * - `Compound` — Multi-step tool (calls several sub-operations).
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { ToolHttpMethod } from "@synapse-sap/sdk";
+ *
+ * const args = { httpMethod: ToolHttpMethod.Post };
+ * ```
+ */
+export const ToolHttpMethod = {
+    Get: { get: {} },
+    Post: { post: {} },
+    Put: { put: {} },
+    Delete: { delete: {} },
+    Compound: { compound: {} },
+};
+// ═══════════════════════════════════════════════════════════════════
+//  Tool Category
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * @name ToolCategory
+ * @description Anchor-compatible enum variants for classifying tools in the on-chain registry.
+ *
+ * Categories power cross-agent tool discovery via the `ToolCategoryIndex` PDA.
+ *
+ * - `Swap` — Token swap / DEX tools.
+ * - `Lend` — Lending protocol tools.
+ * - `Stake` — Staking / validator tools.
+ * - `Nft` — NFT minting / marketplace tools.
+ * - `Payment` — Payment & invoicing tools.
+ * - `Data` — Data feeds / oracles.
+ * - `Governance` — DAO & governance tools.
+ * - `Bridge` — Cross-chain bridge tools.
+ * - `Analytics` — On-chain analytics.
+ * - `Custom` — User-defined category.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { ToolCategory } from "@synapse-sap/sdk";
+ *
+ * const args = { category: ToolCategory.Swap };
+ * ```
+ */
+export const ToolCategory = {
+    Swap: { swap: {} },
+    Lend: { lend: {} },
+    Stake: { stake: {} },
+    Nft: { nft: {} },
+    Payment: { payment: {} },
+    Data: { data: {} },
+    Governance: { governance: {} },
+    Bridge: { bridge: {} },
+    Analytics: { analytics: {} },
+    Custom: { custom: {} },
+};
+//# sourceMappingURL=enums.js.map

package/dist/esm/types/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../src/types/enums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,sEAAsE;AACtE,cAAc;AACd,sEAAsE;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAChB,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;IAClB,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;CACR,CAAC;AASX,sEAAsE;AACtE,eAAe;AACf,sEAAsE;AAEtE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;IACtB,UAAU,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE;IAC9B,UAAU,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE;IAC9B,SAAS,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE;IAC5B,UAAU,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE;IAC9B,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;CACd,CAAC;AAQX,sEAAsE;AACtE,mBAAmB;AACnB,sEAAsE;AAEtE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE;IACxB,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;IACtB,OAAO,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE;IACxB,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;CACV,CAAC;AASX,sEAAsE;AACtE,oBAAoB;AACpB,sEAAsE;AAEtE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAChB,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;IAClB,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAChB,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;IACtB,QAAQ,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;CAClB,CAAC;AASX,sEAAsE;AACtE,iBAAiB;AACjB,sEAAsE;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;IAClB,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;IAClB,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;IACpB,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAChB,OAAO,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE;IACxB,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;IAClB,UAAU,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE;IAC9B,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;IACtB,SAAS,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE;IAC5B,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;CACd,CAAC"}

package/dist/esm/types/index.js

@@ -0,0 +1,25 @@
+/**
+ * @module types
+ * @description Strongly-typed domain models for SAP v2.
+ *
+ * Every type mirrors the onchain Rust struct / enum exactly.
+ * Types are organized into four layers:
+ *
+ * - **enums** — Anchor-style enum variant objects (`TokenType`, `ToolCategory`, …)
+ * - **common** — Shared helper structs (`Capability`, `PricingTier`, `Settlement`, …)
+ * - **accounts** — Deserialized on-chain PDA account data (`AgentAccountData`, …)
+ * - **instructions** — Instruction argument DTOs + permission/schema helpers
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import type { AgentAccountData, RegisterAgentArgs } from "@synapse-sap/sdk/types";
+ * import { TokenType, SettlementMode } from "@synapse-sap/sdk/types";
+ * ```
+ */
+// ── Enums ────────────────────────────────────────────
+export { TokenType, PluginType, SettlementMode, ToolHttpMethod, ToolCategory, } from "./enums";
+export { DelegatePermission, SchemaType, CompressionType, } from "./instructions";
+//# sourceMappingURL=index.js.map

package/dist/esm/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,wDAAwD;AACxD,OAAO,EACL,SAAS,EACT,UAAU,EACV,cAAc,EACd,cAAc,EACd,YAAY,GACb,MAAM,SAAS,CAAC;AA0DjB,OAAO,EACL,kBAAkB,EAClB,UAAU,EACV,eAAe,GAChB,MAAM,gBAAgB,CAAC"}

package/dist/esm/types/instructions.js

@@ -0,0 +1,89 @@
+/**
+ * @module types/instructions
+ * @description Instruction argument DTOs and helper enumerations.
+ *
+ * These interfaces map 1:1 to the Anchor instruction argument structs.
+ * Use them when calling SDK module methods.
+ *
+ * @category Types
+ * @since v0.1.0
+ */
+// ═══════════════════════════════════════════════════════════════════
+//  Permission & Schema Helpers
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * @name DelegatePermission
+ * @description Bitmask constants for vault delegate permissions.
+ *
+ * Combine with bitwise OR to grant multiple permissions.
+ *
+ * | Bit | Value | Permission          |
+ * | --- | ----- | ------------------- |
+ * | 0   | 1     | Inscribe memories   |
+ * | 1   | 2     | Close sessions      |
+ * | 2   | 4     | Open sessions       |
+ * | —   | 7     | All permissions     |
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { DelegatePermission } from "@synapse-sap/sdk";
+ *
+ * // Grant inscribe + open session
+ * const perms = DelegatePermission.Inscribe | DelegatePermission.OpenSession;
+ * ```
+ */
+export const DelegatePermission = {
+    Inscribe: 1,
+    CloseSession: 2,
+    OpenSession: 4,
+    All: 7,
+};
+/**
+ * @name SchemaType
+ * @description Numeric discriminants for tool schema types.
+ *
+ * Used in the `inscribeToolSchema` instruction to specify which schema
+ * is being written on-chain.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { SchemaType } from "@synapse-sap/sdk";
+ *
+ * const args = { schemaType: SchemaType.Input, ... };
+ * ```
+ */
+export const SchemaType = {
+    Input: 0,
+    Output: 1,
+    Description: 2,
+};
+/**
+ * @name CompressionType
+ * @description Numeric discriminants for compression algorithms.
+ *
+ * Used in inscription instructions to declare the compression format
+ * of the payload so consumers can decompress correctly.
+ *
+ * @category Types
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { CompressionType } from "@synapse-sap/sdk";
+ *
+ * const args = { compression: CompressionType.Gzip, ... };
+ * ```
+ */
+export const CompressionType = {
+    None: 0,
+    Deflate: 1,
+    Gzip: 2,
+    Brotli: 3,
+};
+//# sourceMappingURL=instructions.js.map

package/dist/esm/types/instructions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../../src/types/instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA+SH,sEAAsE;AACtE,+BAA+B;AAC/B,sEAAsE;AAEtE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,QAAQ,EAAE,CAAC;IACX,YAAY,EAAE,CAAC;IACf,WAAW,EAAE,CAAC;IACd,GAAG,EAAE,CAAC;CACE,CAAC;AASX;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,CAAC;IACR,MAAM,EAAE,CAAC;IACT,WAAW,EAAE,CAAC;CACN,CAAC;AAQX;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,CAAC;IACP,MAAM,EAAE,CAAC;CACD,CAAC"}

package/dist/esm/utils/hash.js

@@ -0,0 +1,53 @@
+/**
+ * @module utils/hash
+ * @description Cryptographic hashing utilities.
+ *
+ * @category Utils
+ * @since v0.1.0
+ */
+import { createHash } from "crypto";
+/**
+ * Compute the SHA-256 hash of a UTF-8 string or byte buffer.
+ *
+ * Returns a 32-byte `Uint8Array` suitable for PDA seeds
+ * and Anchor instruction arguments.
+ *
+ * @name sha256
+ * @description Hashes the input using Node’s `crypto.createHash("sha256")`.
+ * @param input - A UTF-8 string, `Buffer`, or `Uint8Array` to hash.
+ * @returns {Uint8Array} 32-byte SHA-256 digest.
+ * @category Utils
+ * @since v0.1.0
+ * @example
+ * ```ts
+ * import { sha256 } from "@synapse-sap/sdk/utils";
+ *
+ * const hash = sha256("jupiter:swap"); // Uint8Array (32 bytes)
+ * ```
+ */
+export const sha256 = (input) => {
+    const hash = createHash("sha256");
+    hash.update(typeof input === "string" ? Buffer.from(input, "utf-8") : input);
+    return new Uint8Array(hash.digest());
+};
+/**
+ * Convert a `Uint8Array` hash to a plain `number[]`.
+ *
+ * Anchor instruction argument types expect `number[]` for hash fields
+ * rather than typed arrays.
+ *
+ * @name hashToArray
+ * @description Converts a byte array (typically 32 bytes) to a plain JavaScript `number[]`.
+ * @param hash - The byte array to convert.
+ * @returns {number[]} Shallow copy as a plain array of numbers.
+ * @category Utils
+ * @since v0.1.0
+ * @example
+ * ```ts
+ * import { sha256, hashToArray } from "@synapse-sap/sdk/utils";
+ *
+ * const arr = hashToArray(sha256("jupiter:swap")); // number[]
+ * ```
+ */
+export const hashToArray = (hash) => Array.from(hash);
+//# sourceMappingURL=hash.js.map

package/dist/esm/utils/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../../src/utils/hash.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAmC,EAAc,EAAE;IACxE,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IAClC,IAAI,CAAC,MAAM,CACT,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAChE,CAAC;IACF,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AACvC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAgB,EAAY,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC"}

package/dist/esm/utils/index.js

@@ -0,0 +1,19 @@
+/**
+ * @module utils
+ * @description Shared utilities used across SDK modules.
+ *
+ * @category Utils
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { sha256, hashToArray, assert } from "@synapse-sap/sdk/utils";
+ *
+ * const hash = sha256("jupiter:swap");
+ * const arr  = hashToArray(hash);      // number[] for Anchor args
+ * ```
+ */
+export { sha256, hashToArray } from "./hash";
+export { assert } from "./validation";
+export { serializeAccount, serializeValue } from "./serialization";
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/esm/utils/serialization.js

@@ -0,0 +1,98 @@
+/**
+ * @module utils/serialization
+ * @description JSON-safe serialization helpers for on-chain account data.
+ *
+ * On-chain Anchor account objects contain `PublicKey` and `BN` instances
+ * that are not JSON-serializable. These helpers convert them to plain
+ * strings (`base58` and decimal `string`) recursively.
+ *
+ * @category Utils
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import { serializeAccount } from "@synapse-sap/sdk/utils";
+ *
+ * const raw = await program.account.agent.fetch(pda);
+ * const json = serializeAccount(raw);
+ * // { authority: "GBL...", totalCalls: "42", ... }
+ * ```
+ */
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+/**
+ * Recursively convert a single value for JSON serialization.
+ *
+ * - `PublicKey` → base58 string
+ * - `BN` → decimal string
+ * - `Uint8Array` / `Buffer` → hex string
+ * - `Array` → recursed
+ * - plain `object` → recursed via {@link serializeAccount}
+ * - primitives → identity
+ *
+ * @name serializeValue
+ * @description Transforms a single Anchor-typed value into its JSON-safe equivalent.
+ * @param value - The value to serialize.
+ * @returns The JSON-safe representation of `value`.
+ * @category Utils
+ * @since v0.1.0
+ * @example
+ * ```ts
+ * import { serializeValue } from "@synapse-sap/sdk/utils";
+ *
+ * serializeValue(new PublicKey("11111111111111111111111111111111")); // "1111..."
+ * serializeValue(new BN(42)); // "42"
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function serializeValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof PublicKey)
+        return value.toBase58();
+    if (BN.isBN(value))
+        return value.toString();
+    if (value instanceof Uint8Array || Buffer.isBuffer(value))
+        return Buffer.from(value).toString("hex");
+    if (Array.isArray(value))
+        return value.map(serializeValue);
+    if (typeof value === "object") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return serializeAccount(value);
+    }
+    return value;
+}
+/**
+ * Serialize an entire on-chain account object to a JSON-safe shape.
+ *
+ * Iterates over each key and delegates to {@link serializeValue}.
+ * Handles `PublicKey` → base58, `BN` → string, and nested
+ * objects / arrays recursively.
+ *
+ * @name serializeAccount
+ * @description Converts all non-primitive fields in an Anchor account record to JSON-safe strings.
+ * @param obj - The raw account object returned by `program.account.<name>.fetch()`.
+ * @returns A new plain object with all values converted.
+ * @category Utils
+ * @since v0.1.0
+ * @example
+ * ```ts
+ * import { serializeAccount } from "@synapse-sap/sdk/utils";
+ *
+ * const raw = await program.account.agent.fetch(pda);
+ * const safe = serializeAccount(raw);
+ * console.log(JSON.stringify(safe));
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function serializeAccount(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+obj) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[key] = serializeValue(value);
+    }
+    return result;
+}
+//# sourceMappingURL=serialization.js.map

package/dist/esm/utils/serialization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.js","sourceRoot":"","sources":["../../../src/utils/serialization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,OAAO,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8DAA8D;AAC9D,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACvD,IAAI,KAAK,YAAY,SAAS;QAAE,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;IACxD,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC5C,IAAI,KAAK,YAAY,UAAU,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QACvD,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC5C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAC3D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,8DAA8D;QAC9D,OAAO,gBAAgB,CAAC,KAA4B,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8DAA8D;AAC9D,MAAM,UAAU,gBAAgB;AAC9B,8DAA8D;AAC9D,GAAwB;IAGxB,8DAA8D;IAC9D,MAAM,MAAM,GAAwB,EAAE,CAAC;IACvC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/C,MAAM,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/esm/utils/validation.js

@@ -0,0 +1,33 @@
+/**
+ * @module utils/validation
+ * @description Runtime assertion helpers.
+ *
+ * @category Utils
+ * @since v0.1.0
+ */
+/**
+ * Assert that a condition holds, throwing a descriptive error otherwise.
+ *
+ * Uses TypeScript’s `asserts condition` return type so the compiler
+ * narrows the guarded value after the call.
+ *
+ * @name assert
+ * @description Runtime guard — throws `RangeError` with a `[SAP SDK]` prefix when the condition is falsy.
+ * @param condition - The boolean expression to verify.
+ * @param message   - Human-readable message included in the thrown error.
+ * @throws {RangeError} When `condition` is `false`.
+ * @category Utils
+ * @since v0.1.0
+ * @example
+ * ```ts
+ * import { assert } from "@synapse-sap/sdk/utils";
+ *
+ * assert(name.length <= 64, "Agent name exceeds MAX_NAME_LEN");
+ * ```
+ */
+export function assert(condition, message) {
+    if (!condition) {
+        throw new RangeError(`[SAP SDK] ${message}`);
+    }
+}
+//# sourceMappingURL=validation.js.map

package/dist/esm/utils/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../../src/utils/validation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,MAAM,CACpB,SAAkB,EAClB,OAAe;IAEf,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,UAAU,CAAC,aAAa,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC"}

package/dist/types/constants/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module constants
+ * @description Protocol constants mirroring the on-chain Rust program.
+ *
+ * Organized into:
+ * - **programs** — Network-specific program IDs
+ * - **seeds** — PDA seed prefix strings
+ * - **limits** — Size constraints, versions, enum numeric values
+ *
+ * @category Constants
+ * @since v0.1.0
+ *
+ * @example
+ * ```ts
+ * import {
+ *   MAINNET_SAP_PROGRAM_ID,
+ *   DEVNET_SAP_PROGRAM_ID,
+ *   SEEDS,
+ *   LIMITS,
+ * } from "@synapse-sap/sdk/constants";
+ * ```
+ */
+export { SAP_PROGRAM_ADDRESS, MAINNET_SAP_PROGRAM_ID, DEVNET_SAP_PROGRAM_ID, LOCALNET_SAP_PROGRAM_ID, SAP_PROGRAM_ID, } from "./programs";
+export { SEEDS } from "./seeds";
+export type { SeedKey } from "./seeds";
+export { LIMITS, AGENT_VERSION, VAULT_PROTOCOL_VERSION, TOOL_CATEGORY_VALUES, HTTP_METHOD_VALUES, } from "./limits";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/constants/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,cAAc,GACf,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGvC,OAAO,EACL,MAAM,EACN,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,UAAU,CAAC"}