@xoxno/sdk-js 0.0.1

package/src/utils/SmartContractAbis.ts

@@ -0,0 +1,82 @@
+import { AbiRegistry } from '@multiversx/sdk-core';
+import axios from 'axios';
+
+export class SmartContractAbis {
+  private static manager: AbiRegistry;
+  private static exchange: AbiRegistry;
+  private static minter: AbiRegistry;
+  private static market: AbiRegistry;
+  private static staking: AbiRegistry;
+  private static p2p: AbiRegistry;
+
+  public static async getMarket(): Promise<AbiRegistry> {
+    if (!SmartContractAbis.market) {
+      const { data } = await axios(
+        `${'https://media.xoxno.com/'}smartcontractabi/esdt-nft-marketplace.abi.json`
+      );
+      const abiRegistry = AbiRegistry.create(data);
+      SmartContractAbis.market = abiRegistry;
+    }
+
+    return SmartContractAbis.market;
+  }
+  public static async getManager(): Promise<AbiRegistry> {
+    if (!SmartContractAbis.manager) {
+      const { data } = await axios(
+        `${'https://media.xoxno.com/'}smartcontractabi/manage.json`
+      );
+      const abiRegistry = AbiRegistry.create(data);
+      SmartContractAbis.manager = abiRegistry;
+    }
+
+    return SmartContractAbis.manager;
+  }
+
+  public static async getMinter(): Promise<AbiRegistry> {
+    if (!SmartContractAbis.minter) {
+      const { data } = await axios(
+        `${'https://media.xoxno.com/'}smartcontractabi/minter.json`
+      );
+      const abiRegistry = AbiRegistry.create(data);
+      SmartContractAbis.minter = abiRegistry;
+    }
+
+    return SmartContractAbis.minter;
+  }
+
+  public static async getStaking(): Promise<AbiRegistry> {
+    if (!SmartContractAbis.staking) {
+      const { data } = await axios(
+        `${'https://media.xoxno.com/'}smartcontractabi/staking-nfts.abi.json`
+      );
+      const abiRegistry = AbiRegistry.create(data);
+      SmartContractAbis.staking = abiRegistry;
+    }
+
+    return SmartContractAbis.staking;
+  }
+
+  public static async getExchange(): Promise<AbiRegistry> {
+    if (!SmartContractAbis.exchange) {
+      const { data } = await axios(
+        `${'https://media.xoxno.com/'}smartcontractabi/rs-exchange.abi.json`
+      );
+      const abiRegistry = AbiRegistry.create(data);
+      SmartContractAbis.exchange = abiRegistry;
+    }
+
+    return SmartContractAbis.exchange;
+  }
+
+  public static async getP2P(): Promise<AbiRegistry> {
+    if (!SmartContractAbis.p2p) {
+      const { data } = await axios(
+        `${'https://media.xoxno.com/'}smartcontractabi/p2p.abi.json`
+      );
+      const abiRegistry = AbiRegistry.create(data);
+      SmartContractAbis.p2p = abiRegistry;
+    }
+
+    return SmartContractAbis.p2p;
+  }
+}

package/src/utils/SmartContractService.ts

@@ -0,0 +1,17 @@
+import {
+  AbiRegistry,
+  Address,
+  SmartContract,
+  SmartContractAbi,
+} from '@multiversx/sdk-core/out';
+
+export const getSmartContract = (
+  abiRegistry: AbiRegistry,
+  address: Address,
+  implementedInterface: string
+) => {
+  return new SmartContract({
+    address: address,
+    abi: new SmartContractAbi(abiRegistry, [implementedInterface]),
+  });
+};

package/src/utils/api.ts

