@candledottv/agent-sdk 0.1.0

package/dist/internal/encoding.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared base64/ArrayBuffer/Uint8Array conversion helpers for this SDK's crypto modules
+ * (wallet-import.ts, authorization-signature.ts, secret-store.ts). Internal only -- not
+ * re-exported from index.ts -- since these are plumbing for WebCrypto/HPKE call sites, not part
+ * of the SDK's public surface.
+ *
+ * These used to be copied near-identically in all three call sites. Consolidated here with
+ * byte-identical behavior to the originals: same `Buffer.from`/`.slice` calls, just given one
+ * home. Each call site keeps using whichever pair of functions matches the value shape it already
+ * works with (ArrayBuffer for WebCrypto/HPKE APIs, Uint8Array for everything else).
+ */
+/** A `Uint8Array` sliced down to exactly its own bytes, safe to hand to WebCrypto/HPKE as an `ArrayBuffer`. */
+export declare function toArrayBuffer(view: Uint8Array): ArrayBuffer;
+export declare function arrayBufferToBase64(data: ArrayBuffer): string;
+/** Decodes a base64 string to an `ArrayBuffer` containing exactly its bytes (no pooled-buffer slack). */
+export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+export declare function toBase64(bytes: Uint8Array): string;
+export declare function fromBase64(base64: string): Uint8Array;
+//# sourceMappingURL=encoding.d.ts.map

package/dist/internal/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/internal/encoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,+GAA+G;AAC/G,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,WAAW,CAE3D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAE7D;AAED,yGAAyG;AACzG,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAG/D;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAElD;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAErD"}

package/dist/keychain-secret-store.d.ts

@@ -0,0 +1,51 @@
+/**
+ * keychain-secret-store: the OS-keychain `SecretStore` secret-store.ts's module doc deferred to
+ * "Phase 4", closing the loop with the Candle CLI's wallet import.
+ *
+ * `candle wallets import` stores each imported wallet's signer private key in the OS keychain:
+ * service `tv.candle.cli`, account `wallet_signer_<linkedWalletId>`, value = the PEM's base64
+ * body on a single line (the CLI's `pemToStoredSigner` form; a raw PEM contains newlines, which
+ * the CLI's macOS write path refuses by design). This store reads that exact contract, so an SDK
+ * agent on the same machine picks up CLI-imported wallets with zero manual key handling:
+ *
+ *   const store = KeychainSecretStore.detect()
+ *   const candle = new CandleClient({ apiKey, privyAppId, secretStore: store ?? undefined })
+ *   await candle.trade({ ..., from: { linkedWalletId, privyWalletId } })
+ *
+ * `get()` re-armors the stored single-line value into standard PEM, which is what the signing
+ * path (`buildPrivyAuthorizationSignature`) consumes. `set()` accepts a PEM and stores the
+ * single-line form, so writes from either side stay format-compatible. Node-only (spawns
+ * `security` on macOS, `secret-tool` on Linux), like `EncryptedFileSecretStore`; browser and
+ * ephemeral runs keep using `InMemorySecretStore`.
+ *
+ * Secrets travel exclusively via the child's STDIN or its stdout, never argv, mirroring the
+ * CLI's own stores: macOS `security` only takes secrets as a `-w` argv flag in its normal form,
+ * so writes go through `security -i` (command-on-stdin mode) instead. The stored value is
+ * base64 by construction, so embedding it in the quoted `-w "<value>"` token cannot break out
+ * of the quoting; `assertStorable` makes that invariant checked rather than assumed.
+ */
+import type { SecretStore } from "./secret-store";
+export interface ExecResult {
+    status: number;
+    stdout: string;
+}
+export type ExecFn = (binary: string, args: string[], stdin?: string) => Promise<ExecResult>;
+export declare class KeychainSecretStore implements SecretStore {
+    private readonly backend;
+    private readonly exec;
+    constructor(opts?: {
+        backend?: "security" | "secret-tool";
+        exec?: ExecFn;
+    });
+    /**
+     * The store for this machine, or `null` when no OS keychain tool is on `PATH` (fall back to
+     * `EncryptedFileSecretStore` or `InMemorySecretStore` then). Presence-only: a resolvable
+     * binary whose daemon is down surfaces later as `get() === null`, which every caller already
+     * handles as "no signer stored".
+     */
+    static detect(): KeychainSecretStore | null;
+    get(walletRef: string): Promise<string | null>;
+    set(walletRef: string, privateKeyPem: string): Promise<void>;
+    delete(walletRef: string): Promise<void>;
+}
+//# sourceMappingURL=keychain-secret-store.d.ts.map

