paytonz-node-api-sdk 1.0.0

package/src/multisend/multisend.interface.ts

@@ -0,0 +1,32 @@
+import { AccessWalletOptions } from "src/interfaces/paytonz.interface";
+
+interface MultisendFileOptions {
+  address: string;
+  amount: string;
+}
+
+export interface EstimateSystemFeeOptions {
+  currencyToken: string;
+  multisendWallets: MultisendFileOptions[];
+}
+
+export interface EstimateMultisendInfo {
+  estimationId: string;
+  countTxs: number;
+  systemFee: string;
+  minerFee: string;
+  totalAmount: string;
+  allowance: string;
+  currencyFee: string;
+  needApprove: boolean;
+  multisendWallets: MultisendFileOptions[];
+}
+
+export interface EstimateMultisendCommonOptions extends AccessWalletOptions {
+  estimationId: string;
+  idempotencyKey?: string;
+}
+
+export interface MultisendInfo {
+  ids: string[];
+}

package/src/multisend/multisend.ts

@@ -0,0 +1,91 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import {
+  EstimateMultisendCommonOptions,
+  EstimateMultisendInfo,
+  EstimateSystemFeeOptions,
+  MultisendInfo,
+} from "./multisend.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class Multisend extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async estimateSystemFee(
+    options: EstimateSystemFeeOptions,
+    accessToken?: string
+  ): Promise<EstimateMultisendInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/multisend/estimateSystemFee`;
+
+      return this.auth_post<EstimateMultisendInfo>(
+        `${path}`,
+        options,
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async approve(
+    options: EstimateMultisendCommonOptions,
+    accessToken?: string
+  ): Promise<EstimateMultisendInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/multisend/approve`;
+
+      return this.auth_post<EstimateMultisendInfo>(
+        `${path}`,
+        options,
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async estimateMinerFee(
+    options: EstimateMultisendCommonOptions,
+    accessToken?: string
+  ): Promise<EstimateMultisendInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/multisend/estimateMinerFee`;
+
+      return this.auth_post<EstimateMultisendInfo>(
+        `${path}`,
+        options,
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async create(
+    options: EstimateMultisendCommonOptions,
+    accessToken?: string
+  ): Promise<MultisendInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/multisend`;
+
+      return this.auth_post<MultisendInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+}

package/src/swap/swap.interface.ts

@@ -0,0 +1,90 @@
+import { AccessWalletOptions } from "src/interfaces/paytonz.interface";
+
+export interface SwapEstimateOptions {
+  fromId: string;
+  toId: string;
+  amount: string;
+  sort?: string;
+  type?: string;
+}
+
+export interface SwapCreateOptions extends AccessWalletOptions {
+  currencyFromId: string;
+  toId: string;
+  currencyToId: string;
+  amount: number;
+  partner: string;
+  fixed: boolean;
+  rateId: string;
+  idempotencyKey?: string;
+}
+
+export interface SwapEstimateInfo {
+  id: string;
+  supportRate: number;
+  duration: string;
+  min: number;
+  max: number;
+  fixed: boolean;
+  partner: string;
+  exists: boolean;
+  fromAmount: number;
+  fromCurrency: string;
+  fromNetwork: string;
+  toAmount: number;
+  toCurrency: string;
+  toNetwork: string;
+}
+
+export interface SwapCreateInfo {
+  id: string;
+  exchangeId: string;
+}
+
+export interface SwapHistoryListOptions {
+  currencyFromId?: string;
+  currencyToId?: string;
+  search?: string;
+  sort?: string;
+  order?: string;
+  page?: number;
+  limit?: number;
+}
+
+interface SwapWalletInfo {
+  id: string;
+  address: string;
+  amount: {
+    value: number;
+    usd: number;
+  };
+  currency: {
+    id: string;
+    name: string;
+  };
+  paymentId: string;
+  hash: string;
+}
+
+export interface SwapHistoryInfo {
+  page: number;
+  pages: number;
+  countItems: number;
+  entities: {
+    _id: string;
+    exchangeId: string;
+    partner: string;
+    fixed: boolean;
+    typeNetwork: string;
+    status: boolean;
+    systemStatus: string;
+    convertRate: number;
+    from: SwapWalletInfo;
+    to: SwapWalletInfo;
+    merchant: string;
+    user: string;
+    rateId: string;
+    createdAt: Date;
+    updatedAt: Date;
+  }[];
+}

