@hackthedev/dsync-pay 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/.github/workflows/publish.yml

@@ -0,0 +1,43 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: true
+
+      - name: Skip version bump commits
+        run: |
+          if git log -1 --pretty=%B | grep -q "chore: bump version"; then
+            echo "Version bump commit detected, skipping."
+            exit 0
+          fi
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+
+      - run: npm ci
+
+      - run: |
+          git config user.name "github-actions"
+          git config user.email "actions@github.com"
+          npm version patch -m "chore: bump version %s"
+          git push
+
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+

package/README.md

@@ -0,0 +1,178 @@
+# dSyncPay
+
+As another part of the dSync library family this library is responsible for payment handling currently supporting PayPal and Coinbase Crypto payments. Its works independently and without any percentage cuts by using your own API keys.
+
+> [!NOTE]
+>
+> Payment Providers may take a cut from your money or have other fees that are outside of this library's control. 
+
+------
+
+## Setup
+```js
+import dSyncPay from '@hackthedev/dsync-pay';
+
+// const app = express();
+const payments = new dSyncPay({
+    app,
+    domain: 'https://domain.com',
+    basePath: '/payments', // optional, default is '/payments'
+    paypal: {
+        clientId: 'xxx',
+        clientSecret: 'xxx',
+        sandbox: true // or false for production
+    },
+    coinbase: {
+        apiKey: 'xxx',
+        webhookSecret: 'xxx' // optional
+    },
+    
+    // events from the library
+    onPaymentCreated: (data) => {},
+    onPaymentCompleted: (data) => {},
+    onPaymentFailed: (data) => {},
+    onPaymentCancelled: (data) => {},
+    onSubscriptionCreated: (data) => {},
+    onSubscriptionActivated: (data) => {},
+    onSubscriptionCancelled: (data) => {},
+    onError: (error) => {}
+});
+```
+
+------
+
+## PayPal Usage
+
+### Create an order
+
+```js
+// returnUrl and cancelUrl are auto-generated based on domain + basePath
+const payment = await payments.paypal.createOrder({
+    title: 'product name',
+    price: 19.99
+    // returnUrl automatically becomes https://domain.com/payments/paypal/verify
+    // cancelUrl will become https://domain.com/payments/cancel
+});
+
+// or override manually
+const payment = await payments.paypal.createOrder({
+    title: 'product name',
+    price: 19.99,
+    returnUrl: 'https://custom.com/success',
+    cancelUrl: 'https://custom.com/cancel',
+    metadata: { userId: '123' }
+});
+
+// manual verify. result.status === 'COMPLETED'. see paypal api.
+const result = await payments.paypal.verifyOrder(orderId);
+```
+
+### Managing subscriptions
+
+```js
+// requires you to setup a plan one time
+const plan = await payments.paypal.createPlan({
+    name: 'monthly premium',
+    price: 9.99,
+    interval: 'MONTH'
+});	
+// save plan.planId
+
+// then you can create subscriptions based on that plan
+const sub = await payments.paypal.createSubscription({
+    planId: 'P-xxxxx'
+    // returnUrl becomes https://domain.com/payments/paypal/subscription/verify
+    // cancelUrl becomes https://domain.com/payments/cancel
+});
+
+// or override manually
+const sub = await payments.paypal.createSubscription({
+    planId: 'P-xxxxx',
+    returnUrl: 'https://custom.com/success',
+    cancelUrl: 'https://custom.com/cancel'
+});
+
+// redirect to sub.approvalUrl
+// also returns sub.subscriptionId
+
+// manually verify subscription
+const result = await payments.paypal.verifySubscription(subscriptionId);
+// result.status === 'ACTIVE'
+
+// cancel subscription
+await payments.paypal.cancelSubscription(subscriptionId, 'reason');
+```
+
+------
+
+## Coinbase Usage
+
+### Creating a charge
+
+```js
+// redirectUrl and cancelUrl are auto-generated
+const charge = await payments.coinbase.createCharge({
+    title: 'product name',
+    price: 19.99
+    // redirectUrl becomes  https://domain.com/payments/coinbase/verify
+    // cancelUrl becomes https://domain.com/payments/cancel
+});
+
+// or override manually
+const charge = await payments.coinbase.createCharge({
+    title: 'product name',
+    price: 19.99,
+    redirectUrl: 'https://custom.com/success',
+    cancelUrl: 'https://custom.com/cancel',
+    metadata: { userId: '123' }
+});
+
+// redirect to: charge.hostedUrl
+
+// manually verify
+const result = await payments.coinbase.verifyCharge(chargeCode);
+// result.status === 'COMPLETED'
+```
+
+------
+
+## Routes
+
+dSyncPay automatically creates verification routes for handling payment returns as well to make the entire payment process as simple and straight forward as possible.
+
+### PayPal
+* `GET /payments/paypal/verify?token=xxx`
+* `GET /payments/paypal/subscription/verify?subscription_id=xxx`
+* `GET /payments/cancel`
+
+### Coinbase
+* `GET /payments/coinbase/verify?code=xxx`
+* `POST /payments/webhook/coinbase` (if webhookSecret set)
+* `GET /payments/cancel`
+
+### Usage Example
+
+```javascript
+const order = await payments.paypal.createOrder({
+    title: 'premium plan',
+    price: 19.99
+});
+
+// redirect user to order.approvalUrl
+// paypal redirects back to /payments/paypal/verify?token=XXX
+// route automatically verifies and triggers onPaymentCompleted
+```
+
+### Custom Base Path
+
+```javascript
+const payments = new dSyncPay({
+    app,
+    domain: 'https://domain.com',
+    basePath: '/api/pay', // default is '/payments'
+    paypal: { ... }
+});
+
+// routes: /api/pay/paypal/verify, /api/pay/coinbase/verify, etc.
+// auto urls: https://domain.com/api/pay/paypal/verify
+```

