paytonz-node-api-sdk 1.0.0

package/lib/CpaySDK.d.ts

@@ -0,0 +1,30 @@
+import { Auth } from "./auth/auth";
+import Checkout from "./checkout/checkout";
+import { Client } from "./client/client";
+import { CpaySDKBaseOptions } from "./CpaySDKBase";
+import { Currency } from "./currency/currency";
+import External from "./external/external";
+import { Multisend } from "./multisend/multisend";
+import { Swap } from "./swap/swap";
+import Transaction from "./transaction/transaction";
+import { Wallet } from "./wallet/wallet";
+import { Withdrawal } from "./withdrawal/withdrawal";
+export interface CpaySDKOptions extends CpaySDKBaseOptions {
+}
+export declare class CpaySDK {
+    /**
+     * @param parameters
+     */
+    constructor(parameters: CpaySDKOptions);
+    wallet: Wallet;
+    currency: Currency;
+    withdrawal: Withdrawal;
+    multisend: Multisend;
+    checkout: Checkout;
+    transaction: Transaction;
+    externalCall: External;
+    auth: Auth;
+    swap: Swap;
+    client: Client;
+}
+export default CpaySDK;

package/lib/CpaySDK.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CpaySDK = void 0;
+const auth_1 = require("./auth/auth");
+const checkout_1 = __importDefault(require("./checkout/checkout"));
+const client_1 = require("./client/client");
+const currency_1 = require("./currency/currency");
+const external_1 = __importDefault(require("./external/external"));
+const multisend_1 = require("./multisend/multisend");
+const swap_1 = require("./swap/swap");
+const transaction_1 = __importDefault(require("./transaction/transaction"));
+const wallet_1 = require("./wallet/wallet");
+const withdrawal_1 = require("./withdrawal/withdrawal");
+class CpaySDK {
+    /**
+     * @param parameters
+     */
+    constructor(parameters) {
+        this.wallet = new wallet_1.Wallet(parameters);
+        this.currency = new currency_1.Currency(parameters);
+        this.withdrawal = new withdrawal_1.Withdrawal(parameters);
+        this.multisend = new multisend_1.Multisend(parameters);
+        this.checkout = new checkout_1.default(parameters);
+        this.transaction = new transaction_1.default(parameters);
+        this.externalCall = new external_1.default(parameters);
+        this.auth = new auth_1.Auth(parameters);
+        this.swap = new swap_1.Swap(parameters);
+        this.client = new client_1.Client(parameters);
+    }
+}
+exports.CpaySDK = CpaySDK;
+exports.default = CpaySDK;

package/lib/CpaySDKBase.d.ts

@@ -0,0 +1,30 @@
+import { CpayToken } from "./interfaces/cpay.interface";
+import { Options as HttpOptions } from "./utils/httpClient";
+export interface CpaySDKBaseOptions {
+    publicKey?: string;
+    privateKey?: string;
+    walletId?: string;
+    passphrase?: string;
+    errLogger?: (mssage: string, ...arg: any[]) => void;
+    outLogger?: (mssage: string, ...arg: any[]) => void;
+    httpOptions?: HttpOptions;
+    url?: {
+        rest?: string;
+    };
+}
+export declare class CpaySDKBase {
+    protected options: Required<CpaySDKBaseOptions>;
+    constructor(options?: Partial<CpaySDKBaseOptions>);
+    protected setOptions(options?: Partial<CpaySDKBaseOptions>): void;
+    protected _request: <T>(path: string, options: HttpOptions) => Promise<T>;
+    protected request: <T>(path: string, options: HttpOptions) => Promise<T>;
+    protected auth_get: <T = any>(path: string, params: Record<string, any>, token: string) => Promise<T>;
+    protected auth_post: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected post: <T = any>(path: string, data: Record<string, any>) => Promise<T>;
+    protected auth_delete: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected auth_patch: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected errLogger: (msg: string, ...arg: any[]) => void;
+    protected outLogger: (msg: string, ...arg: any[]) => void;
+    protected auth(publicKey: string, privateKey: string, walletId?: string, passphrase?: string): Promise<CpayToken>;
+    protected getToken(isWallet?: boolean): Promise<string>;
+}