package/src/swap/swap.ts

@@ -0,0 +1,93 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import {
+  SwapCreateInfo,
+  SwapCreateOptions,
+  SwapEstimateInfo,
+  SwapEstimateOptions,
+  SwapHistoryInfo,
+  SwapHistoryListOptions,
+} from "./swap.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class Swap extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async estimate(
+    options: SwapEstimateOptions,
+    accessToken?: string
+  ): Promise<SwapEstimateInfo[]> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/swap/estimate`;
+
+      return this.auth_get<SwapEstimateInfo[]>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async bestOffer(
+    options: SwapEstimateOptions,
+    accessToken?: string
+  ): Promise<SwapEstimateInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/swap/best-offer`;
+
+      return this.auth_get<SwapEstimateInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async create(
+    options: SwapCreateOptions,
+    accessToken?: string
+  ): Promise<SwapCreateInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/swap/create`;
+
+      return this.auth_post<SwapCreateInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async history(
+    options: SwapHistoryListOptions,
+    accessToken?: string
+  ): Promise<SwapHistoryInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/swap/history`;
+
+      return this.auth_get<SwapHistoryInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+}

package/src/transaction/transaction.interface.ts

@@ -0,0 +1,76 @@
+export interface TransactionListOptions {
+  search?: string;
+  from?: number;
+  to?: number;
+  currencyId?: string;
+  fromUSD?: number;
+  toUSD?: number;
+  type?: string;
+  status?: string;
+  sort?: string;
+  order?: string;
+  page?: number;
+  limit?: number;
+}
+
+export interface TransactionListInfo {
+  page: number;
+  pages: number;
+  countItem: number;
+  entities: {
+    id: string;
+    type: string;
+    typeNetwork: string;
+    status: boolean;
+    systemStatus: string;
+    merchant: string;
+    user: string;
+    checkout?: {
+      id: string;
+      name: string;
+      description: string;
+      identifier: string;
+      charge: {
+        id: string;
+      };
+    };
+    info: {
+      incomingTxHash: string;
+      currencyId: string;
+      currency: string;
+      nodeType: string;
+      currencyType: string;
+      exchangeId: number;
+      from: string;
+      to: string;
+      fromId: string;
+      toId: string;
+      hashs: [string];
+      addresses: [string];
+      multisend: {
+        address: string;
+        value: string;
+        usd: string;
+      }[];
+      amount: { value: string; usd: number };
+      minerFee: { value: string; usd: number; currency: string };
+      systemFee?: {
+        value: string;
+        usd: number;
+        currency: string;
+        hash: string;
+      };
+      call?: {
+        contractAddress: string;
+        method: string;
+        options: Record<string, any>;
+        arguments: any[];
+        value: string;
+      };
+    };
+    fees?: Record<string, any>;
+    errorMessage?: string;
+    createdAt: Date;
+    updatedAt?: Date;
+  }[];
+}

package/src/transaction/transaction.ts

