@zebec-network/exchange-card-sdk 1.9.0-dev.6 → 1.9.0-dev.8

package/dist/services/aleoService.d.ts

@@ -1,37 +1,10 @@
+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";
-/**
- * Transaction creation options
- */
-interface TransactionOptions {
-    /**
-     * The program to execute
-     */
-    program: string;
-    /**
-     * The function to call
-     */
-    function: string;
-    /**
-     * The function inputs
-     */
-    inputs: string[];
-    /**
-     * The transaction fee to pay
-     */
-    fee?: number;
-    /**
-     * Record indices to use
-     */
-    recordIndices?: number[];
-    /**
-     * Whether the fee is private
-     */
-    privateFee?: boolean;
-}
 export interface AleoWallet {
     address: string;
+    decrypt: (cipherText: string) => Promise<string>;
     requestRecords: (program: string, includePlaintext?: boolean | undefined) => Promise<unknown[]>;
     executeTransaction: (options: TransactionOptions) => Promise<{
         transactionId: string;
@@ -39,18 +12,41 @@ export interface AleoWallet {
 }
 export type AleoTransferCreditParams = {
     amount: number | string;
-    transferType?: "public" | "private" | "privateToPublic" | "publicToPrivate";
+    transferType?: "public" | "private";
     fee?: number;
     privateFee?: boolean;
 };
-export type AleoTransferTokenParams = {
-    tokenProgramId: string;
-    tokenSymbol: string;
+export type AleoTransferStableCoinParams = {
+    programId: "usad_stablecoin.aleo" | "usdcx_stablecoin.aleo";
     amount: number | string;
-    transferType?: "public" | "private" | "privateToPublic" | "publicToPrivate";
+    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;
@@ -68,16 +64,27 @@ export declare class AleoService {
         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.
      */
-    transferCredits(params: AleoTransferCreditParams): Promise<{
+    transferCredit(params: AleoTransferCreditParams): Promise<{
         transactionId: string;
     }>;
-    transferTokens(params: AleoTransferTokenParams): Promise<{
+    transferStableCoin(params: AleoTransferStableCoinParams): Promise<{
         transactionId: string;
     }>;
-    getBalance(walletAddress: string): Promise<string>;
-    getTokenBalance(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>;
 }
-export {};

package/dist/services/aleoService.js

@@ -1,8 +1,33 @@
-import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
-import { AleoNetworkClient as TestnetAleoNetworkClient } from "@provablehq/sdk/testnet.js";
+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 { creditsToMicrocredits, getTokenBySymbol, microcreditsToCredits, } from "../utils";
+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;
@@ -25,93 +50,143 @@ export class AleoService {
         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 transferCredits(params) {
+    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 amountInMiroCredits = creditsToMicrocredits(amount);
-        const programName = "credits.aleo";
-        const functionName = transferType === "public"
-            ? "transfer_public"
-            : transferType === "private"
-                ? "transfer_private"
-                : transferType === "privateToPublic"
-                    ? "transfer_private_to_public"
-                    : "transfer_public_to_private";
+        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: programName,
+            program: PROGRAM_NAME,
             function: functionName,
-            inputs: [recipient, `${amountInMiroCredits}u64`],
-            fee: Number(creditsToMicrocredits(params.fee || 0.1)),
+            inputs,
+            fee: Number(fee),
             privateFee,
         });
         return result;
     }
-    async transferTokens(params) {
-        const { tokenSymbol, amount } = params;
-        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 tokenDecimals = tokenMetadata.decimals;
-        if (!("token_id" in tokenMetadata)) {
-            throw new Error(`Token metadata for ${tokenSymbol} does not include token_id.`);
-        }
-        const tokenId = tokenMetadata.token_id;
-        if (!("token_id_datatype" in tokenMetadata)) {
-            throw new Error(`Token metadata for ${tokenSymbol} does not include token_id_datatype.`);
-        }
-        const tokenIdDatatype = tokenMetadata.token_id_datatype;
+    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 amountInMicroTokens = creditsToMicrocredits(amount, tokenDecimals);
-        const programName = "token_registry.aleo";
-        const functionName = transferType === "public"
-            ? "transfer_public"
-            : transferType === "private"
-                ? "transfer_private"
-                : transferType === "privateToPublic"
-                    ? "transfer_private_to_public"
-                    : "transfer_public_to_private";
+        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(creditsToMicrocredits(params.fee || 0.1)),
+            fee: Number(fee),
             privateFee,
-            program: programName,
+            program: programId,
             function: functionName,
-            inputs: [`${tokenId}${tokenIdDatatype}`, recipient, `${amountInMicroTokens}u128`],
+            inputs,
         });
         return result;
     }
-    async getBalance(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 = microcreditsToCredits(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 getTokenBalance(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.`);
@@ -125,13 +200,13 @@ 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];
-                const formattedAmount = microcreditsToCredits(amount, tokenMetadata.decimals);
+                const formattedAmount = fromMicroUnits(amount, tokenMetadata.decimals);
                 return formattedAmount;
             }
             else {
@@ -142,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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,57 @@
+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);
+    }
+}

package/dist/services/index.d.ts

@@ -1,6 +1,7 @@
 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,6 +1,7 @@
 export * from "./aleoService";
 export * from "./algorandService";
 export * from "./bobaService";
+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
@@ -35,11 +36,11 @@ export declare function getAssetDecimals(client: algosdk.Algodv2, assetId: numbe
 /**
  * Convert credits to microcredits
  */
-export declare function creditsToMicrocredits(credits: BigNumber.Value, decimals?: number): string;
+export declare function toMicroUnits(credits: BigNumber.Value, decimals?: number, typeSuffix?: string): string;
 /**
  * Convert microcredits to credits
  */
-export declare function microcreditsToCredits(microcredits: BigNumber.Value, decimals?: number): string;
+export declare function fromMicroUnits(microcredits: BigNumber.Value, decimals?: number): string;
 export type TokenMetadata = {
     token_id: string;
     token_id_datatype: string | null;

package/dist/utils.js

@@ -61,13 +61,13 @@ export async function getAssetDecimals(client, assetId) {
 /**
  * Convert credits to microcredits
  */
-export function creditsToMicrocredits(credits, decimals = 6) {
-    return BigNumber(credits).times(BigNumber(10).pow(decimals)).toFixed(0);
+export function toMicroUnits(credits, decimals = 6, typeSuffix) {
+    return `${BigNumber(credits).times(BigNumber(10).pow(decimals)).toFixed(0)}${typeSuffix || ""}`;
 }
 /**
  * Convert microcredits to credits
  */
-export function microcreditsToCredits(microcredits, decimals = 6) {
+export function fromMicroUnits(microcredits, decimals = 6) {
     return BigNumber(microcredits).div(BigNumber(10).pow(decimals)).toFixed();
 }
 export async function getTokenBySymbol(tokenSymbol, network = "mainnet") {

package/package.json

@@ -1,17 +1,18 @@
 {
 	"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",
 		"@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": "^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"
@@ -19,9 +20,11 @@
 	"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",
@@ -62,5 +65,5 @@
 	},
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.9.0-dev.6"
+	"version": "1.9.0-dev.8"
 }

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