@zebec-network/exchange-card-sdk 1.8.2 → 1.9.0-dev.10

package/dist/artifacts/abi/index.js

@@ -1,2 +1,4 @@
-import ERC20 from "./ERC20.json";
+const ERC20 = await import("./ERC20.json", {
+    with: { type: "json" },
+});
 export const ERC20_ABI = ERC20.abi;

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-import { BobaChainId, QuaiChainId } from "./types";
+import type { BobaChainId, QuaiChainId } from "./types";
 export declare const CARD_API_URL: Record<"Production" | "Sandbox", string>;
 export declare const NEAR_RPC_URL: Record<"Production" | "Sandbox", string>;
 export declare const XRPL_RPC_URL: Record<"Production" | "Sandbox", string>;
@@ -17,6 +17,7 @@ export declare const BITCOIN_ENDPOINTS: {
     readonly Sandbox: "https://mempool.space/testnet/api";
     readonly Production: "https://mempool.space/api";
 };
+export declare const ALEO_NETWORK_CLIENT_URL = "https://api.provable.com/v2";
 export declare const BOBA_CHAIN_ID: Record<"mainnet" | "testnet", BobaChainId>;
 export declare const QUAI_CHAIN_ID: Record<"mainnet" | "testnet", QuaiChainId>;
 export declare const DEFAULT_EVM_GAS_LIMIT = 3000000;

package/dist/constants.js

@@ -35,6 +35,7 @@ export const BITCOIN_ENDPOINTS = {
     Sandbox: "https://mempool.space/testnet/api",
     Production: "https://mempool.space/api",
 };
