@coin-voyage/shared 0.0.1 → 0.0.2

package/dist/api/config.d.ts

@@ -0,0 +1 @@
+export declare const API_URL = "https://dev-api.coinvoyage.io";

package/dist/api/config.js

@@ -0,0 +1,3 @@
+export const API_URL = "https://dev-api.coinvoyage.io";
+// export const API_URL = "http://localhost:8000"
+//# sourceMappingURL=config.js.map

package/dist/api/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/api/config.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,+BAA+B,CAAA;AACtD,iDAAiD"}

package/dist/api/fetcher.d.ts

@@ -0,0 +1,7 @@
+type FetchApiOptions = {
+    path: string;
+    options?: RequestInit;
+    throwOnFailure?: boolean;
+};
+export declare function fetchApi<T>(opts: FetchApiOptions): Promise<T | undefined>;
+export {};

package/{src/api/fetcher.ts → dist/api/fetcher.js}

@@ -1,12 +1,5 @@
 import { API_URL } from "./config";
-
-type FetchApiOptions = {
-    path: string;
-    options?: RequestInit;
-    throwOnFailure?: boolean;
-}
-
-export async function fetchApi<T>(opts: FetchApiOptions): Promise<T | undefined> {
+export async function fetchApi(opts) {
     try {
         const response = await fetch(`${API_URL}/${opts.path}`, {
             ...opts.options,
@@ -18,21 +11,21 @@ export async function fetchApi<T>(opts: FetchApiOptions): Promise<T | undefined>
         });
         if (!response.ok) {
             const text = await response.text();
-            console.error(
-                JSON.stringify({
-                    path: opts.path,
-                    status: response.status,
-                    statusText: response.statusText,
-                    details: text
-                })
-            );
+            console.error(JSON.stringify({
+                path: opts.path,
+                status: response.status,
+                statusText: response.statusText,
+                details: text
+            }));
             return;
         }
         return await response.json();
-    } catch (error: any) {
+    }
+    catch (error) {
         console.error(`path: ${opts.path}, message: ${error.message}`);
         if (opts.throwOnFailure) {
             throw error;
         }
     }
 }
+//# sourceMappingURL=fetcher.js.map

package/dist/api/fetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.js","sourceRoot":"","sources":["../../src/api/fetcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAQnC,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAI,IAAqB;IACnD,IAAI,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,EAAE;YACpD,GAAG,IAAI,CAAC,OAAO;YACf,OAAO,EAAE;gBACL,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO;gBACxB,cAAc,EAAE,kBAAkB;gBAClC,iBAAiB,EAAE,mBAAmB;aACzC;SACJ,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACf,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;YACnC,OAAO,CAAC,KAAK,CACT,IAAI,CAAC,SAAS,CAAC;gBACX,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;gBAC/B,OAAO,EAAE,IAAI;aAChB,CAAC,CACL,CAAC;YACF,OAAO;QACX,CAAC;QACD,OAAO,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACjC,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QAClB,OAAO,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,IAAI,cAAc,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC/D,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,MAAM,KAAK,CAAC;QAChB,CAAC;IACL,CAAC;AACL,CAAC"}

package/dist/api/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./config";
+export * from "./fetcher";
+export * from "./pay-order";

package/dist/api/index.js

@@ -0,0 +1,4 @@
+export * from "./config";
+export * from "./fetcher";
+export * from "./pay-order";
+//# sourceMappingURL=index.js.map

package/dist/api/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA"}

package/{src/api/pay-order.ts → dist/api/pay-order.d.ts}

@@ -1,67 +1,53 @@
-import { z } from "zod";
-import { ChainId, ChainType, CurrencyAmount, CurrencyBase, CurrencyWithAmount, CurrencyWithBalance, PayOrder, PayOrderMetadata, PayOrderMode, PayOrderStatus, zDepositPayOrder, zPayOrderMetadata } from "../common/index";
-import { fetchApi } from "./fetcher";
-
+import { ChainId, ChainType, CurrencyAmount, CurrencyBase, CurrencyWithAmount, CurrencyWithBalance, PayOrder, PayOrderMetadata, PayOrderStatus } from "../common/index";
 /**
  * Fetches a PayOrder by its ID.
- * 
+ *
  * Retrieves a PayOrder object from the API using the provided payOrderId.
  * This function requires an API key for authentication.
- * 
+ *
  * @param {string} payOrderId - The unique identifier of the PayOrder.
  * @param {string} apiKey - The API key required for authentication.
  * @returns {Promise<PayOrder | undefined>} - The PayOrder object if the request is successful.
- * 
+ *
  * @example
  * const apiKey = 'yourApiKey';
  * const payOrder = await getPayOrder('123456', apiKey);
  */
-export async function getPayOrder(payOrderId: string, apiKey: string): Promise<PayOrder | undefined> {
-  return fetchApi<PayOrder>({
-    path: `pay-orders/${payOrderId}`,
-    options: {
-      headers: {
-        "X-API-KEY": apiKey
-      }
-    }
-  })
-}
-
+export declare function getPayOrder(payOrderId: string, apiKey: string): Promise<PayOrder | undefined>;
 /** PayOrder parameters. The payOrder is created only after user taps pay. */
 export interface DepositPayOrderParams {
-  /**
-   * Metadata to attach to the payOrder.
-   */
-  metadata?: PayOrderMetadata
-  /**
-   * Value in USD received from the Deposit.
-   */
-  destination_value_usd?: number
-  /**
-   * Desired output token + chain.
-   */
-  destination_currency: CurrencyBase
-  /**
-   * Output amount to deposit.
-   */
-  destination_amount?: string
-  /**
-   * Receiving address for the deposit.
-   */
-  receiving_address: string
+    /**
+     * Metadata to attach to the payOrder.
+     */
+    metadata?: PayOrderMetadata;
+    /**
+     * Value in USD received from the Deposit.
+     */
+    destination_value_usd?: number;
+    /**
+     * Desired output token + chain.
+     */
+    destination_currency: CurrencyBase;
+    /**
+     * Output amount to deposit.
+     */
+    destination_amount?: string;
+    /**
+     * Receiving address for the deposit.
+     */
+    receiving_address: string;
 }
-
 /**
  * Creates a `DEPOSIT` type PayOrder.
- * 
+ *
  * Generates a PayOrder of type `DEPOSIT` with the provided parameters.
  * This function ensures the request parameters are valid using a schema validation.
- * 
+ *
  * @param {DepositPayOrderParams} createOrderParams - Parameters required to create a deposit PayOrder.
  * @param {string} apiKey - The API key required for authentication.
  * @param {boolean} [throwOnFailure] - Whether to throw an error if the request fails.
  * @returns {Promise<PayOrder | undefined>} - The PayOrder object if the request is successful.
- * 
+ *
  * @example
  * const apiKey = 'yourApiKey';
  * const depositOrderParams = {
@@ -71,76 +57,54 @@ export interface DepositPayOrderParams {
  * };
  * const depositPayOrder = await createDepositPayOrder(depositOrderParams, apiKey);
  */
-export async function createDepositPayOrder(createOrderParams: DepositPayOrderParams, apiKey: string, throwOnFailure?: boolean): Promise<PayOrder | undefined> {
-  const result = zDepositPayOrder.safeParse(createOrderParams);
-  if (!result.success) {
-    return
-  }
-
-  return fetchApi<PayOrder>({
-    path: `pay-orders`, options: {
-      method: "POST",
-      body: JSON.stringify({
-        mode: PayOrderMode.DEPOSIT,
-        ...createOrderParams
-      }),
-      headers: {
-        "X-API-KEY": apiKey
-      }
-    },
-    throwOnFailure: throwOnFailure
-  })
-}
-
+export declare function createDepositPayOrder(createOrderParams: DepositPayOrderParams, apiKey: string, throwOnFailure?: boolean): Promise<PayOrder | undefined>;
 export type SalePayOrderParams = {
-  /**
-   * Metadata to attach to the payOrder.
-   */
-  metadata?: PayOrderMetadata
-  /**
-   * Expected value in USD to be received from the Sale.
-   */
-  destination_value_usd: number
-  /**
-   * Expected token on what chain to receive the value from the Sale.
-   */
-  destination_currency?: CurrencyBase
-  /**
-   * Expected receiving address to receive the value from the Sale.
-   */
-  receiving_address?: string
+    /**
+     * Metadata to attach to the payOrder.
+     */
+    metadata?: PayOrderMetadata;
+    /**
+     * Expected value in USD to be received from the Sale.
+     */
+    destination_value_usd: number;
+    /**
+     * Expected token on what chain to receive the value from the Sale.
+     */
+    destination_currency?: CurrencyBase;
+    /**
+     * Expected receiving address to receive the value from the Sale.
+     */
+    receiving_address?: string;
 } | {
-  /**
-   * Metadata to attach to the payOrder.
-   */
-  metadata?: PayOrderMetadata
-  /**
-   * Expected token on what chain to receive the value from the Sale.
-   */
-  destination_currency: CurrencyBase
-  /**
-   * Expected amount to be received from the Sale.
-   */
-  destination_amount: string
-  /**
-   * Expected receiving address to receive the value from the Sale.
-   */
-  receiving_address?: string
-}
-
-
+    /**
+     * Metadata to attach to the payOrder.
+     */
+    metadata?: PayOrderMetadata;
+    /**
+     * Expected token on what chain to receive the value from the Sale.
+     */
+    destination_currency: CurrencyBase;
+    /**
+     * Expected amount to be received from the Sale.
+     */
+    destination_amount: string;
+    /**
+     * Expected receiving address to receive the value from the Sale.
+     */
+    receiving_address?: string;
+};
 /**
  * Generates a `sale` type PayOrder.
- * 
+ *
  * Creates a `sale` type PayOrder with a fixed valueOut `destination_value_usd`.
  * This function should be executed
- * 
- * and a SHA-512 hash signature of the concatenated API key, secret, and timestamp. 
- * 
+ *
+ * and a SHA-512 hash signature of the concatenated API key, secret, and timestamp.
+ *
  * @param {SalePayOrderParams} payOrderParams - destination_value_usd and metadata for this payOrder.
  * @param {string} signature - signature generated by the `generateAuthorizationSignature` function.
  * @returns {PayOrder | undefined} - A PayOrder object if the request was successful.
- * 
+ *
  * @example
  * const apiKey = 'yourApiKey';
  * const apiSecret = 'yourApiSecret';
@@ -161,49 +125,23 @@ export type SalePayOrderParams = {
  *   ]
  *  }}, authSignature)
  */
