paytonz-node-api-sdk 1.0.0

package/lib/wallet/wallet.signature.js

@@ -0,0 +1,104 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletSignature = void 0;
+const PaytonzSDKBase_1 = require("../PaytonzSDKBase");
+class WalletSignature extends PaytonzSDKBase_1.PaytonzSDKBase {
+    constructor(parameters) {
+        super(parameters);
+    }
+    on(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/signature/on`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    off(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/signature/off`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    status(accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/signature/status`;
+                return this.auth_get(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    download(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/signature/download`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    changePassword(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/signature/change-password`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    passwordStatus(accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/wallet/signature/password-status`;
+                return this.auth_get(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+}
+exports.WalletSignature = WalletSignature;
+exports.default = WalletSignature;

package/lib/withdrawal/withdrawal.d.ts

@@ -0,0 +1,14 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { CreateNftWithdrawalOptions, CreateWithdrawalInfo, CreateWithdrawalOptions, EstimateFeeInfo, EstimateFeeNftInfo, EstimateFeeNftOptions, EstimateFeeOptions, EstimateMaxInfo, EstimateMaxOptions, InternalTransferOptions } from "./withdrawal.interface";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class Withdrawal extends PaytonzSDKBase {
+    constructor(parameters: PaytonzSDKOptions);
+    create(options: CreateWithdrawalOptions, accessToken?: string): Promise<CreateWithdrawalInfo>;
+    nftTransfer(options: CreateNftWithdrawalOptions, accessToken?: string): Promise<CreateWithdrawalInfo>;
+    internalTransfer(options: InternalTransferOptions, accessToken?: string): Promise<CreateWithdrawalInfo>;
+    estimateFee(options: EstimateFeeOptions, accessToken?: string): Promise<EstimateFeeInfo>;
+    estimateNftFee(options: EstimateFeeNftOptions, accessToken?: string): Promise<EstimateFeeNftInfo>;
+    estimateMax(options: EstimateMaxOptions, accessToken?: string): Promise<EstimateMaxInfo>;
+}
+export default Withdrawal;

package/lib/withdrawal/withdrawal.interface.d.ts

@@ -0,0 +1,79 @@
+import { AccessWalletOptions } from "src/interfaces/paytonz.interface";
+export interface CreateWithdrawalInfo {
+    id: string;
+}
+export interface EstimateFeeInfo {
+    fee: string;
+    minerFee: string;
+    systemFee?: string;
+    merchantFee?: string;
+    currencyMinerFee: string;
+    currencyFee: string;
+}
+export interface EstimateFeeNftInfo {
+    fee: string;
+    minerFee: string;
+    systemFee: string;
+    currencyMinerFee: string;
+    currencySystemFee: string;
+}
+export interface EstimateMaxInfo {
+    amount: string;
+}
+export declare enum PriorityTx {
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high"
+}
+export interface CreateWithdrawalOptions extends AccessWalletOptions {
+    to: string;
+    amount: string;
+    priority?: PriorityTx;
+    currencyToken?: string;
+    payerFeePrivateKey?: string;
+    comment?: string;
+    isSmartAccount?: boolean;
+    paymasterCurrencyToken?: string;
+    isGasless?: boolean;
+    idempotencyKey?: string;
+}
+export interface InternalTransferOptions {
+    to: string;
+    amount: string;
+    idempotencyKey?: string;
+}
+export interface EstimateFeeOptions extends AccessWalletOptions {
+    to: string;
+    amount: string;
+    priority?: PriorityTx;
+    currencyToken?: string;
+    payerFeePrivateKey?: string;
+    isSmartAccount?: boolean;
+    paymasterCurrencyToken?: string;
+    isGasless?: boolean;
+}
+declare enum TypeNFt {
+    ERC_721 = "erc721",
+    ERC_1155 = "erc1155"
+}
+export interface EstimateFeeNftOptions extends AccessWalletOptions {
+    to: string;
+    amount: string;
+    contractAddress: string;
+    tokenId: number;
+    type: TypeNFt;
+    payerFeePrivateKey?: string;
+    idempotencyKey?: string;
+}
+export interface CreateNftWithdrawalOptions extends EstimateFeeNftOptions {
+}
+export interface EstimateMaxOptions extends AccessWalletOptions {
+    to: string;
+    currencyToken?: string;
+    payerFeePrivateKey?: string;
+    priority?: PriorityTx;
+    isSmartAccount?: boolean;
+    paymasterCurrencyToken?: string;
+    isGasless?: boolean;
+}
+export {};

package/lib/withdrawal/withdrawal.interface.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityTx = void 0;
+var PriorityTx;
+(function (PriorityTx) {
+    PriorityTx["LOW"] = "low";
+    PriorityTx["MEDIUM"] = "medium";
+    PriorityTx["HIGH"] = "high";
+})(PriorityTx = exports.PriorityTx || (exports.PriorityTx = {}));
+var TypeNFt;
+(function (TypeNFt) {
+    TypeNFt["ERC_721"] = "erc721";
+    TypeNFt["ERC_1155"] = "erc1155";
+})(TypeNFt || (TypeNFt = {}));

package/lib/withdrawal/withdrawal.js

@@ -0,0 +1,104 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Withdrawal = void 0;
+const PaytonzSDKBase_1 = require("../PaytonzSDKBase");
+class Withdrawal extends PaytonzSDKBase_1.PaytonzSDKBase {
+    constructor(parameters) {
+        super(parameters);
+    }
+    create(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/withdrawal`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    nftTransfer(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/withdrawal/nft`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    internalTransfer(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/withdrawal/internal`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    estimateFee(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/transaction/fee`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    estimateNftFee(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/transaction/feeNft`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    estimateMax(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    accessToken = yield this.getToken(true);
+                }
+                const path = `/api/public/withdrawal/estimate-max`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+}
+exports.Withdrawal = Withdrawal;
+exports.default = Withdrawal;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "author": {
+    "name": "paytonz"
+  },
+  "bundleDependencies": [],
+  "dependencies": {
+    "dayjs": "^1.10.3",
+    "got": "^11.8.2",
+    "lodash": "^4.17.21",
+    "typescript-memoize": "^1.1.1"
+  },
+  "deprecated": false,
+  "description": "PAYTONZ REST API",
+  "devDependencies": {
+    "typescript": "^4.1.3"
+  },
+  "license": "ISC",
+  "main": "lib/index.js",
+  "name": "paytonz-node-api-sdk",
+  "scripts": {
+    "build": "tsc --build tsconfig.json",
+    "publish:patch": "npm version patch && npm publish",
+    "deploy": "npm run build && npm publish"
+  },
+  "version": "1.0.0"
+}

package/src/PaytonzSDK.ts

@@ -0,0 +1,41 @@
+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 class PaytonzSDK {
+  /**
+   * @param parameters
+   */
+  constructor(parameters: PaytonzSDKOptions) {
+    this.wallet = new Wallet(parameters);
+    this.currency = new Currency(parameters);
+    this.withdrawal = new Withdrawal(parameters);
+    this.multisend = new Multisend(parameters);
+    this.checkout = new Checkout(parameters);
+    this.transaction = new Transaction(parameters);
+    this.externalCall = new External(parameters);
+    this.auth = new Auth(parameters);
+    this.swap = new Swap(parameters);
+  }
+
+  wallet: Wallet;
+  currency: Currency;
+  withdrawal: Withdrawal;
+  multisend: Multisend;
+  checkout: Checkout;
+  transaction: Transaction;
+  externalCall: External;
+  auth: Auth;
+  swap: Swap;
+}
+
+export default PaytonzSDK;

package/src/PaytonzSDKBase.ts

@@ -0,0 +1,252 @@
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc";
+import _ from "lodash";
+
+import { REST_URL } from "./constant";
+import { PaytonzToken, IGetToken } from "./interfaces/paytonz.interface";
+import { request, Options as HttpOptions } from "./utils/httpClient";
+
+dayjs.extend(utc);
+
+export interface PaytonzSDKBaseOptions {
+  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;
+  };
+}
+
+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,
+};
+
+export class PaytonzSDKBase {
+  protected options: Required<PaytonzSDKBaseOptions> =
+    {} as Required<PaytonzSDKBaseOptions>;
+
+  constructor(options?: Partial<PaytonzSDKBaseOptions>) {
+    if (!options) {
+      return;
+    }
+    this.setOptions(options);
+  }
+  protected setOptions(options: Partial<PaytonzSDKBaseOptions> = {}) {
+    const { httpOptions, url, ...otherOptions } = options;
+
+    _.merge(this.options, {
+      httpOptions: _.merge({}, DEFAUTL_HTTP_OPTIONS, httpOptions || {}),
+      url: {
+        rest: REST_URL,
+        ...(url || {}),
+      },
+    });
+    if (otherOptions) {
+      _.merge(this.options, otherOptions);
+    }
+  }
+  protected _request = <T>(path: string, options: HttpOptions): Promise<T> => {
+    return request<T>(path, _.merge({}, this.options.httpOptions, options))
+      .then((data: any) => {
+        try {
+          const json = JSON.parse(data);
+          if (json) {
+            return json.data || json;
+          } else {
+            this.errLogger(
+              options.method as string,
+              "-",
+              path,
+              json.data.message
+            );
+            return Promise.reject(json.data.message);
+          }
+        } catch (error) {
+          this.errLogger(
+            options.method as string,
+            "-",
+            path,
+            "Parse Error",
+            error
+          );
+          return Promise.reject(error);
+        }
+      })
+      .catch((err) => {
+        this.errLogger(options.method as string, "-", path, err);
+        return Promise.reject(err);
+      });
+  };
+
+  protected request = <T>(path: string, options: HttpOptions): Promise<T> => {
+    if (!this.options.url.rest) {
+      return Promise.reject("Rest url is required.");
+    }
+    return this._request<T>(`${this.options.url.rest}${path}`, options);
+  };
+
+  protected auth_get = <T = any>(
+    path: string,
+    params: Record<string, any> = {} as Record<string, any>,
+    token: string
+  ) => {
+    if (!this.options.url.rest) {
+      return Promise.reject("Rest url is required.");
+    }
+    const PATH = `${this.options.url.rest}${path}`;
+
+    return this._request<T>(PATH, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+      searchParams: params,
+    });
+  };
+
+  protected auth_post = <T = any>(
+    path: string,
+    data: Record<string, any>,
+    token: string
+  ) => {
+    const PATH = `${this.options.url.rest}${path}`;
+
+    const { idempotencyKey, ...payload } = data;
+
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${token}`,
+    };
+
+    if (idempotencyKey) {
+      headers["idempotency-key"] = idempotencyKey;
+    }
+
+    return this._request<T>(PATH, {
+      method: "POST",
+      headers,
+      json: payload,
+    });
+  };
+
+  protected post = <T = any>(path: string, data: Record<string, any>) => {
+    const PATH = `${this.options.url.rest}${path}`;
+
+    return this._request<T>(PATH, {
+      method: "POST",
+      json: data,
+    });
+  };
+
+  protected auth_delete = <T = any>(
+    path: string,
+    data: Record<string, any>,
+    token: string
+  ) => {
+    const PATH = `${this.options.url.rest}${path}`;
+
+    return this._request<T>(PATH, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+      json: data,
+    });
+  };
+
+  protected auth_patch = <T = any>(
+    path: string,
+    data: Record<string, any>,
+    token: string
+  ) => {
+    const PATH = `${this.options.url.rest}${path}`;
+
+    return this._request<T>(PATH, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+      json: data,
+    });
+  };
+
+  protected errLogger = (msg: string, ...arg: any[]) => {
+    if (typeof this.options.errLogger === "function") {
+      this.options.errLogger(msg, ...arg);
+      return;
+    }
+    const prefix = `[${dayjs()
+      .utcOffset(8)
+      .format("YYYY-MM-DD HH:mm:ss")}] [ERROR] `;
+    console.error(`${prefix} ${msg}`, ...arg);
+  };
+
+  protected outLogger = (msg: string, ...arg: any[]) => {
+    if (typeof this.options.outLogger === "function") {
+      this.options.outLogger(msg, ...arg);
+      return;
+    }
+    const prefix = `[${dayjs()
+      .utcOffset(8)
+      .format("YYYY-MM-DD HH:mm:ss")}] [INFO] `;
+
+    console.log(`${prefix} ${msg}`, ...arg);
+  };
+
+  protected auth(
+    publicKey: string,
+    privateKey: string,
+    walletId?: string,
+    passphrase?: string
+  ): Promise<PaytonzToken> {
+    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<PaytonzToken>(`${path}`, {
+        method: "POST",
+        json: data,
+      });
+    } else {
+      throw new Error("Keys is required.");
+    }
+  }
+
+  protected async getToken(isWallet = false): Promise<string> {
+    if (isWallet) {
+      if (!this.options.walletId || !this.options.passphrase) {
+        throw new Error("WalletId and passphrase is required.");
+      }
+    }
+    const { token } = await this.auth(
+      this.options.publicKey,
+      this.options.privateKey,
+      this.options?.walletId,
+      this.options?.passphrase
+    );
+    return token;
+  }
+}

package/src/auth/auth.interface.ts

@@ -0,0 +1,26 @@
+export interface RegisterOptions {
+  email: string;
+  password: string;
+  inviterId?: string;
+  roles: string[];
+  agent?: string;
+}
+
+export interface RegisterInfo {
+  wallets: {
+    id: string;
+    address: string;
+    privateKey: string;
+    mnemonic: string;
+    actualBalance: string;
+    systemBalance: string;
+    passphrase: string;
+    nodeType: string;
+  }[];
+  apiKey: {
+    publicKey: string;
+    privateKey: string;
+  };
+  merchantId: string;
+  userId: string;
+}

package/src/auth/auth.ts

@@ -0,0 +1,31 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { RegisterInfo, RegisterOptions } from "./auth.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class Auth extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async register(options: RegisterOptions): Promise<RegisterInfo> {
+    try {
+      const path = `/api/public/auth/register`;
+
+      return this.post<RegisterInfo>(`${path}`, { ...options });
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async login(): Promise<string> {
+    const { token } = await this.auth(
+      this.options.publicKey,
+      this.options.privateKey,
+      this.options?.walletId,
+      this.options?.passphrase
+    );
+
+    return token;
+  }
+}