@zebec-network/exchange-card-sdk 1.2.3 → 1.3.0

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 export * from "./artifacts";
-export * from "./chains";
 export * from "./constants";
-export * from "./errors";
 export * from "./services";
 export * from "./types";
 export * from "./utils";

package/dist/index.js

@@ -15,9 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./artifacts"), exports);
-__exportStar(require("./chains"), exports);
 __exportStar(require("./constants"), exports);
-__exportStar(require("./errors"), exports);
 __exportStar(require("./services"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);

package/dist/services/algorandService.d.ts

@@ -2,10 +2,22 @@ import algosdk from "algosdk";
 import { AlgorandClient } from "@algorandfoundation/algokit-utils";
 import { APIConfig } from "../helpers/apiHelpers";
 import { Quote } from "../types";
+/**
+ * Configuration interface for algo transfers
+ * */
 export interface TransferConfig {
     amount: number | string;
     note?: string;
 }
+/**
+ * Configuration interface for USDC transfers
+ * */
+export interface TokenTransferConfig {
+    /** Asset ID for Asset (e.g. for USDC 31566704) */
+    assetId: number;
+    amount: number | string;
+    note?: string;
+}
 export interface AlgorandWallet {
     address: string;
     signAndSendTransaction: (txn: algosdk.Transaction) => Promise<string>;
@@ -16,6 +28,7 @@ export declare class AlgorandService {
     readonly algodClient: algosdk.Algodv2;
     readonly algorandClient: AlgorandClient;
     private apiService;
+    private readonly network;
     constructor(wallet: AlgorandWallet, apiConfig: APIConfig, sdkOptions?: {
         sandbox?: boolean;
     });
@@ -40,12 +53,34 @@ export declare class AlgorandService {
      * @returns Transaction ID if successful
      */
     transferAlgo(config: TransferConfig): Promise<string>;
+    /**
+     * Transfer USDC (ASA token) from wallet to vault
+     * @param config USDC transfer configuration
+     * @returns Transaction ID if successful
+     */
+    transferAsset(config: TokenTransferConfig): Promise<string>;
+    /**
+     * Check if an account is opted into a specific asset
+     * @param address Account address
+     * @param assetId Asset ID to check
+     * @returns Whether the account is opted into the asset
+     */
+    isOptedIntoAsset(address: string, assetId: number): Promise<boolean>;
+    /**
+     * Get asset balance for a specific account in microAsset (base units)
+     * @param address Account address
+     * @param assetId Asset ID
+     * @returns Asset balance in base units
+     */
+    private getAssetBalanceInMicroUnit;
+    getAssetBalance(walletAddress: string, assetId: number): Promise<string>;
+    getAssetsBalance(walletAddress: string, assetIds: number[]): Promise<Map<number, string>>;
     /**
      * Get account balance in Algos
      * @param address Account address
      * @returns Balance in ALGO
      */
-    getAccountBalance(address: string | algosdk.Address): Promise<number>;
+    getAccountBalance(address: string | algosdk.Address): Promise<string>;
     /**
      * Get account balance in microAlgos (for internal calculations)
      * @param address Account address
@@ -53,15 +88,3 @@ export declare class AlgorandService {
      */
     private getAccountBalanceInMicroAlgo;
 }
-/**
- * Convert ALGO to microAlgos
- * @param algos Amount in ALGO
- * @returns Amount in microAlgos
- */
-export declare function algoToMicroAlgo(algos: number | string): bigint;
-/**
- * Convert microAlgos to ALGO
- * @param microAlgos Amount in microAlgos
- * @returns Amount in ALGO
- */
-export declare function microAlgoToAlgo(microAlgos: number | bigint): number;

package/dist/services/algorandService.js

@@ -4,24 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlgorandService = void 0;
-exports.algoToMicroAlgo = algoToMicroAlgo;
-exports.microAlgoToAlgo = microAlgoToAlgo;
 const algosdk_1 = __importDefault(require("algosdk"));
-const bignumber_js_1 = require("bignumber.js");
 const algokit_utils_1 = require("@algorandfoundation/algokit-utils");
 const client_manager_1 = require("@algorandfoundation/algokit-utils/types/client-manager");
 const apiHelpers_1 = require("../helpers/apiHelpers");
+const utils_1 = require("../utils");
 class AlgorandService {
     wallet;
     apiConfig;
     algodClient;
     algorandClient;
     apiService;
+    network;
     constructor(wallet, apiConfig, sdkOptions) {
         this.wallet = wallet;
         this.apiConfig = apiConfig;
-        const network = sdkOptions?.sandbox ? "testnet" : "mainnet";
-        this.algodClient = client_manager_1.ClientManager.getAlgodClient(client_manager_1.ClientManager.getAlgoNodeConfig(network, "algod"));
+        this.network = sdkOptions?.sandbox ? "testnet" : "mainnet";
+        this.algodClient = client_manager_1.ClientManager.getAlgodClient(client_manager_1.ClientManager.getAlgoNodeConfig(this.network, "algod"));
         this.algorandClient = algokit_utils_1.AlgorandClient.fromClients({
             algod: this.algodClient,
         });
@@ -52,12 +51,12 @@ class AlgorandService {
      */
     async transferAlgo(config) {
         try {
-            const parsedAmount = algoToMicroAlgo(config.amount);
+            const parsedAmount = (0, utils_1.parseAlgo)(config.amount);
             // Check if sender has sufficient balance
             const senderBalance = await this.getAccountBalanceInMicroAlgo(this.wallet.address);
-            const minBalance = algoToMicroAlgo(0.1); // Minimum account balance
+            const minBalance = (0, utils_1.parseAlgo)(0.1); // Minimum account balance
             if (senderBalance < parsedAmount + minBalance) {
-                throw new Error(`Insufficient balance. Need ${microAlgoToAlgo(parsedAmount + minBalance)} ALGO, have ${microAlgoToAlgo(senderBalance)} ALGO`);
+                throw new Error(`Insufficient balance. Need ${(0, utils_1.formatAlgo)(parsedAmount + minBalance)} ALGO, have ${(0, utils_1.formatAlgo)(senderBalance)} ALGO`);
             }
             const vault = await this.fetchVault("ALGO");
             const recipientAddress = vault.address;
@@ -84,6 +83,119 @@ class AlgorandService {
             throw error;
         }
     }
+    /**
+     * Transfer USDC (ASA token) from wallet to vault
+     * @param config USDC transfer configuration
+     * @returns Transaction ID if successful
+     */
+    async transferAsset(config) {
+        try {
+            const assetDecimals = await (0, utils_1.getAssetDecimals)(this.algodClient, config.assetId);
+            // const usdcConfig = USDC_ASSET_CONFIG[this.network];
+            const parsedAmount = (0, utils_1.parseAlgorandAsset)(config.amount, assetDecimals);
+            // Check if sender has sufficient USDC balance
+            const senderAssetBalance = await this.getAssetBalanceInMicroUnit(this.wallet.address, config.assetId);
+            if (senderAssetBalance < parsedAmount) {
+                throw new Error(`Insufficient Asset balance. Need ${(0, utils_1.formatAlgorandAsset)(parsedAmount, assetDecimals)} Asset, have ${(0, utils_1.formatAlgorandAsset)(senderAssetBalance, assetDecimals)} Asset`);
+            }
+            // Check if sender has sufficient ALGO for transaction fees
+            const senderAlgoBalance = await this.getAccountBalanceInMicroAlgo(this.wallet.address);
+            const minAlgoForFees = (0, utils_1.parseAlgo)(0.002); // Minimum ALGO for transaction fees
+            if (senderAlgoBalance < minAlgoForFees) {
+                throw new Error(`Insufficient ALGO for transaction fees. Need at least ${(0, utils_1.formatAlgo)(minAlgoForFees)} ALGO for fees`);
+            }
+            const vault = await this.fetchVault("ALGO-USDC");
+            const recipientAddress = vault.address;
+            // Validate recipient address
+            if (!algosdk_1.default.isValidAddress(recipientAddress)) {
+                throw new Error("Invalid recipient address");
+            }
+            // // Check if recipient is opted into USDC asset
+            const recipientOptedIn = await this.isOptedIntoAsset(recipientAddress, config.assetId);
+            if (!recipientOptedIn) {
+                throw new Error("Recipient address is not opted into USDC asset");
+            }
+            // Get suggested transaction parameters
+            const suggestedParams = await this.algodClient.getTransactionParams().do();
+            // Create asset transfer transaction
+            const assetTransferTxn = algosdk_1.default.makeAssetTransferTxnWithSuggestedParamsFromObject({
+                sender: this.wallet.address,
+                receiver: recipientAddress,
+                amount: parsedAmount,
+                assetIndex: config.assetId,
+                note: config.note ? new Uint8Array(Buffer.from(config.note)) : undefined,
+                suggestedParams: suggestedParams,
+            });
+            // Sign and send the transaction
+            const txId = await this.wallet.signAndSendTransaction(assetTransferTxn);
+            return txId;
+        }
+        catch (error) {
+            console.error("Asset transfer failed:", error);
+            throw error;
+        }
+    }
+    /**
+     * Check if an account is opted into a specific asset
+     * @param address Account address
+     * @param assetId Asset ID to check
+     * @returns Whether the account is opted into the asset
+     */
+    async isOptedIntoAsset(address, assetId) {
+        try {
+            const accountInfo = await this.algodClient.accountInformation(address).do();
+            return accountInfo.assets?.some((asset) => asset.assetId === BigInt(assetId)) || false;
+        }
+        catch (error) {
+            console.error("Error checking asset opt-in status:", error);
+            return false;
+        }
+    }
+    /**
+     * Get asset balance for a specific account in microAsset (base units)
+     * @param address Account address
+     * @param assetId Asset ID
+     * @returns Asset balance in base units
+     */
+    async getAssetBalanceInMicroUnit(walletAddress, assetId) {
+        try {
+            const accountInfo = await this.algodClient.accountInformation(walletAddress).do();
+            const asset = accountInfo.assets?.find((asset) => asset.assetId === BigInt(assetId));
+            return asset ? BigInt(asset.amount) : BigInt(0);
+        }
+        catch (error) {
+            console.error("Error fetching asset balance:", error);
+            return BigInt(0);
+        }
+    }
+    async getAssetBalance(walletAddress, assetId) {
+        const balance = await this.getAssetBalanceInMicroUnit(walletAddress, assetId);
+        const decimals = await (0, utils_1.getAssetDecimals)(this.algodClient, assetId);
+        return (0, utils_1.formatAlgorandAsset)(balance, decimals);
+    }
+    async getAssetsBalance(walletAddress, assetIds) {
+        const map = new Map(Array.from(assetIds.map((id) => [id, "0"])));
+        try {
+            const accountInfo = await this.algodClient.accountInformation(walletAddress).do();
+            const assets = accountInfo.assets;
+            if (!assets) {
+                return map;
+            }
+            await Promise.all(assetIds.map(async (id) => {
+                const asset = assets.find((asset) => asset.assetId === BigInt(id));
+                if (asset) {
+                    const decimals = await (0, utils_1.getAssetDecimals)(this.algodClient, id);
+                    const amount = (0, utils_1.formatAlgorandAsset)(asset.amount, decimals);
+                    map.set(id, amount);
+                }
+            }));
+            return map;
+        }
+        catch (error) {
+            console.error("Error fetching asset balance:", error);
+        }
+        return map;
+    }
     /**
      * Get account balance in Algos
      * @param address Account address
@@ -91,7 +203,7 @@ class AlgorandService {
      */
     async getAccountBalance(address) {
         const amount = await this.getAccountBalanceInMicroAlgo(address);
-        return microAlgoToAlgo(amount);
+        return (0, utils_1.formatAlgo)(amount);
     }
     /**
      * Get account balance in microAlgos (for internal calculations)
@@ -104,19 +216,3 @@ class AlgorandService {
     }
 }
 exports.AlgorandService = AlgorandService;
-/**
- * Convert ALGO to microAlgos
- * @param algos Amount in ALGO
- * @returns Amount in microAlgos
- */
-function algoToMicroAlgo(algos) {
-    return BigInt((0, bignumber_js_1.BigNumber)(algos).times(1_000_000).toFixed(0));
-}
-/**
- * Convert microAlgos to ALGO
- * @param microAlgos Amount in microAlgos
- * @returns Amount in ALGO
- */
-function microAlgoToAlgo(microAlgos) {
-    return (0, bignumber_js_1.BigNumber)(microAlgos).div(1_000_000).toNumber();
-}

package/dist/services/stellarService.d.ts

@@ -33,16 +33,7 @@ export declare class StellarService {
      *
      * @returns {Promise<string>} A promise that resolves to the Vault address.
      */
-    fetchVault(): Promise<{
-        address: string;
-        tag?: string;
-    }>;
-    /**
-     * Fetches the Vault address.
-     *
-     * @returns {Promise<string>} A promise that resolves to the Vault address.
-     */
-    fetchUSDCVault(): Promise<{
+    fetchVault(symbol?: string): Promise<{
         address: string;
         tag?: string;
     }>;

package/dist/services/stellarService.js

@@ -38,17 +38,8 @@ class StellarService {
      *
      * @returns {Promise<string>} A promise that resolves to the Vault address.
      */
-    async fetchVault() {
-        const data = await this.apiService.fetchVault("XLM");
-        return data;
-    }
-    /**
-     * Fetches the Vault address.
-     *
-     * @returns {Promise<string>} A promise that resolves to the Vault address.
-     */
-    async fetchUSDCVault() {
-        const data = await this.apiService.fetchVault("xlm-usdc");
+    async fetchVault(symbol = "XLM") {
+        const data = await this.apiService.fetchVault(symbol);
         return data;
     }
     /**
@@ -120,7 +111,7 @@ class StellarService {
      */
     async transferUSDC(amount) {
         // Fetch deposit address
-        const vault = await this.fetchUSDCVault();
+        const vault = await this.fetchVault("XLM-USDC");
         // Prepare transaction
         const account = await this.server.loadAccount(this.wallet.address);
         const fee = await this.server.fetchBaseFee();

package/dist/types.d.ts

@@ -1,59 +1,5 @@
-import { SupportedChain } from "./chains";
-export declare class OrderCardRequest {
-    readonly amount: Money;
-    readonly recipient: Recipient;
-    readonly receipt: Receipt;
-    constructor(amount: Money, recipient: Recipient, receipt: Receipt);
-}
-export declare class Quote {
+export type Quote = {
     price: number;
     fluctuationPercentage: number;
     token: string;
-    constructor(price: number, // Total token amount needed for the USD purchase
-    fluctuationPercentage: number, // Amount of USD the user wants to purchase
-    token: string);
-}
-export declare class Deposit {
-    tokenName: string;
-    tokenAmount: number;
-    signature: string;
-    buyerAddress: string;
-    txHash?: string;
-    blockHash?: string;
-    chainId?: SupportedChain;
-    purchaseCounter?: number;
-    constructor(tokenName: string, tokenAmount: number, signature: string, buyerAddress: string, txHash?: string, blockHash?: string, chainId?: SupportedChain, purchaseCounter?: number);
-}
-export declare class Receipt {
-    quote?: Quote;
-    deposit?: Deposit;
-    constructor(quote?: Quote, deposit?: Deposit);
-}
-export declare class Money {
-    readonly amount: number;
-    readonly currencyCode: string;
-    private constructor();
-    static create(amount: number | string, currencyCode: string): Money;
-    static USD(amount: number | string): Money;
-}
-export declare class Recipient {
-    readonly participantId: string;
-    readonly firstName: string;
-    readonly lastName: string;
-    readonly emailAddress: string;
-    readonly address1: string;
-    readonly address2?: string;
-    readonly city: string;
-    readonly state: string;
-    readonly postalCode: string;
-    readonly countryCode: CountryCode;
-    readonly language: string;
-    readonly mobilePhone: string;
-    private constructor();
-    static create(participantId: string, firstName: string, lastName: string, emailAddress: string, mobilePhone: string, language: string, city: string, state: string, postalCode: string, countryCode: CountryCode, address1: string, address2?: string): Recipient;
-}
-export declare const allCountriesWithCode: {
-    name: string;
-    code: string;
-}[];
-export type CountryCode = "DZA" | "AGO" | "ARG" | "AUS" | "AUT" | "BEL" | "BOL" | "BRA" | "CMR" | "CAN" | "CHL" | "CRI" | "CYP" | "CZE" | "DNK" | "ECU" | "EGY" | "SLV" | "EST" | "FIN" | "FRA" | "GEO" | "DEU" | "GHA" | "GRC" | "GTM" | "HND" | "HUN" | "ISL" | "IRL" | "ITA" | "JAM" | "JPN" | "JOR" | "KEN" | "KOR" | "KWT" | "LTU" | "LUX" | "MWI" | "MYS" | "MLT" | "MEX" | "MAR" | "MOZ" | "NPL" | "NLD" | "NZL" | "NGA" | "NOR" | "OMN" | "PAK" | "PNG" | "PRY" | "PER" | "PHL" | "POL" | "PRT" | "PRI" | "QAT" | "ROU" | "SAU" | "SGP" | "SVK" | "SVN" | "ESP" | "SWE" | "TWN" | "THA" | "TTO" | "TUN" | "TUR" | "GBR" | "USA" | "URY" | "VUT" | "ZMB";
+};

package/dist/types.js

@@ -1,263 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allCountriesWithCode = exports.Recipient = exports.Money = exports.Receipt = exports.Deposit = exports.Quote = exports.OrderCardRequest = void 0;
-const errors_1 = require("./errors");
-const utils_1 = require("./utils");
-class OrderCardRequest {
-    amount;
-    recipient;
-    receipt;
-    constructor(amount, recipient, receipt) {
-        this.amount = amount;
-        this.receipt = receipt;
-        this.recipient = recipient;
-    }
-}
-exports.OrderCardRequest = OrderCardRequest;
-// export class Quote {
-// 	id: string; // Unique identifier for the quote
-// 	token: string; // Token symbol or name (e.g., BTC, ETH)
-// 	targetCurrency: string; // Target currency (e.g., "USD")
-// 	amountRequested: number; // Amount of USD the user wants to purchase
-// 	pricePerUnitCurrency: number; // Price of 1 USD in terms of the token
-// 	totalPrice: number; // Total token amount needed for the USD purchase
-// 	platformFee: number; // Any additional platform fee
-// 	expiresIn: number; // Validity period for the quote in seconds or ISO date
-// 	timestamp: Date; // Timestamp when the quote was generated
-// 	status: "pending" | "expired" | "accepted" | "rejected"; // Quote status
-// 	constructor(
-// 		id: string,
-// 		token: string,
-// 		targetCurrency: string,
-// 		amountRequested: number,
-// 		pricePerUnitCurrency: number,
-// 		totalPrice: number,
-// 		platformFee: number,
-// 		expiresIn: number,
-// 		timestamp: Date,
-// 		status: "pending" | "expired" | "accepted" | "rejected",
-// 	) {
-// 		this.id = id;
-// 		this.token = token;
-// 		this.targetCurrency = targetCurrency;
-// 		this.amountRequested = amountRequested;
-// 		this.pricePerUnitCurrency = pricePerUnitCurrency;
-// 		this.totalPrice = totalPrice;
-// 		this.platformFee = platformFee;
-// 		this.expiresIn = expiresIn;
-// 		this.timestamp = timestamp;
-// 		this.status = status;
-// 	}
-// }
-class Quote {
-    price; // Total token amount needed for the USD purchase
-    fluctuationPercentage; // Amount of USD the user wants to purchase
-    token; // Timestamp when the quote was generated
-    constructor(price, // Total token amount needed for the USD purchase
-    fluctuationPercentage, // Amount of USD the user wants to purchase
-    token) {
-        this.price = price;
-        this.fluctuationPercentage = fluctuationPercentage;
-        this.token = token;
-    }
-}
-exports.Quote = Quote;
-class Deposit {
-    tokenName;
-    tokenAmount;
-    signature;
-    buyerAddress;
-    txHash;
-    blockHash;
-    chainId;
-    purchaseCounter;
-    constructor(tokenName, tokenAmount, signature, buyerAddress, txHash, blockHash, chainId, purchaseCounter) {
-        this.tokenName = tokenName;
-        this.tokenAmount = tokenAmount;
-        this.signature = signature;
-        this.txHash = txHash;
-        this.blockHash = blockHash;
-        this.chainId = chainId;
-        this.buyerAddress = buyerAddress;
-        this.purchaseCounter = purchaseCounter;
-    }
-}
-exports.Deposit = Deposit;
-class Receipt {
-    quote;
-    deposit;
-    constructor(quote, deposit) {
-        this.quote = quote;
-        this.deposit = deposit;
-    }
-}
-exports.Receipt = Receipt;
-class Money {
-    amount;
-    currencyCode;
-    constructor(amount, currencyCode) {
-        this.amount = amount;
-        this.currencyCode = currencyCode;
-    }
-    // Example static method to create a Money instance from an amount and optional currency code
-    static create(amount, currencyCode) {
-        return new Money(Number(amount), currencyCode);
-    }
-    static USD(amount) {
-        return this.create((0, utils_1.formatAmount)(amount), "USD");
-    }
-}
-exports.Money = Money;
-class Recipient {
-    participantId;
-    firstName;
-    lastName;
-    emailAddress;
-    address1;
-    address2;
-    city;
-    state;
-    postalCode;
-    countryCode;
-    language = "en-US";
-    mobilePhone;
-    constructor(participantId, firstName, lastName, emailAddress, mobilePhone, language, city, state, postalCode, countryCode, address1, address2) {
-        this.participantId = participantId;
-        this.firstName = firstName;
-        this.lastName = lastName;
-        this.address1 = address1;
-        this.address2 = address2;
-        this.city = city;
-        this.state = state;
-        this.postalCode = postalCode;
-        this.countryCode = countryCode;
-        this.emailAddress = emailAddress;
-        this.language = language;
-        this.mobilePhone = mobilePhone;
-    }
-    static create(participantId, firstName, lastName, emailAddress, mobilePhone, language, city, state, postalCode, countryCode, address1, address2) {
-        if (!(0, utils_1.hasLen)(participantId, 1, 20)) {
-            throw new errors_1.ValidationError("Participants must be of 1 to 20 characters.");
-        }
-        if (!(0, utils_1.isAlphaNumeric)(participantId)) {
-            throw new errors_1.ValidationError("Participants must only contains alpha numeric characters");
-        }
-        if (!(0, utils_1.hasLen)(firstName, 1, 50)) {
-            throw new errors_1.ValidationError("Firstname must be within 1 to 50 characters.");
-        }
-        if (!(0, utils_1.hasLen)(lastName, 1, 50)) {
-            throw new errors_1.ValidationError("Lastname must be within 1 to 50 characters.");
-        }
-        if (!(0, utils_1.hasLen)(emailAddress, 1, 80)) {
-            throw new errors_1.ValidationError("Email must be within 1 to 80 characters.");
-        }
-        if (!(0, utils_1.isEmailValid)(emailAddress)) {
-            throw new errors_1.ValidationError("Email address must be a valid email.");
-        }
-        if (!(0, utils_1.hasLen)(language, 2, 5)) {
-            throw new errors_1.ValidationError("Language code must be within 2 to 5 characters.");
-        }
-        if (!(0, utils_1.hasLen)(mobilePhone, 1, 20)) {
-            throw new errors_1.ValidationError("Mobile phone number must be within 1 to 20 characters.");
-        }
-        if (!(0, utils_1.hasLen)(city, 1, 50)) {
-            throw new errors_1.ValidationError("City must be within 1 to 50 characters.");
-        }
-        if (!(0, utils_1.hasLen)(state, 1, 50)) {
-            throw new errors_1.ValidationError("State must be within 1 to 50 characters.");
-        }
-        if (!exports.allCountriesWithCode.find((country) => country.code === countryCode)) {
-            throw new errors_1.ValidationError("CountryCode must be a valid supported ISO 3166-1 alpha-3 code");
-        }
-        if (!(0, utils_1.hasLen)(postalCode, 1, 20)) {
-            throw new errors_1.ValidationError("Postal code must be within 1 to 20 characters.");
-        }
-        if (!(0, utils_1.hasLen)(address1, 1, 50)) {
-            throw new errors_1.ValidationError("Address line 1 must be within 1 to 50 characters.");
-        }
-        if (address2 && !(0, utils_1.hasLen)(address2, 1, 50)) {
-            throw new errors_1.ValidationError("Address line 2 must be within 1 to 50 characters.");
-        }
-        return new Recipient(participantId, firstName, lastName, emailAddress, mobilePhone, language, city, state, postalCode, countryCode, address1, address2 ?? "N/A");
-    }
-}
-exports.Recipient = Recipient;
-exports.allCountriesWithCode = [
-    { name: "Algeria", code: "DZA" },
-    { name: "Angola", code: "AGO" },
-    { name: "Argentina", code: "ARG" },
-    { name: "Australia", code: "AUS" },
-    { name: "Austria", code: "AUT" },
-    { name: "Belgium", code: "BEL" },
-    { name: "Bolivia (Plurinational State of)", code: "BOL" },
-    { name: "Brazil", code: "BRA" },
-    { name: "Cameroon", code: "CMR" },
-    { name: "Canada", code: "CAN" },
-    { name: "Chile", code: "CHL" },
-    { name: "Costa Rica", code: "CRI" },
-    { name: "Cyprus", code: "CYP" },
-    { name: "Czechia", code: "CZE" },
-    { name: "Denmark", code: "DNK" },
-    { name: "Ecuador", code: "ECU" },
-    { name: "Egypt", code: "EGY" },
-    { name: "El Salvador", code: "SLV" },
-    { name: "Estonia", code: "EST" },
-    { name: "Finland", code: "FIN" },
-    { name: "France", code: "FRA" },
-    { name: "Georgia", code: "GEO" },
-    { name: "Germany", code: "DEU" },
-    { name: "Ghana", code: "GHA" },
-    { name: "Greece", code: "GRC" },
-    { name: "Guatemala", code: "GTM" },
-    { name: "Honduras", code: "HND" },
-    { name: "Hungary", code: "HUN" },
-    { name: "Iceland", code: "ISL" },
-    { name: "Ireland", code: "IRL" },
-    { name: "Italy", code: "ITA" },
-    { name: "Jamaica", code: "JAM" },
-    { name: "Japan", code: "JPN" },
-    { name: "Jordan", code: "JOR" },
-    { name: "Kenya", code: "KEN" },
-    { name: "Korea, Republic of Korea", code: "KOR" },
-    { name: "Kuwait", code: "KWT" },
-    { name: "Lithuania", code: "LTU" },
-    { name: "Luxembourg", code: "LUX" },
-    { name: "Malawi", code: "MWI" },
-    { name: "Malaysia", code: "MYS" },
-    { name: "Malta", code: "MLT" },
-    { name: "Mexico", code: "MEX" },
-    { name: "Morocco", code: "MAR" },
-    { name: "Mozambique", code: "MOZ" },
-    { name: "Nepal", code: "NPL" },
-    { name: "Netherlands", code: "NLD" },
-    { name: "New Zealand", code: "NZL" },
-    { name: "Nigeria", code: "NGA" },
-    { name: "Norway", code: "NOR" },
-    { name: "Oman", code: "OMN" },
-    { name: "Pakistan", code: "PAK" },
-    { name: "Papua New Guinea", code: "PNG" },
-    { name: "Paraguay", code: "PRY" },
-    { name: "Peru", code: "PER" },
-    { name: "Philippines", code: "PHL" },
-    { name: "Poland", code: "POL" },
-    { name: "Portugal", code: "PRT" },
-    { name: "Puerto Rico", code: "PRI" },
-    { name: "Qatar", code: "QAT" },
-    { name: "Romania", code: "ROU" },
-    { name: "Saudi Arabia", code: "SAU" },
-    { name: "Singapore", code: "SGP" },
-    { name: "Slovakia", code: "SVK" },
-    { name: "Slovenia", code: "SVN" },
-    { name: "Spain", code: "ESP" },
-    { name: "Sweden", code: "SWE" },
-    { name: "Taiwan", code: "TWN" },
-    { name: "Thailand", code: "THA" },
-    { name: "Trinidad and Tobago", code: "TTO" },
-    { name: "Tunisia", code: "TUN" },
-    { name: "Turkey", code: "TUR" },
-    { name: "United Kingdom", code: "GBR" },
-    { name: "United States", code: "USA" },
-    { name: "Uruguay", code: "URY" },
-    { name: "Vanuatu", code: "VUT" },
-    { name: "Zambia", code: "ZMB" },
-];

package/dist/utils.d.ts

@@ -1,8 +1,35 @@
+import algosdk from "algosdk";
 export declare function hashSHA256(input: string): string;
-export declare function isEmailValid(value: string): boolean;
-export declare function isAlphaNumeric(value: string): boolean;
-export declare function areDatesOfSameDay(date1: Date, date2: Date): boolean;
-export declare function hasMinLen(value: string, len: number): boolean;
-export declare function hasMaxLen(value: string, len: number): boolean;
-export declare function hasLen(value: string, min: number, max?: number): boolean;
-export declare function formatAmount(amount: number | string, decimalPlaces?: number): number;
+/**
+ * Convert ALGO to microAlgos
+ * @param algos Amount in ALGO
+ * @returns Amount in microAlgos
+ */
+export declare function parseAlgo(algos: number | string): bigint;
+/**
+ * Convert microAlgos to ALGO
+ * @param microAlgos Amount in microAlgos
+ * @returns Amount in ALGO
+ */
+export declare function formatAlgo(microAlgos: number | bigint): string;
+/**
+ * Convert Amount to micro-token amount (base units)
+ * @param amount Amount in decimal units
+ * @param decimals Number of decimals for the asset
+ * @returns Amount in micro-token base units
+ */
+export declare function parseAlgorandAsset(amount: number | string, decimals: number): bigint;
+/**
+ * Convert micro-token Amount to Amount
+ * @param microAmount Amount in micro units
+ * @param decimals Number of decimals for the asset
+ * @returns Amount in decimal units
+ */
+export declare function formatAlgorandAsset(microAmount: number | bigint, decimals: number): string;
+/**
+ *
+ * @param client Algod Client
+ * @param assetId asset index of Asset
+ * @returns
+ */
+export declare function getAssetDecimals(client: algosdk.Algodv2, assetId: number): Promise<number>;

package/dist/utils.js

@@ -4,13 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hashSHA256 = hashSHA256;
-exports.isEmailValid = isEmailValid;
-exports.isAlphaNumeric = isAlphaNumeric;
-exports.areDatesOfSameDay = areDatesOfSameDay;
-exports.hasMinLen = hasMinLen;
-exports.hasMaxLen = hasMaxLen;
-exports.hasLen = hasLen;
-exports.formatAmount = formatAmount;
+exports.parseAlgo = parseAlgo;
+exports.formatAlgo = formatAlgo;
+exports.parseAlgorandAsset = parseAlgorandAsset;
+exports.formatAlgorandAsset = formatAlgorandAsset;
+exports.getAssetDecimals = getAssetDecimals;
+const bignumber_js_1 = require("bignumber.js");
 const crypto_1 = __importDefault(require("crypto"));
 function hashSHA256(input) {
     const hash = crypto_1.default.createHash("sha256");
@@ -18,31 +17,55 @@ function hashSHA256(input) {
     const hex = hash.digest("hex");
     return hex;
 }
-function isEmailValid(value) {
-    return /^[a-zA-Z0-9._+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,10}$/.test(value);
+/**
+ * Convert ALGO to microAlgos
+ * @param algos Amount in ALGO
+ * @returns Amount in microAlgos
+ */
+function parseAlgo(algos) {
+    return BigInt((0, bignumber_js_1.BigNumber)(algos).times(1_000_000).toFixed(0));
 }
-function isAlphaNumeric(value) {
-    return /^[a-zA-Z0-9]+$/.test(value);
+/**
+ * Convert microAlgos to ALGO
+ * @param microAlgos Amount in microAlgos
+ * @returns Amount in ALGO
+ */
+function formatAlgo(microAlgos) {
+    return (0, bignumber_js_1.BigNumber)(microAlgos).div(1_000_000).toFixed();
 }
-function areDatesOfSameDay(date1, date2) {
-    return (date1.getUTCDay() === date2.getUTCDay() &&
-        date1.getUTCMonth() === date2.getUTCMonth() &&
-        date1.getUTCFullYear() === date2.getUTCFullYear());
+/**
+ * Convert Amount to micro-token amount (base units)
+ * @param amount Amount in decimal units
+ * @param decimals Number of decimals for the asset
+ * @returns Amount in micro-token base units
+ */
+function parseAlgorandAsset(amount, decimals) {
+    return BigInt((0, bignumber_js_1.BigNumber)(amount).times((0, bignumber_js_1.BigNumber)(10).pow(decimals)).toFixed(0));
 }
-function hasMinLen(value, len) {
-    return value.length >= len;
+/**
+ * Convert micro-token Amount to Amount
+ * @param microAmount Amount in micro units
+ * @param decimals Number of decimals for the asset
+ * @returns Amount in decimal units
+ */
+function formatAlgorandAsset(microAmount, decimals) {
+    return (0, bignumber_js_1.BigNumber)(microAmount).div((0, bignumber_js_1.BigNumber)(10).pow(decimals)).toFixed();
 }
-function hasMaxLen(value, len) {
-    return value.length <= len;
-}
-function hasLen(value, min, max) {
-    if (max) {
-        return hasMinLen(value, min) && hasMaxLen(value, max);
-    }
-    else {
-        return hasMinLen(value, min);
+const ALGORAND_ASSET_DECIMALS_CACHE = new Map();
+/**
+ *
+ * @param client Algod Client
+ * @param assetId asset index of Asset
+ * @returns
+ */
+async function getAssetDecimals(client, assetId) {
+    // Check if we already have this value cached
+    if (ALGORAND_ASSET_DECIMALS_CACHE.has(assetId)) {
+        return ALGORAND_ASSET_DECIMALS_CACHE.get(assetId);
     }
-}
-function formatAmount(amount, decimalPlaces = 2) {
-    return Number(Number(amount).toFixed(decimalPlaces));
+    const assetInfo = await client.getAssetByID(assetId).do();
+    const decimals = assetInfo.params.decimals;
+    // Cache the result for future use
+    ALGORAND_ASSET_DECIMALS_CACHE.set(assetId, decimals);
+    return decimals;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zebec-network/exchange-card-sdk",
-	"version": "1.2.3",
+	"version": "1.3.0",
 	"description": "An sdk for purchasing silver card in zebec",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/dist/chains.d.ts

@@ -1,13 +0,0 @@
-/**
- * Supported chainIds by zebec instant card sdk.
- */
-export declare enum SupportedChain {
-    Mainnet = 1,
-    Sepolia = 11155111,
-    Base = 8453,
-    Bsc = 56,
-    BscTestnet = 97,
-    Polygon = 137
-}
-export declare const TESTNET_CHAINIDS: SupportedChain[];
-export declare function parseSupportedChain(chainId: number): SupportedChain;

package/dist/chains.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TESTNET_CHAINIDS = exports.SupportedChain = void 0;
-exports.parseSupportedChain = parseSupportedChain;
-const errors_1 = require("./errors");
-/**
- * Supported chainIds by zebec instant card sdk.
- */
-var SupportedChain;
-(function (SupportedChain) {
-    SupportedChain[SupportedChain["Mainnet"] = 1] = "Mainnet";
-    SupportedChain[SupportedChain["Sepolia"] = 11155111] = "Sepolia";
-    SupportedChain[SupportedChain["Base"] = 8453] = "Base";
-    SupportedChain[SupportedChain["Bsc"] = 56] = "Bsc";
-    SupportedChain[SupportedChain["BscTestnet"] = 97] = "BscTestnet";
-    SupportedChain[SupportedChain["Polygon"] = 137] = "Polygon";
-    // Bittensor = 558,
-    // BittensorTestnet = 559,
-    // Ton = -239,
-    // TonTestnet = -3,
-    // XdbChain = -4,
-    // Stellar = -5,
-})(SupportedChain || (exports.SupportedChain = SupportedChain = {}));
-exports.TESTNET_CHAINIDS = [SupportedChain.Sepolia, SupportedChain.BscTestnet];
-function parseSupportedChain(chainId) {
-    switch (chainId) {
-        case 1:
-            return SupportedChain.Mainnet;
-        case 11155111:
-            return SupportedChain.Sepolia;
-        case 8453:
-            return SupportedChain.Base;
-        case 56:
-            return SupportedChain.Bsc;
-        case 97:
-            return SupportedChain.BscTestnet;
-        case 137:
-            return SupportedChain.Polygon;
-        default:
-            throw new errors_1.UnsupportedChainError(chainId);
-    }
-}

package/dist/errors.d.ts

@@ -1,24 +0,0 @@
-export declare class UnsupportedChainError extends Error {
-    name: string;
-    constructor(chainId: number);
-}
-export declare class InvalidEmailError extends Error {
-    name: string;
-    constructor(email: string);
-}
-export declare class NotEnoughBalanceError extends Error {
-    name: string;
-    constructor(currentBalance: string, requiredBalance: string);
-}
-export declare class CardPurchaseAmountOutOfRangeError extends Error {
-    name: string;
-    constructor(minRange: string, maxRange: string);
-}
-export declare class DailyCardPurchaseLimitExceedError extends Error {
-    name: string;
-    constructor(dailyLimit: string, purchaseOfADay: string);
-}
-export declare class ValidationError extends Error {
-    name: string;
-    constructor(message: string);
-}

package/dist/errors.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationError = exports.DailyCardPurchaseLimitExceedError = exports.CardPurchaseAmountOutOfRangeError = exports.NotEnoughBalanceError = exports.InvalidEmailError = exports.UnsupportedChainError = void 0;
-class UnsupportedChainError extends Error {
-    name = "UnsupportedChainError";
-    constructor(chainId) {
-        super("Unsupported chainId: " + chainId);
-    }
-}
-exports.UnsupportedChainError = UnsupportedChainError;
-class InvalidEmailError extends Error {
-    name = "InvalidEmailError";
-    constructor(email) {
-        super("Invalid email: " + email);
-    }
-}
-exports.InvalidEmailError = InvalidEmailError;
-class NotEnoughBalanceError extends Error {
-    name = "NotEnoughBalanceError";
-    constructor(currentBalance, requiredBalance) {
-        super("Not enough balance. Current amount: " +
-            currentBalance +
-            " Required amount: " +
-            requiredBalance);
-    }
-}
-exports.NotEnoughBalanceError = NotEnoughBalanceError;
-class CardPurchaseAmountOutOfRangeError extends Error {
-    name = "BuyAmountOutOfRangeError";
-    constructor(minRange, maxRange) {
-        super("Amount must be with range: " + minRange + " - " + maxRange);
-    }
-}
-exports.CardPurchaseAmountOutOfRangeError = CardPurchaseAmountOutOfRangeError;
-class DailyCardPurchaseLimitExceedError extends Error {
-    name = "DailyCardPurchaseLimitExceedError";
-    constructor(dailyLimit, purchaseOfADay) {
-        super("Requested card purchase amount exceeds daily purchase limit. Daily limit: " +
-            dailyLimit +
-            " Today's purchase amount: " +
-            purchaseOfADay);
-    }
-}
-exports.DailyCardPurchaseLimitExceedError = DailyCardPurchaseLimitExceedError;
-class ValidationError extends Error {
-    name = "ValidationError";
-    constructor(message) {
-        super(message);
-    }
-}
-exports.ValidationError = ValidationError;