-export async function createSalePayOrder(createOrderParams: SalePayOrderParams, signature: string): Promise<PayOrder | undefined> {
-  try {
-    if (createOrderParams?.metadata) {
-      zPayOrderMetadata.parse(createOrderParams.metadata);
-    }
-    return fetchApi<PayOrder>({
-      path: `pay-orders`, options: {
-        method: "POST",
-        body: JSON.stringify({
-          mode: PayOrderMode.SALE,
-          ...createOrderParams
-        }),
-        headers: {
-          "Authorization": signature
-        }
-      }
-    })
-  }
-  catch (err) {
-    if (err instanceof z.ZodError) {
-      throw new Error(err.errors.map(e => e.message).join(", "))
-    }
-    throw err
-  }
-}
-
+export declare function createSalePayOrder(createOrderParams: SalePayOrderParams, signature: string): Promise<PayOrder | undefined>;
 export type PayOrderQuoteParams = {
-  wallet_address: string
-  chain_type: ChainType,
-  chain_id?: ChainId
-}
-
+    wallet_address: string;
+    chain_type: ChainType;
+    chain_id?: ChainId;
+};
 /**
  * Generates a PayOrder Quote.
- * 
+ *
  * Creates a PayOrder Quote for an existing PayOrder by providing wallet information and chain details.
  * This function requires an API key for authentication.
- * 
+ *
  * @param {string} orderId - The unique identifier of the PayOrder for which the quote is requested.
  * @param {PayOrderQuoteParams} quoteParams - Contains `wallet_address`, `chain_type`, chain_id`.
  * @param {string} apiKey - The API key for authorization.
  * @returns {CurrencyWithBalance[] | undefined} - An array of PayTokens if the request was successful.
- * 
+ *
  * @example
  * const orderId = 'existingOrderId';
  * const apiKey = 'yourApiKey';
@@ -212,66 +150,48 @@ export type PayOrderQuoteParams = {
  *   chain_type: ChainType.EVM,
  *   chain_id: 1 // Ethereum Mainnet
  * };
- * 
+ *
  * const payOrderQuote = await payOrderQuote(orderId, quoteParams, apiKey);
 
  */
