paj_ramp 1.2.4 → 1.2.6

package/README.md

@@ -1,14 +1,6 @@
 # PAJ Ramp SDK
 
-A comprehensive SDK for PAJ Ramp onramp and offramp operations with real-time transaction updates using Socket.IO.
-
-## Features
-
-- **Onramp Operations**: Create orders and observe real-time updates
-- **Offramp Operations**: Complete offramp workflow with bank account management
-- **Real-time Updates**: Socket.IO integration for live transaction status updates
-- **TypeScript Support**: Full TypeScript definitions included
-- **Functional API**: Clean functional approach for better composability
+A comprehensive SDK for PAJ Ramp onramp and offramp operations with real-time transaction updates using webhooks.
 
 ## Installation
 
@@ -20,9 +12,9 @@ npm install paj_ramp
 yarn add paj_ramp
 ```
 
----
+## Getting Started
 
-## Initialize SDK (select environment: "staging" | "production")
+### Initialize SDK (select environment: "staging" | "production")
 
 ```typescript
 import { initializeSDK } from 'paj_ramp';
@@ -31,10 +23,208 @@ import { initializeSDK } from 'paj_ramp';
 initializeSDK('staging'); // or production
 ```
 
----
+### Initiate Session
+
+```typescript
+import { initiate } from 'paj_ramp';
+
+const initiated = await initiate('your_email@gmail.com', 'business_api_key');
+// Response: { email: string }
+```
+
+### Verify Session
+
+```typescript
+import { verify } from 'paj_ramp';
+
+const verified = await verify(
+  'your_email@gmail.com',
+  'otp',
+  {
+    uuid: string,
+    device: string,
+    //optionL ↓↓↓↓↓
+    os: string, //IOS
+    browser: string, //chrome
+    ip: string,
+  },
+  'business_api_key'
+);
+// Response: { email: string, isActive: string, expiresAt: string, token: string }
+```
+
+## Utility Endpoints
+
+### Handle Rate:
+
+**_Get All Rate_**
+
+```typescript
+import { getRate } from 'paj_ramp';
+
+const rate = await getRate();
+/*
+Response:
+{
+    "onRampRate": {
+        "baseCurrency": "USD",
+        "targetCurrency": "NGN",
+        "isActive": true,
+        "rate": 1510,
+        "type": "onRamp"
+    },
+    "offRampRate": {
+        "baseCurrency": "USD",
+        "targetCurrency": "NGN",
+        "isActive": true,
+        "rate": 1525,
+        "type": "offRamp"
+    }
+}*/
+```
+
+**_Get Rate by Amount_**
+
+```typescript
+import { getRate } from 'paj_ramp';
+
+const rate = await getRate(50000);
+/*
+Response:
+{
+ rate: {
+  baseCurrency: string,
+  targetCurrency: string,
+  rate: number
+  },
+ amounts: {
+  userTax": number,
+  merchantTax": number,
+  amountUSD": number,
+  userAmountFiat": number
+  }
+}*/
+```
+
+**_Get Rate by Rate Type_**
+
+```typescript
+import { getRate, RateType } from 'paj_ramp';
+
+const rate = await getRate(RateType.offRamp); // or RateType.onRamp
+
+/*
+Response:
+"offRampRate": {
+  "baseCurrency": "USD",
+  "targetCurrency": "NGN",
+  "isActive": true,
+  "rate": 1525,
+  "type": "offRamp"
+}*/
+```
+
+**_Get Token Value from Amount and Mint Token_**
 
-# Onramp SDK (Real-time Order Observation)
+```typescript
+import { getRate } from 'paj_ramp';
+
+const tokenValue = await getRate(50000, 'token_mint_address');
+/*
+Response:
+{
+  amount: number,        // requested token amount
+  usdcValue: number,     // USDC value of the token amount
+  mint: string           // token mint address
+}
+*/
+```
+
+### Handle Banks:
+
+**_Get Banks_**
+
+```typescript
+import { getBanks } from 'paj_ramp';
+
+const banks = await getBanks('token');
+// Response: [ { id: string, name: string, country: string } ]
+```
+
+**_Resolve Bank Account_**
+
+```typescript
+import { resolveBankAccount } from 'paj_ramp';
+
+const resolvedBankAccount = await resolveBankAccount(
+  'token',
+  'bank_id',
+  'account_number'
+);
+// Response: { accountName: string, accountNumber: string, bank: { id: string, name: string, code: string, country: string } }
+```
+
+**_Add Bank Account_**
+
+```typescript
+import { addBankAccount } from 'paj_ramp';
+
+const addedBankAccount = await addBankAccount(
+  'token',
+  'bank_id',
+  'account_number'
+);
+// Response: { id: string, accountName: string, accountNumber: string, bank: string }
+```
+
+**_Get Bank Accounts_**
+
+```typescript
+import { getBankAccounts } from 'paj_ramp';
+
+const accounts = await getBankAccounts('token');
+// Response: [ { id: string, accountName: string, accountNumber: string, bank: string } ]
+```
+
+## Offramp Webhook (Direct Offramp)
 
+### Usage Example
+
+```typescript
+import { offRampCreateOrder } from 'paj_ramp';
+
+const createOrder = await offRampCreateOrder(
+  'token',
+  'bank_id',
+  'account_number',
+  'NGN', // Currency
+  10000, // amount
+  'token_mint_address'
+  'webhook_url'
+);
+// Response: { id: string, address: string, signature?: string, mint: string, currency: Currency, amount: number, usdcAmount: number, fiatAmount: number, sender: string, receipiant: string, rate: number, status: TransactionStatus, transactionType: TransactionType }
+```
+
+## Onramp Webhook: Creates a new onramp order and sends status to the webhook url.
+
+### Usage Example
+
+```typescript
+import { createOrder } from 'paj_ramp';
+
+const order = await createOrder({
+  fiatAmount: 10000,
+  currency: 'NGN',
+  recipient: 'wallet_address_here',
+  mint: 'token_mint_address_here',
+  chain: 'SOLANA', //ethereum, polygon, etc
+  webhookURL: 'your_webhook_url',
+  token: 'token_from_verification',
+});
+// Response: { id: string, accountNumber: string, accountName: string, fiatAmount: number, bank: string }
+```
+
+<!--
 ## Quick Start
 
 ### Real-time Order Observation
@@ -142,45 +332,6 @@ Common error messages:
 - `"Connection failed"`
 - `"Socket timeout"`
 
-### createOrder(orderData)
-
-Creates a new onramp order.
-
-**Parameters:**
-
-- `orderData` (object, required): Order creation data
-- `orderData.fiatAmount` (number, required): Order amount
-- `orderData.currency` (string, required): Currency code (e.g., 'USD', 'NGN')
-- `orderData.recipient` (string, required): Wallet address to receive tokens
-- `orderData.mint` (string, required): Token mint address
-- `orderData.chain` (Chain, required): Blockchain network ('solana', 'ethereum', 'polygon')
-- `orderData.token` (string, required): Verification token
-
-**Returns:**
-
-- `id` (string): Unique order identifier
-- `accountNumber` (string): Bank account number for payment
-- `accountName` (string): Bank account holder name
-- `fiatAmount` (number): Order amount in fiat currency
-- `bank` (string): Bank name
-
-**Example:**
-
-```typescript
-import { createOrder } from 'paj_ramp';
-
-const order = await createOrder({
-  fiatAmount: 10000,
-  currency: 'NGN',
-  recipient: 'wallet_address_here',
-  mint: 'token_mint_address_here',
-  chain: 'SOLANA',
-  webhookURL: 'webhook_url',
-  token: 'token_from_verification',
-});
-// Response: { id: string, accountNumber: string, accountName: string, fiatAmount: number, bank: string }
-```
-
 ### Usage Example
 
 ```typescript
