@eventop/sdk 1.0.0

package/README.md

@@ -0,0 +1,44 @@
+# Sdk for event api
+```javascript 
+import { Eventop } from '@eventop/sdk';
+
+// Initialize client
+const eventop = new Eventop({
+  apiKey: process.env.EVENTOP_API_KEY!, // sk_test_... or sk_live_...
+  // environment auto-detected from key prefix
+});
+
+// Create checkout session
+const session = await eventop.checkout.create({
+  planId: 'premium-monthly',
+  customerEmail: 'user@example.com',
+  customerId: 'user_123',
+  successUrl: 'https://yourdomain.com/success',
+  cancelUrl: 'https://yourdomain.com/pricing',
+  metadata: {
+    userId: '123',
+    source: 'web',
+  },
+});
+
+console.log('Checkout URL:', session.url);
+
+// Verify webhook
+app.post('/webhooks/eventop', express.raw({ type: 'application/json' }), (req, res) => {
+  const signature = req.headers['x-webhook-signature'] as string;
+  const payload = req.body.toString();
+
+  try {
+    const event = eventop.webhooks.constructEvent(
+      payload,
+      signature,
+      process.env.WEBHOOK_SECRET!,
+    );
+
+    console.log('Received event:', event.event);
+    res.json({ received: true });
+  } catch (err) {
+    res.status(400).send('Webhook signature verification failed');
+  }
+});
+```

package/package.json

@@ -0,0 +1,36 @@
+{
+ "name": "@eventop/sdk",
+ "version": "1.0.0",
+ "description": "Official SDK for Eventop on-chain subscriptions",
+ "keywords": [
+  "solana",
+  "subscriptions",
+  "crypto",
+  "payments"
+ ],
+ "homepage": "https://github.com/eventop-s/sdk#readme",
+ "bugs": {
+  "url": "https://github.com/eventop-s/sdk/issues"
+ },
+ "repository": {
+  "type": "git",
+  "url": "git+https://github.com/eventop-s/sdk.git"
+ },
+ "license": "MIT",
+ "author": "Eventop",
+ "type": "commonjs",
+ "main": "dist/index.js",
+ "types": "dist/index.d.ts",
+ "scripts": {
+  "build": "tsc",
+  "prepublishOnly": "npm run build"
+ },
+ "dependencies": {
+  "node-fetch": "^2.6.7"
+ },
+ "devDependencies": {
+  "@types/node": "^18.0.0",
+  "@types/node-fetch": "^2.6.2",
+  "typescript": "^5.0.0"
+ }
+}