-export async function payOrderQuote(orderId: string, quoteParams: PayOrderQuoteParams, apiKey: string): Promise<CurrencyWithBalance[] | undefined> {
-  return fetchApi<CurrencyWithBalance[]>({
-    path: `pay-orders/${orderId}/quote`, options: {
-      method: "POST",
-      body: JSON.stringify({
-        ...quoteParams
-      }),
-      headers: {
-        "X-API-KEY": apiKey
-      },
-    }
-  })
-}
-
-
+export declare function payOrderQuote(orderId: string, quoteParams: PayOrderQuoteParams, apiKey: string): Promise<CurrencyWithBalance[] | undefined>;
 export type PaymentDetailsParams = {
-  payOrderId: string
-  outTokenAddress?: string
-  outChainId: ChainId
-  refundAddress: string
-  apiKey: string
-}
-
+    payOrderId: string;
+    outTokenAddress?: string;
+    outChainId: ChainId;
+    refundAddress: string;
+    apiKey: string;
+};
 export type PaymentDetails = {
-  payorder_id: string
-  status: PayOrderStatus
-  expires_at: Date
-
-  refund_address: string
-  deposit_address: string
-  receiving_address?: string
-
-  source_currency: CurrencyWithAmount
-  source_amount: CurrencyAmount
-  destination_currency?: CurrencyWithAmount
-  destination_amount?: CurrencyAmount
-}
-
+    payorder_id: string;
+    status: PayOrderStatus;
+    expires_at: Date;
+    refund_address: string;
+    deposit_address: string;
+    receiving_address?: string;
+    source_currency: CurrencyWithAmount;
+    source_amount: CurrencyAmount;
+    destination_currency?: CurrencyWithAmount;
+    destination_amount?: CurrencyAmount;
+};
 /**
  * Retrieves payment details for a specific PayOrder.
- * 
- * This function fetches payment details associated with a specific PayOrder ID. 
- * It allows specifying the token and blockchain network (via `outTokenAddress` and `outChainId`) 
+ *
+ * This function fetches payment details associated with a specific PayOrder ID.
+ * It allows specifying the token and blockchain network (via `outTokenAddress` and `outChainId`)
  * to retrieve source currency information, as well as a refund address for the transaction.
- * 
+ *
  * The request is authenticated using the provided API key in the headers.
- * 
+ *
  * @param {PaymentDetailsParams} params - Parameters to retrieve the payment details.
  * @param {string} params.payOrderId - The unique identifier of the PayOrder for which payment details are fetched.
  * @param {string} [params.outTokenAddress] - (Optional) The token address of the source currency.
  * @param {ChainId} params.outChainId - The blockchain network ID where the token resides.
  * @param {string} params.refundAddress - The address where funds will be refunded in case of a failed transaction.
  * @param {string} params.apiKey - The API key used to authenticate the request.
- * 
+ *
  * @returns {Promise<PaymentDetails | undefined>} - The payment details object if the request is successful.
- * 
+ *
  * @example
  * const paymentDetails = await payOrderPaymentDetails({
  *   payOrderId: '12345',
@@ -280,70 +200,34 @@ export type PaymentDetails = {
  *   refundAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
  *   apiKey: 'yourApiKey'
  * });
- * 
+ *
  * console.log(paymentDetails);
  */