@@ -0,0 +1,133 @@
+import axios from 'axios';
+import {
+  API_URL,
+  DR_SC,
+  FM_SC,
+  KG_SC,
+  Manager_SC,
+  Manager_SC_DEV,
+  P2P_SC,
+  P2P_SC_DEV,
+  Staking_SC,
+  Staking_SC_DEV,
+  XOXNO_SC,
+  XOXNO_SC_DEV,
+} from './const';
+export const enum Chain {
+  MAINNET = '1',
+  DEVNET = 'D',
+}
+export class APIClient {
+  private static instance: APIClient;
+  public apiUrl: string;
+  private apiKey: string;
+  public chain: Chain;
+  public config: {
+    XO_SC: string;
+    FM_SC: string;
+    DR_SC: string;
+    KG_SC: string;
+    Staking_SC: string;
+    Manager_SC: string;
+    P2P_SC: string;
+  };
+
+  private constructor(apiUrl: string, apiKey: string, chain: Chain) {
+    this.apiUrl = apiUrl;
+    this.apiKey = apiKey;
+    this.chain = chain;
+    this.config =
+      chain === Chain.MAINNET
+        ? {
+            XO_SC: XOXNO_SC,
+            FM_SC: FM_SC,
+            DR_SC,
+            KG_SC,
+            Staking_SC,
+            Manager_SC,
+            P2P_SC,
+          }
+        : {
+            XO_SC: XOXNO_SC_DEV,
+            FM_SC,
+            DR_SC,
+            KG_SC,
+            Staking_SC: Staking_SC_DEV,
+            Manager_SC: Manager_SC_DEV,
+            P2P_SC: P2P_SC_DEV,
+          };
+  }
+
+  public static init(
+    apiUrl: string = API_URL,
+    apiKey = '',
+    chain: Chain = Chain.MAINNET
+  ): APIClient {
+    if (!APIClient.instance) {
+      APIClient.instance = new APIClient(apiUrl, apiKey, chain);
+    }
+    return APIClient.instance;
+  }
+
+  public static getClient(): APIClient {
+    if (!APIClient.instance) {
+      throw new Error('APIClient has not been initialized');
+    }
+    return APIClient.instance;
+  }
+
+  public fetchWithTimeout = async <T>(
+    path: string,
+    options: Record<string, unknown> = {},
+    timeout = 40000
+  ): Promise<T> => {
+    const timestamp = Math.round(new Date().getTime() / 1000);
+
+    const headers = {
+      'Accept-Encoding': 'gzip,deflate,br',
+      'xo-time': `Sent-At:${timestamp}`,
+      Referer: 'https://xoxno.sdk',
+      'User-Agent': 'XOXNO/1.0/SDK',
+      ...(options.method === 'POST'
+        ? { 'Content-Type': 'application/json' }
+        : {}),
+      ...((options.headers as object) ?? {}),
+    };
+    try {
+      const { data } = await axios(
+        `${this.apiUrl}${path}${
+          options.params
+            ? '?' +
+              Object.keys(options.params as any)
+                .map((key) => {
+                  return `${key}=${encodeURIComponent(
+                    (options.params as any)[key]
+                  )}`;
+                })
+                .join('&')
+            : ''
+        }`,
+        {
+          timeout,
+          ...options,
+          ...(Object.keys(headers).length ? { headers } : {}),
+          method: (options.method as any) ?? 'GET',
+        }
+      );
+
+      const result = data;
+
+      return result as T;
+    } catch (error) {
+      throw new Error(
+        'Something went wrong inside fetchWithTimeout' +
+          ' ' +
+          path +
+          ' ' +
+          JSON.stringify(options) +
+          ' ' +
+          error
+      );
+    }
+  };
+}

package/src/utils/const.ts

@@ -0,0 +1,26 @@
+export const API_URL = 'https://api.xoxno.com';
+export const API_URL_DEV = 'https://api-dev.xoxno.com';
+
+export const XOXNO_SC =
+  'erd1qqqqqqqqqqqqqpgq6wegs2xkypfpync8mn2sa5cmpqjlvrhwz5nqgepyg8';
+export const FM_SC =
+  'erd1qqqqqqqqqqqqqpgq705fxpfrjne0tl3ece0rrspykq88mynn4kxs2cg43s';
+export const DR_SC =
+  'erd1qqqqqqqqqqqqqpgqd9rvv2n378e27jcts8vfwynpx0gfl5ufz6hqhfy0u0';
+export const KG_SC =
+  'erd1qqqqqqqqqqqqqpgq8xwzu82v8ex3h4ayl5lsvxqxnhecpwyvwe0sf2qj4e';
+export const Staking_SC =
+  'erd1qqqqqqqqqqqqqpgqvpkd3g3uwludduv3797j54qt6c888wa59w2shntt6z';
+export const Manager_SC =
+  'erd1qqqqqqqqqqqqqpgqg9fa0dmpn8fu3fnleeqn5zt8rl8mdqjkys5s2gtas7';
+export const P2P_SC =
+  'erd1qqqqqqqqqqqqqpgq47y8hnct68v6asjv6gxem6h9rumn9frzah0skhxxt6';
+
+export const XOXNO_SC_DEV =
+  'erd1qqqqqqqqqqqqqpgqn4fnwl43hhchz9emdy66eh5azzhl599zd8ssxjdyh3';
+export const Staking_SC_DEV =
+  'erd1qqqqqqqqqqqqqpgqmkt2fvumf0zgum5qd0awl2l46x2pxdgmr5rswjr6r8';
+export const Manager_SC_DEV =
+  'erd1qqqqqqqqqqqqqpgq6sysl7mga393a850xemfpawaqanf4da5d8ssp3xamn';
+export const P2P_SC_DEV =
+  'erd1qqqqqqqqqqqqqpgqhuvnvkwwmucdzy3g7pvgvjumjfcgfwf69w2svch5c2';

