zyropai 1.0.0

package/src/client.ts

@@ -0,0 +1,167 @@
+/**
+ * Main client for ZyroPAI API
+ */
+
+import axios, { AxiosInstance, AxiosError, AxiosRequestConfig } from 'axios';
+import {
+  ZyroPAIError,
+  AuthenticationError,
+  RateLimitError,
+  InvalidRequestError,
+  APIError,
+  ConnectionError,
+  TimeoutError,
+} from './errors';
+import { ZyroPAIConfig } from './types';
+import { PaymentsResource } from './resources/payments';
+import { InvoicesResource } from './resources/invoices';
+import { PayoutsResource } from './resources/payouts';
+import { CurrenciesResource } from './resources/currencies';
+import { CustodyResource } from './resources/custody';
+import { RatesResource } from './resources/rates';
+import { DonationsResource } from './resources/donations';
+import { POSResource } from './resources/pos';
+import { NetworkResource } from './resources/network';
+import { StatusResource } from './resources/status';
+import { TimezonesResource } from './resources/timezones';
+import { WebhooksResource } from './resources/webhooks';
+
+export class ZyroPAI {
+  public readonly payments: PaymentsResource;
+  public readonly invoices: InvoicesResource;
+  public readonly payouts: PayoutsResource;
+  public readonly currencies: CurrenciesResource;
+  public readonly custody: CustodyResource;
+  public readonly rates: RatesResource;
+  public readonly donations: DonationsResource;
+  public readonly pos: POSResource;
+  public readonly network: NetworkResource;
+  public readonly status: StatusResource;
+  public readonly timezones: TimezonesResource;
+  public readonly webhooks: WebhooksResource;
+
+  private readonly apiKey: string;
+  private readonly baseUrl: string;
+  private readonly timeout: number;
+  private readonly maxRetries: number;
+  private readonly client: AxiosInstance;
+
+  constructor(config: ZyroPAIConfig = {}) {
+    this.apiKey = config.apiKey || process.env.ZYROPAI_API_KEY || '';
+    if (!this.apiKey) {
+      throw new Error(
+        'API key is required. Pass it in config or set ZYROPAI_API_KEY environment variable.'
+      );
+    }
+
+    const mode = config.mode || 'test';
+    this.baseUrl =
+      config.baseUrl ||
+      (mode === 'test'
+        ? 'https://sandbox-api.zyropai.com/api/v1'
+        : 'https://api.zyropai.com/api/v1');
+
+    this.timeout = config.timeout || 30000;
+    this.maxRetries = config.maxRetries || 3;
+
+    this.client = axios.create({
+      baseURL: this.baseUrl,
+      timeout: this.timeout,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'ZyroPAI-Node-SDK/1.0.0',
+      },
+    });
+
+    // Initialize resources
+    this.payments = new PaymentsResource(this);
+    this.invoices = new InvoicesResource(this);
+    this.payouts = new PayoutsResource(this);
+    this.currencies = new CurrenciesResource(this);
+    this.custody = new CustodyResource(this);
+    this.rates = new RatesResource(this);
+    this.donations = new DonationsResource(this);
+    this.pos = new POSResource(this);
+    this.network = new NetworkResource(this);
+    this.status = new StatusResource(this);
+    this.timezones = new TimezonesResource(this);
+    this.webhooks = new WebhooksResource(this);
+  }
+
+  async request<T = any>(method: string, path: string, data?: any, retryCount = 0): Promise<T> {
+    try {
+      const config: AxiosRequestConfig = {
+        method,
+        url: path,
+        ...(data && { data }),
+      };
+
+      const response = await this.client.request<T>(config);
+      return response.data;
+    } catch (err: unknown) {
+      // Handle Axios errors
+      if (err instanceof AxiosError) {
+        const status = err.response?.status || 0;
+        const responseData = err.response?.data as any;
+        const message = responseData?.detail || err.message;
+        const requestId = err.response?.headers?.['x-request-id'];
+
+        // Handle rate limiting
+        if (status === 429 && retryCount < this.maxRetries) {
+          const retryAfter = parseInt(err.response?.headers['retry-after'] || `${Math.pow(2, retryCount)}`);
+          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
+          return this.request(method, path, data, retryCount + 1);
+        }
+
+        if (status === 401) {
+          throw new AuthenticationError(message, status, responseData, requestId);
+        }
+        if (status === 429) {
+          const retryAfter = parseInt(err.response?.headers['retry-after'] || '30');
+          throw new RateLimitError(message, retryAfter, status, responseData, requestId);
+        }
+        if (status === 400) {
+          throw new InvalidRequestError(message, status, responseData, requestId);
+        }
+        if (status >= 500) {
+          throw new APIError(message, status, responseData, requestId);
+        }
+        throw new APIError(message, status, responseData, requestId);
+      }
+      
+      // Handle other error types with proper type checking
+      if (typeof err === 'object' && err !== null) {
+        const errorObj = err as any;
+        
+        if (errorObj.code === 'ECONNABORTED') {
+          throw new TimeoutError(`Request timeout after ${this.timeout}ms`);
+        }
+        if (errorObj.code === 'ECONNREFUSED') {
+          throw new ConnectionError(`Connection refused to ${this.baseUrl}`);
+        }
+      }
+      
+      // Fallback error
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      throw new ZyroPAIError(`Request failed: ${errorMessage}`);
+    }
+  }
+
+  async get<T = any>(path: string): Promise<T> {
+    return this.request<T>('GET', path);
+  }
+
+  async post<T = any>(path: string, data?: any): Promise<T> {
+    return this.request<T>('POST', path, data);
+  }
+
+  async put<T = any>(path: string, data?: any): Promise<T> {
+    return this.request<T>('PUT', path, data);
+  }
+
+  async delete<T = any>(path: string): Promise<T> {
+    return this.request<T>('DELETE', path);
+  }
+}
+