package/index.mjs

@@ -0,0 +1,755 @@
+import crypto from "crypto";
+
+export default class dSyncPay {
+    constructor({
+                    app = null,
+                    domain = null,
+                    basePath = '/payments',
+                    paypal = null,
+                    coinbase = null,
+                    onPaymentCreated = null,
+                    onPaymentCompleted = null,
+                    onPaymentFailed = null,
+                    onPaymentCancelled = null,
+                    onSubscriptionCreated = null,
+                    onSubscriptionActivated = null,
+                    onSubscriptionCancelled = null,
+                    onError = null
+                } = {}) {
+        if (!app) throw new Error("missing express app instance");
+        if (!domain) throw new Error("missing domain");
+
+        this.app = app;
+        this.domain = domain.endsWith('/') ? domain.slice(0, -1) : domain;
+        this.basePath = basePath;
+
+        this.callbacks = {
+            onPaymentCreated,
+            onPaymentCompleted,
+            onPaymentFailed,
+            onPaymentCancelled,
+            onSubscriptionCreated,
+            onSubscriptionActivated,
+            onSubscriptionCancelled,
+            onError
+        };
+
+        if (paypal) {
+            if (!paypal.clientId) throw new Error("missing paypal.clientId");
+            if (!paypal.clientSecret) throw new Error("missing paypal.clientSecret");
+            this.paypal = new this.PayPal(this, paypal);
+        }
+
+        if (coinbase) {
+            if (!coinbase.apiKey) throw new Error("missing coinbase.apiKey");
+            this.coinbase = new this.Coinbase(this, coinbase);
+        }
+
+        this.registerRoutes(basePath);
+    }
+
+    getUrl(path) {
+        return `${this.domain}${this.basePath}${path}`;
+    }
+
+    emit(event, data) {
+        const callback = this.callbacks[event];
+        if (callback) {
+            try {
+                callback(data);
+            } catch (err) {
+                console.error("callback error:", err);
+            }
+        }
+    }
+
+    generateId(length = 17) {
+        let id = '';
+        for (let i = 0; i < length; i++) {
+            id += Math.floor(Math.random() * 10);
+        }
+        return id;
+    }
+
+    sha256(data) {
+        return crypto.createHash("sha256").update(data).digest("hex");
+    }
+
+    async request(url, options = {}) {
+        const {
+            method = 'GET',
+            headers = {},
+            body = null,
+            auth = null,
+            params = null
+        } = options;
+
+        let finalUrl = url;
+        if (params) {
+            const query = new URLSearchParams(params).toString();
+            finalUrl = `${url}?${query}`;
+        }
+
+        const fetchOptions = {
+            method,
+            headers: {...headers}
+        };
+
+        if (auth) {
+            const credentials = Buffer.from(`${auth.username}:${auth.password}`).toString('base64');
+            fetchOptions.headers['Authorization'] = `Basic ${credentials}`;
+        }
+
+        if (body) {
+            fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+            if (!fetchOptions.headers['Content-Type']) {
+                fetchOptions.headers['Content-Type'] = 'application/json';
+            }
+        }
+
+        const response = await fetch(finalUrl, fetchOptions);
+        const text = await response.text();
+
+        if (!response.ok) {
+            const error = new Error(`http error: ${response.status}`);
+            error.status = response.status;
+            error.response = text ? JSON.parse(text) : null;
+            throw error;
+        }
+
+        return text ? JSON.parse(text) : null;
+    }
+
+    PayPal = class {
+        constructor(parent, config) {
+            this.parent = parent;
+            this.config = config;
+            this.baseUrl = config.sandbox
+                ? 'https://api-m.sandbox.paypal.com'
+                : 'https://api-m.paypal.com';
+            this.tokenCache = null;
+            this.tokenExpiry = null;
+        }
+
+        async getAccessToken() {
+            if (this.tokenCache && this.tokenExpiry > Date.now()) {
+                return this.tokenCache;
+            }
+
+            try {
+                const response = await this.parent.request(
+                    `${this.baseUrl}/v1/oauth2/token`,
+                    {
+                        method: 'POST',
+                        auth: {
+                            username: this.config.clientId,
+                            password: this.config.clientSecret
+                        },
+                        params: {
+                            grant_type: 'client_credentials'
+                        },
+                        headers: {
+                            "Accept": "application/json",
+                            "Accept-Language": "en_US"
+                        }
+                    }
+                );
+
+                this.tokenCache = response.access_token;
+                this.tokenExpiry = Date.now() + (60 * 60 * 1000);
+                return this.tokenCache;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'auth',
+                    provider: 'paypal',
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        async createOrder({
+                              title,
+                              description = 'no description',
+                              price,
+                              quantity = 1,
+                              currency = 'EUR',
+                              returnUrl = this.parent.getUrl('/paypal/verify'),
+                              cancelUrl = this.parent.getUrl('/cancel'),
+                              customId = this.parent.generateId(),
+                              metadata = {}
+                          }) {
+            if (!title) throw new Error('missing title');
+            if (!price) throw new Error('missing price');
+
+            const accessToken = await this.getAccessToken();
+            const totalAmount = (price * quantity).toFixed(2);
+
+            const orderPayload = {
+                intent: "CAPTURE",
+                purchase_units: [{
+                    amount: {
+                        currency_code: currency,
+                        value: totalAmount,
+                        breakdown: {
+                            item_total: {
+                                currency_code: currency,
+                                value: totalAmount
+                            }
+                        }
+                    },
+                    items: [{
+                        name: title,
+                        description: description,
+                        unit_amount: {
+                            currency_code: currency,
+                            value: price.toFixed(2)
+                        },
+                        quantity: `${quantity}`
+                    }],
+                    custom_id: customId
+                }],
+                application_context: {
+                    return_url: returnUrl,
+                    cancel_url: cancelUrl
+                }
+            };
+
+            try {
+                const response = await this.parent.request(
+                    `${this.baseUrl}/v2/checkout/orders`,
+                    {
+                        method: 'POST',
+                        headers: {
+                            "Content-Type": "application/json",
+                            "Authorization": `Bearer ${accessToken}`
+                        },
+                        body: orderPayload
+                    }
+                );
+
+                const approvalUrl = response.links.find(link => link.rel === "approve").href;
+
+                const result = {
+                    provider: 'paypal',
+                    type: 'order',
+                    approvalUrl,
+                    transactionId: customId,
+                    orderId: response.id,
+                    amount: parseFloat(totalAmount),
+                    currency,
+                    metadata,
+                    rawResponse: response
+                };
+
+                this.parent.emit('onPaymentCreated', result);
+                return result;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'order_creation',
+                    provider: 'paypal',
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        async verifyOrder(orderId) {
+            const accessToken = await this.getAccessToken();
+
+            try {
+                const orderResponse = await this.parent.request(
+                    `${this.baseUrl}/v2/checkout/orders/${orderId}`,
+                    {
+                        headers: {
+                            "Authorization": `Bearer ${accessToken}`
+                        }
+                    }
+                );
+
+                const orderStatus = orderResponse.status;
+
+                if (orderStatus === "APPROVED") {
+                    await this.parent.request(
+                        `${this.baseUrl}/v2/checkout/orders/${orderId}/capture`,
+                        {
+                            method: 'POST',
+                            headers: {
+                                "Authorization": `Bearer ${accessToken}`
+                            },
+                            body: {}
+                        }
+                    );
+                }
+
+                const purchaseUnit = orderResponse.purchase_units[0];
+
+                const result = {
+                    provider: 'paypal',
+                    type: 'order',
+                    status: orderStatus,
+                    transactionId: purchaseUnit.custom_id,
+                    orderId: orderResponse.id,
+                    amount: parseFloat(purchaseUnit.amount.value),
+                    currency: purchaseUnit.amount.currency_code,
+                    rawResponse: orderResponse
+                };
+
+                if (orderStatus === 'COMPLETED') {
+                    this.parent.emit('onPaymentCompleted', result);
+                } else if (orderStatus === 'VOIDED') {
+                    this.parent.emit('onPaymentCancelled', result);
+                }
+
+                return result;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'order_verification',
+                    provider: 'paypal',
+                    orderId,
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        async createProduct(name, description) {
+            const accessToken = await this.getAccessToken();
+
+            const productData = {
+                name: name,
+                description: description || name,
+                type: "SERVICE",
+                category: "SOFTWARE"
+            };
+
+            const response = await this.parent.request(
+                `${this.baseUrl}/v1/catalogs/products`,
+                {
+                    method: 'POST',
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Authorization": `Bearer ${accessToken}`
+                    },
+                    body: productData
+                }
+            );
+
+            return response.id;
+        }
+
+        async createPlan({
+                             name,
+                             description,
+                             price,
+                             currency = 'EUR',
+                             interval = 'MONTH',
+                             frequency = 1
+                         }) {
+            if (!name) throw new Error('missing name');
+            if (!price) throw new Error('missing price');
+
+            const accessToken = await this.getAccessToken();
+            const productId = await this.createProduct(name, description);
+
+            const planData = {
+                product_id: productId,
+                name: name,
+                description: description || name,
+                billing_cycles: [{
+                    frequency: {
+                        interval_unit: interval,
+                        interval_count: frequency
+                    },
+                    tenure_type: "REGULAR",
+                    sequence: 1,
+                    total_cycles: 0,
+                    pricing_scheme: {
+                        fixed_price: {
+                            value: price.toFixed(2),
+                            currency_code: currency
+                        }
+                    }
+                }],
+                payment_preferences: {
+                    auto_bill_outstanding: true,
+                    payment_failure_threshold: 3
+                }
+            };
+
+            try {
+                const response = await this.parent.request(
+                    `${this.baseUrl}/v1/billing/plans`,
+                    {
+                        method: 'POST',
+                        headers: {
+                            "Content-Type": "application/json",
+                            "Authorization": `Bearer ${accessToken}`
+                        },
+                        body: planData
+                    }
+                );
+
+                return {
+                    provider: 'paypal',
+                    type: 'subscription_plan',
+                    planId: response.id,
+                    name,
+                    price: parseFloat(price),
+                    currency,
+                    interval,
+                    frequency,
+                    rawResponse: response
+                };
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'plan_creation',
+                    provider: 'paypal',
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        async createSubscription({
+                                     planId,
+                                     returnUrl = this.parent.getUrl('/paypal/subscription/verify'),
+                                     cancelUrl = this.parent.getUrl('/cancel'),
+                                     customId = this.parent.generateId(),
+                                     metadata = {}
+                                 }) {
+            if (!planId) throw new Error('missing planId');
+
+            const accessToken = await this.getAccessToken();
+
+            const subscriptionData = {
+                plan_id: planId,
+                custom_id: customId,
+                application_context: {
+                    return_url: returnUrl,
+                    cancel_url: cancelUrl
+                }
+            };
+
+            try {
+                const response = await this.parent.request(
+                    `${this.baseUrl}/v1/billing/subscriptions`,
+                    {
+                        method: 'POST',
+                        headers: {
+                            "Content-Type": "application/json",
+                            "Authorization": `Bearer ${accessToken}`
+                        },
+                        body: subscriptionData
+                    }
+                );
+
+                const approvalUrl = response.links.find(link => link.rel === "approve").href;
+
+                const result = {
+                    provider: 'paypal',
+                    type: 'subscription',
+                    approvalUrl,
+                    transactionId: customId,
+                    subscriptionId: response.id,
+                    planId,
+                    metadata,
+                    rawResponse: response
+                };
+
+                this.parent.emit('onSubscriptionCreated', result);
+                return result;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'subscription_creation',
+                    provider: 'paypal',
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        async verifySubscription(subscriptionId) {
+            const accessToken = await this.getAccessToken();
+
+            try {
+                const response = await this.parent.request(
+                    `${this.baseUrl}/v1/billing/subscriptions/${subscriptionId}`,
+                    {
+                        headers: {
+                            "Authorization": `Bearer ${accessToken}`
+                        }
+                    }
+                );
+
+                const result = {
+                    provider: 'paypal',
+                    type: 'subscription',
+                    status: response.status,
+                    subscriptionId: response.id,
+                    planId: response.plan_id,
+                    customId: response.custom_id,
+                    rawResponse: response
+                };
+
+                if (response.status === 'ACTIVE') {
+                    this.parent.emit('onSubscriptionActivated', result);
+                } else if (response.status === 'CANCELLED') {
+                    this.parent.emit('onSubscriptionCancelled', result);
+                }
+
+                return result;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'subscription_verification',
+                    provider: 'paypal',
+                    subscriptionId,
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        async cancelSubscription(subscriptionId, reason = 'customer request') {
+            const accessToken = await this.getAccessToken();
+
+            try {
+                await this.parent.request(
+                    `${this.baseUrl}/v1/billing/subscriptions/${subscriptionId}/cancel`,
+                    {
+                        method: 'POST',
+                        headers: {
+                            "Content-Type": "application/json",
+                            "Authorization": `Bearer ${accessToken}`
+                        },
+                        body: {reason}
+                    }
+                );
+
+                const result = {
+                    provider: 'paypal',
+                    type: 'subscription',
+                    subscriptionId,
+                    status: 'CANCELLED',
+                    reason
+                };
+
+                this.parent.emit('onSubscriptionCancelled', result);
+                return result;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'subscription_cancellation',
+                    provider: 'paypal',
+                    subscriptionId,
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+    }
+
+    Coinbase = class {
+        constructor(parent, config) {
+            this.parent = parent;
+            this.config = config;
+            this.baseUrl = 'https://api.commerce.coinbase.com';
+        }
+
+        async createCharge({
+                               title,
+                               description = 'no description',
+                               price,
+                               quantity = 1,
+                               currency = 'EUR',
+                               redirectUrl = this.parent.getUrl('/coinbase/verify'),
+                               cancelUrl = this.parent.getUrl('/cancel'),
+                               metadata = {}
+                           }) {
+            if (!title) throw new Error('missing title');
+            if (!price) throw new Error('missing price');
+
+            const totalAmount = (price * quantity).toFixed(2);
+
+            const chargeData = {
+                name: title,
+                description: description,
+                pricing_type: "fixed_price",
+                metadata: metadata,
+                local_price: {
+                    amount: totalAmount,
+                    currency: currency
+                },
+                redirect_url: redirectUrl,
+                cancel_url: cancelUrl
+            };
+
+            try {
+                const response = await this.parent.request(
+                    `${this.baseUrl}/charges`,
+                    {
+                        method: 'POST',
+                        headers: {
+                            "Content-Type": "application/json",
+                            "X-CC-Api-Key": this.config.apiKey,
+                            "X-CC-Version": "2018-03-22"
+                        },
+                        body: chargeData
+                    }
+                );
+
+                const charge = response.data;
+
+                const result = {
+                    provider: 'coinbase',
+                    type: 'charge',
+                    hostedUrl: charge.hosted_url,
+                    chargeId: charge.id,
+                    chargeCode: charge.code,
+                    amount: parseFloat(totalAmount),
+                    currency,
+                    metadata,
+                    rawResponse: charge
+                };
+
+                this.parent.emit('onPaymentCreated', result);
+                return result;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'charge_creation',
+                    provider: 'coinbase',
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        async verifyCharge(chargeId) {
+            try {
+                const response = await this.parent.request(
+                    `${this.baseUrl}/charges/${chargeId}`,
+                    {
+                        headers: {
+                            "Content-Type": "application/json",
+                            "X-CC-Api-Key": this.config.apiKey,
+                            "X-CC-Version": "2018-03-22"
+                        }
+                    }
+                );
+
+                const charge = response.data;
+                const latestStatus = charge.timeline[charge.timeline.length - 1]?.status;
+
+                const result = {
+                    provider: 'coinbase',
+                    type: 'charge',
+                    status: latestStatus,
+                    chargeId: charge.id,
+                    chargeCode: charge.code,
+                    amount: parseFloat(charge.pricing.local.amount),
+                    currency: charge.pricing.local.currency,
+                    metadata: charge.metadata,
+                    rawResponse: charge
+                };
+
+                if (latestStatus === 'COMPLETED') {
+                    this.parent.emit('onPaymentCompleted', result);
+                } else if (latestStatus === 'CANCELED') {
+                    this.parent.emit('onPaymentCancelled', result);
+                } else if (latestStatus === 'EXPIRED' || latestStatus === 'UNRESOLVED') {
+                    this.parent.emit('onPaymentFailed', result);
+                }
+
+                return result;
+            } catch (error) {
+                this.parent.emit('onError', {
+                    type: 'charge_verification',
+                    provider: 'coinbase',
+                    chargeId,
+                    error: error.response || error.message
+                });
+                throw error;
+            }
+        }
+
+        verifyWebhook(payload, signature, secret) {
+            const hmac = crypto.createHmac('sha256', secret);
+            hmac.update(payload);
+            const computedSignature = hmac.digest('hex');
+            return computedSignature === signature;
+        }
+    }
+
+    registerRoutes(basePath = '/payments') {
+        if (this.paypal) {
+            this.app.get(`${basePath}/paypal/verify`, async (req, res) => {
+                try {
+                    const orderId = req.query.token;
+                    if (!orderId) return res.status(400).json({ok: false, error: 'missing_token'});
+
+                    const result = await this.paypal.verifyOrder(orderId);
+                    res.json({ok: true, ...result});
+                } catch (error) {
+                    res.status(500).json({ok: false, error: error.message});
+                }
+            });
+
+            this.app.get(`${basePath}/paypal/subscription/verify`, async (req, res) => {
+                try {
+                    const subscriptionId = req.query.subscription_id;
+                    if (!subscriptionId) return res.status(400).json({ok: false, error: 'missing_subscription_id'});
+
+                    const result = await this.paypal.verifySubscription(subscriptionId);
+                    res.json({ok: true, ...result});
+                } catch (error) {
+                    res.status(500).json({ok: false, error: error.message});
+                }
+            });
+
+            this.app.get(`${basePath}/cancel`, async (req, res) => {
+                res.send('payment cancelled');
+            });
+        }
+
+        if (this.coinbase) {
+            this.app.get(`${basePath}/coinbase/verify`, async (req, res) => {
+                try {
+                    const chargeCode = req.query.code;
+                    if (!chargeCode) return res.status(400).json({ok: false, error: 'missing_code'});
+
+                    const result = await this.coinbase.verifyCharge(chargeCode);
+                    res.json({ok: true, ...result});
+                } catch (error) {
+                    res.status(500).json({ok: false, error: error.message});
+                }
+            });
+
+            if (this.coinbase.config.webhookSecret) {
+                this.app.post(`${basePath}/webhook/coinbase`, async (req, res) => {
+                    try {
+                        const signature = req.headers['x-cc-webhook-signature'];
+                        const isValid = this.coinbase.verifyWebhook(
+                            JSON.stringify(req.body),
+                            signature,
+                            this.coinbase.config.webhookSecret
+                        );
+
+                        if (!isValid) return res.status(401).json({ok: false, error: 'invalid_signature'});
+
+                        const event = req.body;
+
+                        if (event.event.type === 'charge:confirmed') {
+                            const chargeId = event.event.data.id;
+                            const result = await this.coinbase.verifyCharge(chargeId);
+                        }
+
+                        res.status(200).json({ok: true});
+                    } catch (error) {
+                        res.status(500).json({ok: false, error: 'webhook_error'});
+                    }
+                });
+            }
+        }
+
+        return this;
+    }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@hackthedev/dsync-pay",
+  "version": "1.0.0",
+  "description": "As another part of the dSync library family this library is responsible for payment handling currently supporting PayPal and Coinbase Crypto payments. Its works independently and without any percentage cuts by using your own API keys.",
+  "homepage": "https://github.com/NETWORK-Z-Dev/dSyncPay#readme",
+  "bugs": {
+    "url": "https://github.com/NETWORK-Z-Dev/dSyncPay/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NETWORK-Z-Dev/dSyncPay.git"
+  },
+  "license": "ISC",
+  "author": "",
+  "main": "index.mjs",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}