paj_ramp 1.2.7 → 1.2.9

package/README.md

@@ -60,9 +60,9 @@ const verified = await verify(
 **_Get All Rate_**
 
 ```typescript
-import { getRate } from 'paj_ramp';
+import { getAllRate } from 'paj_ramp';
 
-const rate = await getRate();
+const rate = await getAllRate();
 /*
 Response:
 {
@@ -86,9 +86,9 @@ Response:
 **_Get Rate by Amount_**
 
 ```typescript
-import { getRate } from 'paj_ramp';
+import { getRateByAmount } from 'paj_ramp';
 
-const rate = await getRate(50000);
+const rate = await getRateByAmount(50000);
 /*
 Response:
 {
@@ -109,9 +109,9 @@ Response:
 **_Get Rate by Rate Type_**
 
 ```typescript
-import { getRate, RateType } from 'paj_ramp';
+import { getRateByType, RateType } from 'paj_ramp';
 
-const rate = await getRate(RateType.offRamp); // or RateType.onRamp
+const rate = await getRateByType(RateType.offRamp); // or RateType.onRamp
 
 /*
 Response:
@@ -127,9 +127,9 @@ Response:
 **_Get Token Value from Amount and Mint Token_**
 
 ```typescript
-import { getRate } from 'paj_ramp';
+import { getTokenValue } from 'paj_ramp';
 
-const tokenValue = await getRate(50000, 'token_mint_address');
+const tokenValue = await getTokenValue(50000, 'token_mint_address');
 /*
 Response:
 {

package/dist/lib/off_ramp/getAllRate.d.ts

@@ -0,0 +1,27 @@
+type AllRateResponseType = {
+    onRampRate: {
+        baseCurrency: string;
+        targetCurrency: string;
+        isActive: boolean;
+        rate: number;
+        type: string;
+    };
+    offRampRate: {
+        baseCurrency: string;
+        targetCurrency: string;
+        isActive: boolean;
+        rate: number;
+        type: string;
+    };
+};
+/**
+ * This TypeScript function asynchronously fetches all rates from a specified URL and handles any
+ * errors that may occur.
+ * @returns The `getAllRate` function is returning the result of the `get<AllRateResponseType>(url)`
+ * function call, which is fetching rate data from the specified URL '/pub/rate'. The function is using
+ * async/await syntax to handle asynchronous operations and is catching any errors that occur during
+ * the fetch operation. If successful, the function will return the rate data, and if an error occurs,
+ * it
+ */
+export declare const getAllRate: () => Promise<AllRateResponseType>;
+export {};

package/dist/lib/off_ramp/getAllRate.js

@@ -0,0 +1,20 @@
+import { get } from '../../utils/api.js';
+/**
+ * This TypeScript function asynchronously fetches all rates from a specified URL and handles any
+ * errors that may occur.
+ * @returns The `getAllRate` function is returning the result of the `get<AllRateResponseType>(url)`
+ * function call, which is fetching rate data from the specified URL '/pub/rate'. The function is using
+ * async/await syntax to handle asynchronous operations and is catching any errors that occur during
+ * the fetch operation. If successful, the function will return the rate data, and if an error occurs,
+ * it
+ */
+export const getAllRate = async () => {
+    const url = '/pub/rate';
+    try {
+        return await get(url);
+    }
+    catch (err) {
+        console.error('Error fetching Rate:', err);
+        throw err;
+    }
+};

package/dist/lib/off_ramp/getRate.d.ts

@@ -54,7 +54,10 @@ export declare enum RateType {
  * @returns The `getRate` function returns different values based on the conditions inside the
  * function:
  */
-export declare const getRate: (param: number | RateType, mint_token?: string) => Promise<AllRateResponseType | RateByAmountType | RateByRateTypeType | TokenValueType | undefined>;
+export declare function getRate(): Promise<AllRateResponseType>;
+export declare function getRate(param: number, mint_token: string): Promise<TokenValueType>;
+export declare function getRate(param: number): Promise<RateByAmountType>;
+export declare function getRate(param: RateType): Promise<RateByRateTypeType>;
 /**
  * The function `getAllRate` fetches all rates from a specified URL and handles any errors that occur
  * during the process.

package/dist/lib/off_ramp/getRate.js

@@ -4,18 +4,7 @@ export var RateType;
     RateType["onRamp"] = "onRamp";
     RateType["offRamp"] = "offRamp";
 })(RateType || (RateType = {}));
-/**
- * The function `getRate` in TypeScript is an asynchronous function that retrieves rate information
- * based on different parameters such as amount, rate type, and mint token.
- * @param {number | RateType} param - The `param` parameter in the `getRate` function can be either a
- * number or a `RateType`.
- * @param {string} [mint_token] - The `mint_token` parameter is an optional string parameter that
- * represents a token used for minting. It is used in the `getRate` function to calculate the rate
- * based on the specified token value.
- * @returns The `getRate` function returns different values based on the conditions inside the
- * function:
- */
-export const getRate = async (param, mint_token) => {
+export async function getRate(param, mint_token) {
     try {
         const url = '/pub/rate';
         if (!param) {
@@ -34,7 +23,7 @@ export const getRate = async (param, mint_token) => {
         console.error('Error fetching Rate:', err);
         throw err;
     }
-};
+}
 /**
  * The function `getAllRate` fetches all rates from a specified URL and handles any errors that occur
  * during the process.

package/dist/lib/off_ramp/getRateByAmount.d.ts

@@ -0,0 +1,27 @@
+type RateByAmountType = {
+    rate: {
+        baseCurrency: string;
+        targetCurrency: string;
+        rate: number;
+    };
+    amounts: {
+        userTax: number;
+        merchantTax: number;
+        amountUSD: number;
+        userAmountFiat: number;
+    };
+};
+/**
+ * The function `getRateByAmount` fetches a rate based on a specified amount asynchronously.
+ * @param {number} amount - The `amount` parameter in the `getRateByAmount` function is a number
+ * representing the amount for which you want to retrieve the rate. This function makes an asynchronous
+ * request to the `/pub/rate` endpoint with the specified amount to fetch the rate information. If
+ * successful, it returns the rate
+ * @returns The `getRateByAmount` function is returning a Promise that resolves to the rate for a
+ * specific amount. The rate is fetched from the specified URL endpoint `/pub/rate` with the provided
+ * amount as a parameter. If the rate is successfully fetched, it will be returned. If there is an
+ * error during the fetching process, an error message will be logged to the console and the error will
+ * be
+ */
+export declare const getRateByAmount: (amount: number) => Promise<RateByAmountType>;
+export {};

package/dist/lib/off_ramp/getRateByAmount.js

@@ -0,0 +1,23 @@
+import { get } from '../../utils/api.js';
+/**
+ * The function `getRateByAmount` fetches a rate based on a specified amount asynchronously.
+ * @param {number} amount - The `amount` parameter in the `getRateByAmount` function is a number
+ * representing the amount for which you want to retrieve the rate. This function makes an asynchronous
+ * request to the `/pub/rate` endpoint with the specified amount to fetch the rate information. If
+ * successful, it returns the rate
+ * @returns The `getRateByAmount` function is returning a Promise that resolves to the rate for a
+ * specific amount. The rate is fetched from the specified URL endpoint `/pub/rate` with the provided
+ * amount as a parameter. If the rate is successfully fetched, it will be returned. If there is an
+ * error during the fetching process, an error message will be logged to the console and the error will
+ * be
+ */
+export const getRateByAmount = async (amount) => {
+    const url = '/pub/rate';
+    try {
+        return await get(`${url}/${amount}`);
+    }
+    catch (err) {
+        console.error('Error fetching Rate by Amount:', err);
+        throw err;
+    }
+};

package/dist/lib/off_ramp/getRateByType.d.ts

@@ -0,0 +1,21 @@
+type RateByType = {
+    baseCurrency: string;
+    targetCurrency: string;
+    isActive: true;
+    rate: number;
+    type: string;
+};
+export declare enum RateType {
+    onRamp = "onRamp",
+    offRamp = "offRamp"
+}
+/**
+ * This function fetches a rate based on a specified rate type asynchronously.
+ * @param {RateType} rateType - RateType is a type that specifies the type of rate being requested,
+ * such as 'standard', 'premium', 'discount', etc.
+ * @returns The `getRateByType` function is returning a Promise that resolves to a `RateByType` object
+ * fetched from the specified URL based on the `rateType` parameter. If an error occurs during the
+ * fetching process, the function will log an error message and rethrow the error.
+ */
+export declare const getRateByType: (rateType: RateType) => Promise<RateByType>;
+export {};

package/dist/lib/off_ramp/getRateByType.js

@@ -0,0 +1,24 @@
+import { get } from '../../utils/api.js';
+export var RateType;
+(function (RateType) {
+    RateType["onRamp"] = "onRamp";
+    RateType["offRamp"] = "offRamp";
+})(RateType || (RateType = {}));
+/**
+ * This function fetches a rate based on a specified rate type asynchronously.
+ * @param {RateType} rateType - RateType is a type that specifies the type of rate being requested,
+ * such as 'standard', 'premium', 'discount', etc.
+ * @returns The `getRateByType` function is returning a Promise that resolves to a `RateByType` object
+ * fetched from the specified URL based on the `rateType` parameter. If an error occurs during the
+ * fetching process, the function will log an error message and rethrow the error.
+ */
+export const getRateByType = async (rateType) => {
+    const url = '/pub/rate';
+    try {
+        return await get(`${url}/${rateType}`);
+    }
+    catch (err) {
+        console.error('Error fetching Rate by Rate Type:', err);
+        throw err;
+    }
+};

package/dist/lib/off_ramp/getTokenValue.d.ts

@@ -0,0 +1,20 @@
+type TokenValueType = {
+    amount: number;
+    usdcValue: number;
+    mint: string;
+};
+/**
+ * The function `getTokenValue` asynchronously fetches the value of a token based on the specified
+ * amount and token mint.
+ * @param {number} amount - The `amount` parameter is a number representing the quantity of tokens for
+ * which you want to retrieve the value.
+ * @param {string} mint_token - The `mint_token` parameter in the `getTokenValue` function represents
+ * the unique identifier for a specific token. It is used to specify which token you are interested in
+ * when fetching its value.
+ * @returns The `getTokenValue` function is returning the result of the `get` function call with the
+ * URL `/value?amount=&mint=` as its argument. The `get` function is likely
+ * making an HTTP request to fetch the token value based on the provided amount and mint token. If
+ * successful, the function will return the token value. If there is an error during
+ */
+export declare const getTokenValue: (amount: number, mint_token: string) => Promise<TokenValueType>;
+export {};

package/dist/lib/off_ramp/getTokenValue.js

@@ -0,0 +1,24 @@
+import { get } from '../../utils/api.js';
+/**
+ * The function `getTokenValue` asynchronously fetches the value of a token based on the specified
+ * amount and token mint.
+ * @param {number} amount - The `amount` parameter is a number representing the quantity of tokens for
+ * which you want to retrieve the value.
+ * @param {string} mint_token - The `mint_token` parameter in the `getTokenValue` function represents
+ * the unique identifier for a specific token. It is used to specify which token you are interested in
+ * when fetching its value.
+ * @returns The `getTokenValue` function is returning the result of the `get` function call with the
+ * URL `/value?amount=&mint=` as its argument. The `get` function is likely
+ * making an HTTP request to fetch the token value based on the provided amount and mint token. If
+ * successful, the function will return the token value. If there is an error during
+ */
+export const getTokenValue = async (amount, mint_token) => {
+    const url = '/pub/rate';
+    try {
+        return await get(`${url}/value?amount=${amount}&mint=${mint_token}`);
+    }
+    catch (err) {
+        console.log('Error fetching Token Value:', err);
+        throw err;
+    }
+};

package/dist/lib/on_ramp/createOrder.d.ts

@@ -7,5 +7,12 @@ type CreateOrderType = {
     webhookURL: string;
     token?: string;
 };
-export declare const createOrder: (options: CreateOrderType) => Promise<CreateOrderType>;
+type CreateOrderResponseType = {
+    id: string;
+    accountNumber: string;
+    accountName: string;
+    amount: number;
+    bank: string;
+};
+export declare const createOrder: (options: CreateOrderType) => Promise<CreateOrderResponseType>;
 export {};

package/dist/lib/on_ramp/createOrder.js

@@ -1,20 +1,20 @@
-import { post } from "../../utils/api.js";
+import { post } from '../../utils/api.js';
 export const createOrder = async (options) => {
     const { fiatAmount, currency, recipient, mint, chain, webhookURL, token } = options;
     try {
-        return await post("/pub/onramp", {
+        return await post('/pub/onramp', {
             fiatAmount,
             currency,
             recipient,
             mint,
             chain,
-            webhookURL
+            webhookURL,
         }, {
             Authorization: `Bearer ${token}`,
         });
     }
     catch (err) {
-        console.error("Error creating order:", err);
+        console.error('Error creating order:', err);
         throw err;
     }
 };

package/dist/sdk.d.ts

@@ -1,12 +1,14 @@
 export declare const initializeSDK: (env: "staging" | "production") => void;
-export { getRate } from './lib/off_ramp/getRate.js';
+export { getAllRate } from './lib/off_ramp/getAllRate.js';
+export { getRateByAmount } from './lib/off_ramp/getRateByAmount.js';
+export { getRateByType } from './lib/off_ramp/getRateByType.js';
+export { getTokenValue } from './lib/off_ramp/getTokenValue.js';
 export { initiate } from './lib/off_ramp/initiate.js';
 export { verify } from './lib/off_ramp/verify.js';
-export { getBanks } from "./lib/off_ramp/getBanks.js";
-export { resolveBankAccount } from "./lib/off_ramp/resolveBankAccount.js";
-export { addBankAccount } from "./lib/off_ramp/addBankAccount.js";
-export { getBankAccounts } from "./lib/off_ramp/getBankAccounts.js";
+export { getBanks } from './lib/off_ramp/getBanks.js';
+export { resolveBankAccount } from './lib/off_ramp/resolveBankAccount.js';
+export { addBankAccount } from './lib/off_ramp/addBankAccount.js';
+export { getBankAccounts } from './lib/off_ramp/getBankAccounts.js';
 export { offRampCreateOrder } from './lib/direct_off_ramp/directCreateOrder.js';
 export { createOrder } from './lib/on_ramp/createOrder.js';
-export { observeOrder } from './lib/on_ramp/observeOrder.js';
-export { RateType } from './lib/off_ramp/getRate.js';
+export { RateType } from './lib/off_ramp/getRateByType.js';

package/dist/sdk.js

@@ -12,15 +12,18 @@ export const initializeSDK = (env) => {
 // OFF RAMP
 // Wallet Info
 // export { getTXPoolAddress } from "./lib/off_ramp/getTXPoolAddress.js";
-export { getRate } from './lib/off_ramp/getRate.js';
+export { getAllRate } from './lib/off_ramp/getAllRate.js';
+export { getRateByAmount } from './lib/off_ramp/getRateByAmount.js';
+export { getRateByType } from './lib/off_ramp/getRateByType.js';
+export { getTokenValue } from './lib/off_ramp/getTokenValue.js';
 // Session Management
 export { initiate } from './lib/off_ramp/initiate.js';
 export { verify } from './lib/off_ramp/verify.js';
 //  // Banking Operations
-export { getBanks } from "./lib/off_ramp/getBanks.js";
-export { resolveBankAccount } from "./lib/off_ramp/resolveBankAccount.js";
-export { addBankAccount } from "./lib/off_ramp/addBankAccount.js";
-export { getBankAccounts } from "./lib/off_ramp/getBankAccounts.js";
+export { getBanks } from './lib/off_ramp/getBanks.js';
+export { resolveBankAccount } from './lib/off_ramp/resolveBankAccount.js';
+export { addBankAccount } from './lib/off_ramp/addBankAccount.js';
+export { getBankAccounts } from './lib/off_ramp/getBankAccounts.js';
 // Wallet Operations
 // export { getWallet } from './lib/off_ramp/getWallet.js';
 // export { addWallet } from './lib/off_ramp/addWallet.js';
@@ -31,6 +34,6 @@ export { offRampCreateOrder } from './lib/direct_off_ramp/directCreateOrder.js';
 // Create Order
 export { createOrder } from './lib/on_ramp/createOrder.js';
 // Observe Order Socket.IO
-export { observeOrder } from './lib/on_ramp/observeOrder.js';
+// export { observeOrder } from './lib/on_ramp/observeOrder.js';
 // Types
-export { RateType } from './lib/off_ramp/getRate.js';
+export { RateType } from './lib/off_ramp/getRateByType.js';

package/lib/off_ramp/getAllRate.ts

@@ -0,0 +1,39 @@
+import { get } from '../../utils/api.js';
+
+type AllRateResponseType = {
+  onRampRate: {
+    baseCurrency: string;
+    targetCurrency: string;
+    isActive: boolean;
+    rate: number;
+    type: string;
+  };
+  offRampRate: {
+    baseCurrency: string;
+    targetCurrency: string;
+    isActive: boolean;
+    rate: number;
+    type: string;
+  };
+};
+
+
+/**
+ * This TypeScript function asynchronously fetches all rates from a specified URL and handles any
+ * errors that may occur.
+ * @returns The `getAllRate` function is returning the result of the `get<AllRateResponseType>(url)`
+ * function call, which is fetching rate data from the specified URL '/pub/rate'. The function is using
+ * async/await syntax to handle asynchronous operations and is catching any errors that occur during
+ * the fetch operation. If successful, the function will return the rate data, and if an error occurs,
+ * it
+ */
+export const getAllRate = async () => {
+  const url: string = '/pub/rate';
+
+  try {
+    return await get<AllRateResponseType>(url);
+  } catch (err) {
+    console.error('Error fetching Rate:', err);
+    throw err;
+  }
+};

package/lib/off_ramp/getRateByAmount.ts

@@ -0,0 +1,38 @@
+import { get } from '../../utils/api.js';
+
+type RateByAmountType = {
+  rate: {
+    baseCurrency: string;
+    targetCurrency: string;
+    rate: number;
+  };
+  amounts: {
+    userTax: number;
+    merchantTax: number;
+    amountUSD: number;
+    userAmountFiat: number;
+  };
+};
+
+/**
+ * The function `getRateByAmount` fetches a rate based on a specified amount asynchronously.
+ * @param {number} amount - The `amount` parameter in the `getRateByAmount` function is a number
+ * representing the amount for which you want to retrieve the rate. This function makes an asynchronous
+ * request to the `/pub/rate` endpoint with the specified amount to fetch the rate information. If
+ * successful, it returns the rate
+ * @returns The `getRateByAmount` function is returning a Promise that resolves to the rate for a
+ * specific amount. The rate is fetched from the specified URL endpoint `/pub/rate` with the provided
+ * amount as a parameter. If the rate is successfully fetched, it will be returned. If there is an
+ * error during the fetching process, an error message will be logged to the console and the error will
+ * be
+ */
+export const getRateByAmount = async (amount: number) => {
+  const url: string = '/pub/rate';
+
+  try {
+    return await get<RateByAmountType>(`${url}/${amount}`);
+  } catch (err) {
+    console.error('Error fetching Rate by Amount:', err);
+    throw err;
+  }
+};

package/lib/off_ramp/getRateByType.ts

@@ -0,0 +1,33 @@
+import { get } from '../../utils/api.js';
+
+type RateByType = {
+  baseCurrency: string;
+  targetCurrency: string;
+  isActive: true;
+  rate: number;
+  type: string;
+};
+
+export enum RateType {
+  onRamp = 'onRamp',
+  offRamp = 'offRamp',
+}
+
+/**
+ * This function fetches a rate based on a specified rate type asynchronously.
+ * @param {RateType} rateType - RateType is a type that specifies the type of rate being requested,
+ * such as 'standard', 'premium', 'discount', etc.
+ * @returns The `getRateByType` function is returning a Promise that resolves to a `RateByType` object
+ * fetched from the specified URL based on the `rateType` parameter. If an error occurs during the
+ * fetching process, the function will log an error message and rethrow the error.
+ */
+export const getRateByType = async (rateType: RateType) => {
+  const url: string = '/pub/rate';
+
+  try {
+    return await get<RateByType>(`${url}/${rateType}`);
+  } catch (err) {
+    console.error('Error fetching Rate by Rate Type:', err);
+    throw err;
+  }
+};

package/lib/off_ramp/getTokenValue.ts

@@ -0,0 +1,36 @@
+import { get } from '../../utils/api.js';
+
+type TokenValueType = {
+  amount: number;
+  usdcValue: number;
+  mint: string;
+};
+
+/**
+ * The function `getTokenValue` asynchronously fetches the value of a token based on the specified
+ * amount and token mint.
+ * @param {number} amount - The `amount` parameter is a number representing the quantity of tokens for
+ * which you want to retrieve the value.
+ * @param {string} mint_token - The `mint_token` parameter in the `getTokenValue` function represents
+ * the unique identifier for a specific token. It is used to specify which token you are interested in
+ * when fetching its value.
+ * @returns The `getTokenValue` function is returning the result of the `get` function call with the
+ * URL `/value?amount=&mint=` as its argument. The `get` function is likely
+ * making an HTTP request to fetch the token value based on the provided amount and mint token. If
+ * successful, the function will return the token value. If there is an error during
+ */
+export const getTokenValue = async (
+  amount: number,
+  mint_token: string
+) => {
+  const url: string = '/pub/rate';
+
+  try {
+    return await get<TokenValueType>(
+      `${url}/value?amount=${amount}&mint=${mint_token}`
+    );
+  } catch (err) {
+    console.log('Error fetching Token Value:', err);
+    throw err;
+  }
+};

package/lib/on_ramp/createOrder.ts

@@ -1,4 +1,4 @@
-import { post } from "../../utils/api.js";
+import { post } from '../../utils/api.js';
 
 type CreateOrderType = {
   fiatAmount: number;
@@ -10,25 +10,34 @@ type CreateOrderType = {
   token?: string;
 };
 
+type CreateOrderResponseType = {
+  id: string;
+  accountNumber: string;
+  accountName: string;
+  amount: number;
+  bank: string;
+};
+
 export const createOrder = async (options: CreateOrderType) => {
-  const { fiatAmount, currency, recipient, mint, chain, webhookURL, token } = options;
+  const { fiatAmount, currency, recipient, mint, chain, webhookURL, token } =
+    options;
   try {
-    return await post<CreateOrderType>(
-      "/pub/onramp",
+    return await post<CreateOrderResponseType>(
+      '/pub/onramp',
       {
         fiatAmount,
         currency,
         recipient,
         mint,
         chain,
-        webhookURL
+        webhookURL,
       },
       {
         Authorization: `Bearer ${token}`,
       }
     );
   } catch (err) {
-    console.error("Error creating order:", err);
+    console.error('Error creating order:', err);
     throw err;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paj_ramp",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "paj offramp/onramp service",
   "main": "dist/sdk.js",
   "types": "dist/sdk.d.ts",

package/sdk.ts

@@ -2,6 +2,9 @@
 
 // Switch Environment: "staging" | "production"
 import { setBaseUrl } from './utils/axios.js';
+import { getRateByAmount } from './lib/off_ramp/getRateByAmount';
+import { getRateByRateType } from './dist/lib/off_ramp/getRate';
+import { getTokenValue } from './lib/off_ramp/getTokenValue';
 
 export const initializeSDK = (env: 'staging' | 'production') => {
   if (env === 'staging') {
@@ -15,17 +18,20 @@ export const initializeSDK = (env: 'staging' | 'production') => {
 
 // Wallet Info
 // export { getTXPoolAddress } from "./lib/off_ramp/getTXPoolAddress.js";
-export { getRate } from './lib/off_ramp/getRate.js';
+export { getAllRate } from './lib/off_ramp/getAllRate.js';
+export { getRateByAmount } from './lib/off_ramp/getRateByAmount.js';
+export { getRateByType } from './lib/off_ramp/getRateByType.js';
+export { getTokenValue } from './lib/off_ramp/getTokenValue.js';
 
 // Session Management
 export { initiate } from './lib/off_ramp/initiate.js';
 export { verify } from './lib/off_ramp/verify.js';
 
 //  // Banking Operations
-export { getBanks } from "./lib/off_ramp/getBanks.js";
-export { resolveBankAccount } from "./lib/off_ramp/resolveBankAccount.js";
-export { addBankAccount } from "./lib/off_ramp/addBankAccount.js";
-export { getBankAccounts } from "./lib/off_ramp/getBankAccounts.js";
+export { getBanks } from './lib/off_ramp/getBanks.js';
+export { resolveBankAccount } from './lib/off_ramp/resolveBankAccount.js';
+export { addBankAccount } from './lib/off_ramp/addBankAccount.js';
+export { getBankAccounts } from './lib/off_ramp/getBankAccounts.js';
 
 // Wallet Operations
 // export { getWallet } from './lib/off_ramp/getWallet.js';
@@ -35,14 +41,13 @@ export { getBankAccounts } from "./lib/off_ramp/getBankAccounts.js";
 // DIRECT OFF RAMP
 export { offRampCreateOrder } from './lib/direct_off_ramp/directCreateOrder.js';
 
-
 // ON RAMP
 
 // Create Order
 export { createOrder } from './lib/on_ramp/createOrder.js';
 
 // Observe Order Socket.IO
-export { observeOrder } from './lib/on_ramp/observeOrder.js';
+// export { observeOrder } from './lib/on_ramp/observeOrder.js';
 
 // Types
-export { RateType } from './lib/off_ramp/getRate.js';
+export { RateType } from './lib/off_ramp/getRateByType.js';

package/lib/off_ramp/getRate.ts

@@ -1,169 +0,0 @@
-import { get } from '../../utils/api.js';
-
-type AllRateResponseType = {
-  onRampRate: {
-    baseCurrency: string;
-    targetCurrency: string;
-    isActive: boolean;
-    rate: number;
-    type: string;
-  };
-  offRampRate: {
-    baseCurrency: string;
-    targetCurrency: string;
-    isActive: boolean;
-    rate: number;
-    type: string;
-  };
-};
-
-type RateByAmountType = {
-  rate: {
-    baseCurrency: string;
-    targetCurrency: string;
-    rate: number;
-  };
-  amounts: {
-    userTax: number;
-    merchantTax: number;
-    amountUSD: number;
-    userAmountFiat: number;
-  };
-};
-
-type RateByRateTypeType = {
-  baseCurrency: string;
-  targetCurrency: string;
-  isActive: true;
-  rate: number;
-  type: string;
-};
-
-type TokenValueType = {
-  amount: number;
-  usdcValue: number;
-  mint: string;
-};
-
-export enum RateType {
-  onRamp = 'onRamp',
-  offRamp = 'offRamp',
-}
-
-/**
- * The function `getRate` in TypeScript is an asynchronous function that retrieves rate information
- * based on different parameters such as amount, rate type, and mint token.
- * @param {number | RateType} param - The `param` parameter in the `getRate` function can be either a
- * number or a `RateType`.
- * @param {string} [mint_token] - The `mint_token` parameter is an optional string parameter that
- * represents a token used for minting. It is used in the `getRate` function to calculate the rate
- * based on the specified token value.
- * @returns The `getRate` function returns different values based on the conditions inside the
- * function:
- */
-export const getRate = async (
-  param: number | RateType,
-  mint_token?: string
-) => {
-  try {
-    const url = '/pub/rate';
-
-    if (!param) {
-      return getAllRate(url);
-    } else if (typeof param === 'number') {
-      if (mint_token) return getTokenValue(url, param, mint_token);
-      return getRateByAmount(url, param);
-    } else {
-      return getRateByRateType(url, param);
-    }
-  } catch (err) {
-    console.error('Error fetching Rate:', err);
-    throw err;
-  }
-};
-
-/**
- * The function `getAllRate` fetches all rates from a specified URL and handles any errors that occur
- * during the process.
- * @param {string} url - The `url` parameter in the `getAllRate` function is a string representing the
- * URL from which the rate data will be fetched.
- * @returns The `getAllRate` function is returning the result of the `get<AllRateResponseType>(url)`
- * function call, which is fetching rate data from the specified URL. If successful, it will return the
- * rate data. If an error occurs during the fetching process, it will log the error message and rethrow
- * the error.
- */
-export const getAllRate = async (url: string) => {
-  try {
-    return await get<AllRateResponseType>(url);
-  } catch (err) {
-    console.error('Error fetching Rate:', err);
-    throw err;
-  }
-};
-
-/**
- * The function `getRateByAmount` fetches a rate based on a specified amount from a given URL.
- * @param {string} url - The `url` parameter is a string that represents the URL endpoint where the
- * rate information is fetched from.
- * @param {number} amount - The `amount` parameter in the `getRateByAmount` function is a number
- * representing the amount for which you want to fetch the rate. This amount will be used in the URL to
- * make a request to the specified endpoint to get the rate information for that specific amount.
- * @returns The function `getRateByAmount` is returning a Promise that resolves to a `RateByAmountType`
- * object fetched from the specified URL with the provided amount.
- */
-export const getRateByAmount = async (url: string, amount: number) => {
-  try {
-    return await get<RateByAmountType>(`${url}/${amount}`);
-  } catch (err) {
-    console.error('Error fetching Rate by Amount:', err);
-    throw err;
-  }
-};
-
-/**
- * The function `getRateByRateType` fetches a rate based on a specified rate type from a given URL.
- * @param {string} url - The `url` parameter is a string representing the base URL used to fetch data.
- * @param {RateType} rateType - RateType is a type that represents the different types of rates that
- * can be fetched. It is used as a parameter in the getRateByRateType function to specify the type of
- * rate to retrieve from the provided URL.
- * @returns The `getRateByRateType` function is returning a Promise that resolves to a
- * `RateByRateTypeType` object fetched from the specified URL with the provided rate type.
- */
-export const getRateByRateType = async (url: string, rateType: RateType) => {
-  try {
-    return await get<RateByRateTypeType>(`${url}/${rateType}`);
-  } catch (err) {
-    console.error('Error fetching Rate by Rate Type:', err);
-    throw err;
-  }
-};
-
-/**
- * The function `getTokenValue` asynchronously fetches the value of a token based on the provided URL,
- * amount, and mint token.
- * @param {string} url - The `url` parameter is a string representing the base URL for the API endpoint
- * where you can fetch the token value.
- * @param {number} amount - The `amount` parameter in the `getTokenValue` function represents the
- * quantity or number of tokens for which you want to retrieve the value. It is a numeric value
- * (number) indicating the amount of tokens for which you are querying the value.
- * @param {string} mint_token - The `mint_token` parameter in the `getTokenValue` function represents
- * the unique identifier for a specific token. It is used to specify which token's value you want to
- * retrieve based on the provided `amount`.
- * @returns The `getTokenValue` function is returning the result of the `get` function called with the
- * URL `/value?amount=&mint=`. The `get` function is likely making an HTTP
- * request to that URL to fetch some data. The return value is expected to be of type `TokenValueType`.
- * If an error occurs during the fetch operation, an error message will
- */
-export const getTokenValue = async (
-  url: string,
-  amount: number,
-  mint_token: string
-) => {
-  try {
-    return await get<TokenValueType>(
-      `${url}/value?amount=${amount}&mint=${mint_token}`
-    );
-  } catch (err) {
-    console.log('Error fetching Token Value:', err);
-  }
-};