@zebec-network/exchange-card-sdk 1.9.0-dev.7 → 1.9.0-dev.9

package/dist/services/aleoService.d.ts

@@ -83,6 +83,8 @@ export declare class AleoService {
     transferStableCoin(params: AleoTransferStableCoinParams): Promise<{
         transactionId: string;
     }>;
-    getPublicBalance(walletAddress: string): Promise<string>;
-    getPublicTokenBalance(walletAddress: string, tokenProgramId: string, tokenSymbol: string): Promise<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

@@ -181,28 +181,12 @@ export class AleoService {
         });
         return result;
     }
-    async getPublicBalance(walletAddress) {
-        const programId = "credits.aleo";
-        const mappingName = "account";
-        const balance = await this.networkClient.getProgramMappingValue(programId, mappingName, walletAddress);
-        if (balance) {
-            // regex to extract the number part and convert it to a string with 6 decimal places
-            const regex = /(\d+)u64/;
-            const match = balance.match(regex);
-            if (match) {
-                const amount = match[1];
-                const formattedAmount = fromMicroUnits(amount);
-                return formattedAmount;
-            }
-            else {
-                throw new Error(`Invalid balance format: ${balance}`);
-            }
-        }
-        else {
-            return "0";
-        }
+    async getPublicBalance() {
+        const balance = await this.networkClient.getPublicBalance(this.wallet.address);
+        const formattedAmount = fromMicroUnits(balance);
+        return formattedAmount;
     }
-    async getPublicTokenBalance(walletAddress, tokenProgramId, tokenSymbol) {
+    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.`);
@@ -216,9 +200,9 @@ export class AleoService {
         if (!balanceMappingName) {
             throw new Error("No public balance mapping found (no 'balances' or 'account').");
         }
-        const balance = await this.networkClient.getProgramMappingValue(tokenProgramId, balanceMappingName, walletAddress);
+        const balance = await this.networkClient.getProgramMappingValue(tokenProgramId, balanceMappingName, this.wallet.address);
         if (balance) {
-            const regex = /(\d+)u128/;
+            const regex = /(\d+)u\d+/;
             const match = balance.match(regex);
             if (match) {
                 const amount = match[1];
@@ -233,4 +217,64 @@ export class AleoService {
             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.d.ts

@@ -1,31 +0,0 @@
-import { type AuthTokenProvider, LedgerController, TokenStandardController, ValidatorController, type WalletSDK } from "@canton-network/wallet-sdk";
-export interface CantonWallet {
-    partyId: string;
-    executeTransaction: (command: unknown, disclosedContractId: unknown[]) => Promise<string>;
-}
-export interface CantonConfig {
-    ledgerApiUrl: string;
-    validatorAppApiUrl: string;
-}
-export declare function createLedgerFactory(ledgerApiUrl: string): (userId: string, authTokenProvider: AuthTokenProvider, isAdmin: boolean) => LedgerController;
-export declare function createValidatorFactory(validatorAppApiUrl: string): (userId: string, authTokenProvider: AuthTokenProvider) => ValidatorController;
-export declare function createTokenStandardFactory(ledgerApiUrl: string, validatorAppApiUrl: string): (userId: string, authTokenProvider: AuthTokenProvider, isAdmin: boolean) => TokenStandardController;
-export declare class CantonService {
-    readonly wallet: CantonWallet;
-    readonly cantonConfig: CantonConfig;
-    readonly cantonWalletSdk: WalletSDK;
-    private apiService;
-    constructor(wallet: CantonWallet, cantonConfig: CantonConfig, sdkOptions?: {
-        sandbox?: boolean;
-    });
-    connect(): Promise<void>;
-    fetchVault(symbol?: string): Promise<{
-        address: string;
-        tag?: string;
-    }>;
-    transferNative(params: {
-        amount: number | string;
-        instrumentId: string;
-        instrumentAdmin: string;
-    }): Promise<string>;
-}

package/dist/services/cantonService.js

@@ -1,57 +1,103 @@
-import { LedgerController, localNetStaticConfig, TokenStandardController, ValidatorController, WalletSDKImpl, } from "@canton-network/wallet-sdk";
-import { ZebecCardAPIService } from "../helpers/apiHelpers";
-export function createLedgerFactory(ledgerApiUrl) {
-    return (userId, authTokenProvider, isAdmin) => {
-        return new LedgerController(userId, new URL(ledgerApiUrl), undefined, isAdmin, authTokenProvider);
-    };
-}
-export function createValidatorFactory(validatorAppApiUrl) {
-    return (userId, authTokenProvider) => {
-        return new ValidatorController(userId, new URL(validatorAppApiUrl), authTokenProvider);
-    };
-}
-export function createTokenStandardFactory(ledgerApiUrl, validatorAppApiUrl) {
-    return (userId, authTokenProvider, isAdmin) => {
-        return new TokenStandardController(userId, new URL(ledgerApiUrl), new URL(validatorAppApiUrl), undefined, authTokenProvider, isAdmin);
-    };
-}
-export class CantonService {
-    wallet;
-    cantonConfig;
-    cantonWalletSdk;
-    apiService;
-    constructor(wallet, cantonConfig, sdkOptions) {
-        this.wallet = wallet;
-        this.cantonConfig = cantonConfig;
-        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") {
-        const data = await this.apiService.fetchVault(symbol);
-        return data;
-    }
-    // methods for transfering natve assets
-    async transferNative(params) {
-        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);
-    }
-}
+"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,7 +1,6 @@
 export * from "./aleoService";
 export * from "./algorandService";
 export * from "./bobaService";
-export * from "./cantonService";
 export * from "./nearService";
 export * from "./octaService";
 export * from "./quaiService";

package/dist/services/index.js

@@ -1,7 +1,7 @@
 export * from "./aleoService";
 export * from "./algorandService";
 export * from "./bobaService";
-export * from "./cantonService";
+// export * from "./cantonService";
 export * from "./nearService";
 export * from "./octaService";
 export * from "./quaiService";

package/dist/utils.d.ts

@@ -1,4 +1,5 @@
 import type algosdk from "algosdk";
+import { BigNumber } from "bignumber.js";
 /**
  * Convert ALGO to microAlgos
  * @param algos Amount in ALGO

package/package.json

@@ -1,7 +1,6 @@
 {
 	"author": "Zebec Network | Ashish Sapkota",
 	"dependencies": {
-		"@canton-network/wallet-sdk": "^0.21.1",
 		"@near-js/crypto": "^2.5.1",
 		"@near-js/providers": "^2.5.1",
 		"@near-js/transactions": "^2.5.1",
@@ -12,8 +11,7 @@
 		"@stellar/stellar-sdk": "^14.4.3",
 		"algosdk": "^3.4.0",
 		"axios": "^1.11.0",
-		"bignumber.js": "^9.3.1",
-		"bitcoinjs-lib": "^6.1.7",
+		"bignumber.js": "^10.0.2",
 		"ethers": "^6.15.0",
 		"quais": "^1.0.0-alpha.52",
 		"xrpl": "^4.4.1"
@@ -25,6 +23,7 @@
 		"@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",
@@ -54,7 +53,7 @@
 	},
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/Zebec-Fintech-Labs/zebec-card-minimal-sdk.git"
+		"url": "git+git@github.com:Zebec-Fintech-Labs/card-sdk-mono.git"
 	},
 	"scripts": {
 		"build": "npm run clean && tsc",
@@ -65,5 +64,5 @@
 	},
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.9.0-dev.7"
+	"version": "1.9.0-dev.9"
 }

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";
-        }
-    }
-}