package/src/client.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventopClient = void 0;
+var node_fetch_1 = require("node-fetch");
+var errors_1 = require("./errors");
+var EventopClient = /** @class */ (function () {
+    function EventopClient(config) {
+        this.apiKey = config.apiKey;
+        // Set base URL based on environment
+        if (config.apiUrl) {
+            this.baseUrl = config.apiUrl;
+        }
+        else {
+            var env = config.environment || this.detectEnvironment();
+            this.baseUrl =
+                env === 'devnet'
+                    ? 'https://api-devnet.eventop.xyz'
+                    : 'https://api.eventop.xyz';
+        }
+    }
+    EventopClient.prototype.detectEnvironment = function () {
+        // Detect from API key prefix
+        if (this.apiKey.startsWith('sk_test_')) {
+            return 'devnet';
+        }
+        else if (this.apiKey.startsWith('sk_live_')) {
+            return 'mainnet';
+        }
+        throw new errors_1.AuthenticationError('Invalid API key format');
+    };
+    EventopClient.prototype.request = function (method, path, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, headers, response, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "".concat(this.baseUrl).concat(path);
+                        headers = {
+                            'Authorization': "Bearer ".concat(this.apiKey),
+                            'Content-Type': 'application/json',
+                        };
+                        return [4 /*yield*/, (0, node_fetch_1.default)(url, {
+                                method: method,
+                                headers: headers,
+                                body: body ? JSON.stringify(body) : undefined,
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        data = _a.sent();
+                        if (!response.ok) {
+                            throw new errors_1.EventopError(data.message || 'Request failed', response.status, data.code);
+                        }
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    };
+    return EventopClient;
+}());
+exports.EventopClient = EventopClient;

package/src/client.ts

@@ -0,0 +1,64 @@
+import fetch from 'node-fetch';
+import { EventopConfig, Environment } from './types';
+import { EventopError, AuthenticationError } from './errors';
+
+export class EventopClient {
+  private apiKey: string;
+  private baseUrl: string;
+
+  constructor(config: EventopConfig) {
+    this.apiKey = config.apiKey;
+
+    // Set base URL based on environment
+    if (config.apiUrl) {
+      this.baseUrl = config.apiUrl;
+    } else {
+      const env = config.environment || this.detectEnvironment();
+      this.baseUrl =
+        env === 'devnet'
+          ? 'https://api-devnet.eventop.xyz'
+          : 'https://api.eventop.xyz';
+    }
+  }
+
+  private detectEnvironment(): Environment {
+    // Detect from API key prefix
+    if (this.apiKey.startsWith('sk_test_')) {
+      return 'devnet';
+    } else if (this.apiKey.startsWith('sk_live_')) {
+      return 'mainnet';
+    }
+    throw new AuthenticationError('Invalid API key format');
+  }
+
+  async request<T>(
+    method: string,
+    path: string,
+    body?: any,
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+
+    const headers: Record<string, string> = {
+      'Authorization': `Bearer ${this.apiKey}`,
+      'Content-Type': 'application/json',
+    };
+
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new EventopError(
+        data.message || 'Request failed',
+        response.status,
+        data.code,
+      );
+    }
+
+    return data as T;
+  }
+}

package/src/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.InvalidRequestError = exports.AuthenticationError = exports.EventopError = void 0;
+var EventopError = /** @class */ (function (_super) {
+    __extends(EventopError, _super);
+    function EventopError(message, statusCode, code) {
+        var _this = _super.call(this, message) || this;
+        _this.statusCode = statusCode;
+        _this.code = code;
+        _this.name = 'EventopError';
+        return _this;
+    }
+    return EventopError;
+}(Error));
+exports.EventopError = EventopError;
+var AuthenticationError = /** @class */ (function (_super) {
+    __extends(AuthenticationError, _super);
+    function AuthenticationError(message) {
+        if (message === void 0) { message = 'Invalid API key'; }
+        var _this = _super.call(this, message, 401, 'authentication_error') || this;
+        _this.name = 'AuthenticationError';
+        return _this;
+    }
+    return AuthenticationError;
+}(EventopError));
+exports.AuthenticationError = AuthenticationError;
+var InvalidRequestError = /** @class */ (function (_super) {
+    __extends(InvalidRequestError, _super);
+    function InvalidRequestError(message) {
+        var _this = _super.call(this, message, 400, 'invalid_request') || this;
+        _this.name = 'InvalidRequestError';
+        return _this;
+    }
+    return InvalidRequestError;
+}(EventopError));
+exports.InvalidRequestError = InvalidRequestError;
+var NotFoundError = /** @class */ (function (_super) {
+    __extends(NotFoundError, _super);
+    function NotFoundError(message) {
+        var _this = _super.call(this, message, 404, 'not_found') || this;
+        _this.name = 'NotFoundError';
+        return _this;
+    }
+    return NotFoundError;
+}(EventopError));
+exports.NotFoundError = NotFoundError;

package/src/errors.ts

@@ -0,0 +1,31 @@
+export class EventopError extends Error {
+  constructor(
+    message: string,
+    public statusCode?: number,
+    public code?: string,
+  ) {
+    super(message);
+    this.name = 'EventopError';
+  }
+}
+
+export class AuthenticationError extends EventopError {
+  constructor(message: string = 'Invalid API key') {
+    super(message, 401, 'authentication_error');
+    this.name = 'AuthenticationError';
+  }
+}
+
+export class InvalidRequestError extends EventopError {
+  constructor(message: string) {
+    super(message, 400, 'invalid_request');
+    this.name = 'InvalidRequestError';
+  }
+}
+
+export class NotFoundError extends EventopError {
+  constructor(message: string) {
+    super(message, 404, 'not_found');
+    this.name = 'NotFoundError';
+  }
+}

package/src/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Eventop = void 0;
+var client_1 = require("./client");
+var checkout_1 = require("./resources/checkout");
+var subscriptions_1 = require("./resources/subscriptions");
+var webhooks_1 = require("./resources/webhooks");
+var Eventop = /** @class */ (function () {
+    function Eventop(config) {
+        var client = new client_1.EventopClient(config);
+        this.checkout = new checkout_1.Checkout(client);
+        this.subscriptions = new subscriptions_1.Subscriptions(client);
+        this.webhooks = new webhooks_1.Webhooks(client);
+    }
+    return Eventop;
+}());
+exports.Eventop = Eventop;
+__exportStar(require("./types"), exports);
+__exportStar(require("./errors"), exports);

package/src/index.ts

@@ -0,0 +1,22 @@
+import { EventopClient } from './client';
+import { Checkout } from './resources/checkout';
+import { Subscriptions } from './resources/subscriptions';
+import { Webhooks } from './resources/webhooks';
+import { EventopConfig } from './types';
+
+export class Eventop {
+  public checkout: Checkout;
+  public subscriptions: Subscriptions;
+  public webhooks: Webhooks;
+
+  constructor(config: EventopConfig) {
+    const client = new EventopClient(config);
+
+    this.checkout = new Checkout(client);
+    this.subscriptions = new Subscriptions(client);
+    this.webhooks = new Webhooks(client);
+  }
+}
+
+export * from './types';
+export * from './errors';

package/src/resources/checkout.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checkout = void 0;
+var Checkout = /** @class */ (function () {
+    function Checkout(client) {
+        this.client = client;
+    }
+    Checkout.prototype.create = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.request('POST', '/checkout/create', params)];
+            });
+        });
+    };
+    Checkout.prototype.get = function (sessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.request('GET', "/checkout/".concat(sessionId))];
+            });
+        });
+    };
+    Checkout.prototype.cancel = function (sessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.request('POST', "/checkout/".concat(sessionId, "/cancel"))];
+            });
+        });
+    };
+    return Checkout;
+}());
+exports.Checkout = Checkout;

