paytonz-node-api-sdk 1.0.0

package/src/checkout/checkout.interface.ts

@@ -0,0 +1,110 @@
+export interface CheckoutInfo {
+  _id: string;
+  identifier: string;
+  currencies: string[];
+  createdAt: string;
+  updatedAt: string;
+  organizationName?: string;
+  type: string;
+  merchant: string;
+  expireTime: number;
+  description: string;
+  collectName: boolean;
+  collectEmail: boolean;
+  fiatCurrency?: string;
+  price?: string;
+  productName?: string;
+  fixed?: boolean;
+  max?: string;
+  min?: string;
+  tradedCurrency?: string;
+  tradedWallet?: string;
+  accentColor?: string;
+  backgroundColor?: string;
+  logoImage?: string;
+  image?: string;
+  metadata?: Record<string, any>;
+}
+export interface CheckoutListInfo {
+  entities: CheckoutInfo[];
+  page: number;
+  pages: number;
+  countItem: number;
+}
+
+export interface CheckoutChargeListInfo {
+  entities: {
+    id: boolean;
+    systemStatus: string;
+    createdAt: string;
+  }[];
+  page: number;
+  pages: number;
+  countItem: number;
+}
+
+export interface CreateCheckoutBaseOptions {
+  expireTime: number;
+  currencies: string[];
+  collectName?: boolean;
+  collectEmail?: boolean;
+  description: string;
+  linkImage?: string;
+  linkLogoImage?: string;
+  metadata?: Record<string, any>;
+  accentColor?: string;
+  backgroundColor?: string;
+}
+
+export interface UpdateCheckoutBaseOptions {
+  deleteImage?: boolean;
+  deleteLogoImage?: boolean;
+}
+
+export interface CreateDonationOptions extends CreateCheckoutBaseOptions {
+  organizationName: string;
+}
+
+export interface UpdateDonationOptions
+  extends CreateDonationOptions,
+    UpdateCheckoutBaseOptions {}
+
+export interface CreateSaleOptions extends CreateCheckoutBaseOptions {
+  productName: string;
+  price: string;
+  fiatCurrency: string;
+}
+
+export interface UpdateSaleOptions
+  extends CreateSaleOptions,
+    UpdateCheckoutBaseOptions {}
+
+export interface CreateCartOptions extends CreateCheckoutBaseOptions {
+  cartName: string;
+  fiatCurrency: string;
+}
+
+export interface UpdateCartOptions
+  extends CreateCartOptions,
+    UpdateCheckoutBaseOptions {}
+
+export interface CreateSaleTokenOptions extends CreateCheckoutBaseOptions {
+  productName: string;
+  price?: string;
+  min: string;
+  max: string;
+  fiatCurrency?: string;
+  fixed: string;
+  tradedCurrency: string;
+  tradedWallet: string;
+}
+
+export interface UpdateSaleTokenOptions
+  extends CreateSaleTokenOptions,
+    UpdateCheckoutBaseOptions {}
+
+export interface SaleTokenEstimateMaxOptions {
+  tradedWallet: string;
+  tradedCurrency: string;
+  checkoutId?: string;
+}

package/src/checkout/checkout.ts