package/lib/CpaySDKBase.js

@@ -0,0 +1,216 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CpaySDKBase = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const lodash_1 = __importDefault(require("lodash"));
+const constant_1 = require("./constant");
+const httpClient_1 = require("./utils/httpClient");
+dayjs_1.default.extend(utc_1.default);
+const DEFAUTL_HTTP_OPTIONS = {
+    headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36",
+    },
+    timeout: 6000,
+};
+class CpaySDKBase {
+    constructor(options) {
+        this.options = {};
+        this._request = (path, options) => {
+            return (0, httpClient_1.request)(path, lodash_1.default.merge({}, this.options.httpOptions, options))
+                .then((data) => {
+                try {
+                    const json = JSON.parse(data);
+                    if (json) {
+                        return json.data || json;
+                    }
+                    else {
+                        this.errLogger(options.method, "-", path, json.data.message);
+                        return Promise.reject(json.data.message);
+                    }
+                }
+                catch (error) {
+                    this.errLogger(options.method, "-", path, "Parse Error", error);
+                    return Promise.reject(error);
+                }
+            })
+                .catch((err) => {
+                var _a, _b;
+                let response = {
+                    status: (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.statusCode,
+                    response: err === null || err === void 0 ? void 0 : err.response,
+                };
+                try {
+                    const parseError = JSON.parse(((_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.body) || '{"message":"Unknown error"}');
+                    if (parseError && parseError.data && parseError.data.message) {
+                        Object.assign(response, {
+                            message: parseError.data.message,
+                        });
+                    }
+                }
+                catch (err) {
+                    console.log(err);
+                    Object.assign(response, {
+                        message: "Unknown error",
+                    });
+                }
+                return Promise.reject(response);
+            });
+        };
+        this.request = (path, options) => {
+            if (!this.options.url.rest) {
+                return Promise.reject("Rest url is required.");
+            }
+            return this._request(`${this.options.url.rest}${path}`, options);
+        };
+        this.auth_get = (path, params = {}, token) => {
+            if (!this.options.url.rest) {
+                return Promise.reject("Rest url is required.");
+            }
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                searchParams: params,
+            });
+        };
+        this.auth_post = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            const { idempotencyKey } = data, payload = __rest(data, ["idempotencyKey"]);
+            const headers = {
+                Authorization: `Bearer ${token}`,
+            };
+            if (idempotencyKey) {
+                headers["idempotency-key"] = idempotencyKey;
+            }
+            return this._request(PATH, {
+                method: "POST",
+                headers,
+                json: payload,
+            });
+        };
+        this.post = (path, data) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "POST",
+                json: data,
+            });
+        };
+        this.auth_delete = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "DELETE",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                json: data,
+            });
+        };
+        this.auth_patch = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "PATCH",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                json: data,
+            });
+        };
+        this.errLogger = (msg, ...arg) => {
+            if (typeof this.options.errLogger === "function") {
+                this.options.errLogger(msg, ...arg);
+                return;
+            }
+            const prefix = `[${(0, dayjs_1.default)()
+                .utcOffset(8)
+                .format("YYYY-MM-DD HH:mm:ss")}] [ERROR] `;
+            console.error(`${prefix} ${msg}`, ...arg);
+        };
+        this.outLogger = (msg, ...arg) => {
+            if (typeof this.options.outLogger === "function") {
+                this.options.outLogger(msg, ...arg);
+                return;
+            }
+            const prefix = `[${(0, dayjs_1.default)()
+                .utcOffset(8)
+                .format("YYYY-MM-DD HH:mm:ss")}] [INFO] `;
+            console.log(`${prefix} ${msg}`, ...arg);
+        };
+        if (!options) {
+            return;
+        }
+        this.setOptions(options);
+    }
+    setOptions(options = {}) {
+        const { httpOptions, url } = options, otherOptions = __rest(options, ["httpOptions", "url"]);
+        lodash_1.default.merge(this.options, {
+            httpOptions: lodash_1.default.merge({}, DEFAUTL_HTTP_OPTIONS, httpOptions || {}),
+            url: Object.assign({ rest: constant_1.REST_URL }, (url || {})),
+        });
+        if (otherOptions) {
+            lodash_1.default.merge(this.options, otherOptions);
+        }
+    }
+    auth(publicKey, privateKey, walletId, passphrase) {
+        if (this.options.publicKey && this.options.privateKey) {
+            const path = `/api/public/auth`;
+            let data = {
+                publicKey,
+                privateKey,
+            };
+            if (walletId) {
+                data = Object.assign(data, { walletId });
+                if (!passphrase) {
+                    throw new Error("Passphrase is required.");
+                }
+                data = Object.assign(data, { passphrase });
+            }
+            return this.request(`${path}`, {
+                method: "POST",
+                json: data,
+            });
+        }
+        else {
+            throw new Error("Keys is required.");
+        }
+    }
+    getToken(isWallet = false) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isWallet) {
+                if (!this.options.walletId || !this.options.passphrase) {
+                    throw new Error("WalletId and passphrase is required.");
+                }
+            }
+            const { token } = yield this.auth(this.options.publicKey, this.options.privateKey, (_a = this.options) === null || _a === void 0 ? void 0 : _a.walletId, (_b = this.options) === null || _b === void 0 ? void 0 : _b.passphrase);
+            return token;
+        });
+    }
+}
+exports.CpaySDKBase = CpaySDKBase;