-export async function payOrderPaymentDetails({
-  payOrderId,
-  outTokenAddress,
-  outChainId,
-  refundAddress,
-  apiKey
-}: PaymentDetailsParams): Promise<PaymentDetails | undefined> {
-  return fetchApi<PaymentDetails>({
-    path: `pay-orders/${payOrderId}/payment-details`, options: {
-      method: "POST",
-      body: JSON.stringify({
-        source_currency: {
-          address: outTokenAddress,
-          chain_id: outChainId
-        },
-        refund_address: refundAddress
-      }),
-      headers: {
-        "X-API-KEY": apiKey
-      },
-    }
-  })
-}
-
+export declare function payOrderPaymentDetails({ payOrderId, outTokenAddress, outChainId, refundAddress, apiKey }: PaymentDetailsParams): Promise<PaymentDetails | undefined>;
 /**
  * Processes a PayOrder transaction.
- * 
- * This function triggers the processing of a PayOrder by providing the transaction hash 
+ *
+ * This function triggers the processing of a PayOrder by providing the transaction hash
  * that represents the payment on the blockchain. The request is authenticated using an API key.
- * 
+ *
  * @param {Object} params - Parameters required to process the PayOrder.
  * @param {string} params.payOrderId - The unique identifier of the PayOrder to be processed.
  * @param {string} params.sourceTransactionHash - The transaction hash representing the payment on the blockchain.
  * @param {string} params.apiKey - The API key used to authenticate the request.
- * 
+ *
  * @returns {Promise<void>}
- * 
+ *
  * @example
  * const processedPayment = await processPayOrder({
  *   payOrderId: '12345',
  *   sourceTransactionHash: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
  *   apiKey: 'yourApiKey'
  * });
- * 
+ *
  * console.log(processedPayment);
  */
-export async function processPayOrder({
-  payOrderId,
-  sourceTransactionHash,
-  apiKey
-}: {
-  payOrderId: string
-  sourceTransactionHash: string
-  apiKey: string
-}): Promise<void> {
-  return fetchApi<void>({
-    path: `pay-orders/${payOrderId}/process?tx_hash=${sourceTransactionHash}`, options: {
-      method: "GET",
-      headers: {
-        "X-API-KEY": apiKey
-      },
-    }
-  })
-}
+export declare function processPayOrder({ payOrderId, sourceTransactionHash, apiKey }: {
+    payOrderId: string;
+    sourceTransactionHash: string;
+    apiKey: string;
+}): Promise<void>;