package/dist/keychain-secret-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keychain-secret-store.d.ts","sourceRoot":"","sources":["../src/keychain-secret-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AA4BjD,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;AAiC5F,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;IACpD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAQ;gBAEjB,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,UAAU,GAAG,aAAa,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAO;IAK9E;;;;;OAKG;IACH,MAAM,CAAC,MAAM,IAAI,mBAAmB,GAAG,IAAI;IAMrC,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAa9C,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB5D,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAS/C"}

package/dist/secret-store.d.ts

@@ -0,0 +1,82 @@
+/**
+ * secret-store: pluggable storage for an agent's P-256 signer private key (Agent Pilot Phase 3).
+ *
+ * Phase 3 lets a headless agent sign for its own linked wallets by holding the P-256 signer key
+ * (`generateSignerKeypair`'s `privateKeyPem`, wallet-import.ts) client-side, not on Candle's
+ * servers. Candle never sees this key; the SDK is where it has to live instead, so this module
+ * defines where and how. A later task (one-shot trade / selfLaunch) loads the key from a
+ * `SecretStore` by `walletRef` to compute the signature at call time.
+ *
+ * Two implementations ship here:
+ *   - `InMemorySecretStore`: a plain `Map`, universal (browser or Node), for tests and ephemeral
+ *     agent runs that re-import or re-generate the key each process start.
+ *   - `EncryptedFileSecretStore`: AES-GCM-at-rest via WebCrypto, keyed from a passphrase through
+ *     PBKDF2, Node-only (it touches the filesystem via `node:fs/promises`).
+ *
+ * An OS-keychain-backed store (macOS Keychain / libsecret / Windows Credential Manager) is
+ * deliberately NOT included here -- it is Node/CLI-specific and belongs to a later phase (Phase
+ * 4). Implement `SecretStore` for it then.
+ */
+/**
+ * Storage for an agent's signer private-key PEM, keyed by `walletRef` (the caller's stable
+ * handle for a linked wallet: its `linkedWalletId` or its address). Implementations decide the
+ * medium (memory, an encrypted file, later an OS keychain) but must agree on this shape.
+ *
+ * Deliberately excluded from this module: an OS-keychain implementation. That store is
+ * Node/CLI-specific (macOS Keychain, libsecret, Windows Credential Manager) and is planned for
+ * Phase 4, not Phase 3 -- implement this interface against it there rather than here.
+ */
+export interface SecretStore {
+    /** Returns the stored PEM for `walletRef`, or `null` if nothing is stored under that ref. */
+    get(walletRef: string): Promise<string | null>;
+    /** Stores `privateKeyPem` under `walletRef`, replacing any previous value for that ref. */
+    set(walletRef: string, privateKeyPem: string): Promise<void>;
+    /** Removes any stored value for `walletRef`. A no-op if nothing was stored under it. */
+    delete(walletRef: string): Promise<void>;
+}
+/**
+ * A plain in-memory `SecretStore`. Works identically in a browser or Node (no filesystem, no
+ * platform APIs), which makes it the right default for tests and for ephemeral agent runs that
+ * are fine re-deriving or re-importing the key on every process start. Nothing here survives
+ * process exit.
+ */
+export declare class InMemorySecretStore implements SecretStore {
+    private readonly entries;
+    get(walletRef: string): Promise<string | null>;
+    set(walletRef: string, privateKeyPem: string): Promise<void>;
+    delete(walletRef: string): Promise<void>;
+}
+/**
+ * A `SecretStore` backed by a single encrypted JSON file, keyed from a passphrase. Node-only (it
+ * reads and writes the filesystem via `node:fs/promises`, imported lazily inside each method so
+ * that importing `InMemorySecretStore` from this module never drags a `node:fs` dependency into
+ * a browser bundle).
+ *
+ * Crypto construction (WebCrypto, matching wallet-import.ts's use of `crypto.subtle`):
+ *   - Key derivation: PBKDF2-HMAC-SHA256, {@link PBKDF2_ITERATIONS} iterations at the time of
+ *     writing, a random {@link SALT_LENGTH_BYTES}-byte salt generated fresh for every `set` call.
+ *     Both the salt and the iteration count actually used are stored alongside that entry's
+ *     ciphertext (not read back from the module constant), so a correct passphrase can always
+ *     re-derive the key even after {@link PBKDF2_ITERATIONS} is raised for new entries later.
+ *   - Encryption: AES-GCM-256, a random {@link IV_LENGTH_BYTES}-byte IV generated fresh for every
+ *     `set` call (never reused across entries or across overwrites of the same entry).
+ *   - At rest: one JSON object per file, one salt/iv/iterations/ciphertext record per `walletRef`.
+ *     The ciphertext is AES-GCM's own output (ciphertext + auth tag), so a wrong passphrase
+ *     derives the wrong key and `crypto.subtle.decrypt` throws on the auth-tag check -- it can
+ *     never silently return garbage plaintext instead of the real PEM.
+ *
+ * Not safe for concurrent writers against the same file: `set` and `delete` both do a
+ * read-modify-write of the whole file, so two concurrent calls (same process or different
+ * processes) against the same `path` can race and lose one write.
+ */
+export declare class EncryptedFileSecretStore implements SecretStore {
+    private readonly path;
+    private readonly passphrase;
+    constructor(path: string, passphrase: string);
+    get(walletRef: string): Promise<string | null>;
+    set(walletRef: string, privateKeyPem: string): Promise<void>;
+    delete(walletRef: string): Promise<void>;
+    private readFile;
+    private writeFile;
+}
+//# sourceMappingURL=secret-store.d.ts.map