+export const ALEO_NETWORK_CLIENT_URL = "https://api.provable.com/v2";
 export const BOBA_CHAIN_ID = {
     mainnet: 288,
     testnet: 28882,

package/dist/services/aleoService.d.ts

@@ -0,0 +1,90 @@
+import { type TransactionOptions } from "@provablehq/aleo-types";
+import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+import { AleoNetworkClient as TestnetAleoNetworkClient } from "@provablehq/sdk/testnet.js";
+import { ZebecCardAPIService } from "../helpers/apiHelpers";
+export interface AleoWallet {
+    address: string;
+    decrypt: (cipherText: string) => Promise<string>;
+    requestRecords: (program: string, includePlaintext?: boolean | undefined) => Promise<unknown[]>;
+    executeTransaction: (options: TransactionOptions) => Promise<{
+        transactionId: string;
+    }>;
+}
+export type AleoTransferCreditParams = {
+    amount: number | string;
+    transferType?: "public" | "private";
+    fee?: number;
+    privateFee?: boolean;
+};
+export type AleoTransferStableCoinParams = {
+    programId: "usad_stablecoin.aleo" | "usdcx_stablecoin.aleo";
+    amount: number | string;
+    transferType?: "public" | "private";
+    fee?: number;
+    privateFee?: boolean;
+};
+export declare const NETWORK_CONFIG: {
+    mainnet: {
+        explorer: string;
+        stablecoins: {
+            usad: string;
+            usdcx: string;
+        };
+        freezeListApi: {
+            usad: string;
+            usdcx: string;
+        };
+    };
+    testnet: {
+        explorer: string;
+        stablecoins: {
+            usad: string;
+            usdcx: string;
+        };
+        freezeListApi: {
+            usad: string;
+            usdcx: string;
+        };
+    };
+};
+export declare class AleoService {
+    readonly wallet: AleoWallet;
+    readonly sandbox: boolean;
+    readonly apiService: ZebecCardAPIService;
+    readonly networkClient: AleoNetworkClient | TestnetAleoNetworkClient;
+    constructor(wallet: AleoWallet, options?: {
+        sandbox?: boolean;
+    });
+    /**
+     * Fetches the Bitcoin vault address.
+     *
+     * @returns {Promise<{ address: string }>} A promise that resolves to the vault address.
+     */
+    fetchVault(symbol?: string): Promise<{
+        address: string;
+        tag?: string;
+    }>;
+    /**
+     * Fetch unspent records for a program, decrypt them, and return the one
+     * with the highest non-zero balance as a single-line plaintext string.
+     */
+    private _getRecord;
+    /**
+     * Build a Sealance Merkle exclusion proof proving the sender is NOT on the
+     * program's freeze list. Required for compliant stablecoin transfers.
+     */
+    private _getComplianceProof;
+    /**
+     * Transfer native Aleo credits to the specified recipient.
+     */
+    transferCredit(params: AleoTransferCreditParams): Promise<{
+        transactionId: string;
+    }>;
+    transferStableCoin(params: AleoTransferStableCoinParams): Promise<{
+        transactionId: string;
+    }>;
+    getPublicBalance(): Promise<string>;
+    getPublicTokenBalance(tokenProgramId: string, tokenSymbol: string): Promise<string>;
+    getPrivateBalance(): Promise<string>;
+    getPrivateTokenBalance(tokenProgramId: string, tokenSymbol: string): Promise<string>;
+}

package/dist/services/aleoService.js

@@ -0,0 +1,280 @@
+import { Network } from "@provablehq/aleo-types";
+import { AleoNetworkClient, SealanceMerkleTree } from "@provablehq/sdk/mainnet.js";
+import { AleoNetworkClient as TestnetAleoNetworkClient, SealanceMerkleTree as TestnetSealanceMerkleTree, } from "@provablehq/sdk/testnet.js";
+import { ALEO_NETWORK_CLIENT_URL } from "../constants";
+import { ZebecCardAPIService } from "../helpers/apiHelpers";
+import { fromMicroUnits, getTokenBySymbol, toMicroUnits } from "../utils";
+export const NETWORK_CONFIG = {
+    [Network.MAINNET]: {
+        explorer: "https://explorer.provable.com/transaction",
+        stablecoins: {
+            usad: "usad_stablecoin.aleo",
+            usdcx: "usdcx_stablecoin.aleo",
+        },
+        freezeListApi: {
+            usad: "https://api.explorer.provable.com/v2/mainnet/programs/usad_freezelist.aleo/compliance/freeze-list",
+            usdcx: "https://api.explorer.provable.com/v2/mainnet/programs/usdcx_freezelist.aleo/compliance/freeze-list",
+        },
+    },
+    [Network.TESTNET]: {
+        explorer: "https://explorer.provable.com/testnet/transaction",
+        stablecoins: {
+            usad: "test_usad_stablecoin.aleo",
+            usdcx: "test_usdcx_stablecoin.aleo",
+        },
+        freezeListApi: {
+            usad: "https://api.explorer.provable.com/v2/testnet/programs/test_usad_freezelist.aleo/compliance/freeze-list",
+            usdcx: "https://api.explorer.provable.com/v2/testnet/programs/test_usdcx_freezelist.aleo/compliance/freeze-list",
+        },
+    },
+};
+export class AleoService {
+    wallet;
+    sandbox;
+    apiService;
+    networkClient;
+    constructor(wallet, options) {
+        this.wallet = wallet;
+        this.sandbox = options?.sandbox || false;
+        this.apiService = new ZebecCardAPIService(options?.sandbox || false);
+        this.networkClient = this.sandbox
+            ? new TestnetAleoNetworkClient(ALEO_NETWORK_CLIENT_URL)
+            : new AleoNetworkClient(ALEO_NETWORK_CLIENT_URL);
+    }
+    /**
+     * Fetches the Bitcoin vault address.
+     *
+     * @returns {Promise<{ address: string }>} A promise that resolves to the vault address.
+     */
+    async fetchVault(symbol = "ALEO") {
+        const data = await this.apiService.fetchVault(symbol);
+        return data;
+    }
+    /**
+     * Fetch unspent records for a program, decrypt them, and return the one
+     * with the highest non-zero balance as a single-line plaintext string.
+     */
+    async _getRecord(program, includePlaintext = false) {
+        const records = await this.wallet.requestRecords(program, includePlaintext);
+        console.debug("Fetched records:", records);
+        const unspent = records?.filter((r) => typeof r === "object" && r !== null && "spent" in r && !r.spent);
+        if (!unspent?.length) {
+            throw new Error(`No unspent ${program} records found`);
+        }
+        // Decrypt all unspent records in parallel (fast with AutoDecrypt permission)
+        const decrypted = await Promise.all(unspent.map(async (rec) => {
+            if (typeof rec !== "object" ||
+                rec === null ||
+                !("recordCiphertext" in rec) ||
+                typeof rec.recordCiphertext !== "string") {
+                throw new Error("Invalid record format");
+            }
+            console.debug("Decrypting record:", rec);
+            const plaintext = await this.wallet.decrypt(rec.recordCiphertext);
+            console.debug("Decrypted plaintext:", plaintext);
+            return plaintext.replace(/\s+/g, " ").trim();
+        }));
+        // Find records with non-zero balance, sorted highest-first
+        const withBalance = decrypted
+            .map((line) => {
+            const match = line.match(/microcredits:\s*(\d+)u64/) || line.match(/amount:\s*(\d+)u\d+/);
+            return { line, balance: match ? BigInt(match[1]) : 0n };
+        })
+            .filter((r) => r.balance > 0n)
+            .sort((a, b) => (b.balance > a.balance ? 1 : -1));
+        if (!withBalance.length) {
+            throw new Error(`No ${program} records with balance found`);
+        }
+        return withBalance[0].line;
+    }
+    /**
+     * Build a Sealance Merkle exclusion proof proving the sender is NOT on the
+     * program's freeze list. Required for compliant stablecoin transfers.
+     */
+    async _getComplianceProof(stablecoinKey, senderAddress, network) {
+        if (network === Network.CANARY) {
+            throw new Error("Compliance proof generation is not supported on canary network");
+        }
+        const sealance = this.sandbox ? new TestnetSealanceMerkleTree() : new SealanceMerkleTree();
+        const url = NETWORK_CONFIG[network].freezeListApi[stablecoinKey];
+        const res = await fetch(url);
+        const freezeList = await res.json();
+        const tree = sealance.convertTreeToBigInt(freezeList);
+        const [leftIdx, rightIdx] = sealance.getLeafIndices(tree, senderAddress);
+        const leftProof = sealance.getSiblingPath(tree, leftIdx, 16);
+        const rightProof = sealance.getSiblingPath(tree, rightIdx, 16);
+        return sealance.formatMerkleProof([leftProof, rightProof]);
+    }
+    /**
+     * Transfer native Aleo credits to the specified recipient.
+     */
+    async transferCredit(params) {
+        const { amount } = params;
+        const transferType = params.transferType || "public";
+        const privateFee = params?.privateFee || false;
+        const fee = toMicroUnits(params.fee || 0.1, 6);
+        const vault = await this.fetchVault("ALEO");
+        const recipient = vault.address;
+        console.log("recipient:", recipient);
+        const amountInMicroCredits = toMicroUnits(amount, 6, "u64");
+        const PROGRAM_NAME = "credits.aleo";
+        const functionName = transferType === "public" ? "transfer_public" : "transfer_private";
+        let inputs;
+        switch (functionName) {
+            case "transfer_public":
+                inputs = [recipient, `${amountInMicroCredits}u64`];
+                break;
+            case "transfer_private": {
+                const record = await this._getRecord(PROGRAM_NAME);
+                inputs = [record, recipient, amountInMicroCredits];
+                break;
+            }
+            default:
+                throw new Error("Invalid or Unsupported transfer type");
+        }
+        if (functionName !== "transfer_public") {
+            throw new Error("Only public transfers are currently supported for credits. Private and cross-type transfers require additional implementation.");
+        }
+        const result = await this.wallet.executeTransaction({
+            program: PROGRAM_NAME,
+            function: functionName,
+            inputs,
+            fee: Number(fee),
+            privateFee,
+        });
+        return result;
+    }
+    async transferStableCoin(params) {
+        const { amount } = params;
+        const transferType = params.transferType || "public";
+        const privateFee = params?.privateFee || false;
+        const fee = toMicroUnits(params.fee || 0.1, 6);
+        const programId = this.sandbox ? `test_${params.programId}` : params.programId;
+        const tokenSymbol = params.programId === "usad_stablecoin.aleo" ? "USAD" : "USDCX";
+        const functionName = transferType === "public" ? "transfer_public" : "transfer_private";
+        const vault = await this.fetchVault(tokenSymbol);
+        const recipient = vault.address;
+        const amountInMicroUnits = toMicroUnits(amount, 6, "u128");
+        let inputs;
+        switch (functionName) {
+            case "transfer_public":
+                inputs = [recipient, amountInMicroUnits];
+                break;
+            case "transfer_private": {
+                // For private transfer, we need to find a record with sufficient balance
+                const [record, complianceProof] = await Promise.all([
+                    this._getRecord(programId),
+                    this._getComplianceProof(tokenSymbol.toLowerCase(), this.wallet.address, this.sandbox ? Network.TESTNET : Network.MAINNET),
+                ]);
+                inputs = [recipient, amountInMicroUnits, record, complianceProof];
+                break;
+            }
+            default:
+                throw new Error("Invalid or Unsupported transfer type");
+        }
+        const result = await this.wallet.executeTransaction({
+            fee: Number(fee),
+            privateFee,
+            program: programId,
+            function: functionName,
+            inputs,
+        });
+        return result;
+    }
+    async getPublicBalance() {
+        const balance = await this.networkClient.getPublicBalance(this.wallet.address);
+        const formattedAmount = fromMicroUnits(balance);
+        return formattedAmount;
+    }
+    async getPublicTokenBalance(tokenProgramId, tokenSymbol) {
+        const tokenMetadata = await getTokenBySymbol(tokenSymbol, this.sandbox ? "testnet" : "mainnet");
+        if (!("decimals" in tokenMetadata)) {
+            throw new Error(`Token metadata for ${tokenSymbol} does not include decimals.`);
+        }
+        const mappingNames = await this.networkClient.getProgramMappingNames(tokenProgramId);
+        const balanceMappingName = mappingNames.includes("balances")
+            ? "balances"
+            : mappingNames.includes("account")
+                ? "account"
+                : null;
+        if (!balanceMappingName) {
+            throw new Error("No public balance mapping found (no 'balances' or 'account').");
+        }
+        const balance = await this.networkClient.getProgramMappingValue(tokenProgramId, balanceMappingName, this.wallet.address);
+        if (balance) {
+            const regex = /(\d+)u\d+/;
+            const match = balance.match(regex);
+            if (match) {
+                const amount = match[1];
+                const formattedAmount = fromMicroUnits(amount, tokenMetadata.decimals);
+                return formattedAmount;
+            }
+            else {
+                throw new Error(`Invalid balance format: ${balance}`);
+            }
+        }
+        else {
+            return "0";
+        }
+    }
+    async getPrivateBalance() {
+        const programId = "credits.aleo";
+        const records = await this.wallet.requestRecords(programId, false);
+        if (!records) {
+            throw new Error(`No records found for program ${programId}`);
+        }
+        // console.log("Fetched Records:", records);
+        const unspent = records.filter((r) => r && typeof r === "object" && "spent" in r && !r.spent);
+        if (!unspent || !unspent.length) {
+            throw new Error(`No unspent ${programId} records found`);
+        }
+        const decrypted = await Promise.all(unspent.map(async (rec) => {
+            if (!rec ||
+                typeof rec !== "object" ||
+                !("recordCiphertext" in rec) ||
+                typeof rec.recordCiphertext !== "string") {
+                throw new Error(`Invalid record format: ${JSON.stringify(rec)}`);
+            }
+            const plaintext = await this.wallet.decrypt(rec.recordCiphertext);
+            return plaintext.replace(/\s+/g, " ").trim();
+        }));
+        const balance = decrypted
+            .map((line) => {
+            const match = line.match(/microcredits:\s*(\d+)u64/);
+            return match ? BigInt(match[1]) : 0n;
+        })
+            .reduce((acc, val) => acc + val, 0n);
+        return fromMicroUnits(balance, 6);
+    }
+    async getPrivateTokenBalance(tokenProgramId, tokenSymbol) {
+        const records = await this.wallet.requestRecords(tokenProgramId, false);
+        if (!records) {
+            throw new Error(`No records found for program ${tokenProgramId}`);
+        }
+        const unspent = records.filter((r) => r && typeof r === "object" && "spent" in r && !r.spent);
+        if (!unspent || !unspent.length) {
+            throw new Error(`No unspent ${tokenProgramId} records found`);
+        }
+        const decrypted = await Promise.all(unspent.map(async (rec) => {
+            if (!rec ||
+                typeof rec !== "object" ||
+                !("recordCiphertext" in rec) ||
+                typeof rec.recordCiphertext !== "string") {
+                throw new Error(`Invalid record format: ${JSON.stringify(rec)}`);
+            }
+            const plaintext = await this.wallet.decrypt(rec.recordCiphertext);
+            return plaintext.replace(/\s+/g, " ").trim();
+        }));
+        const balance = decrypted
+            .map((line) => {
+            const match = line.match(/amount:\s*(\d+)u\d+/);
+            return match ? BigInt(match[1]) : 0n;
+        })
+            .reduce((acc, val) => acc + val, 0n);
+        const tokenMetadata = await getTokenBySymbol(tokenSymbol, this.sandbox ? "testnet" : "mainnet");
+        if (!("decimals" in tokenMetadata)) {
+            throw new Error(`Token metadata for ${tokenSymbol} does not include decimals.`);
+        }
+        return fromMicroUnits(balance, tokenMetadata.decimals);
+    }
+}

package/dist/services/cantonService.js

@@ -0,0 +1,103 @@
+"use strict";
+// import {
+// 	type AuthTokenProvider,
+// 	LedgerController,
+// 	localNetStaticConfig,
+// 	TokenStandardController,
+// 	ValidatorController,
+// 	type WalletSDK,
+// 	WalletSDKImpl,
+// } from "@canton-network/wallet-sdk";
+// import { ZebecCardAPIService } from "../helpers/apiHelpers";
+// export interface CantonWallet {
+// 	partyId: string;
+// 	executeTransaction: (command: unknown, disclosedContractId: unknown[]) => Promise<string>;
+// }
+// export interface CantonConfig {
+// 	ledgerApiUrl: string;
+// 	validatorAppApiUrl: string;
+// }
+// export function createLedgerFactory(ledgerApiUrl: string) {
+// 	return (userId: string, authTokenProvider: AuthTokenProvider, isAdmin: boolean) => {
+// 		return new LedgerController(
+// 			userId,
+// 			new URL(ledgerApiUrl),
+// 			undefined,
+// 			isAdmin,
+// 			authTokenProvider,
+// 		);
+// 	};
+// }
+// export function createValidatorFactory(validatorAppApiUrl: string) {
+// 	return (userId: string, authTokenProvider: AuthTokenProvider) => {
+// 		return new ValidatorController(userId, new URL(validatorAppApiUrl), authTokenProvider);
+// 	};
+// }
+// export function createTokenStandardFactory(ledgerApiUrl: string, validatorAppApiUrl: string) {
+// 	return (userId: string, authTokenProvider: AuthTokenProvider, isAdmin: boolean) => {
+// 		return new TokenStandardController(
+// 			userId,
+// 			new URL(ledgerApiUrl),
+// 			new URL(validatorAppApiUrl),
+// 			undefined,
+// 			authTokenProvider,
+// 			isAdmin,
+// 		);
+// 	};
+// }
+// export class CantonService {
+// 	readonly cantonWalletSdk: WalletSDK;
+// 	private apiService: ZebecCardAPIService;
+// 	constructor(
+// 		readonly wallet: CantonWallet,
+// 		readonly cantonConfig: CantonConfig,
+// 		sdkOptions?: { sandbox?: boolean },
+// 	) {
+// 		this.apiService = new ZebecCardAPIService(sdkOptions?.sandbox || false);
+// 		this.cantonWalletSdk = new WalletSDKImpl().configure({
+// 			logger: console,
+// 			ledgerFactory: createLedgerFactory(cantonConfig.ledgerApiUrl),
+// 			validatorFactory: createValidatorFactory(cantonConfig.validatorAppApiUrl),
+// 			tokenStandardFactory: createTokenStandardFactory(
+// 				cantonConfig.ledgerApiUrl,
+// 				cantonConfig.validatorAppApiUrl,
+// 			),
+// 		});
+// 	}
+// 	async connect() {
+// 		await this.cantonWalletSdk.connect();
+// 	}
+// 	async fetchVault(symbol = "CANTON"): Promise<{ address: string; tag?: string }> {
+// 		const data = await this.apiService.fetchVault(symbol);
+// 		return data;
+// 	}
+// 	// methods for transfering natve assets
+// 	async transferNative(params: {
+// 		amount: number | string;
+// 		instrumentId: string;
+// 		instrumentAdmin: string;
+// 	}) {
+// 		const vault = await this.fetchVault("CANTON");
+// 		const sender = this.wallet.partyId;
+// 		const receiver = vault.address;
+// 		const memo = vault.tag;
+// 		// implement transfer logic here
+// 		this.cantonWalletSdk.tokenStandard?.setTransferFactoryRegistryUrl(
+// 			localNetStaticConfig.LOCALNET_REGISTRY_API_URL,
+// 		);
+// 		const [transferCommand, disclosedContracts] =
+// 			// biome-ignore lint/style/noNonNullAssertion: we can be sure that tokenStandard is defined here since we set its factory in the SDK constructor
+// 			await this.cantonWalletSdk.tokenStandard!.createTransfer(
+// 				sender,
+// 				receiver,
+// 				params.amount.toString(),
+// 				{
+// 					instrumentId: params.instrumentId,
+// 					instrumentAdmin: params.instrumentAdmin,
+// 				},
+// 				[],
+// 				memo,
+// 			);
+// 		return this.wallet.executeTransaction(transferCommand, disclosedContracts);
+// 	}
+// }

package/dist/services/index.d.ts

@@ -1,8 +1,9 @@
-export * from "./stellarService";
-export * from "./xrplService";
-export * from "./nearService";
+export * from "./aleoService";
 export * from "./algorandService";
-export * from "./xdbService";
-export * from "./octaService";
 export * from "./bobaService";
+export * from "./nearService";
+export * from "./octaService";
 export * from "./quaiService";
+export * from "./stellarService";
+export * from "./xdbService";
+export * from "./xrplService";

package/dist/services/index.js

@@ -1,8 +1,10 @@
-export * from "./stellarService";
-export * from "./xrplService";
-export * from "./nearService";
+export * from "./aleoService";
 export * from "./algorandService";
-export * from "./xdbService";
-export * from "./octaService";
 export * from "./bobaService";
+// export * from "./cantonService";
+export * from "./nearService";
+export * from "./octaService";
 export * from "./quaiService";
+export * from "./stellarService";
+export * from "./xdbService";
+export * from "./xrplService";

package/dist/utils.d.ts

@@ -1,4 +1,5 @@
-import algosdk from "algosdk";
+import type algosdk from "algosdk";
+import { BigNumber } from "bignumber.js";
 /**
  * Convert ALGO to microAlgos
  * @param algos Amount in ALGO
@@ -32,3 +33,29 @@ export declare function formatAlgorandAsset(microAmount: number | bigint, decima
  * @returns
  */
 export declare function getAssetDecimals(client: algosdk.Algodv2, assetId: number): Promise<number>;
+/**
+ * Convert credits to microcredits
+ */
+export declare function toMicroUnits(credits: BigNumber.Value, decimals?: number, typeSuffix?: string): string;
+/**
+ * Convert microcredits to credits
+ */
+export declare function fromMicroUnits(microcredits: BigNumber.Value, decimals?: number): string;
+export type TokenMetadata = {
+    token_id: string;
+    token_id_datatype: string | null;
+    symbol: string;
+    display: string;
+    program_name: string;
+    decimals: number;
+    total_supply: string;
+    verified: boolean;
+    token_icon_url: string;
+    compliance_freeze_list: string;
+    price: string;
+    price_change_percentage_24h: string;
+    fully_diluted_value: string;
+    total_market_cap: string;
+    volume_24h: string;
+};
+export declare function getTokenBySymbol(tokenSymbol: string, network?: "mainnet" | "testnet"): Promise<TokenMetadata>;

package/dist/utils.js

@@ -1,4 +1,5 @@
 import { BigNumber } from "bignumber.js";
+import { ALEO_NETWORK_CLIENT_URL } from "./constants";
 /**
  * Convert ALGO to microAlgos
  * @param algos Amount in ALGO
@@ -43,7 +44,13 @@ const ALGORAND_ASSET_DECIMALS_CACHE = new Map();
 export 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);
+        const value = ALGORAND_ASSET_DECIMALS_CACHE.get(assetId);
+        if (value) {
+            return value;
+        }
+        else {
+            throw new Error("Cached value is undefined, this should not happen");
+        }
     }
     const assetInfo = await client.getAssetByID(assetId).do();
     const decimals = assetInfo.params.decimals;
@@ -51,3 +58,28 @@ export async function getAssetDecimals(client, assetId) {
     ALGORAND_ASSET_DECIMALS_CACHE.set(assetId, decimals);
     return decimals;
 }
+/**
+ * Convert credits to microcredits
+ */
+export function toMicroUnits(credits, decimals = 6, typeSuffix) {
+    return `${BigNumber(credits).times(BigNumber(10).pow(decimals)).toFixed(0)}${typeSuffix || ""}`;
+}
+/**
+ * Convert microcredits to credits
+ */
+export function fromMicroUnits(microcredits, decimals = 6) {
+    return BigNumber(microcredits).div(BigNumber(10).pow(decimals)).toFixed();
+}
+export async function getTokenBySymbol(tokenSymbol, network = "mainnet") {
+    const response = await fetch(`${ALEO_NETWORK_CLIENT_URL}/${network}/tokens?symbol=${encodeURIComponent(tokenSymbol)}`);
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`Failed to fetch token decimals for ${tokenSymbol}: ${response.statusText} ${body}`.trim());
+    }
+    const result = await response.json();
+    const tokens = Array.isArray(result) ? result : result?.data;
+    if (!Array.isArray(tokens) || tokens.length === 0) {
+        throw new Error(`No token found with symbol ${tokenSymbol}`);
+    }
+    return tokens.find((token) => token.verified) ?? tokens[0];
+}

