@caspay/sdk 1.0.4 → 1.1.1

package/dist/core/client.d.ts

@@ -1,14 +1,10 @@
 import type { CasPayConfig } from '../types';
-/**
- * HTTP Client for CasPay API
- * Handles all API requests with authentication and error handling
- */
 export declare class HttpClient {
     private readonly baseUrl;
     private apiKey;
     private merchantId;
-    private readonly SDK_VERSION;
     constructor(config: CasPayConfig);
     request<T>(method: string, path: string, body?: Record<string, any>): Promise<T>;
     getMerchantId(): string;
+    getBaseUrl(): string;
 }

package/dist/core/transfer.d.ts

@@ -0,0 +1,8 @@
+import type { Wallet } from '../resources/wallet';
+import type { TransferParams, TransferResult } from '../types';
+export declare class Transfer {
+    private wallet;
+    private apiBaseUrl;
+    constructor(wallet: Wallet, apiBaseUrl: string);
+    execute(params: TransferParams): Promise<TransferResult>;
+}

package/dist/index.d.ts

@@ -1,38 +1,17 @@
 import { Payments } from './resources/payments';
+import { Subscriptions } from './resources/subscriptions';
+import { Wallet } from './resources/wallet';
 import type { CasPayConfig } from './types';
-/**
- * CasPay SDK
- * Official JavaScript/TypeScript SDK for CasPay payment gateway
- *
- * @example
- * ```typescript
- * import CasPay from '@caspay/sdk';
- *
- * const caspay = new CasPay({
- *   apiKey: 'cp_live_...',
- *   merchantId: 'MERCH_...'
- * });
- *
- * const payment = await caspay.payments.create({
- *   senderAddress: '0x123...',
- *   productId: 'prod_abc',
- *   amount: 100
- * });
- * ```
- */
 export default class CasPay {
-    /** Payments resource for creating and managing payments */
     payments: Payments;
+    subscriptions: Subscriptions;
+    wallet: Wallet;
     private client;
-    /**
-     * Create a new CasPay SDK instance
-     * @param config - SDK configuration
-     */
+    private transfer;
+    private config;
     constructor(config: CasPayConfig);
-    /**
-     * Get SDK version
-     */
     static get version(): string;
+    getConfig(): CasPayConfig;
 }
 export { CasPay };
 export * from './types';

package/dist/index.esm.js