package/lib/CryptoNowSDK.d.ts

@@ -0,0 +1,30 @@
+import { Auth } from "./auth/auth";
+import Checkout from "./checkout/checkout";
+import { CryptoNowSDKBaseOptions } from "./CryptoNowSDKBase";
+import { Currency } from "./currency/currency";
+import External from "./external/external";
+import { Multisend } from "./multisend/multisend";
+import { Client } from "./client/client";
+import { Swap } from "./swap/swap";
+import Transaction from "./transaction/transaction";
+import { Wallet } from "./wallet/wallet";
+import { Withdrawal } from "./withdrawal/withdrawal";
+export interface CryptoNowSDKOptions extends CryptoNowSDKBaseOptions {
+}
+export declare class CryptoNowSDK {
+    /**
+     * @param parameters
+     */
+    constructor(parameters: CryptoNowSDKOptions);
+    wallet: Wallet;
+    currency: Currency;
+    withdrawal: Withdrawal;
+    multisend: Multisend;
+    checkout: Checkout;
+    transaction: Transaction;
+    externalCall: External;
+    auth: Auth;
+    swap: Swap;
+    client: Client;
+}
+export default CryptoNowSDK;

package/lib/CryptoNowSDK.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoNowSDK = void 0;
+const auth_1 = require("./auth/auth");
+const checkout_1 = __importDefault(require("./checkout/checkout"));
+const currency_1 = require("./currency/currency");
+const external_1 = __importDefault(require("./external/external"));
+const multisend_1 = require("./multisend/multisend");
+const client_1 = require("./client/client");
+const swap_1 = require("./swap/swap");
+const transaction_1 = __importDefault(require("./transaction/transaction"));
+const wallet_1 = require("./wallet/wallet");
+const withdrawal_1 = require("./withdrawal/withdrawal");
+class CryptoNowSDK {
+    /**
+     * @param parameters
+     */
+    constructor(parameters) {
+        this.wallet = new wallet_1.Wallet(parameters);
+        this.currency = new currency_1.Currency(parameters);
+        this.withdrawal = new withdrawal_1.Withdrawal(parameters);
+        this.multisend = new multisend_1.Multisend(parameters);
+        this.checkout = new checkout_1.default(parameters);
+        this.transaction = new transaction_1.default(parameters);
+        this.externalCall = new external_1.default(parameters);
+        this.auth = new auth_1.Auth(parameters);
+        this.swap = new swap_1.Swap(parameters);
+        this.client = new client_1.Client(parameters);
+    }
+}
+exports.CryptoNowSDK = CryptoNowSDK;
+exports.default = CryptoNowSDK;

