@usepraxis/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,372 @@
+/**
+ * Signs the wallet-ownership challenge. Implement this to bridge any wallet:
+ * - Node / backend agents: use {@link keypairSigner} with a secret key.
+ * - Browser: wrap a wallet-adapter, e.g.
+ *   `{ address: wallet.publicKey.toBase58(), signMessage: (m) => wallet.signMessage(m) }`.
+ *
+ * `signMessage` must return the raw 64-byte Ed25519 signature; the SDK base58-
+ * encodes it for the API.
+ */
+interface PraxisSigner {
+    /** base58-encoded Solana public key. */
+    readonly address: string;
+    signMessage(message: Uint8Array): Promise<Uint8Array> | Uint8Array;
+}
+type SecretKeyInput = Uint8Array | number[] | string;
+/**
+ * Build a {@link PraxisSigner} from a Solana secret key — a 64-byte keypair or a
+ * 32-byte seed, as raw bytes, a number array, or a base58 string (Phantom /
+ * `solana-keygen` export). Node and browser friendly; no `@solana/web3.js`
+ * dependency.
+ */
+declare function keypairSigner(secret: SecretKeyInput): PraxisSigner;
+
+/**
+ * Praxis SDK wire types — the JSON contract exposed by `/api/praxis/*`.
+ *
+ * MONEY RULE: every monetary value crosses the wire as a **decimal string of
+ * integer base units** (lamports for SOL, token base units for SPL) — never a
+ * float. On the server these are `bigint`; the API serializes them to strings.
+ * The SDK keeps them as strings and leaves bigint conversion to the caller
+ * (see `toBaseUnits` / `fromBaseUnits` in `units.ts`). This file intentionally
+ * mirrors `@praxis/shared` but with `string` money, so the SDK ships a
+ * self-contained type contract with no internal workspace dependency.
+ */
+/** A base58-encoded Solana public key. */
+type Address = string;
+/** Integer base units as a decimal string (e.g. "500000000" = 0.5 SOL). */
+type BaseUnitString = string;
+/** Mirrors the on-chain `ActionKind` discriminants. */
+declare enum ActionKind {
+    Transfer = 0,
+    TransferSpl = 1
+}
+/** Why Aegis rejected an agent action. Mirrors the on-chain enum order. */
+declare enum RejectReason {
+    Unauthorized = 0,
+    Paused = 1,
+    Expired = 2,
+    OverPerTx = 3,
+    OverDaily = 4,
+    RecipientNotAllowed = 5,
+    Overflow = 6,
+    MintNotAllowed = 7
+}
+/** Returned by `POST /auth/challenge`; sign `message` to prove wallet ownership. */
+interface WalletChallenge {
+    address: Address;
+    /** Opaque signed token echoed back to `/auth/verify`. */
+    nonce: string;
+    /** The exact UTF-8 string the wallet must sign. */
+    message: string;
+    /** ISO-8601 expiry of the challenge. */
+    expiresAt: string;
+}
+interface SessionInfo {
+    authenticated: boolean;
+    walletAddress: Address;
+}
+interface TokenInfo {
+    symbol: string;
+    mint: Address;
+    decimals: number;
+    verified: boolean;
+}
+interface AddressBookEntry {
+    label: string;
+    name: string;
+    address: Address;
+    note?: string;
+}
+interface PolicyView {
+    address: Address;
+    owner: Address;
+    /** `11111…1111` (default) once the agent key is revoked. */
+    agentAuthority: Address;
+    maxPerTx: BaseUnitString;
+    dailyLimit: BaseUnitString;
+    spentToday: BaseUnitString;
+    dayStartTs: number;
+    allowedPrograms: Address[];
+    /** Empty array means "any recipient allowed". */
+    allowedRecipients: Address[];
+    allowedMints: Address[];
+    expiryTs: number;
+    paused: boolean;
+    vaultBalance: BaseUnitString;
+    tokenMint: Address;
+    tokenMaxPerTx: BaseUnitString;
+    tokenDailyLimit: BaseUnitString;
+    tokenSpentToday: BaseUnitString;
+    tokenDayStartTs: number;
+}
+interface PolicyCheckResult {
+    allowed: boolean;
+    reason?: string;
+    reasonCode?: RejectReason;
+    spentToday: BaseUnitString;
+    dailyLimit: BaseUnitString;
+    remaining: BaseUnitString;
+}
+interface PolicyUpdate {
+    maxPerTx?: BaseUnitString;
+    dailyLimit?: BaseUnitString;
+    expiryTs?: number;
+    paused?: boolean;
+}
+interface TokenEnvelopeConfig {
+    tokenMint: Address;
+    tokenMaxPerTx: BaseUnitString;
+    tokenDailyLimit: BaseUnitString;
+}
+type AllowListKind = "programs" | "recipients" | "mints";
+interface TransferDetail {
+    kind: "transfer";
+    amount: BaseUnitString;
+    asset: TokenInfo;
+    recipientName: string;
+    recipientAddress: Address;
+    recipientNote?: string;
+}
+interface SwapDetail {
+    kind: "swap";
+    amountIn: BaseUnitString;
+    assetIn: TokenInfo;
+    estAmountOut: BaseUnitString;
+    assetOut: TokenInfo;
+    route: string;
+    priceImpactBps: number;
+}
+type ProposalDetail = TransferDetail | SwapDetail;
+type ProposalState = "pending" | "signing" | "signed" | "blocked" | "cancelled";
+interface ActionProposal {
+    id: string;
+    detail: ProposalDetail;
+    networkFee: BaseUnitString;
+    simulation: string;
+    check: PolicyCheckResult;
+    state: ProposalState;
+    sig?: string;
+}
+interface ClarifyOption {
+    label: string;
+    value: string;
+    hint?: string;
+}
+interface ResearchMetric {
+    label: string;
+    value: string;
+    trend?: "up" | "down" | "flat";
+}
+interface ResearchData {
+    token: string;
+    mint: Address;
+    metrics: ResearchMetric[];
+    summary: string;
+}
+type AgentBlock = {
+    type: "prose";
+    text: string;
+} | {
+    type: "clarify";
+    text: string;
+    options: ClarifyOption[];
+} | {
+    type: "proposal";
+    text: string;
+    proposalId: string;
+} | {
+    type: "research";
+    text: string;
+    data: ResearchData;
+};
+type UserMessage = {
+    id: string;
+    role: "user";
+    ts: number;
+    text: string;
+};
+type AgentMessage = {
+    id: string;
+    role: "agent";
+    ts: number;
+    blocks: AgentBlock[];
+};
+type Message = UserMessage | AgentMessage;
+interface Thread {
+    id: string;
+    title: string;
+    messages: Message[];
+    updatedAt: number;
+}
+interface ActivityEntry {
+    id: string;
+    kind: "transfer" | "swap";
+    label: string;
+    asset: string;
+    amount: BaseUnitString;
+    decimals: number;
+    result: "allowed" | "rejected";
+    reason?: string;
+    reasonCode?: RejectReason;
+    ts: number;
+    sig?: string;
+}
+interface UnsignedOwnerTransaction {
+    /** base64-encoded unsigned transaction for the owner wallet to sign. */
+    transaction: string;
+    blockhash: string;
+    lastValidBlockHeight: number;
+}
+/** Typed owner action accepted by `POST /owner/build`. */
+type OwnerAction = {
+    kind: "bootstrapPolicy";
+    fundLamports?: BaseUnitString;
+} | {
+    kind: "fundVault";
+    amount: BaseUnitString;
+} | {
+    kind: "withdrawVault";
+    amount: BaseUnitString;
+} | {
+    kind: "closePolicy";
+} | {
+    kind: "revoke";
+} | {
+    kind: "rotate";
+} | {
+    kind: "updatePolicy";
+    patch: PolicyUpdate;
+} | {
+    kind: "allowList";
+    listKind: AllowListKind;
+    address: Address;
+    mode: "add" | "remove";
+};
+
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+interface PraxisClientOptions {
+    /** Base origin of the Praxis deployment, e.g. "http://localhost:3000". */
+    baseUrl: string;
+    /** Wallet signer for `connect()`. Optional if you only call public reads after an external login. */
+    signer?: PraxisSigner;
+    /** Custom fetch (defaults to global fetch). Required in runtimes without one. */
+    fetch?: FetchLike;
+    /** Per-request timeout in ms (default 20_000). */
+    timeoutMs?: number;
+}
+/** Result of {@link PraxisClient.ask} — the agent's reply, distilled. */
+interface AskResult {
+    threadId: string;
+    /** The agent's reply message (prose / clarify / proposal / research blocks). */
+    message: AgentMessage;
+    /** Any action proposals the agent produced, hydrated for convenience. */
+    proposals: ActionProposal[];
+}
+/**
+ * Typed client for a hosted Praxis agent. The agent's LLM, scoped agent key, and
+ * Aegis policy enforcement all live server-side; this SDK is an authenticated
+ * client of the `/api/praxis/*` surface.
+ *
+ * ```ts
+ * const praxis = new PraxisClient({ baseUrl, signer: keypairSigner(secret) });
+ * await praxis.connect();
+ * const { proposals } = await praxis.ask("send 0.5 SOL to maya");
+ * if (proposals[0]?.check.allowed) await praxis.signProposal(proposals[0].id);
+ * ```
+ */
+declare class PraxisClient {
+    private readonly baseUrl;
+    private readonly signer?;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    /** Manual cookie jar — Node's fetch does not persist Set-Cookie across calls. */
+    private sessionCookie?;
+    constructor(options: PraxisClientOptions);
+    /** The signer's wallet address, if a signer was provided. */
+    get address(): string | undefined;
+    /**
+     * Run the wallet-ownership handshake: request a challenge, sign its message,
+     * verify it, and store the resulting session cookie. Idempotent.
+     */
+    connect(): Promise<SessionInfo>;
+    /** Current session, or `null` if not signed in. */
+    session(): Promise<SessionInfo | null>;
+    /** Clear the session (server-side cookie + local jar). */
+    logout(): Promise<void>;
+    /** Send a line to the agent. Creates a thread when `threadId` is omitted. */
+    send(text: string, threadId?: string | null): Promise<{
+        threadId: string;
+    }>;
+    /**
+     * Send a line and return the agent's reply in one call. The API resolves
+     * `send` only after the agent has finished, so this needs no polling.
+     */
+    ask(text: string, threadId?: string | null): Promise<AskResult>;
+    newThread(threadId?: string): Promise<{
+        threadId: string;
+    }>;
+    signProposal(proposalId: string): Promise<void>;
+    cancelProposal(proposalId: string): Promise<void>;
+    getThreads(): Promise<Thread[]>;
+    getThread(id: string): Promise<Thread>;
+    getProposal(id: string): Promise<ActionProposal>;
+    getPolicy(): Promise<PolicyView>;
+    getActivity(): Promise<ActivityEntry[]>;
+    getAddressBook(): Promise<AddressBookEntry[]>;
+    isThinking(threadId: string): Promise<boolean>;
+    getVersion(): Promise<number>;
+    bootstrapPolicy(fundLamports?: BaseUnitString): Promise<void>;
+    updatePolicy(patch: PolicyUpdate): Promise<void>;
+    configureToken(config: TokenEnvelopeConfig): Promise<void>;
+    prepareTokenAccounts(recipientAddresses?: string[]): Promise<void>;
+    revokeAgent(): Promise<void>;
+    rotateAgent(): Promise<void>;
+    addToAllowList(kind: AllowListKind, address: string): Promise<void>;
+    removeFromAllowList(kind: AllowListKind, address: string): Promise<void>;
+    /** Build an unsigned owner transaction for the wallet to sign. */
+    buildOwnerTransaction(action: OwnerAction): Promise<UnsignedOwnerTransaction>;
+    /** Submit a wallet-signed owner transaction. */
+    submitOwnerTransaction(signed: UnsignedOwnerTransaction): Promise<{
+        sig: string;
+    }>;
+    private get;
+    private post;
+    private request;
+    private captureCookie;
+}
+
+/**
+ * Thrown when the Praxis API returns a non-2xx response. The backend's error
+ * envelope is `{ error: string, type: string }` with a meaningful HTTP status
+ * (400 input, 401 auth, 404 not-found, 429 rate-limit, 503 config, 500 other).
+ */
+declare class PraxisApiError extends Error {
+    readonly status: number;
+    /** The backend error class name, e.g. "PraxisAuthError", "PraxisRateLimitError". */
+    readonly type: string;
+    constructor(status: number, type: string, message: string);
+    get isAuth(): boolean;
+    get isRateLimited(): boolean;
+    get isInput(): boolean;
+}
+/** Thrown for SDK-side misconfiguration (no fetch, no signer, bad key, …). */
+declare class PraxisConfigError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Money helpers. Praxis money crosses the wire as decimal strings of integer
+ * base units (lamports / token base units). These convert to/from `bigint` and
+ * human decimal amounts without floats.
+ */
+/** Parse a base-unit string (or bigint) into a bigint. */
+declare function toBaseUnits(value: string | bigint): bigint;
+/** Serialize a bigint (or number of whole base units) into a base-unit string. */
+declare function fromBaseUnits(value: bigint | number): string;
+/** Convert a human decimal amount ("0.5") into base units for `decimals` places. */
+declare function humanToBaseUnits(amount: string, decimals: number): string;
+/** Convert base units into a human decimal string for `decimals` places. */
+declare function baseUnitsToHuman(value: string | bigint, decimals: number): string;
+
+export { ActionKind, type ActionProposal, type ActivityEntry, type Address, type AddressBookEntry, type AgentBlock, type AgentMessage, type AllowListKind, type AskResult, type BaseUnitString, type ClarifyOption, type FetchLike, type Message, type OwnerAction, type PolicyCheckResult, type PolicyUpdate, type PolicyView, PraxisApiError, PraxisClient, type PraxisClientOptions, PraxisConfigError, type PraxisSigner, type ProposalDetail, type ProposalState, RejectReason, type ResearchData, type ResearchMetric, type SecretKeyInput, type SessionInfo, type SwapDetail, type Thread, type TokenEnvelopeConfig, type TokenInfo, type TransferDetail, type UnsignedOwnerTransaction, type UserMessage, type WalletChallenge, baseUnitsToHuman, fromBaseUnits, humanToBaseUnits, keypairSigner, toBaseUnits };