@@ -1,14 +1,12 @@
-/**
- * HTTP Client for CasPay API
- * Handles all API requests with authentication and error handling
- */
+import { PublicKey, ExecutableDeployItem, TransferDeployItem, DeployHeader, Deploy } from 'casper-js-sdk';
+
+const SDK_VERSION = '1.1.1';
+
 class HttpClient {
     constructor(config) {
-        this.baseUrl = 'https://caspay.link/api';
-        this.SDK_VERSION = '1.0.4';
         this.apiKey = config.apiKey;
         this.merchantId = config.merchantId;
-        // Validate required config
+        this.baseUrl = config.baseUrl || 'https://caspay.link/api';
         if (!this.apiKey) {
             throw new Error('CasPay SDK: apiKey is required');
         }
@@ -24,8 +22,8 @@ class HttpClient {
                 headers: {
                     'Content-Type': 'application/json',
                     'X-CasPay-Key': this.apiKey,
-                    'X-CasPay-SDK-Version': this.SDK_VERSION,
-                    'User-Agent': `CasPay-SDK-JS/${this.SDK_VERSION}`,
+                    'X-CasPay-SDK-Version': SDK_VERSION,
+                    'User-Agent': `CasPay-SDK-JS/${SDK_VERSION}`,
                 },
                 body: body ? JSON.stringify(body) : undefined,
             });
@@ -41,11 +39,9 @@ class HttpClient {
             return data;
         }
         catch (error) {
-            // Re-throw CasPay errors
             if (error.error && error.code) {
                 throw error;
             }
-            // Wrap network errors
             throw {
                 error: error.message || 'Network error',
                 code: 'NETWORK_ERROR',
@@ -56,35 +52,126 @@ class HttpClient {
     getMerchantId() {
         return this.merchantId;
     }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+}
+
+const CSPR_TO_MOTES = 1000000000;
+const DEFAULT_PAYMENT_AMOUNT = '100000000';
+class Transfer {
+    constructor(wallet, apiBaseUrl) {
+        this.wallet = wallet;
+        this.apiBaseUrl = apiBaseUrl;
+    }
+    async execute(params) {
+        const senderAddress = await this.wallet.getAddress();
+        if (!senderAddress) {
+            const error = {
+                code: 'WALLET_NOT_FOUND',
+                message: 'Please connect your wallet first.',
+            };
+            throw error;
+        }
+        const provider = this.wallet.getProvider();
+        if (!provider) {
+            const error = {
+                code: 'WALLET_NOT_FOUND',
+                message: 'Wallet provider not available.',
+            };
+            throw error;
+        }
+        const amountInMotes = Math.floor(params.amount * CSPR_TO_MOTES).toString();
+        const network = this.wallet.getNetwork();
+        const transferId = Date.now();
+        try {
+            const senderPublicKey = PublicKey.fromHex(senderAddress);
+            const recipientPublicKey = PublicKey.fromHex(params.recipientAddress);
+            const session = new ExecutableDeployItem();
+            session.transfer = TransferDeployItem.newTransfer(amountInMotes, recipientPublicKey, undefined, transferId);
+            const payment = ExecutableDeployItem.standardPayment(DEFAULT_PAYMENT_AMOUNT);
+            const deployHeader = DeployHeader.default();
+            deployHeader.account = senderPublicKey;
+            deployHeader.chainName = network;
+            const deploy = Deploy.makeDeploy(deployHeader, payment, session);
+            const deployJson = Deploy.toJSON(deploy);
+            const signResult = await provider.sign(JSON.stringify(deployJson), senderAddress);
+            if (signResult.cancelled) {
+                const error = {
+                    code: 'TRANSFER_REJECTED',
+                    message: 'Transfer was cancelled by the user.',
+                };
+                throw error;
+            }
+            const algorithmTag = senderAddress.substring(0, 2);
+            const signatureHex = typeof signResult.signature === 'string'
+                ? signResult.signature
+                : Array.from(signResult.signature)
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join('');
+            const signatureWithTag = algorithmTag + signatureHex;
+            const signedDeployJson = Deploy.toJSON(deploy);
+            signedDeployJson.approvals = [
+                {
+                    signer: senderAddress,
+                    signature: signatureWithTag,
+                },
+            ];
+            const isMainnet = network === 'casper';
+            const rpcProxyUrl = `${this.apiBaseUrl}/rpc`;
+            const response = await fetch(rpcProxyUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    deploy: signedDeployJson,
+                    network: isMainnet ? 'mainnet' : 'testnet',
+                }),
+            });
+            const result = await response.json();
+            if (!response.ok || result.error) {
+                throw new Error(result.error || 'RPC request failed');
+            }
+            const deployHash = result.deploy_hash;
+            return {
+                deployHash,
+                senderAddress,
+                recipientAddress: params.recipientAddress,
+                amount: params.amount,
+            };
+        }
+        catch (error) {
+            if (error.code === 'TRANSFER_REJECTED') {
+                throw error;
+            }
+            if (error.cancelled || error.code === 2 || error.message?.includes('rejected') || error.message?.includes('cancel')) {
+                const walletError = {
+                    code: 'TRANSFER_REJECTED',
+                    message: 'Transfer was cancelled by the user.',
+                };
+                throw walletError;
+            }
+            const walletError = {
+                code: 'NETWORK_ERROR',
+                message: error.message || 'Failed to execute transfer.',
+            };
+            throw walletError;
+        }
+    }
 }
 