@@ -240,251 +391,9 @@ const order = await createOrder({
 
 await example(order.id);
 // Response: { id: string, fiatAmount: string, currency: string, , recipient: string,  mint: string, chain: Chain, amount: number, status: OnRampStatus }
-```
-
----
-
-# Offramp SDK
-
-## Overview
-
-The Offramp SDK provides a set of functions to help users convert Solana-based digital assets to fiat and transfer the resulting funds to traditional bank accounts. It includes session management, rate queries, bank account management, and wallet operations.
-
-## Usage Examples
-
-<!-- ### Get TX Pool Address
-
-```typescript
-import { getTXPoolAddress } from "paj_ramp";
-
-const txpooladdress = await getTXPoolAddress();
-// Response: { address: string }
 ``` -->
 
-### Get Rate
-
-```typescript
-import { getRate } from 'paj_ramp';
-
-const rate = await getRate();
-/*
-Response:
-{
-    "onRampRate": {
-        "baseCurrency": "USD",
-        "targetCurrency": "NGN",
-        "isActive": true,
-        "rate": 1510,
-        "type": "onRamp"
-    },
-    "offRampRate": {
-        "baseCurrency": "USD",
-        "targetCurrency": "NGN",
-        "isActive": true,
-        "rate": 1525,
-        "type": "offRamp"
-    }
-}*/
-```
-
-### Get Rate by Amount
-
-```typescript
-import { getRate } from 'paj_ramp';
-
-const rate = await getRate(50000);
-/*
-Response:
-{
- rate: {
-  baseCurrency: string,
-  targetCurrency: string,
-  rate: number
-  },
- amounts: {
-  userTax": number,
-  merchantTax": number,
-  amountUSD": number,
-  userAmountFiat": number
-  }
-}*/
-```
-
-### Get Rate by Rate Type
-
-```typescript
-import { getRate, RateType } from 'paj_ramp';
-
-const rate = await getRate(RateType.offRamp); // or RateType.onRamp
-
-/*
-Response:
-"offRampRate": {
-  "baseCurrency": "USD",
-  "targetCurrency": "NGN",
-  "isActive": true,
-  "rate": 1525,
-  "type": "offRamp"
-}*/
-```
-
-### Initiate Session
-
-```typescript
-import { initiate } from 'paj_ramp';
-
-const initiated = await initiate('your_email@gmail.com', 'business_api_key');
-// Response: { email: string }
-```
-
-### Verify Session
-
-```typescript
-import { verify } from 'paj_ramp';
-
-const verified = await verify(
-  'your_email@gmail.com',
-  'otp',
-  {
-    uuid: string,
-    device: string,
-    //optionL ↓↓↓↓↓
-    os: string, //IOS
-    browser: string, //chrome
-    ip: string,
-  },
-  'business_api_key'
-);
-// Response: { email: string, isActive: string, expiresAt: string, token: string }
-```
-
-### Get Banks
-
-```typescript
-import { getBanks } from 'paj_ramp';
-
-const banks = await getBanks('token');
-// Response: [ { id: string, name: string, country: string } ]
-```
-
-### Resolve Bank Account
-
-```typescript
-import { resolveBankAccount } from 'paj_ramp';
-
-const resolvedBankAccount = await resolveBankAccount(
-  'token',
-  'bank_id',
-  'account_number'
-);
-// Response: { accountName: string, accountNumber: string, bank: { id: string, name: string, code: string, country: string } }
-```
-
-### Add Bank Account
-
-```typescript
-import { addBankAccount } from 'paj_ramp';
-
-const addedBankAccount = await addBankAccount(
-  'token',
-  'bank_id',
-  'account_number'
-);
-// Response: { id: string, accountName: string, accountNumber: string, bank: string }
-```
-
-### Get Bank Accounts
-
-```typescript
-import { getBankAccounts } from 'paj_ramp';
-
-const accounts = await getBankAccounts('token');
-// Response: [ { id: string, accountName: string, accountNumber: string, bank: string } ]
-```
-
-# Offramp 2 (Direct Offramp)
-
-## Usage Examples
-
-### Create Order
-
-```typescript
-import { offRampCreateOrder } from 'paj_ramp';
-
-const createOrder = await offRampCreateOrder(
-  'token',
-  'bank_id',
-  'account_number',
-  'NGN', // Currency
-  10000, // amount
-  'token_mint_address'
-  'webhook_url'
-);
-// Response: { id: string, address: string, signature?: string, mint: string, currency: Currency, amount: number, usdcAmount: number, fiatAmount: number, sender: string, receipiant: string, rate: number, status: TransactionStatus, transactionType: TransactionType }
-```
-
-<!--
-### Get Wallet Info
-
-```typescript
-import { getWallet } from 'paj_ramp';
-
-const wallet = await getWallet('wallet public key');
-// Response: { id: string, publicKey: string, bankAccount: { id: string, accountName: string, accountNumber: string, bank: string } }
-``` -->
-<!--
-### Add Wallet
-
-```typescript
-import { addWallet } from 'paj_ramp';
-
-// To create wallet.json file with an array of 64 numbers
-// npm install @solana/web3.js then run this code
-import { Keypair } from '@solana/web3.js';
-import fs from 'fs';
-
-const keypair = Keypair.generate();
-const secretKey = Array.from(keypair.secretKey);
-
-fs.writeFileSync('wallet.json', JSON.stringify(secretKey));
-console.log('✅ wallets.json generated successfully');
-
-// To get secret key
-import * as fs from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// wallet.json that you created with an array of 64 numbers
-const walletPath = resolve(__dirname, './wallet.json');
-const secretKeyRaw = fs.readFileSync(walletPath, 'utf8');
-const secretKeyArray = JSON.parse(secretKeyRaw);
-
-if (!Array.isArray(secretKeyArray) || secretKeyArray.length !== 64) {
-  throw new Error('Invalid secret key: must be an array of 64 numbers.');
-}
-
-const secretKey = Uint8Array.from(secretKeyArray);
-
-const addedWallet = await addWallet('token', 'bank account id', secretKey);
-// Response: { id: string, publicKey: string, bankAccount: { id: string, accountName: string, accountNumber: string, bank: string } }
-``` -->
-<!--
-### Switch Bank Account on Wallet
-
-```typescript
-import { switchWalletBankAccount } from 'paj_ramp';
-
-const switchedWallet = await switchWalletBankAccount(
-  'token',
-  'bank account id to switch to',
-  'wallet id',
-  'secret key'
-);
-// Response: { id: string, publicKey: string, bankAccount: { id: string, accountName: string, accountNumber: string, bank: string } }
-``` -->
+---
 
 ## License
 

package/dist/lib/direct_off_ramp/directCreateOrder.d.ts

@@ -15,5 +15,5 @@ type offRampCreateOrderResponse = {
     status: string;
     webhookURL: string;
 };
-export declare const offRampCreateOrder: (token: string, bank: string, accountNumber: string, currency: Currency, amount: number, mint: string, webhookURL: string) => Promise<offRampCreateOrderResponse>;
+export declare const offRampCreateOrder: (token: string, bank: string, accountNumber: string, currency: string, amount: number, mint: string, webhookURL: string) => Promise<offRampCreateOrderResponse>;
 export {};

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

@@ -1,17 +1,17 @@
 type AllRateResponseType = {
     onRampRate: {
-        baseCurrency: "USD";
-        targetCurrency: "NGN";
+        baseCurrency: 'USD';
+        targetCurrency: 'NGN';
         isActive: true;
         rate: 1510;
-        type: "onRamp";
+        type: 'onRamp';
     };
     offRampRate: {
-        baseCurrency: "USD";
-        targetCurrency: "NGN";
+        baseCurrency: 'USD';
+        targetCurrency: 'NGN';
         isActive: true;
         rate: 1525;
-        type: "offRamp";
+        type: 'offRamp';
     };
 };
 type RateByAmountType = {
@@ -28,58 +28,80 @@ type RateByAmountType = {
     };
 };
 type RateByRateTypeType = {
-    baseCurrency: "USD";
-    targetCurrency: "NGN";
+    baseCurrency: 'USD';
+    targetCurrency: 'NGN';
     isActive: true;
     rate: 1525;
-    type: "offRamp";
+    type: 'offRamp';
+};
+type TokenValueType = {
+    amount: number;
+    usdcValue: number;
+    mint: string;
 };
 export declare enum RateType {
     onRamp = "onRamp",
     offRamp = "offRamp"
 }
 /**
- * Fetches rate information based on the provided parameter, which can be a number or a rate type.
- * This function returns all rates, rates by amount, or rates by type depending on the input.
- *
- * Args:
- *   param: A number representing the amount or a RateType enum value.
- *
- * Returns:
- *   A promise resolving to the rate information relevant to the input parameter.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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 declare const getRate: (param: number | RateType, mint_token?: string) => Promise<AllRateResponseType | RateByAmountType | RateByRateTypeType | TokenValueType | undefined>;
+/**
+ * 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 declare const getRate: (param: number | RateType) => Promise<AllRateResponseType | RateByAmountType | RateByRateTypeType>;
+export declare const getAllRate: (url: string) => Promise<AllRateResponseType>;
 /**
- * Retrieves rate information based on a specific amount for on-ramp or off-ramp transactions.
- * This function returns a promise that resolves to the rate and associated amounts for the given value.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *   amount: The amount for which the rate information is requested.
- *
- * Returns:
- *   A promise resolving to the rate and amount details for the specified value.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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 declare const getRateByAmount: (url: string, amount: number) => Promise<RateByAmountType>;
 /**
- * Retrieves rate information based on a specific rate type for on-ramp or off-ramp transactions.
- * This function returns a promise that resolves to the rate details for the given rate type.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *   rateType: The type of rate to retrieve, specified as a RateType enum value.
- *
- * Returns:
- *   A promise resolving to the rate details for the specified rate type.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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 declare const getRateByRateType: (url: string, rateType: RateType) => Promise<RateByRateTypeType>;
+/**
+ * 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 declare const getTokenValue: (url: string, amount: number, mint_token: string) => Promise<TokenValueType | undefined>;
 export {};

package/dist/lib/off_ramp/getRate.js

@@ -1,29 +1,29 @@
-import { get } from "../../utils/api.js";
+import { get } from '../../utils/api.js';
 export var RateType;
 (function (RateType) {
     RateType["onRamp"] = "onRamp";
     RateType["offRamp"] = "offRamp";
 })(RateType || (RateType = {}));
 /**
- * Fetches rate information based on the provided parameter, which can be a number or a rate type.
- * This function returns all rates, rates by amount, or rates by type depending on the input.
- *
- * Args:
- *   param: A number representing the amount or a RateType enum value.
- *
- * Returns:
- *   A promise resolving to the rate information relevant to the input parameter.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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) => {
+export const getRate = async (param, mint_token) => {
     try {
-        const url = "/pub/rate";
+        const url = '/pub/rate';
         if (!param) {
             return getAllRate(url);
         }
-        else if (typeof param === "number") {
+        else if (typeof param === 'number') {
+            if (mint_token)
+                return getTokenValue(url, param, mint_token);
             return getRateByAmount(url, param);
         }
         else {
@@ -31,75 +31,87 @@ export const getRate = async (param) => {
         }
     }
     catch (err) {
-        console.error("Error fetching Rate:", err);
+        console.error('Error fetching Rate:', err);
         throw err;
     }
 };
 /**
- * Retrieves all available rate information for on-ramp and off-ramp transactions.
- * This function returns a promise that resolves to the complete set of rate data.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *
- * Returns:
- *   A promise resolving to the full rate response data.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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.
  */
-const getAllRate = async (url) => {
+export const getAllRate = async (url) => {
     try {
         return await get(url);
     }
     catch (err) {
-        console.error("Error fetching Rate:", err);
+        console.error('Error fetching Rate:', err);
         throw err;
     }
 };
 /**
- * Retrieves rate information based on a specific amount for on-ramp or off-ramp transactions.
- * This function returns a promise that resolves to the rate and associated amounts for the given value.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *   amount: The amount for which the rate information is requested.
- *
- * Returns:
- *   A promise resolving to the rate and amount details for the specified value.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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, amount) => {
     try {
-        return await get(`/pub/rate/${amount}`);
+        return await get(`${url}/${amount}`);
     }
     catch (err) {
-        console.error("Error fetching Rate by Amount:", err);
+        console.error('Error fetching Rate by Amount:', err);
         throw err;
     }
 };
 /**
- * Retrieves rate information based on a specific rate type for on-ramp or off-ramp transactions.
- * This function returns a promise that resolves to the rate details for the given rate type.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *   rateType: The type of rate to retrieve, specified as a RateType enum value.
- *
- * Returns:
- *   A promise resolving to the rate details for the specified rate type.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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, rateType) => {
     try {
-        return await get(`/pub/rate/${rateType}`);
+        return await get(`${url}/${rateType}`);
     }
     catch (err) {
-        console.error("Error fetching Rate by Rate Type:", 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, amount, mint_token) => {
+    try {
+        return await get(`${url}/value?amount=${amount}&mint=${mint_token}`);
+    }
+    catch (err) {
+        console.log('Error fetching Token Value:', err);
+    }
+};

package/dist/sdk.d.ts

@@ -1,5 +1,5 @@
 export declare const initializeSDK: (env: "staging" | "production") => void;
-export { getRate, RateType } from './lib/off_ramp/getRate.js';
+export { getRate } from './lib/off_ramp/getRate.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";
@@ -9,3 +9,4 @@ 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';

package/dist/sdk.js

@@ -12,7 +12,7 @@ export const initializeSDK = (env) => {
 // OFF RAMP
 // Wallet Info
 // export { getTXPoolAddress } from "./lib/off_ramp/getTXPoolAddress.js";
-export { getRate, RateType } from './lib/off_ramp/getRate.js';
+export { getRate } from './lib/off_ramp/getRate.js';
 // Session Management
 export { initiate } from './lib/off_ramp/initiate.js';
 export { verify } from './lib/off_ramp/verify.js';
@@ -32,3 +32,5 @@ export { offRampCreateOrder } from './lib/direct_off_ramp/directCreateOrder.js';
 export { createOrder } from './lib/on_ramp/createOrder.js';
 // Observe Order Socket.IO
 export { observeOrder } from './lib/on_ramp/observeOrder.js';
+// Types
+export { RateType } from './lib/off_ramp/getRate.js';

package/lib/direct_off_ramp/directCreateOrder.ts

@@ -33,7 +33,7 @@ export const offRampCreateOrder = async (
   token: string,
   bank: string,
   accountNumber: string,
-  currency: Currency,
+  currency: string,
   amount: number,
   mint: string,
   webhookURL: string

package/lib/off_ramp/getRate.ts

@@ -1,19 +1,19 @@
-import { get } from "../../utils/api.js";
+import { get } from '../../utils/api.js';
 
 type AllRateResponseType = {
   onRampRate: {
-    baseCurrency: "USD";
-    targetCurrency: "NGN";
+    baseCurrency: 'USD';
+    targetCurrency: 'NGN';
     isActive: true;
     rate: 1510;
-    type: "onRamp";
+    type: 'onRamp';
   };
   offRampRate: {
-    baseCurrency: "USD";
-    targetCurrency: "NGN";
+    baseCurrency: 'USD';
+    targetCurrency: 'NGN';
     isActive: true;
     rate: 1525;
-    type: "offRamp";
+    type: 'offRamp';
   };
 };
 
@@ -32,112 +32,139 @@ type RateByAmountType = {
 };
 
 type RateByRateTypeType = {
-  baseCurrency: "USD";
-  targetCurrency: "NGN";
+  baseCurrency: 'USD';
+  targetCurrency: 'NGN';
   isActive: true;
   rate: 1525;
-  type: "offRamp";
+  type: 'offRamp';
+};
+
+type TokenValueType = {
+  amount: number;
+  usdcValue: number;
+  mint: string;
 };
 
 export enum RateType {
-  onRamp = "onRamp",
-  offRamp = "offRamp",
+  onRamp = 'onRamp',
+  offRamp = 'offRamp',
 }
 
 /**
- * Fetches rate information based on the provided parameter, which can be a number or a rate type.
- * This function returns all rates, rates by amount, or rates by type depending on the input.
- *
- * Args:
- *   param: A number representing the amount or a RateType enum value.
- *
- * Returns:
- *   A promise resolving to the rate information relevant to the input parameter.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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) => {
+export const getRate = async (
+  param: number | RateType,
+  mint_token?: string
+) => {
   try {
-    const url = "/pub/rate";
+    const url = '/pub/rate';
 
     if (!param) {
       return getAllRate(url);
-    } else if (typeof param === "number") {
+    } 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);
+    console.error('Error fetching Rate:', err);
     throw err;
   }
 };
 
 /**
- * Retrieves all available rate information for on-ramp and off-ramp transactions.
- * This function returns a promise that resolves to the complete set of rate data.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *
- * Returns:
- *   A promise resolving to the full rate response data.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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.
  */
-const getAllRate = async (url: string) => {
+export const getAllRate = async (url: string) => {
   try {
     return await get<AllRateResponseType>(url);
   } catch (err) {
-    console.error("Error fetching Rate:", err);
+    console.error('Error fetching Rate:', err);
     throw err;
   }
 };
 
 /**
- * Retrieves rate information based on a specific amount for on-ramp or off-ramp transactions.
- * This function returns a promise that resolves to the rate and associated amounts for the given value.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *   amount: The amount for which the rate information is requested.
- *
- * Returns:
- *   A promise resolving to the rate and amount details for the specified value.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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>(`/pub/rate/${amount}`);
+    return await get<RateByAmountType>(`${url}/${amount}`);
   } catch (err) {
-    console.error("Error fetching Rate by Amount:", err);
+    console.error('Error fetching Rate by Amount:', err);
     throw err;
   }
 };
 
+
 /**
- * Retrieves rate information based on a specific rate type for on-ramp or off-ramp transactions.
- * This function returns a promise that resolves to the rate details for the given rate type.
- *
- * Args:
- *   url: The endpoint URL to fetch rate information from.
- *   rateType: The type of rate to retrieve, specified as a RateType enum value.
- *
- * Returns:
- *   A promise resolving to the rate details for the specified rate type.
- *
- * Raises:
- *   Throws an error if the rate information cannot be fetched.
+ * 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>(`/pub/rate/${rateType}`);
+    return await get<RateByRateTypeType>(`${url}/${rateType}`);
   } catch (err) {
-    console.error("Error fetching Rate by Rate Type:", 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);
+  }
+};

package/package.json

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

package/sdk.ts

@@ -15,7 +15,7 @@ export const initializeSDK = (env: 'staging' | 'production') => {
 
 // Wallet Info
 // export { getTXPoolAddress } from "./lib/off_ramp/getTXPoolAddress.js";
-export { getRate, RateType } from './lib/off_ramp/getRate.js';
+export { getRate } from './lib/off_ramp/getRate.js';
 
 // Session Management
 export { initiate } from './lib/off_ramp/initiate.js';
@@ -35,6 +35,7 @@ export { getBankAccounts } from "./lib/off_ramp/getBankAccounts.js";
 // DIRECT OFF RAMP
 export { offRampCreateOrder } from './lib/direct_off_ramp/directCreateOrder.js';
 
+
 // ON RAMP
 
 // Create Order
@@ -42,3 +43,6 @@ export { createOrder } from './lib/on_ramp/createOrder.js';
 
 // Observe Order Socket.IO
 export { observeOrder } from './lib/on_ramp/observeOrder.js';
+
+// Types
+export { RateType } from './lib/off_ramp/getRate.js';