@zebec-network/exchange-card-sdk 1.9.0-dev.2 → 1.9.0-dev.4

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

@@ -1,3 +1,5 @@
+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;
@@ -13,23 +15,21 @@ export interface AleoTransaction {
 }
 export interface AleoWallet {
     address: string;
-    requestRecords: (programId: string) => Promise<any[]>;
     requestTransaction: (transaction: AleoTransaction) => Promise<{
         transactionId: string;
     }>;
 }
 export type AleoTransferCreditParams = {
     amount: number | string;
-    chainId: string;
+    transferType?: "public" | "private" | "privateToPublic" | "publicToPrivate";
     fee?: number;
     feePrivate?: boolean;
 };
 export type AleoTransferTokenParams = {
     tokenProgramId: string;
-    tokenDecimals: number;
     tokenSymbol: string;
-    chainId: string;
     amount: number | string;
+    transferType?: "public" | "private" | "privateToPublic" | "publicToPrivate";
     fee?: number;
     feePrivate?: boolean;
 };
@@ -37,9 +37,9 @@ export declare class AleoService {
     readonly wallet: AleoWallet;
     readonly sandbox: boolean;
     readonly apiService: ZebecCardAPIService;
+    readonly networkClient: AleoNetworkClient | TestnetAleoNetworkClient;
     constructor(wallet: AleoWallet, options?: {
         sandbox?: boolean;
-        aleoNetworkClientUrl?: string;
     });
     /**
      * Fetches the Bitcoin vault address.
@@ -52,13 +52,13 @@ export declare class AleoService {
     }>;
     /**
      * Transfer native Aleo credits to the specified recipient.
-     *
-     * @param recipient - The recipient's Aleo address.
      */
     transferCredits(params: AleoTransferCreditParams): Promise<{
         transactionId: string;
     }>;
-    transferTokens(tokens: AleoTransferTokenParams): Promise<{
+    transferTokens(params: AleoTransferTokenParams): Promise<{
         transactionId: string;
     }>;
+    getBalance(walletAddress: string): Promise<string>;
+    getTokenBalance(walletAddress: string, tokenProgramId: string, tokenSymbol: string): Promise<string>;
 }

package/dist/services/aleoService.js

@@ -1,13 +1,20 @@
+import { AleoNetworkClient } from "@provablehq/sdk/mainnet.js";
+import { AleoNetworkClient as TestnetAleoNetworkClient } from "@provablehq/sdk/testnet.js";
+import { ALEO_NETWORK_CLIENT_URL } from "../constants";
 import { ZebecCardAPIService } from "../helpers/apiHelpers";
-import { creditsToMicrocredits } from "../utils";
+import { creditsToMicrocredits, getTokenBySymbol, microcreditsToCredits } from "../utils";
 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.
@@ -20,55 +27,131 @@ export class AleoService {
     }
     /**
      * Transfer native Aleo credits to the specified recipient.
-     *
-     * @param recipient - The recipient's Aleo address.
      */
     async transferCredits(params) {
-        const { amount, chainId } = params;
-        const fee = params?.fee || 100000; // Default fee, can be adjusted as needed
+        const { amount } = params;
+        const transferType = params.transferType || "public";
         const feePrivate = params?.feePrivate || false;
-        const programId = "credits.aleo";
-        const functionName = "transfer_public";
         const vault = await this.fetchVault("ALEO");
         const recipient = vault.address;
+        console.log("recipient:", recipient);
         const amountInMiroCredits = creditsToMicrocredits(amount);
-        const transition = {
-            program: programId,
-            functionName,
-            inputs: [recipient, `${amountInMiroCredits}u64`],
-        };
-        const transaction = {
+        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,
-            transitions: [transition],
-            fee,
+            chainId: this.sandbox ? "testnet" : "mainnet",
+            fee: Number(creditsToMicrocredits(params.fee || 0.035)),
             feePrivate,
-        };
-        const result = await this.wallet.requestTransaction(transaction);
+            transitions: [
+                {
+                    functionName,
+                    program: programName,
+                    inputs: [recipient, `${amountInMiroCredits}u64`],
+                },
+            ],
+        });
         return result;
     }