-/**
- * Payments Resource
- * Handle payment creation and verification
- */
 class Payments {
     constructor(client) {
+        this.wallet = null;
+        this.transfer = null;
         this.client = client;
     }
-    /**
-     * Create a new payment record
-     *
-     * @param params - Payment parameters
-     * @returns Payment response with transaction details
-     * @throws {CasPayError} If payment creation fails
-     *
-     * @example
-     * ```typescript
-     * const payment = await caspay.payments.create({
-     *   senderAddress: '0x123...',
-     *   productId: 'prod_abc123',
-     *   amount: 100,
-     *   currency: 'USD'
-     * });
-     * ```
-     */
-    async create(params) {
-        // Validate required fields
+    setWallet(wallet, transfer) {
+        this.wallet = wallet;
+        this.transfer = transfer;
+    }
+    async recordPayment(params) {
         if (!params.senderAddress) {
             throw {
                 error: 'senderAddress is required',
@@ -117,42 +204,353 @@ class Payments {
         };
         return this.client.request('POST', '/v1/payments/record', payload);
     }
+    async recordSubscription(params) {
+        if (!params.subscriptionPlanId) {
+            throw {
+                error: 'subscriptionPlanId is required for subscription recording',
+                code: 'INVALID_PARAMS',
+                status: 400,
+            };
+        }
+        return this.recordPayment(params);
+    }
+    async makePayment(params) {
+        if (!this.wallet || !this.transfer) {
+            throw {
+                error: 'Wallet not initialized. Make sure to use the SDK in browser environment.',
+                code: 'WALLET_NOT_INITIALIZED',
+                status: 500,
+            };
+        }
+        if (!params.amount || params.amount <= 0) {
+            throw {
+                error: 'amount must be greater than 0',
+                code: 'INVALID_PARAMS',
+                status: 400,
+            };
+        }
+        if (!params.productId && !params.subscriptionPlanId) {
+            throw {
+                error: 'Either productId or subscriptionPlanId is required',
+                code: 'INVALID_PARAMS',
+                status: 400,
+            };
+        }
+        try {
+            const isConnected = await this.wallet.isConnected();
+            if (!isConnected) {
+                await this.wallet.connect();
+            }
+            const senderAddress = await this.wallet.getAddress();
+            if (!senderAddress) {
+                throw {
+                    error: 'Failed to get wallet address',
+                    code: 'WALLET_ERROR',
+                    status: 500,
+                };
+            }
+            const merchantWalletAddress = this.wallet.getMerchantWalletAddress();
+            const transferResult = await this.transfer.execute({
+                recipientAddress: merchantWalletAddress,
+                amount: params.amount
+            });
+            try {
+                const paymentRecord = await this.recordPayment({
+                    senderAddress: senderAddress,
+                    transactionHash: transferResult.deployHash,
+                    productId: params.productId,
+                    subscriptionPlanId: params.subscriptionPlanId,
+                    amount: params.amount,
+                    currency: params.currency || 'CSPR',
+                });
+                return {
+                    success: true,
+                    transactionHash: transferResult.deployHash,
+                    payment: paymentRecord,
+                };
+            }
+            catch (recordError) {
+                return {
+                    success: true,
+                    transactionHash: transferResult.deployHash,
+                    error: `Payment transferred but recording failed: ${recordError.error || recordError.message}`,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                transactionHash: '',
+                error: error.message || error.error || 'Payment failed',
+            };
+        }
+    }
+}
+
+class Subscriptions {
+    constructor(client) {
+        this.client = client;
+    }
+    async checkStatus(params) {
+        if (!params.subscriberAddress) {
+            throw {
+                error: 'subscriberAddress is required',
+                code: 'INVALID_PARAMS',
+                status: 400,
+            };
+        }
+        const merchantId = this.client.getMerchantId();
+        let url = `/v1/subscriptions/check/?merchant_id=${merchantId}&subscriber=${params.subscriberAddress}`;
+        if (params.planId) {
+            url += `&plan_id=${params.planId}`;
+        }
+        return this.client.request('GET', url);
+    }
+}
+
+const CASPER_WALLET_INSTALL_URL = 'https://www.casperwallet.io/';
+class Wallet {
+    constructor(config) {
+        this.provider = null;
+        this.connected = false;
+        this.activeAddress = null;
+        this.config = config;
+        this.initProvider();
+    }
+    initProvider() {
+        if (typeof window === 'undefined')
+            return;
+        const CasperWalletProvider = window.CasperWalletProvider;
+        if (CasperWalletProvider) {
+            this.provider = CasperWalletProvider({ timeout: 30 * 60 * 1000 });
+            this.setupEventListeners();
+        }
+    }
+    setupEventListeners() {
+        if (typeof window === 'undefined')
+            return;
+        window.addEventListener('casper-wallet:connected', (event) => {
+            try {
+                const state = JSON.parse(event.detail);
+                this.connected = true;
+                this.activeAddress = state.activeKey || null;
+            }
+            catch (e) {
+            }
+        });
+        window.addEventListener('casper-wallet:disconnected', () => {
+            this.connected = false;
+            this.activeAddress = null;
+        });
+        window.addEventListener('casper-wallet:activeKeyChanged', (event) => {
+            try {
+                const state = JSON.parse(event.detail);
+                this.activeAddress = state.activeKey || null;
+            }
+            catch (e) {
+            }
+        });
+        window.addEventListener('casper-wallet:locked', () => {
+            this.connected = false;
+        });
+        window.addEventListener('casper-wallet:unlocked', async () => {
+            if (this.provider) {
+                try {
+                    const isConnected = await this.provider.isConnected();
+                    this.connected = isConnected;
+                    if (isConnected) {
+                        this.activeAddress = await this.provider.getActivePublicKey();
+                    }
+                }
+                catch (e) {
+                }
+            }
+        });
+    }
+    isAvailable() {
+        return typeof window !== 'undefined' && !!window.CasperWalletProvider;
+    }
+    async isConnected() {
+        if (!this.provider) {
+            this.connected = false;
+            return false;
+        }
+        try {
+            const connected = await this.provider.isConnected();
+            this.connected = connected;
+            return connected;
+        }
+        catch (error) {
+            this.connected = false;
+            if (error.code === 1) {
+                return false;
+            }
+            return false;
+        }
+    }
+    async connect() {
+        if (!this.isAvailable()) {
+            const error = {
+                code: 'WALLET_NOT_FOUND',
+                message: 'Casper Wallet extension not found. Please install it first.',
+                installUrl: CASPER_WALLET_INSTALL_URL,
+            };
+            throw error;
+        }
+        if (!this.provider) {
+            this.initProvider();
+        }
+        if (!this.provider) {
+            const error = {
+                code: 'WALLET_NOT_FOUND',
+                message: 'Failed to initialize Casper Wallet provider.',
+                installUrl: CASPER_WALLET_INSTALL_URL,
+            };
+            throw error;
+        }
+        try {
+            const connected = await this.provider.requestConnection();
+            if (!connected) {
+                const error = {
+                    code: 'CONNECTION_REJECTED',
+                    message: 'Wallet connection was rejected by the user.',
+                };
+                throw error;
+            }
+            this.connected = true;
+            this.activeAddress = await this.provider.getActivePublicKey();
+            if (!this.activeAddress) {
+                const error = {
+                    code: 'UNKNOWN_ERROR',
+                    message: 'Failed to get wallet address after connection.',
+                };
+                throw error;
+            }
+            return this.activeAddress;
+        }
+        catch (error) {
+            if (error.code === 'CONNECTION_REJECTED') {
+                throw error;
+            }
+            if (error.code === 1) {
+                const walletError = {
+                    code: 'WALLET_LOCKED',
+                    message: 'Wallet is locked. Please unlock your Casper Wallet and try again.',
+                };
+                throw walletError;
+            }
+            const walletError = {
+                code: 'UNKNOWN_ERROR',
+                message: error.message || 'Failed to connect to wallet.',
+            };
+            throw walletError;
+        }
+    }
+    async disconnect() {
+        if (this.provider) {
+            try {
+                await this.provider.disconnectFromSite();
+            }
+            catch (e) {
+            }
+        }
+        this.connected = false;
+        this.activeAddress = null;
+    }
+    async getAddress() {
+        if (!this.provider) {
+            return null;
+        }
+        try {
+            const isConnected = await this.isConnected();
+            if (!isConnected) {
+                return null;
+            }
+            this.activeAddress = await this.provider.getActivePublicKey();
+            return this.activeAddress;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getInfo() {
+        return {
+            isConnected: this.connected,
+            address: this.activeAddress,
+        };
+    }
+    async getState() {
+        const connected = await this.isConnected();
+        const address = connected ? await this.getAddress() : null;
+        return {
+            connected,
+            address,
+            locked: !connected && this.isAvailable(),
+        };
+    }
+    getProvider() {
+        return this.provider;
+    }
+    getMerchantWalletAddress() {
+        return this.config.walletAddress;
+    }
+    getNetwork() {
+        return this.config.network === 'mainnet' ? 'casper' : 'casper-test';
+    }
+    async signDeploy(deploy) {
+        if (!this.provider) {
+            const error = {
+                code: 'WALLET_NOT_FOUND',
+                message: 'Casper Wallet not available.',
+                installUrl: CASPER_WALLET_INSTALL_URL,
+            };
+            throw error;
+        }
+        const isConnected = await this.isConnected();
+        if (!isConnected) {
+            await this.connect();
+        }
+        try {
+            const deployJson = JSON.stringify(deploy);
+            const signature = await this.provider.sign(deployJson, this.activeAddress);
+            return signature;
+        }
+        catch (error) {
+            if (error.code === 2 || error.message?.includes('rejected') || error.message?.includes('cancelled')) {
+                const walletError = {
+                    code: 'TRANSFER_REJECTED',
+                    message: 'Transaction was rejected by the user.',
+                };
+                throw walletError;
+            }
+            const walletError = {
+                code: 'UNKNOWN_ERROR',
+                message: error.message || 'Failed to sign deploy.',
+            };
+            throw walletError;
+        }
+    }
 }
 
-/**
- * CasPay SDK
- * Official JavaScript/TypeScript SDK for CasPay payment gateway
- *
- * @example
- * ```typescript
- * import CasPay from '@caspay/sdk';
- *
- * const caspay = new CasPay({
- *   apiKey: 'cp_live_...',
- *   merchantId: 'MERCH_...'
- * });
- *
- * const payment = await caspay.payments.create({
- *   senderAddress: '0x123...',
- *   productId: 'prod_abc',
- *   amount: 100
- * });
- * ```
- */
 class CasPay {
-    /**
-     * Create a new CasPay SDK instance
-     * @param config - SDK configuration
-     */
     constructor(config) {
+        if (!config.walletAddress) {
+            throw new Error('CasPay SDK: walletAddress is required');
+        }
+        this.config = config;
         this.client = new HttpClient(config);
+        this.wallet = new Wallet(config);
+        const apiBaseUrl = this.client.getBaseUrl();
+        this.transfer = new Transfer(this.wallet, apiBaseUrl);
         this.payments = new Payments(this.client);
+        this.payments.setWallet(this.wallet, this.transfer);
+        this.subscriptions = new Subscriptions(this.client);
     }
-    /**
-     * Get SDK version
-     */
     static get version() {
-        return '1.0.4';
+        return SDK_VERSION;
+    }
+    getConfig() {
+        return { ...this.config };
     }
 }