package/package.json

@@ -1,26 +1,29 @@
 {
-	"name": "@zebec-network/exchange-card-sdk",
-	"version": "1.8.2",
-	"description": "An sdk for purchasing silver card in zebec",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"author": "Ashish Sapkota",
-	"license": "MIT",
-	"files": [
-		"dist"
-	],
-	"scripts": {
-		"build": "npm run clean && tsc",
-		"clean": "rimraf dist",
-		"format": "prettier --write .",
-		"test": "ts-mocha -p ./tsconfig.test.json -t 1000000",
-		"gen:typechain": "typechain --target ethers-v6 --out-dir \"src/artifacts/typechain-types\" \"src/artifacts/abi/*.json\""
+	"author": "Zebec Network | Ashish Sapkota",
+	"dependencies": {
+		"@near-js/crypto": "^2.5.1",
+		"@near-js/providers": "^2.5.1",
+		"@near-js/transactions": "^2.5.1",
+		"@near-js/types": "^2.5.1",
+		"@near-js/utils": "^2.5.1",
+		"@provablehq/aleo-types": "^0.3.0-alpha.3",
+		"@provablehq/sdk": "^0.9.15",
+		"@stellar/stellar-sdk": "^14.4.3",
+		"algosdk": "^3.4.0",
+		"axios": "^1.11.0",
+		"bignumber.js": "^10.0.2",
+		"ethers": "^6.15.0",
+		"quais": "^1.0.0-alpha.52",
+		"xrpl": "^4.4.1"
 	},
+	"description": "An sdk for purchasing silver card in zebec",
 	"devDependencies": {
 		"@algorandfoundation/algokit-utils": "^9.1.2",
+		"@canton-network/dapp-sdk": "^0.21.2",
 		"@near-js/accounts": "^2.5.1",
 		"@near-js/keystores": "^2.5.1",
 		"@near-js/signers": "^2.5.1",
+		"@near-js/tokens": "^2.5.1",
 		"@typechain/ethers-v6": "^0.5.1",
 		"@types/mocha": "^10.0.10",
 		"@types/node": "^24.3.1",
@@ -33,32 +36,33 @@
 		"typechain": "^8.3.2",
 		"typescript": "^5.9.2"
 	},
-	"dependencies": {
-		"@near-js/crypto": "^2.5.1",
-		"@near-js/providers": "^2.5.1",
-		"@near-js/transactions": "^2.5.1",
-		"@near-js/types": "^2.5.1",
-		"@near-js/utils": "^2.5.1",
-		"@stellar/stellar-sdk": "^14.4.3",
-		"algosdk": "^3.4.0",
-		"axios": "^1.11.0",
-		"bignumber.js": "^9.3.1",
-		"bitcoinjs-lib": "^6.1.7",
-		"ethers": "^6.15.0",
-		"quais": "^1.0.0-alpha.52",
-		"xrpl": "^4.4.1"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/Zebec-Fintech-Labs/zebec-card-minimal-sdk.git"
-	},
+	"files": [
+		"dist"
+	],
 	"homepage": "https://github.com/Zebec-Fintech-Labs/zebec-card-minimal-sdk.git#README",
 	"keywords": [
 		"zebec",
 		"zebec fintech",
 		"zebec instant card"
 	],
+	"license": "MIT",
+	"main": "dist/index.js",
+	"name": "@zebec-network/exchange-card-sdk",
 	"publishConfig": {
 		"access": "public"
-	}
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+git@github.com:Zebec-Fintech-Labs/card-sdk-mono.git"
+	},
+	"scripts": {
+		"build": "npm run clean && tsc",
+		"clean": "rimraf dist",
+		"format": "prettier --write .",
+		"gen:typechain": "typechain --target ethers-v6 --out-dir \"src/artifacts/typechain-types\" \"src/artifacts/abi/*.json\"",
+		"test": "ts-mocha -p ./tsconfig.test.json -t 1000000"
+	},
+	"type": "module",
+	"types": "dist/index.d.ts",
+	"version": "1.9.0-dev.10"
 }