-    async transferTokens(tokens) {
-        const { tokenProgramId, tokenDecimals, tokenSymbol, amount, chainId } = tokens;
-        const fee = tokens?.fee || 100000; // Default fee, can be adjusted as needed
-        const feePrivate = tokens?.feePrivate || false;
+    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;
+        const transferType = params.transferType || "public";
+        const feePrivate = params?.feePrivate || false;
         const vault = await this.fetchVault(tokenSymbol);
         const recipient = vault.address;
         const amountInMicroTokens = creditsToMicrocredits(amount, tokenDecimals);
-        const programId = "token_registry.aleo";
-        const functionName = "transfer_public";
-        const transition = {
-            program: programId,
-            functionName,
-            inputs: [tokenProgramId, recipient, `${amountInMicroTokens}u128`],
-        };
-        const transaction = {
+        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,
-            transitions: [transition],
-            fee,
+            chainId: this.sandbox ? "testnet" : "mainnet",
+            fee: Number(creditsToMicrocredits(params.fee || 0.035)),
             feePrivate,
-        };
-        const result = await this.wallet.requestTransaction(transaction);
+            transitions: [
+                {
+                    functionName,
+                    program: programName,
+                    inputs: [`${tokenId}${tokenIdDatatype}`, recipient, `${amountInMicroTokens}u128`],
+                },
+            ],
+        });
         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 getTokenBalance(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.`);
+        }
+        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, walletAddress);
+        if (balance) {
+            const regex = /(\d+)u128/;
+            const match = balance.match(regex);
+            if (match) {
+                const amount = match[1];
+                const formattedAmount = microcreditsToCredits(amount, tokenMetadata.decimals);
+                return formattedAmount;
+            }
+            else {
+                throw new Error(`Invalid balance format: ${balance}`);
+            }
+        }
+        else {
+            return "0";
+        }
+    }
 }

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import algosdk from "algosdk";
+import type algosdk from "algosdk";
 /**
  * Convert ALGO to microAlgos
  * @param algos Amount in ALGO
@@ -34,15 +34,27 @@ export declare function formatAlgorandAsset(microAmount: number | bigint, decima
 export declare function getAssetDecimals(client: algosdk.Algodv2, assetId: number): Promise<number>;
 /**
  * Convert credits to microcredits
- * @param {number} credits - Amount in credits
- * @param {number} decimals - Number of decimals for the token (default is 6)
- * @returns {number} Amount in microcredits
  */
 export declare function creditsToMicrocredits(credits: BigNumber.Value, decimals?: number): string;
 /**
  * Convert microcredits to credits
- * @param {number} microcredits - Amount in microcredits
- * @param {number} decimals - Number of decimals for the token (default is 6)
- * @returns {number} Amount in credits
  */
 export declare function microcreditsToCredits(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;
@@ -53,19 +60,26 @@ export async function getAssetDecimals(client, assetId) {
 }
 /**
  * Convert credits to microcredits
- * @param {number} credits - Amount in credits
- * @param {number} decimals - Number of decimals for the token (default is 6)
- * @returns {number} Amount in microcredits
  */
 export function creditsToMicrocredits(credits, decimals = 6) {
     return BigNumber(credits).times(BigNumber(10).pow(decimals)).toFixed(0);
 }
 /**
  * Convert microcredits to credits
- * @param {number} microcredits - Amount in microcredits
- * @param {number} decimals - Number of decimals for the token (default is 6)
- * @returns {number} Amount in credits
  */
 export function microcreditsToCredits(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

@@ -6,6 +6,7 @@
 		"@near-js/transactions": "^2.5.1",
 		"@near-js/types": "^2.5.1",
 		"@near-js/utils": "^2.5.1",
+		"@provablehq/sdk": "^0.9.15",
 		"@stellar/stellar-sdk": "^14.4.3",
 		"algosdk": "^3.4.0",
 		"axios": "^1.11.0",
@@ -59,6 +60,7 @@
 		"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.2"
+	"version": "1.9.0-dev.4"
 }