package/src/utils/getActivity.ts

@@ -0,0 +1,55 @@
+import {
+  TradincActivityArgs,
+  TradingActivityResponse,
+  TradingActivityQueryFilter,
+} from '../types/trading';
+import { APIClient } from '../utils/api';
+
+/**
+ * Fetches the trading activity of the given collections
+ * @param args - The trading activity arguments
+ * @param api - The API client
+ * @returns - The trading activity response
+ * @throws - If the top is greater than 35
+ */
+export const getActivity = async (
+  args: TradincActivityArgs,
+  api: APIClient
+): Promise<TradingActivityResponse> => {
+  if (args.top && args.top > 35) {
+    throw new Error('Top cannot be greater than 35');
+  }
+
+  const payloadBody: TradingActivityQueryFilter = {
+    filters: {
+      collection: args.collections,
+      identifier: args.identifiers || undefined,
+      address: args.owners || undefined,
+      tokens: args.placedInToken || undefined,
+      marketplace: args.marketplaces || undefined,
+      action: args.actions || undefined,
+      range: args.priceRange,
+      rankRange: args.rankRange,
+      timestampRange: args.timestampRange,
+      attributes: args.attributes,
+    },
+    orderBy: args.orderBy,
+    select: args.select,
+    top: args.top || 35,
+    skip: args.skip || 0,
+  };
+
+  const buffer = Buffer.from(JSON.stringify(payloadBody)).toString('base64');
+  const response = await api.fetchWithTimeout<TradingActivityResponse>(
+    `/getTradingActivity/${buffer}`
+  );
+
+  return {
+    ...response,
+    getNextPagePayload: {
+      ...args,
+      skip: (args.skip ?? 0) + (args.top ?? 35),
+    },
+    empty: response.resources.length === 0,
+  };
+};

package/src/utils/helpers.ts

@@ -0,0 +1,14 @@
+export const nonceToHex = (nonce: number): string => {
+  let nonceHex = nonce.toString(16);
+  if (nonceHex.length % 2 !== 0) {
+    nonceHex = '0' + nonceHex;
+  }
+  return nonceHex;
+};
+
+export const getIdentifierFromColAndNonce = (
+  collection: string,
+  nonce: number
+): string => {
+  return [collection, nonceToHex(nonce)].join('-');
+};

package/src/utils/regex.ts

@@ -0,0 +1,7 @@
+export const isValidCollectionTicker = (ticker: string): boolean => {
+  return /^[A-Z0-9]{3,10}-[a-z0-9]{6}$/.test(ticker);
+};
+
+export const isValidNftIdentifier = (identifier: string): boolean => {
+  return /^[A-Za-z0-9]{3,10}-[A-Za-z0-9]{6}-[A-Za-z0-9]{2,5}$/.test(identifier);
+};

package/src/utils/scCalls.ts

@@ -0,0 +1,48 @@
+import {
+  ContractQueryResponse,
+  ProxyNetworkProvider,
+} from '@multiversx/sdk-network-providers';
+import { INetworkProvider } from '@multiversx/sdk-network-providers/out/interface';
+import {
+  ResultsParser,
+  SmartContract,
+  Interaction,
+  TypedOutcomeBundle,
+} from '@multiversx/sdk-core';
+import { APIClient } from './api';
+
+export class ContractQueryRunner {
+  private readonly proxy: INetworkProvider;
+  private readonly parser: ResultsParser = new ResultsParser();
+
+  constructor() {
+    const api = APIClient.getClient().apiUrl;
+    this.proxy = new ProxyNetworkProvider(api, {
+      timeout: 10000,
+    });
+  }
+
+  async runQuery(
+    contract: SmartContract,
+    interaction: Interaction
+  ): Promise<TypedOutcomeBundle> {
+    try {
+      const queryResponse: ContractQueryResponse =
+        await this.proxy.queryContract(interaction.buildQuery());
+
+      return this.parser.parseQueryResponse(
+        queryResponse,
+        interaction.getEndpoint()
+      );
+    } catch (error) {
+      console.log(
+        `Unexpected error when running query '${
+          interaction.buildQuery().func
+        }' to sc '${contract.getAddress().bech32()}' `
+      );
+      console.error(error);
+
+      throw error;
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"]
+}

package/webpack.config.js

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const path = require('path');
+
+module.exports = {
+  mode: 'production',
+  entry: './src/index.ts',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'xoxno.min.js',
+    library: {
+      name: 'XOXNO',
+      type: 'umd',
+    },
+    clean: true,
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+    ],
+  },
+};