package/dist/index.js

@@ -0,0 +1,334 @@
+import bs582 from 'bs58';
+import nacl from 'tweetnacl';
+
+// src/client.ts
+
+// src/errors.ts
+var PraxisApiError = class _PraxisApiError extends Error {
+  status;
+  /** The backend error class name, e.g. "PraxisAuthError", "PraxisRateLimitError". */
+  type;
+  constructor(status, type, message) {
+    super(message);
+    this.name = "PraxisApiError";
+    this.status = status;
+    this.type = type;
+    Object.setPrototypeOf(this, _PraxisApiError.prototype);
+  }
+  get isAuth() {
+    return this.status === 401;
+  }
+  get isRateLimited() {
+    return this.status === 429;
+  }
+  get isInput() {
+    return this.status === 400;
+  }
+};
+var PraxisConfigError = class _PraxisConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PraxisConfigError";
+    Object.setPrototypeOf(this, _PraxisConfigError.prototype);
+  }
+};
+
+// src/client.ts
+var API_PREFIX = "/api/praxis";
+var PraxisClient = class {
+  baseUrl;
+  signer;
+  fetchImpl;
+  timeoutMs;
+  /** Manual cookie jar — Node's fetch does not persist Set-Cookie across calls. */
+  sessionCookie;
+  constructor(options) {
+    if (!options.baseUrl) throw new PraxisConfigError("baseUrl is required");
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.signer = options.signer;
+    const resolvedFetch = options.fetch ?? globalThis.fetch;
+    if (!resolvedFetch) {
+      throw new PraxisConfigError("No fetch available; pass options.fetch (Node <18 or non-browser runtime).");
+    }
+    this.fetchImpl = resolvedFetch;
+    this.timeoutMs = options.timeoutMs ?? 2e4;
+  }
+  // --- auth ----------------------------------------------------------------
+  /** The signer's wallet address, if a signer was provided. */
+  get address() {
+    return this.signer?.address;
+  }
+  /**
+   * Run the wallet-ownership handshake: request a challenge, sign its message,
+   * verify it, and store the resulting session cookie. Idempotent.
+   */
+  async connect() {
+    if (!this.signer) {
+      throw new PraxisConfigError("connect() requires a signer. Pass one to the constructor.");
+    }
+    const challenge = await this.post("/auth/challenge", {
+      address: this.signer.address
+    });
+    const signature = await this.signer.signMessage(new TextEncoder().encode(challenge.message));
+    return this.post("/auth/verify", {
+      address: this.signer.address,
+      nonce: challenge.nonce,
+      signature: bs582.encode(signature)
+    });
+  }
+  /** Current session, or `null` if not signed in. */
+  async session() {
+    try {
+      return await this.get("/auth/session");
+    } catch (error) {
+      if (error instanceof PraxisApiError && error.isAuth) return null;
+      throw error;
+    }
+  }
+  /** Clear the session (server-side cookie + local jar). */
+  async logout() {
+    await this.request("DELETE", "/auth/session");
+    this.sessionCookie = void 0;
+  }
+  // --- conversation --------------------------------------------------------
+  /** Send a line to the agent. Creates a thread when `threadId` is omitted. */
+  send(text, threadId = null) {
+    return this.post("/send", { text, threadId });
+  }
+  /**
+   * Send a line and return the agent's reply in one call. The API resolves
+   * `send` only after the agent has finished, so this needs no polling.
+   */
+  async ask(text, threadId = null) {
+    const { threadId: tid } = await this.send(text, threadId);
+    const thread = await this.getThread(tid);
+    const message = lastAgentMessage(thread);
+    if (!message) {
+      throw new PraxisApiError(500, "Error", "Agent produced no reply message.");
+    }
+    const proposalIds = message.blocks.filter((b) => b.type === "proposal").map((b) => b.proposalId);
+    const proposals = await Promise.all(proposalIds.map((id) => this.getProposal(id)));
+    return { threadId: tid, message, proposals };
+  }
+  newThread(threadId) {
+    return this.post("/new-thread", threadId ? { threadId } : {});
+  }
+  signProposal(proposalId) {
+    return this.post("/sign-proposal", { proposalId });
+  }
+  cancelProposal(proposalId) {
+    return this.post("/cancel-proposal", { proposalId });
+  }
+  // --- reads ---------------------------------------------------------------
+  getThreads() {
+    return this.get("/get-threads");
+  }
+  getThread(id) {
+    return this.get("/get-thread", { id });
+  }
+  getProposal(id) {
+    return this.get("/get-proposal", { id });
+  }
+  getPolicy() {
+    return this.get("/get-policy");
+  }
+  getActivity() {
+    return this.get("/get-activity");
+  }
+  getAddressBook() {
+    return this.get("/get-address-book");
+  }
+  isThinking(threadId) {
+    return this.get("/is-thinking", { threadId });
+  }
+  getVersion() {
+    return this.get("/get-version");
+  }
+  // --- policy / owner mutations (server-key mode) --------------------------
+  bootstrapPolicy(fundLamports) {
+    return this.post("/bootstrap-policy", fundLamports ? { fundLamports } : {});
+  }
+  updatePolicy(patch) {
+    return this.post("/update-policy", { patch });
+  }
+  configureToken(config) {
+    return this.post("/configure-token", { config });
+  }
+  prepareTokenAccounts(recipientAddresses) {
+    return this.post("/prepare-token-accounts", recipientAddresses ? { recipientAddresses } : {});
+  }
+  revokeAgent() {
+    return this.post("/revoke-agent", {});
+  }
+  rotateAgent() {
+    return this.post("/rotate-agent", {});
+  }
+  addToAllowList(kind, address) {
+    return this.post("/add-to-allow-list", { kind, address });
+  }
+  removeFromAllowList(kind, address) {
+    return this.post("/remove-from-allow-list", { kind, address });
+  }
+  // --- owner wallet-signed transaction path --------------------------------
+  /** Build an unsigned owner transaction for the wallet to sign. */
+  buildOwnerTransaction(action) {
+    return this.post("/owner/build", { action });
+  }
+  /** Submit a wallet-signed owner transaction. */
+  submitOwnerTransaction(signed) {
+    return this.post("/owner/submit", signed);
+  }
+  // --- transport -----------------------------------------------------------
+  get(path, query) {
+    return this.request("GET", path, { query });
+  }
+  post(path, body) {
+    return this.request("POST", path, { body });
+  }
+  async request(method, path, opts = {}) {
+    const url = new URL(this.baseUrl + API_PREFIX + path);
+    for (const [k, v] of Object.entries(opts.query ?? {})) url.searchParams.set(k, v);
+    const headers = { accept: "application/json" };
+    if (opts.body !== void 0) headers["content-type"] = "application/json";
+    if (this.sessionCookie) headers["cookie"] = this.sessionCookie;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await this.fetchImpl(url.toString(), {
+        method,
+        headers,
+        body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body),
+        // Browser same-origin: let the HttpOnly cookie ride along.
+        credentials: "include",
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new PraxisApiError(0, "TimeoutError", `Praxis request timed out after ${this.timeoutMs}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+    this.captureCookie(res);
+    const text = await res.text();
+    const parsed = text ? safeJsonParse(text) : void 0;
+    if (!res.ok) {
+      const message = (parsed && typeof parsed === "object" && "error" in parsed && typeof parsed.error === "string" ? parsed.error : void 0) ?? `Praxis API error ${res.status}`;
+      const type = parsed && typeof parsed === "object" && "type" in parsed && typeof parsed.type === "string" ? parsed.type : "Error";
+      throw new PraxisApiError(res.status, type, message);
+    }
+    return parsed;
+  }
+  captureCookie(res) {
+    const anyHeaders = res.headers;
+    const cookies = anyHeaders.getSetCookie?.() ?? splitSetCookie(res.headers.get("set-cookie"));
+    for (const cookie of cookies) {
+      const [pair] = cookie.split(";");
+      if (pair && pair.trim().startsWith("praxis_session=")) {
+        this.sessionCookie = pair.trim();
+      }
+    }
+  }
+};
+function lastAgentMessage(thread) {
+  for (let i = thread.messages.length - 1; i >= 0; i--) {
+    const m = thread.messages[i];
+    if (m.role === "agent") return m;
+  }
+  return void 0;
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function splitSetCookie(header) {
+  if (!header) return [];
+  return header.split(/,(?=\s*[^;,\s]+=)/);
+}
+function keypairSigner(secret) {
+  const bytes = normalizeSecret(secret);
+  const pair = bytes.length === 64 ? nacl.sign.keyPair.fromSecretKey(bytes) : nacl.sign.keyPair.fromSeed(bytes);
+  const address = bs582.encode(pair.publicKey);
+  const secretKey = pair.secretKey;
+  return {
+    address,
+    signMessage: (message) => nacl.sign.detached(message, secretKey)
+  };
+}
+function normalizeSecret(secret) {
+  let bytes;
+  if (typeof secret === "string") {
+    try {
+      bytes = bs582.decode(secret.trim());
+    } catch {
+      throw new PraxisConfigError("secret key string must be base58-encoded");
+    }
+  } else if (Array.isArray(secret)) {
+    bytes = Uint8Array.from(secret);
+  } else {
+    bytes = secret;
+  }
+  if (bytes.length !== 64 && bytes.length !== 32) {
+    throw new PraxisConfigError(
+      `secret key must be 64 bytes (keypair) or 32 bytes (seed), got ${bytes.length}`
+    );
+  }
+  return bytes;
+}
+
+// src/units.ts
+function toBaseUnits(value) {
+  return typeof value === "bigint" ? value : BigInt(value.trim());
+}
+function fromBaseUnits(value) {
+  return BigInt(value).toString();
+}
+function humanToBaseUnits(amount, decimals) {
+  const trimmed = amount.trim();
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+    throw new Error(`invalid decimal amount: "${amount}"`);
+  }
+  const [whole, fraction = ""] = trimmed.split(".");
+  if (fraction.length > decimals) {
+    throw new Error(`"${amount}" has more than ${decimals} decimal places`);
+  }
+  const padded = fraction.padEnd(decimals, "0");
+  return (BigInt(whole) * 10n ** BigInt(decimals) + BigInt(padded || "0")).toString();
+}
+function baseUnitsToHuman(value, decimals) {
+  const units = toBaseUnits(value);
+  const negative = units < 0n;
+  const abs = negative ? -units : units;
+  const divisor = 10n ** BigInt(decimals);
+  const whole = abs / divisor;
+  const fraction = (abs % divisor).toString().padStart(decimals, "0").replace(/0+$/, "");
+  const sign = negative ? "-" : "";
+  return fraction ? `${sign}${whole}.${fraction}` : `${sign}${whole}`;
+}
+
+// src/types.ts
+var ActionKind = /* @__PURE__ */ ((ActionKind2) => {
+  ActionKind2[ActionKind2["Transfer"] = 0] = "Transfer";
+  ActionKind2[ActionKind2["TransferSpl"] = 1] = "TransferSpl";
+  return ActionKind2;
+})(ActionKind || {});
+var RejectReason = /* @__PURE__ */ ((RejectReason2) => {
+  RejectReason2[RejectReason2["Unauthorized"] = 0] = "Unauthorized";
+  RejectReason2[RejectReason2["Paused"] = 1] = "Paused";
+  RejectReason2[RejectReason2["Expired"] = 2] = "Expired";
+  RejectReason2[RejectReason2["OverPerTx"] = 3] = "OverPerTx";
+  RejectReason2[RejectReason2["OverDaily"] = 4] = "OverDaily";
+  RejectReason2[RejectReason2["RecipientNotAllowed"] = 5] = "RecipientNotAllowed";
+  RejectReason2[RejectReason2["Overflow"] = 6] = "Overflow";
+  RejectReason2[RejectReason2["MintNotAllowed"] = 7] = "MintNotAllowed";
+  return RejectReason2;
+})(RejectReason || {});
+
+export { ActionKind, PraxisApiError, PraxisClient, PraxisConfigError, RejectReason, baseUnitsToHuman, fromBaseUnits, humanToBaseUnits, keypairSigner, toBaseUnits };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map