@payotex.com/node 1.0.0

package/README.md

@@ -0,0 +1,184 @@
+# @payotex/node
+
+Server-side SDK for Payotex crypto payment processing. Accept cryptocurrency payments with cross-chain swap support.
+
+## Installation
+
+```bash
+npm install @payotex/node
+```
+
+## Requirements
+
+- Node.js 18+ (uses native `fetch`)
+- Zero runtime dependencies
+
+## Quick Start
+
+```typescript
+import { Payotex } from '@payotex/node';
+
+const payotex = new Payotex({
+  secretKey: 'sk_live_your_secret_key_here',
+});
+
+// Create a checkout session
+const session = await payotex.checkout.create({
+  amount: '49.99',
+  currency: 'USD',
+});
+
+console.log(session.sessionId); // Redirect user to pay
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+const payotex = new Payotex({
+  secretKey: 'sk_live_...', // Required. Your secret API key.
+  baseUrl: 'https://payotex.com', // Optional. Defaults to https://payotex.com
+});
+```
+
+### Keys
+
+#### `payotex.keys.create(params)`
+
+Create a new API key pair for a merchant.
+
+```typescript
+const keys = await payotex.keys.create({
+  payoutChain: 'ETH',
+  payoutToken: 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48',
+  payoutAddress: '0xYourAddress...',
+  // Optional secondary payout
+  payoutChain2: 'BTC',
+  payoutToken2: 'BTC.BTC',
+  payoutAddress2: 'bc1q...',
+  label: 'My Store',
+});
+
+console.log(keys.secretKey);      // sk_live_...
+console.log(keys.publishableKey); // pk_live_...
+```
+
+#### `payotex.keys.verify()`
+
+Verify the current API key and get merchant configuration.
+
+```typescript
+const info = await payotex.keys.verify();
+console.log(info.payoutChain);  // "ETH"
+console.log(info.configValid);  // true
+console.log(info.isActive);     // true
+```
+
+### Checkout
+
+#### `payotex.checkout.create(params)`
+
+Create a new checkout session.
+
+```typescript
+const session = await payotex.checkout.create({
+  amount: '100.00',       // Required. Amount as string or number.
+  currency: 'USD',        // Required. USD, EUR, GBP, or crypto asset.
+  metadata: {             // Optional. Custom metadata (max 4096 chars).
+    orderId: 'order-123',
+    customerId: 'cust-456',
+  },
+  expiresIn: 60,          // Optional. Minutes until expiry (5-1440, default 30).
+});
+
+console.log(session.sessionId); // Use to track payment
+console.log(session.status);    // "pending"
+```
+
+### Sessions
+
+#### `payotex.sessions.get(sessionId)`
+
+Get details for a checkout session. This is a public endpoint (no auth required).
+
+```typescript
+const details = await payotex.sessions.get('session-id-here');
+console.log(details.status);           // "pending" | "paid" | "expired"
+console.log(details.payotex_fee_percent);
+```
+
+#### `payotex.sessions.getAssets(sessionId)`
+
+Get available payment assets for a session.
+
+```typescript
+const assets = await payotex.sessions.getAssets('session-id-here');
+assets.forEach(asset => {
+  console.log(`${asset.symbol} on ${asset.chain}`);
+});
+```
+
+#### `payotex.sessions.createQuote(sessionId, params)`
+
+Create a swap quote for a session.
+
+```typescript
+const quote = await payotex.sessions.createQuote('session-id-here', {
+  fromAsset: 'BTC.BTC',
+});
+
+console.log(quote.inbound_address);     // Where to send funds
+console.log(quote.expected_amount_in);   // Amount to send
+console.log(quote.expected_amount_out);  // Amount merchant receives
+console.log(quote.memo);                 // Include in transaction if present
+```
+
+## Error Handling
+
+All methods throw on errors. Errors from the API include a `status` code and `response` object.
+
+```typescript
+try {
+  const session = await payotex.checkout.create({
+    amount: '100',
+    currency: 'USD',
+  });
+} catch (err) {
+  console.error(err.message);  // Human-readable error
+  console.error(err.status);   // HTTP status code (e.g., 400, 401)
+  console.error(err.response); // Full API response body
+}
+```
+
+## TypeScript
+
+All types are exported from the main entry point:
+
+```typescript
+import {
+  Payotex,
+  PayotexConfig,
+  CreateKeysRequest,
+  CreateKeysResponse,
+  VerifyKeyResponse,
+  CreateCheckoutSessionRequest,
+  CheckoutSession,
+  SessionDetails,
+  SessionAsset,
+  CreateQuoteRequest,
+  SessionQuote,
+  PayotexError,
+} from '@payotex/node';
+```
+
+## Security Best Practices
+
+- **Never expose your secret key (`sk_live_`) client-side.** Use it only in server-side code.
+- Use the publishable key (`pk_live_`) for client-side integrations.
+- Store your secret key in environment variables, never in source code.
+- The SDK validates key format on initialization and rejects publishable keys to prevent misuse.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,135 @@
+"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);
+
+// packages/node/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Payotex: () => Payotex
+});
+module.exports = __toCommonJS(index_exports);
+
+// packages/node/src/client.ts
+var DEFAULT_BASE_URL = "https://payotex.com";
+var Payotex = class {
+  secretKey;
+  baseUrl;
+  constructor(config) {
+    if (!config.secretKey) {
+      throw new Error("Payotex: secretKey is required");
+    }
+    if (!config.secretKey.startsWith("sk_live_")) {
+      throw new Error(
+        "Payotex: Invalid key format. Use your secret key (sk_live_...). Never use publishable keys (pk_live_) server-side."
+      );
+    }
+    this.secretKey = config.secretKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  }
+  async request(method, path, body, auth = true) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (auth) {
+      headers["Authorization"] = `Bearer ${this.secretKey}`;
+    }
+    const url = `${this.baseUrl}${path}`;
+    const options = { method, headers };
+    if (body && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    const data = await response.json();
+    if (!response.ok) {
+      const err = new Error(data.error || `HTTP ${response.status}`);
+      err.status = response.status;
+      err.response = data;
+      throw err;
+    }
+    return data;
+  }
+  keys = {
+    create: async (params) => {
+      if (!params.payoutChain || !params.payoutToken || !params.payoutAddress) {
+        throw new Error(
+          "payoutChain, payoutToken, and payoutAddress are required"
+        );
+      }
+      return this.request(
+        "POST",
+        "/api/merchant/keys",
+        params
+      );
+    },
+    verify: async () => {
+      return this.request("GET", "/api/merchant/keys/verify");
+    }
+  };
+  checkout = {
+    create: async (params) => {
+      if (!params.amount) {
+        throw new Error("amount is required");
+      }
+      if (!params.currency) {
+        throw new Error("currency is required");
+      }
+      const amount = typeof params.amount === "number" ? params.amount.toString() : params.amount;
+      if (isNaN(parseFloat(amount)) || parseFloat(amount) <= 0) {
+        throw new Error("amount must be a positive number");
+      }
+      return this.request("POST", "/api/merchant/checkout", {
+        ...params,
+        amount
+      });
+    }
+  };
+  sessions = {
+    get: async (sessionId) => {
+      if (!sessionId) throw new Error("sessionId is required");
+      return this.request(
+        "GET",
+        `/api/merchant/session/${encodeURIComponent(sessionId)}`,
+        void 0,
+        false
+      );
+    },
+    getAssets: async (sessionId) => {
+      if (!sessionId) throw new Error("sessionId is required");
+      return this.request(
+        "GET",
+        `/api/merchant/session/${encodeURIComponent(sessionId)}/assets`,
+        void 0,
+        false
+      );
+    },
+    createQuote: async (sessionId, params) => {
+      if (!sessionId) throw new Error("sessionId is required");
+      if (!params.fromAsset) throw new Error("fromAsset is required");
+      return this.request(
+        "POST",
+        `/api/merchant/session/${encodeURIComponent(sessionId)}/quote`,
+        params,
+        false
+      );
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Payotex
+});

package/dist/index.d.cts

@@ -0,0 +1,120 @@
+interface PayotexConfig {
+    secretKey: string;
+    baseUrl?: string;
+}
+interface CreateKeysRequest {
+    payoutChain: string;
+    payoutToken: string;
+    payoutAddress: string;
+    payoutChain2?: string;
+    payoutToken2?: string;
+    payoutAddress2?: string;
+    label?: string;
+}
+interface CreateKeysResponse {
+    id: string;
+    secretKey: string;
+    publishableKey: string;
+    secretKeyPrefix: string;
+    publishableKeyPrefix: string;
+    payoutChain: string;
+    payoutToken: string;
+    payoutAddress: string;
+    payoutChain2?: string;
+    payoutToken2?: string;
+    payoutAddress2?: string;
+    configHash: string;
+    message: string;
+}
+interface VerifyKeyResponse {
+    id: string;
+    payoutChain: string;
+    payoutToken: string;
+    payoutAddress: string;
+    configHash: string;
+    configValid: boolean;
+    isActive: boolean;
+    createdAt: string;
+}
+interface CreateCheckoutSessionRequest {
+    amount: string | number;
+    currency: string;
+    metadata?: Record<string, any>;
+    expiresIn?: number;
+}
+interface CheckoutSession {
+    sessionId: string;
+    amount: string;
+    currency: string;
+    status: "pending" | "paid" | "expired";
+    expiresAt: string;
+}
+interface SessionDetails {
+    id: string;
+    amount: string;
+    currency: string;
+    status: "pending" | "paid" | "expired";
+    expiresAt: string;
+    payoutChain: string;
+    payoutChain2?: string;
+    payoutToken?: string;
+    payoutToken2?: string;
+    payotex_fee_percent: number;
+}
+interface SessionAsset {
+    chain: string;
+    asset: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    priceUsd?: number;
+}
+interface CreateQuoteRequest {
+    fromAsset: string;
+}
+interface SessionQuote {
+    inbound_address: string;
+    expected_amount_out: string;
+    expected_amount_in: string;
+    fees: {
+        total: string;
+        slippage_bps: number;
+    };
+    payotex_fee_percent: number;
+    expiry: number;
+    payout_chain: string;
+    payout_address: string;
+    from_asset: string;
+    to_asset: string;
+    session_id: string;
+    session_amount: string;
+    session_currency: string;
+    memo?: string;
+    total_swap_seconds?: number;
+    router?: string;
+}
+interface PayotexError {
+    error: string;
+    status: number;
+}
+
+declare class Payotex {
+    private secretKey;
+    private baseUrl;
+    constructor(config: PayotexConfig);
+    private request;
+    keys: {
+        create: (params: CreateKeysRequest) => Promise<CreateKeysResponse>;
+        verify: () => Promise<VerifyKeyResponse>;
+    };
+    checkout: {
+        create: (params: CreateCheckoutSessionRequest) => Promise<CheckoutSession>;
+    };
+    sessions: {
+        get: (sessionId: string) => Promise<SessionDetails>;
+        getAssets: (sessionId: string) => Promise<SessionAsset[]>;
+        createQuote: (sessionId: string, params: CreateQuoteRequest) => Promise<SessionQuote>;
+    };
+}
+
+export { type CheckoutSession, type CreateCheckoutSessionRequest, type CreateKeysRequest, type CreateKeysResponse, type CreateQuoteRequest, Payotex, type PayotexConfig, type PayotexError, type SessionAsset, type SessionDetails, type SessionQuote, type VerifyKeyResponse };

package/dist/index.d.ts

@@ -0,0 +1,120 @@
+interface PayotexConfig {
+    secretKey: string;
+    baseUrl?: string;
+}
+interface CreateKeysRequest {
+    payoutChain: string;
+    payoutToken: string;
+    payoutAddress: string;
+    payoutChain2?: string;
+    payoutToken2?: string;
+    payoutAddress2?: string;
+    label?: string;
+}
+interface CreateKeysResponse {
+    id: string;
+    secretKey: string;
+    publishableKey: string;
+    secretKeyPrefix: string;
+    publishableKeyPrefix: string;
+    payoutChain: string;
+    payoutToken: string;
+    payoutAddress: string;
+    payoutChain2?: string;
+    payoutToken2?: string;
+    payoutAddress2?: string;
+    configHash: string;
+    message: string;
+}
+interface VerifyKeyResponse {
+    id: string;
+    payoutChain: string;
+    payoutToken: string;
+    payoutAddress: string;
+    configHash: string;
+    configValid: boolean;
+    isActive: boolean;
+    createdAt: string;
+}
+interface CreateCheckoutSessionRequest {
+    amount: string | number;
+    currency: string;
+    metadata?: Record<string, any>;
+    expiresIn?: number;
+}
+interface CheckoutSession {
+    sessionId: string;
+    amount: string;
+    currency: string;
+    status: "pending" | "paid" | "expired";
+    expiresAt: string;
+}
+interface SessionDetails {
+    id: string;
+    amount: string;
+    currency: string;
+    status: "pending" | "paid" | "expired";
+    expiresAt: string;
+    payoutChain: string;
+    payoutChain2?: string;
+    payoutToken?: string;
+    payoutToken2?: string;
+    payotex_fee_percent: number;
+}
+interface SessionAsset {
+    chain: string;
+    asset: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    priceUsd?: number;
+}
+interface CreateQuoteRequest {
+    fromAsset: string;
+}
+interface SessionQuote {
+    inbound_address: string;
+    expected_amount_out: string;
+    expected_amount_in: string;
+    fees: {
+        total: string;
+        slippage_bps: number;
+    };
+    payotex_fee_percent: number;
+    expiry: number;
+    payout_chain: string;
+    payout_address: string;
+    from_asset: string;
+    to_asset: string;
+    session_id: string;
+    session_amount: string;
+    session_currency: string;
+    memo?: string;
+    total_swap_seconds?: number;
+    router?: string;
+}
+interface PayotexError {
+    error: string;
+    status: number;
+}
+
+declare class Payotex {
+    private secretKey;
+    private baseUrl;
+    constructor(config: PayotexConfig);
+    private request;
+    keys: {
+        create: (params: CreateKeysRequest) => Promise<CreateKeysResponse>;
+        verify: () => Promise<VerifyKeyResponse>;
+    };
+    checkout: {
+        create: (params: CreateCheckoutSessionRequest) => Promise<CheckoutSession>;
+    };
+    sessions: {
+        get: (sessionId: string) => Promise<SessionDetails>;
+        getAssets: (sessionId: string) => Promise<SessionAsset[]>;
+        createQuote: (sessionId: string, params: CreateQuoteRequest) => Promise<SessionQuote>;
+    };
+}
+
+export { type CheckoutSession, type CreateCheckoutSessionRequest, type CreateKeysRequest, type CreateKeysResponse, type CreateQuoteRequest, Payotex, type PayotexConfig, type PayotexError, type SessionAsset, type SessionDetails, type SessionQuote, type VerifyKeyResponse };

package/dist/index.js

@@ -0,0 +1,108 @@
+// packages/node/src/client.ts
+var DEFAULT_BASE_URL = "https://payotex.com";
+var Payotex = class {
+  secretKey;
+  baseUrl;
+  constructor(config) {
+    if (!config.secretKey) {
+      throw new Error("Payotex: secretKey is required");
+    }
+    if (!config.secretKey.startsWith("sk_live_")) {
+      throw new Error(
+        "Payotex: Invalid key format. Use your secret key (sk_live_...). Never use publishable keys (pk_live_) server-side."
+      );
+    }
+    this.secretKey = config.secretKey;
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  }
+  async request(method, path, body, auth = true) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (auth) {
+      headers["Authorization"] = `Bearer ${this.secretKey}`;
+    }
+    const url = `${this.baseUrl}${path}`;
+    const options = { method, headers };
+    if (body && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    const data = await response.json();
+    if (!response.ok) {
+      const err = new Error(data.error || `HTTP ${response.status}`);
+      err.status = response.status;
+      err.response = data;
+      throw err;
+    }
+    return data;
+  }
+  keys = {
+    create: async (params) => {
+      if (!params.payoutChain || !params.payoutToken || !params.payoutAddress) {
+        throw new Error(
+          "payoutChain, payoutToken, and payoutAddress are required"
+        );
+      }
+      return this.request(
+        "POST",
+        "/api/merchant/keys",
+        params
+      );
+    },
+    verify: async () => {
+      return this.request("GET", "/api/merchant/keys/verify");
+    }
+  };
+  checkout = {
+    create: async (params) => {
+      if (!params.amount) {
+        throw new Error("amount is required");
+      }
+      if (!params.currency) {
+        throw new Error("currency is required");
+      }
+      const amount = typeof params.amount === "number" ? params.amount.toString() : params.amount;
+      if (isNaN(parseFloat(amount)) || parseFloat(amount) <= 0) {
+        throw new Error("amount must be a positive number");
+      }
+      return this.request("POST", "/api/merchant/checkout", {
+        ...params,
+        amount
+      });
+    }
+  };
+  sessions = {
+    get: async (sessionId) => {
+      if (!sessionId) throw new Error("sessionId is required");
+      return this.request(
+        "GET",
+        `/api/merchant/session/${encodeURIComponent(sessionId)}`,
+        void 0,
+        false
+      );
+    },
+    getAssets: async (sessionId) => {
+      if (!sessionId) throw new Error("sessionId is required");
+      return this.request(
+        "GET",
+        `/api/merchant/session/${encodeURIComponent(sessionId)}/assets`,
+        void 0,
+        false
+      );
+    },
+    createQuote: async (sessionId, params) => {
+      if (!sessionId) throw new Error("sessionId is required");
+      if (!params.fromAsset) throw new Error("fromAsset is required");
+      return this.request(
+        "POST",
+        `/api/merchant/session/${encodeURIComponent(sessionId)}/quote`,
+        params,
+        false
+      );
+    }
+  };
+};
+export {
+  Payotex
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@payotex.com/node",
+  "version": "1.0.0",
+  "description": "Server-side SDK for Payotex crypto payment processing",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "node --experimental-vm-modules ../../node_modules/.bin/vitest run --config vitest.config.ts"
+  },
+  "keywords": ["payotex", "crypto", "payments", "checkout", "cross-chain", "swap", "bitcoin", "ethereum"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}