package/src/resources/checkout.ts

@@ -0,0 +1,22 @@
+import { EventopClient } from '../client';
+import { CheckoutSessionParams, CheckoutSession } from '../types';
+
+export class Checkout {
+  constructor(private client: EventopClient) {}
+
+  async create(params: CheckoutSessionParams): Promise<CheckoutSession> {
+    return this.client.request<CheckoutSession>(
+      'POST',
+      '/checkout/create',
+      params,
+    );
+  }
+
+  async get(sessionId: string): Promise<any> {
+    return this.client.request('GET', `/checkout/${sessionId}`);
+  }
+
+  async cancel(sessionId: string): Promise<any> {
+    return this.client.request('POST', `/checkout/${sessionId}/cancel`);
+  }
+}

package/src/resources/subscriptions.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscriptions = void 0;
+var Subscriptions = /** @class */ (function () {
+    function Subscriptions(client) {
+        this.client = client;
+    }
+    Subscriptions.prototype.list = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.request('GET', '/subscriptions')];
+            });
+        });
+    };
+    Subscriptions.prototype.get = function (subscriptionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.request('GET', "/subscriptions/".concat(subscriptionId))];
+            });
+        });
+    };
+    Subscriptions.prototype.cancel = function (subscriptionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.request('POST', "/subscriptions/".concat(subscriptionId, "/cancel"))];
+            });
+        });
+    };
+    return Subscriptions;
+}());
+exports.Subscriptions = Subscriptions;