package/src/errors.ts

@@ -0,0 +1,74 @@
+/**
+ * Custom error classes for ZyroPAI SDK
+ */
+
+export class ZyroPAIError extends Error {
+    public readonly status?: number;
+    public readonly responseBody?: any;
+    public readonly requestId?: string;
+
+    constructor(message: string, status?: number, responseBody?: any, requestId?: string) {
+        super(message);
+        this.name = 'ZyroPAIError';
+        this.status = status;
+        this.responseBody = responseBody;
+        this.requestId = requestId;
+    }
+}
+
+export class AuthenticationError extends ZyroPAIError {
+    constructor(message: string, status?: number, responseBody?: any, requestId?: string) {
+        super(message, status, responseBody, requestId);
+        this.name = 'AuthenticationError';
+    }
+}
+
+export class RateLimitError extends ZyroPAIError {
+    public readonly retryAfter?: number;
+
+    constructor(message: string, retryAfter?: number, status?: number, responseBody?: any, requestId?: string) {
+        super(message, status, responseBody, requestId);
+        this.name = 'RateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+
+export class InvalidRequestError extends ZyroPAIError {
+    constructor(message: string, status?: number, responseBody?: any, requestId?: string) {
+        super(message, status, responseBody, requestId);
+        this.name = 'InvalidRequestError';
+    }
+}
+
+export class APIError extends ZyroPAIError {
+    constructor(message: string, status?: number, responseBody?: any, requestId?: string) {
+        super(message, status, responseBody, requestId);
+        this.name = 'APIError';
+    }
+}
+
+export class WebhookSignatureError extends ZyroPAIError {
+    constructor(message: string) {
+        super(message);
+        this.name = 'WebhookSignatureError';
+    }
+}
+
+export class ConnectionError extends ZyroPAIError {
+    constructor(message: string) {
+        super(message);
+        this.name = 'ConnectionError';
+    }
+}
+
+export class TimeoutError extends ZyroPAIError {
+    constructor(message: string) {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+
+
+
+
+

package/src/index.ts

@@ -0,0 +1,8 @@
+/**
+ * ZyroPAI Node.js SDK
+ */
+
+export { ZyroPAI } from './client';
+export { ZyroPAIConfig } from './types';
+export * from './errors';
+

package/src/resources/base.ts

@@ -0,0 +1,33 @@
+/**
+ * Base resource class
+ */
+
+import { ZyroPAI } from '../client';
+
+export class APIResource {
+  protected client: ZyroPAI;
+
+  constructor(client: ZyroPAI) {
+    this.client = client;
+  }
+
+  protected async request<T = any>(method: string, path: string, data?: any): Promise<T> {
+    return this.client.request<T>(method, path, data);
+  }
+
+  protected async get<T = any>(path: string): Promise<T> {
+    return this.client.get<T>(path);
+  }
+
+  protected async post<T = any>(path: string, data?: any): Promise<T> {
+    return this.client.post<T>(path, data);
+  }
+
+  protected async put<T = any>(path: string, data?: any): Promise<T> {
+    return this.client.put<T>(path, data);
+  }
+
+  protected async delete<T = any>(path: string): Promise<T> {
+    return this.client.delete<T>(path);
+  }
+}

package/src/resources/currencies.ts

@@ -0,0 +1,39 @@
+/**
+ * Currencies resource
+ */
+
+import { APIResource } from './base';
+import { CurrenciesListParams } from '../types';
+
+export class CurrenciesResource extends APIResource {
+  async list(params?: CurrenciesListParams): Promise<any> {
+    const queryParams = new URLSearchParams();
+    if (params?.include_rates) queryParams.append('include_rates', 'true');
+    if (params?.include_networks) queryParams.append('include_networks', 'true');
+
+    const path = `/currencies${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+    return this.request('GET', path);
+  }
+
+  async getDetails(currency: string): Promise<any> {
+    return this.request('GET', `/currencies/${currency}`);
+  }
+
+  async getNetworks(currency: string): Promise<any> {
+    return this.request('GET', `/currencies/${currency}/networks`);
+  }
+
+  async getFiat(): Promise<any> {
+    return this.request('GET', '/currencies/fiat');
+  }
+
+  async getSupported(params?: { category?: string; min_confirmations?: number }): Promise<any> {
+    const queryParams = new URLSearchParams();
+    if (params?.category) queryParams.append('category', params.category);
+    if (params?.min_confirmations) queryParams.append('min_confirmations', String(params.min_confirmations));
+
+    const path = `/currencies/supported${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+    return this.request('GET', path);
+  }
+}
+

package/src/resources/custody.ts

@@ -0,0 +1,82 @@
+/**
+ * Custody/Wallets resource
+ */
+
+import { APIResource } from './base';
+import { WithdrawalCreateParams } from '../types';
+
+export interface WalletResponse {
+  id: string;
+  name: string;
+  currency: string;
+  network: string;
+  address: string;
+  is_default: boolean;
+  settlement_preference: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface WalletBalanceResponse {
+  currency: string;
+  network: string;
+  balance: number;
+  balance_usd: number;
+  available_for_withdrawal: number;
+}
+
+export interface WithdrawalResponse {
+  id: string;
+  status: string;
+  amount: number;
+  currency: string;
+  destination_address: string;
+  created_at: string;
+  estimated_completion?: string;
+  tx_hash?: string;
+  fee_amount?: number;
+  fee_currency?: string;
+  completed_at?: string;
+  explorer_url?: string;
+}
+
+export class CustodyResource extends APIResource {
+  async listWallets(): Promise<WalletResponse[]> {
+    return this.request('GET', '/custody/wallets');
+  }
+
+  async getBalance(walletId: string): Promise<WalletBalanceResponse> {
+    return this.request('GET', `/custody/wallets/${walletId}/balance`);
+  }
+
+  async createWithdrawal(params: WithdrawalCreateParams): Promise<WithdrawalResponse> {
+    const data = {
+      amount: params.amount,
+      currency: params.currency,
+      address: params.address,
+      network: params.network || 'solana',
+    };
+    return this.request('POST', '/custody/withdrawals', data);
+  }
+
+  async listWithdrawals(params?: {
+    limit?: number;
+    offset?: number;
+    status?: string;
+    currency?: string;
+  }): Promise<WithdrawalResponse[]> {
+    const queryParams = new URLSearchParams();
+    if (params?.limit) queryParams.append('limit', String(params.limit));
+    if (params?.offset) queryParams.append('offset', String(params.offset));
+    if (params?.status) queryParams.append('status', params.status);
+    if (params?.currency) queryParams.append('currency', params.currency);
+
+    const path = `/custody/withdrawals${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+    return this.request('GET', path);
+  }
+
+  async getWithdrawalStatus(withdrawalId: string): Promise<WithdrawalResponse> {
+    return this.request('GET', `/custody/withdrawals/${withdrawalId}`);
+  }
+}
+

package/src/resources/donations.ts

@@ -0,0 +1,84 @@
+/**
+ * Donations resource
+ */
+
+import { APIResource } from './base';
+
+export interface DonationCreateParams {
+  api_key?: string;
+  amount: number;
+  currency?: string;
+  crypto_currency?: string;
+  donor_name?: string;
+  donor_email?: string;
+  donor_phone?: string;
+  donor_social?: string;
+  donor_address?: string;
+  donor_comment?: string;
+  source?: string;
+}
+
+export interface DonationResponse {
+  donation_id: string;
+  amount: number;
+  currency: string;
+  crypto_amount: number;
+  crypto_currency: string;
+  pay_address: string;
+  status: string;
+  expires_at: string;
+  qr_code: string;
+  created_at: string;
+}
+
+export class DonationsResource extends APIResource {
+  async create(params: DonationCreateParams): Promise<DonationResponse> {
+    const data: any = {
+      api_key: params.api_key,
+      amount: params.amount,
+      currency: params.currency || 'USD',
+      crypto_currency: params.crypto_currency || 'SOL',
+      source: params.source || 'api',
+    };
+
+    if (params.donor_name) data.donor_name = params.donor_name;
+    if (params.donor_email) data.donor_email = params.donor_email;
+    if (params.donor_phone) data.donor_phone = params.donor_phone;
+    if (params.donor_social) data.donor_social = params.donor_social;
+    if (params.donor_address) data.donor_address = params.donor_address;
+    if (params.donor_comment) data.donor_comment = params.donor_comment;
+
+    return this.request('POST', '/donations/create', data);
+  }
+
+  async createPublic(
+    slug: string,
+    params: Omit<DonationCreateParams, 'api_key'>
+  ): Promise<DonationResponse> {
+    const data: any = {
+      amount: params.amount,
+      currency: params.currency || 'USD',
+      crypto_currency: params.crypto_currency || 'SOL',
+    };
+
+    if (params.donor_name) data.donor_name = params.donor_name;
+    if (params.donor_email) data.donor_email = params.donor_email;
+    if (params.donor_comment) data.donor_comment = params.donor_comment;
+
+    return this.request('POST', `/donations/public/${slug}`, data);
+  }
+
+  async getStatus(donationId: string): Promise<{
+    donation_id: string;
+    amount: number;
+    currency: string;
+    crypto_amount: number;
+    crypto_currency: string;
+    pay_address: string;
+    status: string;
+    created_at: string;
+  }> {
+    return this.request('GET', `/donations/${donationId}`);
+  }
+}
+

package/src/resources/invoices.ts

@@ -0,0 +1,35 @@
+/**
+ * Invoices resource
+ */
+
+import { APIResource } from './base';
+import { InvoiceCreateParams, InvoiceResponse } from '../types';
+
+export class InvoicesResource extends APIResource {
+  async create(params: InvoiceCreateParams): Promise<InvoiceResponse> {
+    const data: Record<string, any> = {
+      price_amount: params.price_amount,
+      price_currency: params.price_currency || 'USD',
+      pay_currency: params.pay_currency || 'USDC',
+    };
+
+    if (params.order_id) data.order_id = params.order_id;
+    if (params.order_description) data.order_description = params.order_description;
+    if (params.customer_email) data.customer_email = params.customer_email;
+    if (params.success_url) data.success_url = params.success_url;
+    if (params.cancel_url) data.cancel_url = params.cancel_url;
+    if (params.metadata) data.metadata = params.metadata;
+
+    return this.request('POST', '/invoice', data);
+  }
+
+  async retrieve(invoiceId: string): Promise<InvoiceResponse & {
+    order_id?: string;
+    order_description?: string;
+    success_url?: string;
+    cancel_url?: string;
+  }> {
+    return this.request('GET', `/invoice/${invoiceId}`);
+  }
+}
+

package/src/resources/network.ts

@@ -0,0 +1,26 @@
+/**
+ * Network Fees resource
+ */
+
+import { APIResource } from './base';
+
+export interface NetworkFeeResponse {
+  network: string;
+  currency: string;
+  native_fee: number;
+  native_fee_currency: string;
+  fee: number;
+  fee_currency: string;
+  fee_usd: number;
+  updated_at: string;
+}
+
+export class NetworkResource extends APIResource {
+  async getFee(params: { network: string; currency?: string }): Promise<NetworkFeeResponse> {
+    const queryParams = new URLSearchParams({
+      network: params.network,
+      currency: params.currency || 'SOL',
+    });
+    return this.request('GET', `/network-fee?${queryParams.toString()}`);
+  }
+}

package/src/resources/payments.ts

@@ -0,0 +1,50 @@
+/**
+ * Payments resource
+ */
+
+import { APIResource } from './base';
+import { PaymentCreateParams, PaymentResponse } from '../types';
+
+export class PaymentsResource extends APIResource {
+  async create(params: PaymentCreateParams): Promise<PaymentResponse> {
+    const data: Record<string, any> = {
+      price_amount: params.price_amount,
+      price_currency: params.price_currency || 'USD',
+      pay_currency: params.pay_currency || 'USDC',
+    };
+
+    if (params.order_id) data.order_id = params.order_id;
+    if (params.order_description) data.order_description = params.order_description;
+    if (params.customer_email) data.customer_email = params.customer_email;
+    if (params.ipn_callback_url) data.ipn_callback_url = params.ipn_callback_url;
+    if (params.success_url) data.success_url = params.success_url;
+    if (params.cancel_url) data.cancel_url = params.cancel_url;
+    if (params.metadata) data.metadata = params.metadata;
+
+    return this.request('POST', '/payments', data);
+  }
+
+  async retrieve(paymentId: string): Promise<PaymentResponse> {
+    return this.request('GET', `/payments/${paymentId}`);
+  }
+
+  async list(params?: { limit?: number; page?: number; status?: string }): Promise<{
+    payments: PaymentResponse[];
+    total: number;
+    limit: number;
+    offset: number;
+  }> {
+    const queryParams = new URLSearchParams();
+    if (params?.limit) queryParams.append('limit', String(params.limit));
+    if (params?.page) queryParams.append('page', String(params.page));
+    if (params?.status) queryParams.append('status', params.status);
+
+    const path = `/payments${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+    return this.request('GET', path);
+  }
+
+  async cancel(paymentId: string): Promise<{ success: boolean; message: string }> {
+    return this.request('POST', `/payments/${paymentId}/cancel`);
+  }
+}
+