package/lib/CryptoNowSDKBase.d.ts

@@ -0,0 +1,30 @@
+import { CryptoNowToken } from "./interfaces/cryptonow.interface";
+import { Options as HttpOptions } from "./utils/httpClient";
+export interface CryptoNowSDKBaseOptions {
+    publicKey?: string;
+    privateKey?: string;
+    walletId?: string;
+    passphrase?: string;
+    errLogger?: (mssage: string, ...arg: any[]) => void;
+    outLogger?: (mssage: string, ...arg: any[]) => void;
+    httpOptions?: HttpOptions;
+    url?: {
+        rest?: string;
+    };
+}
+export declare class CryptoNowSDKBase {
+    protected options: Required<CryptoNowSDKBaseOptions>;
+    constructor(options?: Partial<CryptoNowSDKBaseOptions>);
+    protected setOptions(options?: Partial<CryptoNowSDKBaseOptions>): void;
+    protected _request: <T>(path: string, options: HttpOptions) => Promise<T>;
+    protected request: <T>(path: string, options: HttpOptions) => Promise<T>;
+    protected auth_get: <T = any>(path: string, params: Record<string, any>, token: string) => Promise<T>;
+    protected auth_post: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected post: <T = any>(path: string, data: Record<string, any>) => Promise<T>;
+    protected auth_delete: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected auth_patch: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected errLogger: (msg: string, ...arg: any[]) => void;
+    protected outLogger: (msg: string, ...arg: any[]) => void;
+    protected auth(publicKey: string, privateKey: string, walletId?: string, passphrase?: string): Promise<CryptoNowToken>;
+    protected getToken(isWallet?: boolean): Promise<string>;
+}

package/lib/CryptoNowSDKBase.js