package/src/resources/subscriptions.ts

@@ -0,0 +1,24 @@
+import { EventopClient } from '../client';
+import { Subscription } from '../types';
+
+export class Subscriptions {
+  constructor(private client: EventopClient) {}
+
+  async list(): Promise<Subscription[]> {
+    return this.client.request<Subscription[]>('GET', '/subscriptions');
+  }
+
+  async get(subscriptionId: string): Promise<Subscription> {
+    return this.client.request<Subscription>(
+      'GET',
+      `/subscriptions/${subscriptionId}`,
+    );
+  }
+
+  async cancel(subscriptionId: string): Promise<any> {
+    return this.client.request(
+      'POST',
+      `/subscriptions/${subscriptionId}/cancel`,
+    );
+  }
+}

package/src/resources/webhooks.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhooks = void 0;
+var crypto = require("crypto");
+var Webhooks = /** @class */ (function () {
+    function Webhooks(client) {
+        this.client = client;
+    }
+    Webhooks.prototype.verifySignature = function (payload, signature, secret) {
+        var payloadString = typeof payload === 'string' ? payload : JSON.stringify(payload);
+        var expectedSignature = crypto
+            .createHmac('sha256', secret)
+            .update(payloadString)
+            .digest('hex');
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+    };
+    Webhooks.prototype.constructEvent = function (payload, signature, secret) {
+        var payloadString = Buffer.isBuffer(payload)
+            ? payload.toString('utf8')
+            : payload;
+        if (!this.verifySignature(payloadString, signature, secret)) {
+            throw new Error('Invalid webhook signature');
+        }
+        return JSON.parse(payloadString);
+    };
+    return Webhooks;
+}());
+exports.Webhooks = Webhooks;

package/src/resources/webhooks.ts

@@ -0,0 +1,42 @@
+import * as crypto from 'crypto';
+import { EventopClient } from '../client';
+import { WebhookPayload } from '../types';
+
+export class Webhooks {
+  constructor(private client: EventopClient) {}
+
+  verifySignature(
+    payload: WebhookPayload | string,
+    signature: string,
+    secret: string,
+  ): boolean {
+    const payloadString =
+      typeof payload === 'string' ? payload : JSON.stringify(payload);
+
+    const expectedSignature = crypto
+      .createHmac('sha256', secret)
+      .update(payloadString)
+      .digest('hex');
+
+    return crypto.timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSignature),
+    );
+  }
+
+  constructEvent(
+    payload: string | Buffer,
+    signature: string,
+    secret: string,
+  ): WebhookPayload {
+    const payloadString = Buffer.isBuffer(payload)
+      ? payload.toString('utf8')
+      : payload;
+
+    if (!this.verifySignature(payloadString, signature, secret)) {
+      throw new Error('Invalid webhook signature');
+    }
+
+    return JSON.parse(payloadString);
+  }
+}

package/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/types.ts

@@ -0,0 +1,49 @@
+export type Environment = 'devnet' | 'mainnet';
+
+export interface EventopConfig {
+  apiKey: string;
+  environment?: Environment;
+  apiUrl?: string;
+}
+
+export interface CheckoutSessionParams {
+  planId: string;
+  customerEmail: string;
+  customerId?: string;
+  successUrl: string;
+  cancelUrl?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface CheckoutSession {
+  sessionId: string;
+  url: string;
+  expiresAt: string;
+}
+
+export interface Subscription {
+  subscriptionPda: string;
+  userWallet: string;
+  merchantWallet: string;
+  planId: string;
+  feeAmount: string;
+  paymentInterval: string;
+  isActive: boolean;
+  totalPaid: string;
+  paymentCount: number;
+  createdAt: string;
+  cancelledAt?: string;
+}
+
+export interface Customer {
+  email: string;
+  customerId?: string;
+  walletAddress: string;
+  subscriptions: Subscription[];
+}
+
+export interface WebhookPayload {
+  event: string;
+  timestamp: number;
+  data: any;
+}