package/dist/services/bitcoinService.d.ts

@@ -1,48 +0,0 @@
-import * as bitcoin from "bitcoinjs-lib";
-interface BitcoinWallet {
-    address: string;
-    signTransaction: (psbt: bitcoin.Psbt) => Promise<bitcoin.Psbt>;
-    broadcastTransaction: (tx: string) => Promise<string>;
-}
-export declare class BitcoinService {
-    readonly wallet: BitcoinWallet;
-    private apiService;
-    private network;
-    private apiEndpoint;
-    constructor(wallet: BitcoinWallet, sdkOptions?: {
-        sandbox?: boolean;
-        apiKey?: string;
-    });
-    /**
-     * Fetches the Bitcoin vault address.
-     *
-     * @returns {Promise<{ address: string }>} A promise that resolves to the vault address.
-     */
-    fetchVault(): Promise<{
-        address: string;
-        tag?: string;
-    }>;
-    getUTXOs(): Promise<Array<{
-        txid: string;
-        vout: number;
-        value: number;
-        rawTx: Buffer;
-    }>>;
-    private getBalance;
-    /**
-     * Transfers Bitcoin to the vault address.
-     *
-     * @param {string} amount - The amount of BTC to transfer in BTC units
-     * @param {number} feeRate - Fee rate in satoshis per byte
-     * @returns {Promise<string>} - A promise that resolves to the transaction hash
-     * @throws {Error} If there is not enough balance or if the transaction fails.
-     */
-    transferBTC(amount: string, feeRate?: number): Promise<string>;
-    /**
-     * Gets the balance of the Bitcoin wallet.
-     *
-     * @returns {Promise<string>} - A promise that resolves to the wallet balance in BTC
-     */
-    getWalletBalance(): Promise<string>;
-}
-export {};