@@ -0,0 +1,35 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import {
+  TransactionListInfo,
+  TransactionListOptions,
+} from "./transaction.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class Transaction extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async list(
+    options: TransactionListOptions,
+    accessToken?: string
+  ): Promise<TransactionListInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/transaction/list`;
+
+      return this.auth_get<TransactionListInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+export default Transaction;

package/src/utils/httpClient.ts

@@ -0,0 +1,60 @@
+import http from "http";
+import https from "https";
+import got, { Headers, Method } from "got";
+import { default as URLOptions } from "got/dist/source/core/utils/url-to-options";
+
+export interface Options {
+  timeout?: number;
+  headers?: Headers;
+  method?: Method;
+  json?: Record<string, any>;
+  searchParams?: Record<string, any>;
+}
+
+const DEFAULT_HEADER = {
+  "content-type": "application/json;charset=utf-8",
+};
+const keepAliveAgent = new http.Agent({ keepAlive: true, maxSockets: 256 });
+const keepAliveAgent2 = new https.Agent({ keepAlive: true, maxSockets: 256 });
+
+export const request = async function <T>(url, options: Options = {}) {
+  const instance = got.extend({
+    request: (url, options, callback) => {
+      if (url.protocol === "https:") {
+        return https.request({ ...options, ...URLOptions(url) }, callback);
+      }
+
+      return http.request({ ...options, ...URLOptions(url) }, callback);
+    },
+  });
+
+  try {
+    const response = await instance<T>(url, {
+      method: options.method,
+      timeout: options.timeout || 6000,
+      headers: options.headers || DEFAULT_HEADER,
+      agent: {
+        http: keepAliveAgent,
+        https: keepAliveAgent2,
+      },
+      json: options.json,
+      searchParams: options.searchParams,
+    });
+
+    if (response.statusCode >= 200 && response.statusCode < 300) {
+      return response.body;
+    }
+    if (response.statusMessage) {
+      throw Error(response.statusMessage);
+    }
+  } catch (err) {
+    const parseError = JSON.parse(
+      err?.response?.body || '{"message":"Unknown error"}'
+    );
+    if (parseError && parseError.data && parseError.data.message) {
+      throw Error(parseError.data.message);
+    }
+
+    throw Error(err.message);
+  }
+};

package/src/wallet/wallet.interface.ts

@@ -0,0 +1,67 @@
+interface WalletTokensData {
+  currencyId: string;
+  currencyName: string;
+  balance: string;
+  holdBalance: string;
+  balanceUSD: string;
+  availableBalance: string;
+  availableBalanceUSD: string;
+}
+
+interface NftItem {
+  contractAddress: string;
+  tokenId: number;
+  balance: number;
+  holdBalance: number;
+  name: string;
+  symbol: string;
+}
+
+interface NftData {
+  erc721: NftItem[];
+  erc1155: NftItem[];
+}
+
+export interface WalletInfo {
+  id: string;
+  address: string;
+  currencyId: string;
+  balance: string;
+  balanceUSD: string;
+  holdBalance: string;
+  availableBalance: string;
+  availableBalanceUSD: string;
+  tokens?: WalletTokensData[];
+  nfts?: NftData;
+}
+
+export interface CreateWalletOptions {
+  currencyId: string;
+  typeWallet?: string;
+  privateKey?: string;
+  isMnemonic?: boolean;
+  password?: string;
+  setMain?: boolean;
+  isNew?: boolean;
+}
+
+export interface CreateWalletInfo {
+  id: string;
+  address: string;
+  balance: number;
+  balanceUSD: number;
+  passphrase: string;
+}
+
+export interface SignatureCommonOptions {
+  password?: string;
+}
+
+export interface SignatureOnOptions extends SignatureCommonOptions {
+  sign: string;
+}
+
+export interface SignatureChangePasswordOptions {
+  oldPassword?: string;
+  password: string;
+}

package/src/wallet/wallet.signature.ts

@@ -0,0 +1,106 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import {
+  SignatureChangePasswordOptions,
+  SignatureCommonOptions,
+  SignatureOnOptions,
+} from "./wallet.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class WalletSignature extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async on(
+    options: SignatureOnOptions,
+    accessToken?: string
+  ): Promise<boolean> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/wallet/signature/on`;
+
+      return this.auth_post<boolean>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async off(
+    options: SignatureCommonOptions,
+    accessToken?: string
+  ): Promise<string> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/wallet/signature/off`;
+
+      return this.auth_post<string>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async status(accessToken?: string): Promise<boolean> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/wallet/signature/status`;
+
+      return this.auth_get<boolean>(`${path}`, {}, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async download(
+    options: SignatureCommonOptions,
+    accessToken?: string
+  ): Promise<string> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/wallet/signature/download`;
+
+      return this.auth_post<string>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async changePassword(
+    options: SignatureChangePasswordOptions,
+    accessToken?: string
+  ): Promise<boolean> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/wallet/signature/change-password`;
+
+      return this.auth_post<boolean>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async passwordStatus(accessToken?: string): Promise<boolean> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/wallet/signature/password-status`;
+
+      return this.auth_get<boolean>(`${path}`, {}, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+export default WalletSignature;