@zebec-network/exchange-card-sdk 1.1.0

package/dist/errors.d.ts

@@ -0,0 +1,24 @@
+export declare class UnsupportedChainError extends Error {
+    name: string;
+    constructor(chainId: number);
+}
+export declare class InvalidEmailError extends Error {
+    name: string;
+    constructor(email: string);
+}
+export declare class NotEnoughBalanceError extends Error {
+    name: string;
+    constructor(currentBalance: string, requiredBalance: string);
+}
+export declare class CardPurchaseAmountOutOfRangeError extends Error {
+    name: string;
+    constructor(minRange: string, maxRange: string);
+}
+export declare class DailyCardPurchaseLimitExceedError extends Error {
+    name: string;
+    constructor(dailyLimit: string, purchaseOfADay: string);
+}
+export declare class ValidationError extends Error {
+    name: string;
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.DailyCardPurchaseLimitExceedError = exports.CardPurchaseAmountOutOfRangeError = exports.NotEnoughBalanceError = exports.InvalidEmailError = exports.UnsupportedChainError = void 0;
+class UnsupportedChainError extends Error {
+    name = "UnsupportedChainError";
+    constructor(chainId) {
+        super("Unsupported chainId: " + chainId);
+    }
+}
+exports.UnsupportedChainError = UnsupportedChainError;
+class InvalidEmailError extends Error {
+    name = "InvalidEmailError";
+    constructor(email) {
+        super("Invalid email: " + email);
+    }
+}
+exports.InvalidEmailError = InvalidEmailError;
+class NotEnoughBalanceError extends Error {
+    name = "NotEnoughBalanceError";
+    constructor(currentBalance, requiredBalance) {
+        super("Not enough balance. Current amount: " +
+            currentBalance +
+            " Required amount: " +
+            requiredBalance);
+    }
+}
+exports.NotEnoughBalanceError = NotEnoughBalanceError;
+class CardPurchaseAmountOutOfRangeError extends Error {
+    name = "BuyAmountOutOfRangeError";
+    constructor(minRange, maxRange) {
+        super("Amount must be with range: " + minRange + " - " + maxRange);
+    }
+}
+exports.CardPurchaseAmountOutOfRangeError = CardPurchaseAmountOutOfRangeError;
+class DailyCardPurchaseLimitExceedError extends Error {
+    name = "DailyCardPurchaseLimitExceedError";
+    constructor(dailyLimit, purchaseOfADay) {
+        super("Requested card purchase amount exceeds daily purchase limit. Daily limit: " +
+            dailyLimit +
+            " Today's purchase amount: " +
+            purchaseOfADay);
+    }
+}
+exports.DailyCardPurchaseLimitExceedError = DailyCardPurchaseLimitExceedError;
+class ValidationError extends Error {
+    name = "ValidationError";
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ValidationError = ValidationError;

package/dist/helpers/apiHelpers.d.ts

@@ -0,0 +1,30 @@
+import { Quote } from "../types";
+export type APIConfig = {
+    apiKey: string;
+    encryptionKey: string;
+};
+export declare class ZebecCardAPIService {
+    readonly apiConfig: APIConfig & {
+        apiUrl: string;
+    };
+    private readonly sdkVersion;
+    private readonly api;
+    constructor(apiConfig: APIConfig, sandbox?: boolean);
+    private generateSignature;
+    generateRequestHeaders(method: string, path: string, body?: any): {
+        "X-API-Key": string;
+        "X-Timestamp": string;
+        "X-Nonce": string;
+        "X-Signature": string;
+        "X-SDK-Version": string;
+        "Content-Type": string;
+    };
+    encryptSensitiveData(data: any): string;
+    ping(): Promise<boolean>;
+    purchaseCard(data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    fetchQuote(symbol: string): Promise<Quote>;
+    fetchVault(symbol: string): Promise<{
+        depositVault: string;
+        tag?: string;
+    }>;
+}

package/dist/helpers/apiHelpers.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZebecCardAPIService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const crypto_1 = __importDefault(require("crypto"));
+const constants_1 = require("../constants");
+class ZebecCardAPIService {
+    apiConfig;
+    sdkVersion = "1.0.0";
+    api;
+    constructor(apiConfig, sandbox) {
+        this.apiConfig = {
+            ...apiConfig,
+            apiUrl: sandbox ? constants_1.CARD_API_URL.Sandbox : constants_1.CARD_API_URL.Production,
+        };
+        this.api = axios_1.default.create({ baseURL: this.apiConfig.apiUrl });
+    }
+    // Generate request signature
+    generateSignature(method, path, timestamp, body) {
+        const stringToSign = [
+            method.toUpperCase(),
+            path,
+            timestamp,
+            this.apiConfig.apiKey,
+            body ? JSON.stringify(body) : "",
+        ].join("");
+        return crypto_1.default
+            .createHmac("sha256", this.apiConfig.encryptionKey)
+            .update(stringToSign)
+            .digest("hex");
+    }
+    // Generate request headers
+    generateRequestHeaders(method, path, body) {
+        const timestamp = Math.floor(Date.now() / 1000);
+        const nonce = crypto_1.default.randomBytes(16).toString("hex");
+        return {
+            "X-API-Key": this.apiConfig.apiKey,
+            "X-Timestamp": timestamp.toString(),
+            "X-Nonce": nonce,
+            "X-Signature": this.generateSignature(method, path, timestamp, body),
+            "X-SDK-Version": this.sdkVersion,
+            "Content-Type": "application/json",
+        };
+    }
+    // Encrypt sensitive data fields
+    encryptSensitiveData(data) {
+        const iv = crypto_1.default.randomBytes(16);
+        const key = crypto_1.default.pbkdf2Sync(this.apiConfig.encryptionKey, iv, 1000, 32, "sha256");
+        const cipher = crypto_1.default.createCipheriv("aes-256-gcm", key, iv);
+        let encrypted = cipher.update(JSON.stringify(data), "utf8", "base64");
+        encrypted += cipher.final("base64");
+        const authTag = cipher.getAuthTag();
+        return `${iv.toString("base64")}:${encrypted}:${authTag.toString("base64")}`;
+    }
+    // Ping API status
+    async ping() {
+        try {
+            await this.api.get("/ping");
+            return true;
+        }
+        catch (error) {
+            throw new Error("Card service is down. Please try again later.");
+        }
+    }
+    // Purchase Card
+    async purchaseCard(data) {
+        console.debug("Payload data:", data);
+        const encryptedData = this.encryptSensitiveData(data);
+        console.debug("Encrypted Data: %s \n", encryptedData);
+        const method = "POST";
+        const path = "/orders/create";
+        const url = this.apiConfig.apiUrl + path;
+        const payload = { data: encryptedData };
+        const headers = this.generateRequestHeaders(method, path, payload);
+        const response = await axios_1.default.post(url, payload, { headers });
+        return response;
+    }
+    // Fetch quote
+    async fetchQuote(symbol) {
+        const response = await this.api.get("/exchange/price", { params: { symbol } });
+        const data = response.data;
+        return data;
+    }
+    async fetchVault(symbol) {
+        const { data } = await this.api.get(`/exchange/deposit-address`, { params: { symbol } });
+        return data;
+    }
+}
+exports.ZebecCardAPIService = ZebecCardAPIService;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./artifacts";
+export * from "./chains";
+export * from "./constants";
+export * from "./errors";
+export * from "./services/EvmService";
+export * from "./services/TaoService";
+export * from "./services/TonService";
+export * from "./services/stellarService";
+export * from "./types";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./artifacts"), exports);
+__exportStar(require("./chains"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./services/EvmService"), exports);
+__exportStar(require("./services/TaoService"), exports);
+__exportStar(require("./services/TonService"), exports);
+__exportStar(require("./services/stellarService"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/services/EvmService.d.ts

@@ -0,0 +1,37 @@
+import { AxiosResponse } from "axios";
+import { ethers } from "ethers";
+import { ERC20, ZebecCard } from "../artifacts";
+import { SupportedChain } from "../chains";
+import { Quote, Recipient } from "../types";
+import { APIConfig } from "../helpers/apiHelpers";
+export declare class ZebecCardService {
+    readonly signer: ethers.Signer;
+    readonly zebecCard: ZebecCard;
+    readonly usdcToken: ERC20;
+    readonly chainId: SupportedChain;
+    private readonly apiService;
+    constructor(signer: ethers.Signer, chainId: number, apiConfig: APIConfig, sdkOptions?: {
+        sandbox?: boolean;
+    });
+    /**
+     * Fetches a quote for the given amount.
+     *
+     * @param {string | number} amount - The amount for which to fetch the quote.
+     * @returns {Promise<Quote>} A promise that resolves to a Quote object.
+     */
+    fetchQuote(): Promise<Quote>;
+    /**
+     * Transfer specified amount from user's vault balance to card vault with some fee amount for card purchase.
+     * @param params
+     * @returns
+     */
+    purchaseCard(params: {
+        amount: number;
+        recipient: Recipient;
+        quote: Quote;
+    }): Promise<[
+        ethers.ContractTransactionResponse,
+        ethers.ContractTransactionResponse,
+        AxiosResponse
+    ]>;
+}

package/dist/services/EvmService.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZebecCardService = void 0;
+const axios_1 = require("axios");
+const ethers_1 = require("ethers");
+const artifacts_1 = require("../artifacts");
+const chains_1 = require("../chains");
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const apiHelpers_1 = require("../helpers/apiHelpers");
+class ZebecCardService {
+    signer;
+    zebecCard;
+    usdcToken;
+    chainId;
+    apiService;
+    constructor(signer, chainId, apiConfig, sdkOptions) {
+        this.signer = signer;
+        const sandbox = sdkOptions?.sandbox ? sdkOptions.sandbox : false;
+        const isTesnetChainId = chains_1.TESTNET_CHAINIDS.includes(chainId);
+        if ((sandbox && !isTesnetChainId) || (!sandbox && isTesnetChainId)) {
+            throw new Error("Only testnet chains are allowed in sandbox environment");
+        }
+        this.apiService = new apiHelpers_1.ZebecCardAPIService(apiConfig, sandbox);
+        this.chainId = (0, chains_1.parseSupportedChain)(chainId);
+        const zebecCardAddress = constants_1.ZEBEC_CARD_ADDRESS[this.chainId];
+        const usdcAddress = constants_1.USDC_ADDRESS[this.chainId];
+        this.zebecCard = artifacts_1.ZebecCard__factory.connect(zebecCardAddress, signer);
+        this.usdcToken = artifacts_1.ERC20__factory.connect(usdcAddress, signer);
+    }
+    /**
+     * Fetches a quote for the given amount.
+     *
+     * @param {string | number} amount - The amount for which to fetch the quote.
+     * @returns {Promise<Quote>} A promise that resolves to a Quote object.
+     */
+    async fetchQuote() {
+        const res = await this.apiService.fetchQuote("USDC");
+        return res;
+    }
+    /**
+     * Transfer specified amount from user's vault balance to card vault with some fee amount for card purchase.
+     * @param params
+     * @returns
+     */
+    async purchaseCard(params) {
+        // Check card service status
+        await this.apiService.ping();
+        const decimals = await this.usdcToken.decimals();
+        const totalAmount = (0, utils_1.formatAmount)(params.amount + constants_1.PLATFORM_FEE, Number(decimals));
+        const parsedAmount = ethers_1.ethers.parseUnits(totalAmount.toString(), decimals);
+        if (!(0, utils_1.isEmailValid)(params.recipient.emailAddress)) {
+            throw new errors_1.InvalidEmailError(params.recipient.emailAddress);
+        }
+        const usdcBalance = await this.usdcToken.balanceOf(this.signer);
+        console.debug("Usdc Balance:", usdcBalance);
+        if (parsedAmount > usdcBalance) {
+            throw new errors_1.NotEnoughBalanceError(ethers_1.ethers.formatUnits(usdcBalance, decimals), params.amount.toString());
+        }
+        let cardConfig = await this.zebecCard.cardConfig();
+        const minRange = cardConfig.minCardAmount;
+        const maxRange = cardConfig.maxCardAmount;
+        if (parsedAmount < minRange || parsedAmount > maxRange) {
+            throw new errors_1.CardPurchaseAmountOutOfRangeError(ethers_1.ethers.formatUnits(minRange, decimals), ethers_1.ethers.formatUnits(maxRange, decimals));
+        }
+        const cardPurchaseInfo = await this.zebecCard.cardPurchases(this.signer);
+        const lastCardPurchaseDate = new Date(Number(cardPurchaseInfo.unixInRecord * 1000n));
+        const today = new Date();
+        let cardPurchaseOfDay = 0n;
+        if ((0, utils_1.areDatesOfSameDay)(today, lastCardPurchaseDate)) {
+            cardPurchaseOfDay = cardPurchaseInfo.totalCardBoughtPerDay + parsedAmount;
+        }
+        else {
+            cardPurchaseOfDay = parsedAmount;
+        }
+        if (cardPurchaseOfDay > cardConfig.dailyCardBuyLimit) {
+            throw new errors_1.DailyCardPurchaseLimitExceedError(ethers_1.ethers.formatUnits(cardConfig.dailyCardBuyLimit, decimals), ethers_1.ethers.formatUnits(cardPurchaseInfo.totalCardBoughtPerDay, decimals));
+        }
+        const allowance = await this.usdcToken.allowance(this.signer, this.zebecCard);
+        console.debug("Allowance:", allowance);
+        if (allowance < parsedAmount) {
+            console.debug("===== Approving token =====");
+            const approveResponse = await this.usdcToken.approve(this.zebecCard, parsedAmount);
+            const approveReceipt = await approveResponse.wait();
+            console.debug("Approve hash: %s \n", approveReceipt?.hash);
+        }
+        console.debug("===== Depositing USDC =====");
+        const depositResponse = await this.zebecCard.depositUsdc(parsedAmount);
+        const depositReceipt = await depositResponse.wait();
+        console.debug("Deposit hash: %s \n", depositReceipt?.hash);
+        cardConfig = await this.zebecCard.cardConfig();
+        const purchaseCounter = Number((cardConfig.counter + 1n).toString());
+        const cardTypeId = "103253238082";
+        const emailHash = await (0, utils_1.hashSHA256)(params.recipient.emailAddress);
+        console.debug("===== Purchasing Card =====");
+        const buyCardResponse = await this.zebecCard.buyCard(parsedAmount, cardTypeId, emailHash);
+        const buyCardReceipt = await buyCardResponse.wait();
+        console.debug("Purchase hash: %s \n", buyCardReceipt?.hash);
+        const usdAmount = types_1.Money.USD(params.amount);
+        const buyer = await this.signer.getAddress();
+        const receipt = new types_1.Receipt(params.quote, new types_1.Deposit("USDC", Number(totalAmount), "", buyer, buyCardResponse.hash, "", this.chainId, purchaseCounter));
+        const payload = new types_1.OrderCardRequest(usdAmount, params.recipient, receipt);
+        let retries = 0;
+        let delay = 1000; // Initial delay in milliseconds (1 second)
+        const maxRetries = 5; // Max retry default
+        while (retries < maxRetries) {
+            try {
+                const response = await this.apiService.purchaseCard(payload);
+                console.debug("API response: %o \n", response.data);
+                return [depositResponse, buyCardResponse, response];
+            }
+            catch (error) {
+                if (error instanceof axios_1.AxiosError) {
+                    console.debug("error", error.response?.data);
+                    console.debug("error", error.message);
+                }
+                else {
+                    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");
+    }
+}
+exports.ZebecCardService = ZebecCardService;

package/dist/services/TaoService.d.ts

@@ -0,0 +1,49 @@
+import { Quote } from "../types";
+import { Signer } from "@polkadot/types/types";
+import { KeyringPair } from "@polkadot/keyring/types";
+import { APIConfig } from "../helpers/apiHelpers";
+export declare class ZebecCardTAOService {
+    readonly signer: Signer | KeyringPair;
+    private apiService;
+    private taoRPC;
+    /**
+     * Constructs an instance of the service.
+     *
+     * @param {Signer} signer - The signer which can be either a PolkadotJs Signer or a KeyringPair.
+     * @param {APIConfig} apiConfig - The configuration object for the API.
+     * @param sdkOptions - Optional configuration for the SDK.
+     */
+    constructor(signer: Signer | KeyringPair, apiConfig: APIConfig, sdkOptions?: {
+        sandbox?: boolean;
+    });
+    /**
+     * Fetches a quote for the given amount.
+     *
+     * @param {string | number} amount - The amount for which to fetch the quote.
+     * @returns {Promise<Quote>} A promise that resolves to a Quote object.
+     */
+    fetchQuote(): Promise<Quote>;
+    /**
+     * Fetches the TAO Vault address.
+     *
+     * @returns {Promise<string>} A promise that resolves to the TAO Vault address.
+     */
+    fetchTAOVault(): Promise<string>;
+    /**
+     * Executes TAO token transfer for card purchase.
+     *
+     * @param params - The parameters required for token transfer.
+     * @param params.walletAddress - The wallet address from which TAO tokens will be transferred.
+     * @param params.amount - The amount of TAO tokens to transfer.
+     * @param params.depositAddress - The destination address to receive tokens.
+     * @returns A promise that resolves to an object containing transaction and block hashes.
+     * @throws {Error} If there is not enough balance or if the transaction fails.
+     */
+    transferTAO(params: {
+        walletAddress: string;
+        amount: number;
+    }): Promise<{
+        txHash: string;
+        blockHash: string;
+    }>;
+}

package/dist/services/TaoService.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZebecCardTAOService = void 0;
+const constants_1 = require("../constants");
+const api_1 = require("@polkadot/api");
+const api_2 = require("@polkadot/api");
+const apiHelpers_1 = require("../helpers/apiHelpers");
+class ZebecCardTAOService {
+    signer;
+    apiService;
+    taoRPC;
+    /**
+     * Constructs an instance of the service.
+     *
+     * @param {Signer} signer - The signer which can be either a PolkadotJs Signer or a KeyringPair.
+     * @param {APIConfig} apiConfig - The configuration object for the API.
+     * @param sdkOptions - Optional configuration for the SDK.
+     */
+    constructor(signer, apiConfig, sdkOptions) {
+        this.signer = signer;
+        const sandbox = sdkOptions?.sandbox ? sdkOptions.sandbox : false;
+        this.apiService = new apiHelpers_1.ZebecCardAPIService(apiConfig, sandbox);
+        this.taoRPC = sandbox ? constants_1.TAO_RPC_URL.Sandbox : constants_1.TAO_RPC_URL.Production;
+    }
+    /**
+     * Fetches a quote for the given amount.
+     *
+     * @param {string | number} amount - The amount for which to fetch the quote.
+     * @returns {Promise<Quote>} A promise that resolves to a Quote object.
+     */
+    async fetchQuote() {
+        const res = await this.apiService.fetchQuote("TAO");
+        return res;
+    }
+    /**
+     * Fetches the TAO Vault address.
+     *
+     * @returns {Promise<string>} A promise that resolves to the TAO Vault address.
+     */
+    async fetchTAOVault() {
+        const data = await this.apiService.fetchVault("TAO");
+        return data.depositVault;
+    }
+    /**
+     * Executes TAO token transfer for card purchase.
+     *
+     * @param params - The parameters required for token transfer.
+     * @param params.walletAddress - The wallet address from which TAO tokens will be transferred.
+     * @param params.amount - The amount of TAO tokens to transfer.
+     * @param params.depositAddress - The destination address to receive tokens.
+     * @returns A promise that resolves to an object containing transaction and block hashes.
+     * @throws {Error} If there is not enough balance or if the transaction fails.
+     */
+    async transferTAO(params) {
+        // Connect to TAO network
+        const provider = new api_1.WsProvider(this.taoRPC);
+        const api = await api_2.ApiPromise.create({ provider });
+        try {
+            // Calculate total amount with proper decimal places
+            const totalAmount = Math.floor(params.amount * 10 ** 9);
+            // Check wallet balance
+            const balance = await api?.query.system.account(params.walletAddress);
+            const freeBalance = balance.data.free.toNumber();
+            if (freeBalance < totalAmount) {
+                throw new Error("Not enough balance");
+            }
+            // Create and submit transaction
+            let resolveOut;
+            let rejectOut;
+            const promise = new Promise((resolve, reject) => {
+                resolveOut = resolve;
+                rejectOut = reject;
+            });
+            let blockHash = "";
+            let txHash = "";
+            const depositAddress = await this.fetchTAOVault();
+            const tx = api.tx.balances.transferKeepAlive(depositAddress, totalAmount);
+            const unsub = await tx.signAndSend("address" in this.signer ? this.signer : params.walletAddress, {
+                signer: "address" in this.signer ? undefined : this.signer,
+            }, ({ events = [], isInBlock, isFinalized, isError, status, txHash: _txHash }) => {
+                console.debug("Transaction status:", status.type);
+                if (isInBlock || isFinalized) {
+                    console.debug("Included at block hash", status.asInBlock.toHex());
+                    blockHash = status.asInBlock.toHex();
+                    txHash = _txHash.toHex();
+                    const isSuccess = events.every(({ event }) => !api.events.system.ExtrinsicFailed.is(event));
+                    if (isSuccess) {
+                        unsub();
+                        resolveOut();
+                    }
+                }
+                else if (isError) {
+                    unsub();
+                    rejectOut(new Error("Transaction failed"));
+                }
+            });
+            await promise;
+            return { txHash, blockHash };
+        }
+        finally {
+            // Ensure API is disconnected
+            await api.disconnect().catch(() => { });
+        }
+    }
+}
+exports.ZebecCardTAOService = ZebecCardTAOService;

package/dist/services/TonService.d.ts

@@ -0,0 +1,57 @@
+import { APIConfig } from "../helpers/apiHelpers";
+import { ITonConnect } from "@tonconnect/sdk";
+import { Quote } from "../types";
+export declare class ZebecCardTONService {
+    readonly signer: ITonConnect;
+    private apiService;
+    private tonRPC;
+    private tonweb;
+    private sandbox;
+    /**
+     * Constructs an instance of the service.
+     *
+     * @param {Signer} signer - The signer which can be either a PolkadotJs Signer or a KeyringPair.
+     * @param {APIConfig} apiConfig - The configuration object for the API.
+     * @param sdkOptions - Optional configuration for the SDK.
+     */
+    constructor(signer: ITonConnect, apiConfig: APIConfig, sdkOptions?: {
+        sandbox?: boolean;
+        apiKey?: string;
+    });
+    /**
+     * Fetches a quote for the given amount.
+     *
+     * @param {string | number} amount - The amount for which to fetch the quote.
+     * @returns {Promise<Quote>} A promise that resolves to a Quote object.
+     */
+    fetchQuote(): Promise<Quote>;
+    /**
+     * Fetches the TAO Vault address.
+     *
+     * @returns {Promise<string>} A promise that resolves to the TAO Vault address.
+     */
+    fetchVault(): Promise<{
+        depositVault: string;
+        tag?: string;
+    }>;
+    /**
+     * Purchases a card by transferring TAO tokens.
+     *
+     * @param params - The parameters required to purchase a card.
+     * @param params.walletAddress - The wallet address from which TAO tokens will be transferred.
+     * @param params.amount - The amount of TAO tokens to transfer.
+     * @returns A promise that resolves to transaction hash.
+     * @throws {Error} If there is not enough balance or if the transaction fails.
+     */
+    transferTon(params: {
+        walletAddress: string;
+        amount: number;
+    }): Promise<string>;
+    /**
+     * Retrieves the balance of the specified wallet.
+     *
+     * @param {string} wallet - The address of the wallet to get the balance for. If the address starts with "0:", it will be converted to a full address format.
+     * @returns {Promise<string>} - A promise that resolves to the balance of the wallet.
+     */
+    getWalletBalance(wallet: string): Promise<string>;
+}