package/dist/services/bitcoinService.js

@@ -1,146 +0,0 @@
-import axios from "axios";
-import * as bitcoin from "bitcoinjs-lib";
-import { BITCOIN_ENDPOINTS } from "../constants";
-import { ZebecCardAPIService } from "../helpers/apiHelpers";
-export class BitcoinService {
-    wallet;
-    apiService;
-    network;
-    apiEndpoint;
-    constructor(wallet, sdkOptions) {
-        this.wallet = wallet;
-        const sandbox = sdkOptions?.sandbox ?? false;
-        this.apiService = new ZebecCardAPIService(sandbox);
-        this.network = sandbox ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
-        this.apiEndpoint = sandbox ? BITCOIN_ENDPOINTS.Sandbox : BITCOIN_ENDPOINTS.Production;
-    }
-    /**
-     * Fetches the Bitcoin vault address.
-     *
-     * @returns {Promise<{ address: string }>} A promise that resolves to the vault address.
-     */
-    async fetchVault() {
-        const data = await this.apiService.fetchVault("BTC");
-        return data;
-    }
-    async getUTXOs() {
-        const response = await axios.get(`${this.apiEndpoint}/address/${this.wallet.address}/utxo`);
-        console.log("utxos:", response.data);
-        return Promise.all(response.data.map(async (utxo) => {
-            const rawTx = await axios.get(`${this.apiEndpoint}/tx/${utxo.txid}/hex`);
-            console.log("txHex:", rawTx.data);
-            if (!rawTx.data) {
-                throw new Error("Transaction not found");
-            }
-            // const scriptPubKey = txResponse.data.vout[utxo.vout].scriptpubkey;
-            return {
-                txid: utxo.txid,
-                vout: utxo.vout,
-                value: utxo.value,
-                rawTx: Buffer.from(rawTx.data, "hex"),
-            };
-        }));
-    }
-    async getBalance() {
-        const response = await axios.get(`${this.apiEndpoint}/address/${this.wallet.address}/utxo`);
-        const utxos = response.data;
-        return utxos.reduce((sum, utxo) => sum + utxo.value, 0);
-    }
-    /**
-     * Transfers Bitcoin to the vault address.
-     *
-     * @param {string} amount - The amount of BTC to transfer in BTC units
-     * @param {number} feeRate - Fee rate in satoshis per byte
-     * @returns {Promise<string>} - A promise that resolves to the transaction hash
-     * @throws {Error} If there is not enough balance or if the transaction fails.
-     */
-    async transferBTC(amount, feeRate = 10) {
-        // Convert BTC to satoshis
-        const satoshisToSend = Math.floor(Number(amount) * 100_000_000);
-        // Fetch deposit address
-        const vault = await this.fetchVault();
-        console.log({ vault });
-        let retries = 0;
-        const maxRetries = 5;
-        let delay = 1000;
-        const psbt = new bitcoin.Psbt({ network: this.network });
-        const utxos = await this.getUTXOs();
-        let inputAmount = 0;
-        for (const utxo of utxos) {
-            const transaction = bitcoin.Transaction.fromBuffer(utxo.rawTx);
-            const script = transaction.outs[utxo.vout].script;
-            const value = transaction.outs[utxo.vout].value;
-            inputAmount += value;
-            psbt.addInput({
-                hash: utxo.txid,
-                index: utxo.vout,
-                // nonWitnessUtxo: utxo.rawTx,
-                witnessUtxo: {
-                    script: script,
-                    value: value,
-                },
-            });
-            if (inputAmount >= satoshisToSend)
-                break;
-        }
-        if (inputAmount < satoshisToSend) {
-            throw new Error("Insufficient UTXO amount");
-        }
-        // Add output for payment
-        psbt.addOutput({
-            // address: vault.address,
-            address: "tb1q6h8w53xzj74n28kg8qq3d78xxgrch8zd2km97d",
-            value: satoshisToSend,
-        });
-        // Add change output if necessary
-        const estimatedFee = Math.ceil(psbt.toBuffer().length * feeRate);
-        // Check wallet balance
-        const balance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
-        if (balance < satoshisToSend + estimatedFee) {
-            throw new Error("Insufficient balance");
-        }
-        const changeAmount = inputAmount - satoshisToSend - estimatedFee;
-        if (changeAmount > 0) {
-            psbt.addOutput({
-                address: this.wallet.address,
-                value: changeAmount,
-            });
-        }
-        console.log("psbt:", JSON.stringify(psbt));
-        // Sign transaction
-        const signedPsbt = await this.wallet.signTransaction(psbt);
-        const tx = signedPsbt.finalizeAllInputs().extractTransaction();
-        while (retries < maxRetries) {
-            try {
-                // Broadcast transaction
-                return this.wallet.broadcastTransaction(tx.toHex());
-            }
-            catch (error) {
-                console.debug("error: ", error);
-                if (retries >= maxRetries) {
-                    throw error;
-                }
-                retries += 1;
-                console.debug(`Retrying in ${delay / 1000} seconds...`);
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                delay *= 2; // Exponential backoff
-            }
-        }
-        throw new Error("Max retries reached");
-    }
-    /**
-     * Gets the balance of the Bitcoin wallet.
-     *
-     * @returns {Promise<string>} - A promise that resolves to the wallet balance in BTC
-     */
-    async getWalletBalance() {
-        try {
-            const balanceSats = await this.getBalance();
-            return (balanceSats / 100_000_000).toString();
-        }
-        catch (error) {
-            console.debug("Error fetching BTC balance:", error);
-            return "0";
-        }
-    }
-}