valta-sdk 2.0.1 → 2.1.1

package/dist/index.cjs

@@ -0,0 +1,276 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthError: () => AuthError,
+  NotFoundError: () => NotFoundError,
+  RateLimitError: () => RateLimitError,
+  TierError: () => TierError,
+  ValtaClient: () => ValtaClient,
+  ValtaError: () => ValtaError,
+  default: () => ValtaClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/index.ts
+var ValtaError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.name = "ValtaError";
+    this.code = code;
+    this.status = status;
+  }
+};
+var AuthError = class extends ValtaError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, "UNAUTHORIZED", 401);
+    this.name = "AuthError";
+  }
+};
+var TierError = class extends ValtaError {
+  constructor(message, requiredTier) {
+    super(message, "TIER_LIMIT", 403);
+    this.name = "TierError";
+    this.requiredTier = requiredTier;
+    this.upgradeUrl = "https://valta.co/upgrade";
+  }
+};
+var RateLimitError = class extends ValtaError {
+  constructor(message = "Rate limit exceeded. Slow down your requests.") {
+    super(message, "RATE_LIMIT", 429);
+    this.name = "RateLimitError";
+  }
+};
+var NotFoundError = class extends ValtaError {
+  constructor(resource) {
+    super(`${resource} not found`, "NOT_FOUND", 404);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/http/requester.ts
+var DEFAULT_BASE_URL = "https://valta.co/api/v1";
+var Requester = class {
+  constructor(apiKey, baseUrl) {
+    if (!apiKey || typeof apiKey !== "string") {
+      throw new AuthError("An API key is required. Get one at https://valta.co/dashboard/api-keys");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+  }
+  async request(path, options = {}) {
+    const { method = "GET", body } = options;
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Valta-SDK": "0.2.0"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let errorData = {};
+      try {
+        errorData = await res.json();
+      } catch {
+      }
+      const message = errorData.message ?? "An unknown error occurred";
+      switch (res.status) {
+        case 401:
+          throw new AuthError(message);
+        case 403:
+          throw new TierError(message, errorData.requiredTier ?? "builder");
+        case 404:
+          throw new NotFoundError(path);
+        case 429:
+          throw new RateLimitError(message);
+        default:
+          throw new ValtaError(message, "SERVER_ERROR", res.status);
+      }
+    }
+    return res.json();
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  // Get all agents
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit) query.set("limit", String(params.limit));
+    if (params.offset) query.set("offset", String(params.offset));
+    if (params.status) query.set("status", params.status);
+    const qs = query.toString();
+    return this.requester.request(
+      `/agents${qs ? `?${qs}` : ""}`
+    );
+  }
+  // Get one agent by ID
+  async get(agentId) {
+    return this.requester.request(`/agents/${agentId}`);
+  }
+  // Create a new agent
+  async create(params) {
+    return this.requester.request("/agents", {
+      method: "POST",
+      body: params
+    });
+  }
+  // Update an agent
+  async update(agentId, params) {
+    return this.requester.request(`/agents/${agentId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  // Freeze an agent (stops it from spending)
+  async freeze(agentId) {
+    return this.requester.request(`/agents/${agentId}/freeze`, {
+      method: "POST"
+    });
+  }
+  // Unfreeze an agent
+  async unfreeze(agentId) {
+    return this.requester.request(`/agents/${agentId}/unfreeze`, {
+      method: "POST"
+    });
+  }
+  // Delete an agent
+  async delete(agentId) {
+    return this.requester.request(
+      `/agents/${agentId}`,
+      { method: "DELETE" }
+    );
+  }
+};
+
+// src/resources/wallets.ts
+var WalletsResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  // Get wallet balance for an agent
+  async get(agentId) {
+    return this.requester.request(
+      `/agents/${agentId}/wallet`
+    );
+  }
+  // Transfer funds from one agent wallet to another
+  async transfer(agentId, params) {
+    return this.requester.request(
+      `/agents/${agentId}/wallet/transfer`,
+      { method: "POST", body: params }
+    );
+  }
+};
+
+// src/resources/policies.ts
+var PoliciesResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list(agentId) {
+    const qs = agentId ? `?agentId=${agentId}` : "";
+    return this.requester.request(`/policies${qs}`);
+  }
+  async create(params) {
+    return this.requester.request("/policies", {
+      method: "POST",
+      body: params
+    });
+  }
+  async update(policyId, params) {
+    return this.requester.request(`/policies/${policyId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  async delete(policyId) {
+    return this.requester.request(`/policies/${policyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/resources/audit.ts
+var AuditResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    if (params.agentId) query.set("agentId", params.agentId);
+    if (params.limit) query.set("limit", String(params.limit));
+    if (params.offset) query.set("offset", String(params.offset));
+    if (params.from) query.set("from", params.from);
+    if (params.to) query.set("to", params.to);
+    const qs = query.toString();
+    return this.requester.request(`/audit${qs ? `?${qs}` : ""}`);
+  }
+};
+
+// src/resources/keys.ts
+var KeysResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list() {
+    return this.requester.request("/keys");
+  }
+  async create(name) {
+    return this.requester.request("/keys", {
+      method: "POST",
+      body: { name }
+    });
+  }
+  async revoke(keyId) {
+    return this.requester.request(`/keys/${keyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/client.ts
+var ValtaClient = class {
+  constructor(config) {
+    const apiKey = typeof config === "string" ? config : config.apiKey;
+    const baseUrl = typeof config === "object" ? config.baseUrl : void 0;
+    const requester = new Requester(apiKey, baseUrl);
+    this.agents = new AgentsResource(requester);
+    this.wallets = new WalletsResource(requester);
+    this.policies = new PoliciesResource(requester);
+    this.audit = new AuditResource(requester);
+    this.keys = new KeysResource(requester);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthError,
+  NotFoundError,
+  RateLimitError,
+  TierError,
+  ValtaClient,
+  ValtaError
+});

package/dist/index.d.cts

@@ -0,0 +1,197 @@
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    body?: unknown;
+}
+declare class Requester {
+    private apiKey;
+    private baseUrl;
+    constructor(apiKey: string, baseUrl?: string);
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+}
+
+interface Agent {
+    id: string;
+    name: string;
+    type: string;
+    status: 'active' | 'frozen' | 'paused';
+    walletAddress?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateAgentParams {
+    name: string;
+    type: string;
+    description?: string;
+}
+interface ListAgentsParams {
+    limit?: number;
+    offset?: number;
+    status?: 'active' | 'frozen' | 'paused';
+}
+interface ListAgentsResponse {
+    agents: Agent[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+declare class AgentsResource {
+    private requester;
+    constructor(requester: Requester);
+    list(params?: ListAgentsParams): Promise<ListAgentsResponse>;
+    get(agentId: string): Promise<Agent>;
+    create(params: CreateAgentParams): Promise<Agent>;
+    update(agentId: string, params: Partial<CreateAgentParams>): Promise<Agent>;
+    freeze(agentId: string): Promise<Agent>;
+    unfreeze(agentId: string): Promise<Agent>;
+    delete(agentId: string): Promise<{
+        deleted: boolean;
+        id: string;
+    }>;
+}
+
+interface WalletBalance {
+    usdc: string;
+    usdcPending: string;
+    lastUpdated: string;
+}
+interface WalletTransferParams {
+    toAgentId?: string;
+    toAddress?: string;
+    amount: string;
+    currency: 'USDC';
+    note?: string;
+}
+interface WalletTransfer {
+    id: string;
+    fromAgentId: string;
+    toAgentId?: string;
+    toAddress?: string;
+    amount: string;
+    currency: string;
+    status: 'pending' | 'completed' | 'failed';
+    createdAt: string;
+}
+declare class WalletsResource {
+    private requester;
+    constructor(requester: Requester);
+    get(agentId: string): Promise<WalletBalance>;
+    transfer(agentId: string, params: WalletTransferParams): Promise<WalletTransfer>;
+}
+
+interface Policy {
+    id: string;
+    agentId: string;
+    name: string;
+    maxSpendPerDay?: number;
+    maxSpendPerTransaction?: number;
+    allowedRecipients?: string[];
+    currency: string;
+    active: boolean;
+    createdAt: string;
+}
+interface CreatePolicyParams {
+    agentId: string;
+    name: string;
+    maxSpendPerDay?: number;
+    maxSpendPerTransaction?: number;
+    allowedRecipients?: string[];
+    currency?: string;
+}
+declare class PoliciesResource {
+    private requester;
+    constructor(requester: Requester);
+    list(agentId?: string): Promise<Policy[]>;
+    create(params: CreatePolicyParams): Promise<Policy>;
+    update(policyId: string, params: Partial<CreatePolicyParams>): Promise<Policy>;
+    delete(policyId: string): Promise<{
+        deleted: boolean;
+    }>;
+}
+
+interface AuditLog {
+    id: string;
+    agentId: string;
+    action: string;
+    amount?: string;
+    currency?: string;
+    metadata?: Record<string, unknown>;
+    hash: string;
+    previousHash: string;
+    createdAt: string;
+}
+interface ListAuditParams {
+    agentId?: string;
+    limit?: number;
+    offset?: number;
+    from?: string;
+    to?: string;
+}
+interface ListAuditResponse {
+    logs: AuditLog[];
+    total: number;
+}
+declare class AuditResource {
+    private requester;
+    constructor(requester: Requester);
+    list(params?: ListAuditParams): Promise<ListAuditResponse>;
+}
+
+interface ApiKey {
+    id: string;
+    name: string;
+    prefix: string;
+    tier: 'free' | 'builder' | 'startup' | 'enterprise';
+    lastUsed?: string;
+    createdAt: string;
+}
+interface CreateKeyResponse {
+    id: string;
+    name: string;
+    key: string;
+    tier: string;
+    createdAt: string;
+}
+declare class KeysResource {
+    private requester;
+    constructor(requester: Requester);
+    list(): Promise<ApiKey[]>;
+    create(name: string): Promise<CreateKeyResponse>;
+    revoke(keyId: string): Promise<{
+        deleted: boolean;
+    }>;
+}
+
+interface ValtaConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+declare class ValtaClient {
+    agents: AgentsResource;
+    wallets: WalletsResource;
+    policies: PoliciesResource;
+    audit: AuditResource;
+    keys: KeysResource;
+    constructor(config: ValtaConfig | string);
+}
+
+declare class ValtaError extends Error {
+    code: string;
+    status: number;
+    constructor(message: string, code: string, status: number);
+}
+declare class AuthError extends ValtaError {
+    constructor(message?: string);
+}
+declare class TierError extends ValtaError {
+    requiredTier: string;
+    upgradeUrl: string;
+    constructor(message: string, requiredTier: string);
+}
+declare class RateLimitError extends ValtaError {
+    constructor(message?: string);
+}
+declare class NotFoundError extends ValtaError {
+    constructor(resource: string);
+}
+
+export { type Agent, type ApiKey, type AuditLog, AuthError, type CreateAgentParams, type CreateKeyResponse, type CreatePolicyParams, type ListAgentsParams, type ListAuditParams, NotFoundError, type Policy, RateLimitError, TierError, ValtaClient, ValtaError, type WalletBalance, type WalletTransfer, type WalletTransferParams, ValtaClient as default };