@@ -0,0 +1,279 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { BasePaginationOptions } from "../interfaces/paytonz.interface";
+import {
+  CheckoutChargeListInfo,
+  CheckoutInfo,
+  CheckoutListInfo,
+  CreateCartOptions,
+  CreateDonationOptions,
+  CreateSaleOptions,
+  CreateSaleTokenOptions,
+  SaleTokenEstimateMaxOptions,
+  UpdateCartOptions,
+  UpdateDonationOptions,
+  UpdateSaleOptions,
+  UpdateSaleTokenOptions,
+} from "./checkout.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class Checkout extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async list(options: BasePaginationOptions, accessToken?: string) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+
+      const path = `/api/public/checkout`;
+
+      return this.auth_get<CheckoutListInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async info(checkoutId: string, accessToken?: string) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/${checkoutId}`;
+
+      return this.auth_get<CheckoutInfo>(`${path}`, {}, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async remove(checkoutId: string, accessToken?: string) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/${checkoutId}`;
+
+      return this.auth_delete<boolean>(`${path}`, {}, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async createDonation(options: CreateDonationOptions, accessToken?: string) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/donation`;
+
+      return this.auth_post<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async createSale(options: CreateSaleOptions, accessToken?: string) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/sale`;
+
+      return this.auth_post<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async createSaleToken(options: CreateSaleTokenOptions, accessToken?: string) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/saleToken`;
+
+      return this.auth_post<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async createCart(options: CreateCartOptions, accessToken?: string) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/cart`;
+
+      return this.auth_post<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async saleTokenEstimateMax(
+    options: SaleTokenEstimateMaxOptions,
+    accessToken?: string
+  ) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/saleToken/estimateMax`;
+
+      return this.auth_post<{ max: string }>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async updateDonation(
+    checkoutId: string,
+    options: UpdateDonationOptions,
+    accessToken?: string
+  ) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/${checkoutId}/donation`;
+
+      return this.auth_patch<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async updateSale(
+    checkoutId: string,
+    options: UpdateSaleOptions,
+    accessToken?: string
+  ) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/${checkoutId}/sale`;
+
+      return this.auth_patch<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async updateSaleToken(
+    checkoutId: string,
+    options: UpdateSaleTokenOptions,
+    accessToken?: string
+  ) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/${checkoutId}/saleToken`;
+
+      return this.auth_patch<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async updateCart(
+    checkoutId: string,
+    options: UpdateCartOptions,
+    accessToken?: string
+  ) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/${checkoutId}/cart`;
+
+      return this.auth_patch<CheckoutInfo>(`${path}`, options, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async chargeList(
+    checkoutId: string,
+    options?: BasePaginationOptions,
+    accessToken?: string
+  ) {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/checkout/${checkoutId}/charge-list`;
+
+      return this.auth_get<CheckoutChargeListInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+export default Checkout;

package/src/constant.ts

@@ -0,0 +1 @@
+export const REST_URL = "https://api.paytonz.com";

package/src/currency/currency.interface.ts

@@ -0,0 +1,21 @@
+export interface CurrencyInfo {
+  currencies: {
+    _id: string;
+    title: string;
+    name: string;
+    nodeType: string;
+    currencyType: string;
+    mainCurrency?: string;
+    replenishMinimumValue?: number;
+    decimals: number;
+    supportMultisend: boolean;
+    supportSwap: boolean;
+  }[];
+  page: number;
+  pages: number;
+}
+
+export interface CurrencyOptions {
+  page?: number;
+  limit?: number;
+}

package/src/currency/currency.ts

@@ -0,0 +1,60 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { CurrencyInfo, CurrencyOptions } from "./currency.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class Currency extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async getAvailableCurrencies(
+    options: CurrencyOptions,
+    accessToken?: string
+  ): Promise<CurrencyInfo> {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/currency`;
+
+      return this.auth_get<CurrencyInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async getPaymasters(
+    options: CurrencyOptions,
+    accessToken?: string
+  ): Promise<CurrencyInfo> {
+    try {
+      if (!accessToken) {
+        const { token } = await this.auth(
+          this.options.publicKey,
+          this.options.privateKey
+        );
+        accessToken = token;
+      }
+      const path = `/api/public/currency/paymasters`;
+
+      return this.auth_get<CurrencyInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+export default Currency;

package/src/external/external.interface.ts

@@ -0,0 +1,65 @@
+import { AccessWalletOptions } from "src/interfaces/paytonz.interface";
+
+export interface ExternalOptions extends AccessWalletOptions {
+  abi: Record<string, any>[];
+  contractAddress: string;
+  method: string;
+  args?: any[];
+  value?: string;
+  options?: Record<string, any>;
+  isSmartAccount?: boolean;
+  isGasless?: boolean;
+  paymasterCurrencyToken?: string;
+  idempotencyKey?: string;
+}
+
+export interface ExternalEstimateWriteInfo {
+  gasPrice?: string;
+  gasLimit?: string;
+  fee: string;
+}
+
+export interface ExternalWriteInfo {
+  _id: string;
+  hash: string;
+}
+
+export interface ExternalSolanaMintNftInfo extends ExternalWriteInfo {
+  address: string;
+}
+
+export interface SolanaMetadataOptions {
+  trait_type: string;
+  value: string;
+}
+
+export enum SolanaNftType {
+  COLLECTION = "collection",
+  NFT = "nft",
+}
+
+export enum SolanaNftStorageType {
+  CPAY = "cpay",
+}
+
+export interface SolanaCollectionInfo {
+  name: string;
+  family: string;
+}
+
+export interface ExternalSolanaMintNftOptions extends AccessWalletOptions {
+  name: string;
+  description: string;
+  symbol: string;
+  attributes?: SolanaMetadataOptions[];
+  type: SolanaNftType;
+  image?: string;
+  sellerFeeBasisPoints?: number;
+  collectionAddress?: string;
+  storage?: SolanaNftStorageType;
+  collectionInfo?: SolanaCollectionInfo;
+  payerFeePrivateKey?: string;
+  tokenOwner?: string;
+  creators?: { address: string; share: number }[];
+  imageLink?: string;
+}

package/src/external/external.solana.ts

@@ -0,0 +1,54 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import {
+  ExternalEstimateWriteInfo,
+  ExternalSolanaMintNftInfo,
+  ExternalSolanaMintNftOptions,
+} from "./external.interface";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class ExternalSolana extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+  }
+
+  async mintNft(
+    options: ExternalSolanaMintNftOptions,
+    accessToken?: string
+  ): Promise<ExternalSolanaMintNftInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/external/mint-solana-nft`;
+
+      return this.auth_post<ExternalSolanaMintNftInfo>(
+        `${path}`,
+        options,
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async estimateMintNft(
+    options: ExternalSolanaMintNftOptions,
+    accessToken?: string
+  ): Promise<ExternalEstimateWriteInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/external/mint-solana-nft/estimate`;
+
+      return this.auth_post<ExternalEstimateWriteInfo>(
+        `${path}`,
+        options,
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+}

package/src/external/external.ts

@@ -0,0 +1,73 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import {
+  ExternalEstimateWriteInfo,
+  ExternalOptions,
+  ExternalWriteInfo,
+} from "./external.interface";
+import { ExternalSolana } from "./external.solana";
+
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {}
+
+export class External extends PaytonzSDKBase {
+  constructor(parameters: PaytonzSDKOptions) {
+    super(parameters);
+    this.solana = new ExternalSolana(parameters);
+  }
+
+  solana: ExternalSolana;
+
+  async read(options: ExternalOptions, accessToken?: string): Promise<any> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/external/read`;
+
+      return this.auth_post<any>(`${path}`, { ...options }, accessToken);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async estimateWrite(
+    options: ExternalOptions,
+    accessToken?: string
+  ): Promise<ExternalEstimateWriteInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/external/estimateWrite`;
+
+      return this.auth_post<ExternalEstimateWriteInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async write(
+    options: ExternalOptions,
+    accessToken?: string
+  ): Promise<ExternalWriteInfo> {
+    try {
+      if (!accessToken) {
+        accessToken = await this.getToken(true);
+      }
+      const path = `/api/public/external/write`;
+
+      return this.auth_post<ExternalWriteInfo>(
+        `${path}`,
+        { ...options },
+        accessToken
+      );
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+export default External;

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./constant";
+export { default as PaytonzSDK } from "./PaytonzSDK";
+export { default as default } from "./PaytonzSDK";
+export { PaytonzSDKBase } from "./PaytonzSDKBase";
+export * from "./interfaces/paytonz.interface";

package/src/interfaces/paytonz.interface.ts

@@ -0,0 +1,23 @@
+export interface PaytonzToken {
+  token: string;
+}
+
+export interface AccessWalletOptions {
+  sign?: string;
+  password?: string;
+}
+
+export interface BasePaginationOptions {
+  search?: string;
+  sort?: string;
+  order?: string;
+  page?: number;
+  limit?: number;
+}
+
+export interface IGetToken {
+  publicKey: string;
+  privateKey: string;
+  walletId?: string;
+  passphrase?: string;
+}