@@ -0,0 +1,216 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoNowSDKBase = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const lodash_1 = __importDefault(require("lodash"));
+const constant_1 = require("./constant");
+const httpClient_1 = require("./utils/httpClient");
+dayjs_1.default.extend(utc_1.default);
+const DEFAUTL_HTTP_OPTIONS = {
+    headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36",
+    },
+    timeout: 6000,
+};
+class CryptoNowSDKBase {
+    constructor(options) {
+        this.options = {};
+        this._request = (path, options) => {
+            return (0, httpClient_1.request)(path, lodash_1.default.merge({}, this.options.httpOptions, options))
+                .then((data) => {
+                try {
+                    const json = JSON.parse(data);
+                    if (json) {
+                        return json.data || json;
+                    }
+                    else {
+                        this.errLogger(options.method, "-", path, json.data.message);
+                        return Promise.reject(json.data.message);
+                    }
+                }
+                catch (error) {
+                    this.errLogger(options.method, "-", path, "Parse Error", error);
+                    return Promise.reject(error);
+                }
+            })
+                .catch((err) => {
+                var _a, _b;
+                let response = {
+                    status: (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.statusCode,
+                    response: err === null || err === void 0 ? void 0 : err.response,
+                };
+                try {
+                    const parseError = JSON.parse(((_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.body) || '{"message":"Unknown error"}');
+                    if (parseError && parseError.data && parseError.data.message) {
+                        Object.assign(response, {
+                            message: parseError.data.message,
+                        });
+                    }
+                }
+                catch (err) {
+                    console.log(err);
+                    Object.assign(response, {
+                        message: "Unknown error",
+                    });
+                }
+                return Promise.reject(response);
+            });
+        };
+        this.request = (path, options) => {
+            if (!this.options.url.rest) {
+                return Promise.reject("Rest url is required.");
+            }
+            return this._request(`${this.options.url.rest}${path}`, options);
+        };
+        this.auth_get = (path, params = {}, token) => {
+            if (!this.options.url.rest) {
+                return Promise.reject("Rest url is required.");
+            }
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                searchParams: params,
+            });
+        };
+        this.auth_post = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            const { idempotencyKey } = data, payload = __rest(data, ["idempotencyKey"]);
+            const headers = {
+                Authorization: `Bearer ${token}`,
+            };
+            if (idempotencyKey) {
+                headers["idempotency-key"] = idempotencyKey;
+            }
+            return this._request(PATH, {
+                method: "POST",
+                headers,
+                json: payload,
+            });
+        };
+        this.post = (path, data) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "POST",
+                json: data,
+            });
+        };
+        this.auth_delete = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "DELETE",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                json: data,
+            });
+        };
+        this.auth_patch = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "PATCH",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                json: data,
+            });
+        };
+        this.errLogger = (msg, ...arg) => {
+            if (typeof this.options.errLogger === "function") {
+                this.options.errLogger(msg, ...arg);
+                return;
+            }
+            const prefix = `[${(0, dayjs_1.default)()
+                .utcOffset(8)
+                .format("YYYY-MM-DD HH:mm:ss")}] [ERROR] `;
+            console.error(`${prefix} ${msg}`, ...arg);
+        };
+        this.outLogger = (msg, ...arg) => {
+            if (typeof this.options.outLogger === "function") {
+                this.options.outLogger(msg, ...arg);
+                return;
+            }
+            const prefix = `[${(0, dayjs_1.default)()
+                .utcOffset(8)
+                .format("YYYY-MM-DD HH:mm:ss")}] [INFO] `;
+            console.log(`${prefix} ${msg}`, ...arg);
+        };
+        if (!options) {
+            return;
+        }
+        this.setOptions(options);
+    }
+    setOptions(options = {}) {
+        const { httpOptions, url } = options, otherOptions = __rest(options, ["httpOptions", "url"]);
+        lodash_1.default.merge(this.options, {
+            httpOptions: lodash_1.default.merge({}, DEFAUTL_HTTP_OPTIONS, httpOptions || {}),
+            url: Object.assign({ rest: constant_1.REST_URL }, (url || {})),
+        });
+        if (otherOptions) {
+            lodash_1.default.merge(this.options, otherOptions);
+        }
+    }
+    auth(publicKey, privateKey, walletId, passphrase) {
+        if (this.options.publicKey && this.options.privateKey) {
+            const path = `/api/public/auth`;
+            let data = {
+                publicKey,
+                privateKey,
+            };
+            if (walletId) {
+                data = Object.assign(data, { walletId });
+                if (!passphrase) {
+                    throw new Error("Passphrase is required.");
+                }
+                data = Object.assign(data, { passphrase });
+            }
+            return this.request(`${path}`, {
+                method: "POST",
+                json: data,
+            });
+        }
+        else {
+            throw new Error("Keys is required.");
+        }
+    }
+    getToken(isWallet = false) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isWallet) {
+                if (!this.options.walletId || !this.options.passphrase) {
+                    throw new Error("WalletId and passphrase is required.");
+                }
+            }
+            const { token } = yield this.auth(this.options.publicKey, this.options.privateKey, (_a = this.options) === null || _a === void 0 ? void 0 : _a.walletId, (_b = this.options) === null || _b === void 0 ? void 0 : _b.passphrase);
+            return token;
+        });
+    }
+}
+exports.CryptoNowSDKBase = CryptoNowSDKBase;

package/lib/PaytonzSDK.d.ts

@@ -0,0 +1,28 @@
+import { Auth } from "./auth/auth";
+import Checkout from "./checkout/checkout";
+import { PaytonzSDKBaseOptions } from "./PaytonzSDKBase";
+import { Currency } from "./currency/currency";
+import External from "./external/external";
+import { Multisend } from "./multisend/multisend";
+import { Swap } from "./swap/swap";
+import Transaction from "./transaction/transaction";
+import { Wallet } from "./wallet/wallet";
+import { Withdrawal } from "./withdrawal/withdrawal";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class PaytonzSDK {
+    /**
+     * @param parameters
+     */
+    constructor(parameters: PaytonzSDKOptions);
+    wallet: Wallet;
+    currency: Currency;
+    withdrawal: Withdrawal;
+    multisend: Multisend;
+    checkout: Checkout;
+    transaction: Transaction;
+    externalCall: External;
+    auth: Auth;
+    swap: Swap;
+}
+export default PaytonzSDK;