package/dist/secret-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-store.d.ts","sourceRoot":"","sources":["../src/secret-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,6FAA6F;IAC7F,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAC9C,2FAA2F;IAC3F,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5D,wFAAwF;IACxF,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;IAE9C,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAI9C,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5D,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/C;AA6CD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,wBAAyB,YAAW,WAAW;IAExD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBADV,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM;IAG/B,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAoB9C,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB5D,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAOhC,QAAQ;YAWR,SAAS;CAMxB"}

package/dist/wallet-import.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Client-side HPKE for Candle's ciphertext-only wallet import (PR3, Task 8).
+ *
+ * `POST /api/v1/agent/wallets/import/init` proxies Privy's HPKE receiver public key so an agent
+ * can encrypt a wallet's private key locally; `POST /api/v1/agent/wallets/import/submit` accepts
+ * only the resulting ciphertext. Candle -- and the network in between -- never sees plaintext.
+ * `CandleClient.importWallet` (client.ts) drives both requests and is the only place in this SDK
+ * that ever holds the plaintext key; this module supplies the pure crypto it calls.
+ *
+ * HPKE parameters match Privy's import contract exactly (RFC 9180, mode Base):
+ *   - KEM: DHKEM(P-256, HKDF-SHA256)  -- `DhkemP256HkdfSha256`
+ *   - KDF: HKDF-SHA256                -- `HkdfSha256`
+ *   - AEAD: ChaCha20-Poly1305         -- `Chacha20Poly1305`
+ * All three wire values -- the receiver's `encryptionPublicKey` (input) and the `ciphertext` /
+ * `encapsulatedKey` this module produces (output) -- are base64-encoded raw KEM bytes (an
+ * uncompressed SEC1 point for the P-256 public key), never DER. DER only shows up below for the
+ * UNRELATED signer keypair, which is a separate WebCrypto ECDSA key, not part of the HPKE
+ * exchange.
+ *
+ * `@hpke/core`, `@hpke/chacha20poly1305`, and `@scure/base` are this SDK's first three runtime
+ * dependencies (previously zero -- see client.ts's module doc). All three already resolve in
+ * this monorepo as transitive hoists of apps/api's `@privy-io/server-auth`, but a phantom hoist
+ * is invisible to a package's own manifest: publishing the SDK without declaring them would
+ * break any consumer that doesn't happen to also depend on `@privy-io/server-auth`.
+ *
+ * CRITICAL: what gets HPKE-sealed is not the `privateKey` string's own UTF-8 bytes -- it is that
+ * string DECODED to the wallet's raw private-key bytes first, exactly like Privy's own reference
+ * import flow (node_modules/@privy-io/server-auth/dist/cjs/wallet-api/import.js,
+ * `handleWalletImport`): "evm" keys are hex (an optional leading "0x" is stripped, then
+ * hex-decoded), "solana" keys are base58 (decoded with `@scure/base`'s `base58.decode`, the same
+ * codec Privy's own SDK uses). Sealing the string's UTF-8 text instead -- what an earlier version
+ * of this module did -- produces a ciphertext that either fails to decrypt correctly on Privy's
+ * side or, worse, silently decrypts to the WRONG bytes and provisions a garbage-keyed wallet.
+ */
+/**
+ * Chain for the linked-wallets import flow (PR3). "evm" covers every EVM chain (Privy's own
+ * `chain_type: "ethereum"`), not just Ethereum mainnet; "solana" is Solana. Deliberately NOT the
+ * launch-surface `Chain` in client.ts ("solana" | "hood"): import targets Privy's wallet chain
+ * types, which distinguish "solana" from EVM rather than from Candle's own Hood/base-mainnet
+ * split.
+ */
+export type WalletChain = "solana" | "evm";
+/**
+ * Decodes a Solana private key given as either a base58 string (`solana-keygen`'s
+ * "phantom-paste" form) or the JSON byte-array contents of an `id.json` keyfile (the form
+ * `solana-keygen new` actually writes to disk). Branches on whether the trimmed input starts
+ * with `[`: no -> base58 decode; yes -> parse as a 64-int 0..255 JSON array. That branch (rather
+ * than "try base58, then try JSON") is what lets a malformed array get a keyfile-specific error
+ * ("this looks like an id.json but...") instead of the generic base58 one.
+ */
+export declare function parseSolanaSecret(input: string): Uint8Array;
+export interface EncryptWalletKeyParams {
+    /** Which chain `privateKey` belongs to; selects how it is decoded to raw bytes before sealing. */
+    chain: WalletChain;
+    /**
+     * The wallet's private key exactly as the caller holds it: a hex string for "evm" (an optional
+     * leading "0x" is accepted and stripped), or a base58 string for "solana". This is decoded to
+     * raw bytes locally -- matching Privy's own wallet-import reference decode -- and THOSE bytes
+     * are what gets HPKE-sealed, never the input string's own UTF-8 text.
+     */
+    privateKey: string;
+    /** Privy's HPKE receiver public key from `/wallets/import/init`'s `encryptionPublicKey`, base64-encoded. */
+    encryptionPublicKey: string;
+}
+export interface EncryptWalletKeyResult {
+    /** Base64-encoded HPKE seal output; posted as `/wallets/import/submit`'s `ciphertext`. */
+    ciphertext: string;
+    /** Base64-encoded HPKE encapsulated key; posted as `/wallets/import/submit`'s `encapsulatedKey`. */
+    encapsulatedKey: string;
+}
+/**
+ * Encrypts `privateKey` (decoded to raw bytes per `chain`, see `decodeWalletPrivateKey`) to
+ * `encryptionPublicKey` under the HPKE suite above (RFC 9180 single-shot Base-mode seal with a
+ * fresh ephemeral sender keypair per call). Neither the input string nor its decoded bytes leave
+ * this function call; only the returned ciphertext and encapsulated key are meant to travel
+ * further.
+ */
+export declare function encryptWalletKeyForImport(params: EncryptWalletKeyParams): Promise<EncryptWalletKeyResult>;
+export interface SignerKeypair {
+    /** PEM-encoded PKCS8 private key. The caller keeps this; the SDK never transmits it anywhere. */
+    privateKeyPem: string;
+    /** Base64-encoded SPKI (DER) public key -- the value `CandleClient.importWallet`'s `signerPublicKey` expects. */
+    publicKeyDerBase64: string;
+}
+/**
+ * Generates a fresh P-256 (ECDSA) keypair via WebCrypto for use as an agent's wallet signer.
+ * Only `publicKeyDerBase64` is meant to leave the process (it becomes `signerPublicKey` in
+ * `/wallets/import/submit`, which Privy registers as a 1-of-1 key quorum authorized to sign for
+ * the imported wallet); `privateKeyPem` is the caller's to store and use for that later signing,
+ * never sent to Candle or Privy by this SDK.
+ */
+export declare function generateSignerKeypair(): Promise<SignerKeypair>;
+//# sourceMappingURL=wallet-import.d.ts.map

package/dist/wallet-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-import.d.ts","sourceRoot":"","sources":["../src/wallet-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAeH;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,KAAK,CAAA;AAE1C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CA0B3D;AAkBD,MAAM,WAAW,sBAAsB;IACrC,kGAAkG;IAClG,KAAK,EAAE,WAAW,CAAA;IAClB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB,4GAA4G;IAC5G,mBAAmB,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,0FAA0F;IAC1F,UAAU,EAAE,MAAM,CAAA;IAClB,oGAAoG;IACpG,eAAe,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAY/G;AAED,MAAM,WAAW,aAAa;IAC5B,iGAAiG;IACjG,aAAa,EAAE,MAAM,CAAA;IACrB,iHAAiH;IACjH,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,aAAa,CAAC,CAUpE"}

package/dist/webhooks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Webhook signature verification for Candle webhook deliveries (Phase 2, R9).
+ *
+ * Every delivery carries `x-candle-signature: t=<unix seconds>,v1=<hex hmac-sha256(secret,
+ * "<t>.<body>")>` where `<body>` is the EXACT raw request body string (re-serializing the
+ * parsed JSON can reorder keys and break the signature; always verify the raw bytes as text).
+ *
+ * Implemented with `node:crypto` (`createHmac` + `timingSafeEqual`), which both Node 18+ and
+ * Bun provide, so the SDK stays zero-dependency. Edge runtimes without `node:crypto` would
+ * need a Web Crypto (`crypto.subtle`) implementation; that is a deliberate later concern, not
+ * covered here.
+ */
+/**
+ * Returns true only when `header` carries a well-formed `t=...,v1=...` signature whose
+ * timestamp is within `toleranceSec` (default 300) of `nowSec` and whose `v1` digest matches
+ * HMAC-SHA256(secret, `${t}.${body}`). Never throws on malformed input; every failure mode
+ * (missing header, bad format, stale timestamp, wrong secret, tampered body) is `false`.
+ */
+export declare function verifyWebhookSignature(secret: string, header: string | null | undefined, body: string, nowSec: number, toleranceSec?: number): boolean;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../src/webhooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,YAAY,SAAM,GACjB,OAAO,CA0BT"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@candledottv/agent-sdk",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for the Candle agent rail: typed headless launches, market reads, and webhook verification",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/candledottv/agentic.git",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://docs.candle.tv/developers/agent-sdk",
+  "bugs": {
+    "url": "https://github.com/candledottv/agentic/issues"
+  },
+  "keywords": [
+    "candle",
+    "solana",
+    "agent",
+    "sdk",
+    "token-launch",
+    "ai-agent"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build:js": "bun build src/index.ts --target=node --format=esm --packages=external --outfile=dist/index.js",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build": "bun run build:js && bun run build:types",
+    "clean": "rm -rf dist",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check ."
+  },
+  "dependencies": {
+    "@hpke/chacha20poly1305": "^1.6.2",
+    "@hpke/core": "^1.7.2",
+    "@scure/base": "^1.2.6",
+    "canonicalize": "^2.1.0"
+  },
+  "devDependencies": {
+    "@privy-io/server-auth": "^1.32.5",
+    "@types/bun": "^1.1.14",
+    "typescript": "^5.7.2"
+  }
+}