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

package/dist/services/aleoService.d.ts

@@ -1,37 +1,51 @@
+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 AleoTransition {
-    program: string;
-    functionName: string;
-    inputs: any[];
-}
-export interface AleoTransaction {
-    address: string;
-    chainId: string;
-    transitions: AleoTransition[];
-    fee: number;
-    feePrivate: boolean;
-}
 export interface AleoWallet {
     address: string;
-    requestTransaction: (transaction: AleoTransaction) => Promise<{
+    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" | "privateToPublic" | "publicToPrivate";
+    transferType?: "public" | "private";
     fee?: number;
-    feePrivate?: boolean;
+    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;
-    feePrivate?: boolean;
+    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;
@@ -50,15 +64,25 @@ 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(walletAddress: string): Promise<string>;
+    getPublicTokenBalance(walletAddress: string, tokenProgramId: string, tokenSymbol: string): Promise<string>;
 }

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,84 +50,138 @@ 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 feePrivate = params?.feePrivate || false;
+        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 result = await this.wallet.requestTransaction({
-            address: this.wallet.address,
-            chainId: this.sandbox ? "testnetbeta" : "mainnet",
-            fee: Number(creditsToMicrocredits(params.fee || 0.035)),
-            feePrivate,
-            transitions: [
-                {
-                    functionName,
-                    program: programName,
-                    inputs: [recipient, `${amountInMiroCredits}u64`],
-                },
-            ],
+        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 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 feePrivate = params?.feePrivate || false;
+        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 result = await this.wallet.requestTransaction({
-            address: this.wallet.address,
-            chainId: this.sandbox ? "testnetbeta" : "mainnet",
-            fee: Number(creditsToMicrocredits(params.fee || 0.035)),
-            feePrivate,
-            transitions: [
-                {
-                    functionName,
-                    program: programName,
-                    inputs: [`${tokenId}${tokenIdDatatype}`, recipient, `${amountInMicroTokens}u128`],
-                },
-            ],
+        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 getBalance(walletAddress) {
+    async getPublicBalance(walletAddress) {
         const programId = "credits.aleo";
         const mappingName = "account";
         const balance = await this.networkClient.getProgramMappingValue(programId, mappingName, walletAddress);
@@ -112,7 +191,7 @@ export class AleoService {
             const match = balance.match(regex);
             if (match) {
                 const amount = match[1];
-                const formattedAmount = microcreditsToCredits(amount);
+                const formattedAmount = fromMicroUnits(amount);
                 return formattedAmount;
             }
             else {
@@ -123,7 +202,7 @@ export class AleoService {
             return "0";
         }
     }
-    async getTokenBalance(walletAddress, tokenProgramId, tokenSymbol) {
+    async getPublicTokenBalance(walletAddress, 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.`);
@@ -143,7 +222,7 @@ export class AleoService {
             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 {

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

@@ -35,11 +35,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,11 +1,13 @@
 {
 	"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",
@@ -19,6 +21,7 @@
 	"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",
@@ -62,5 +65,5 @@
 	},
 	"type": "module",
 	"types": "dist/index.d.ts",
-	"version": "1.9.0-dev.5"
+	"version": "1.9.0-dev.7"
 }