@t402/near 2.3.0

package/dist/esm/exact-direct/client/index.d.mts

@@ -0,0 +1,105 @@
+import { SchemeNetworkClient, PaymentRequirements, PaymentPayload, Network } from '@t402/core/types';
+import { C as ClientNearSigner } from '../../types-Ca7ztL_f.mjs';
+import { t402Client, PaymentPolicy } from '@t402/core/client';
+
+/**
+ * NEAR Client Scheme Implementation - Exact Direct
+ *
+ * Creates payment payloads for NEAR NEP-141 transfers using the exact-direct scheme.
+ * In this scheme, the client executes the ft_transfer directly and provides
+ * the transaction hash as proof of payment.
+ */
+
+/**
+ * Configuration for ExactDirectNearClient
+ */
+interface ExactDirectNearClientConfig {
+    /** Override the gas amount for ft_transfer */
+    gasAmount?: string;
+    /** Optional memo to include in the transfer */
+    memo?: string;
+}
+/**
+ * NEAR client implementation for the Exact-Direct payment scheme.
+ *
+ * Executes NEP-141 ft_transfer and returns the transaction hash as proof.
+ */
+declare class ExactDirectNearClient implements SchemeNetworkClient {
+    private readonly signer;
+    private readonly config;
+    readonly scheme = "exact-direct";
+    /**
+     * Creates a new ExactDirectNearScheme instance.
+     *
+     * @param signer - The NEAR signer for client operations
+     * @param config - Optional configuration overrides
+     */
+    constructor(signer: ClientNearSigner, config?: ExactDirectNearClientConfig);
+    /**
+     * Creates a payment payload by executing the transfer.
+     *
+     * Unlike other schemes where the client creates a signed message for
+     * the facilitator to execute, the exact-direct scheme has the client
+     * execute the transfer directly. The transaction hash is then used
+     * as proof of payment.
+     *
+     * @param t402Version - The t402 protocol version
+     * @param paymentRequirements - The payment requirements
+     * @returns Promise resolving to a payment payload with transaction hash
+     */
+    createPaymentPayload(t402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "t402Version" | "payload">>;
+}
+
+/**
+ * Registration function for NEAR Exact-Direct client
+ */
+
+/**
+ * Configuration options for registering NEAR schemes to a t402Client
+ */
+interface NearClientConfig {
+    /**
+     * The NEAR signer to use for creating payment payloads
+     */
+    signer: ClientNearSigner;
+    /**
+     * Optional policies to apply to the client
+     */
+    policies?: PaymentPolicy[];
+    /**
+     * Optional specific networks to register
+     * If not provided, registers wildcard support (near:*)
+     */
+    networks?: Network[];
+    /**
+     * Optional scheme configuration (gas amounts, memo)
+     */
+    schemeConfig?: ExactDirectNearClientConfig;
+}
+/**
+ * Registers NEAR exact-direct payment schemes to a t402Client instance.
+ *
+ * @param client - The t402Client instance to register schemes to
+ * @param config - Configuration for NEAR client registration
+ * @returns The client instance for chaining
+ *
+ * @example
+ * ```typescript
+ * import { registerExactDirectNearClient } from "@t402/near/exact-direct/client";
+ * import { t402Client } from "@t402/core/client";
+ *
+ * const client = new t402Client();
+ * registerExactDirectNearClient(client, {
+ *   signer: {
+ *     accountId: "alice.near",
+ *     signAndSendTransaction: async (receiverId, methodName, args, gas, deposit) => {
+ *       // Sign and send using wallet
+ *       return txHash;
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function registerExactDirectNearClient(client: t402Client, config: NearClientConfig): t402Client;
+
+export { ExactDirectNearClient, type ExactDirectNearClientConfig, type NearClientConfig, registerExactDirectNearClient };

package/dist/esm/exact-direct/client/index.mjs

@@ -0,0 +1,10 @@
+import {
+  ExactDirectNearClient,
+  registerExactDirectNearClient
+} from "../../chunk-YXBOH4MJ.mjs";
+import "../../chunk-WANNPL6S.mjs";
+export {
+  ExactDirectNearClient,
+  registerExactDirectNearClient
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/exact-direct/client/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/exact-direct/facilitator/index.d.mts

@@ -0,0 +1,114 @@
+import { SchemeNetworkFacilitator, Network, PaymentPayload, PaymentRequirements, VerifyResponse, SettleResponse } from '@t402/core/types';
+import { f as FacilitatorNearSigner } from '../../types-Ca7ztL_f.mjs';
+import { t402Facilitator } from '@t402/core/facilitator';
+
+/**
+ * NEAR Facilitator Scheme Implementation - Exact Direct
+ *
+ * Verifies and settles NEAR NEP-141 payments using the exact-direct scheme.
+ * The facilitator verifies that the client's transaction was successful
+ * and matches the payment requirements.
+ */
+
+/**
+ * Configuration for ExactDirectNearFacilitator
+ */
+interface ExactDirectNearFacilitatorConfig {
+    /** Maximum age of a transaction to accept (in milliseconds) */
+    maxTransactionAge?: number;
+    /** Duration to cache used transaction hashes (in milliseconds) */
+    usedTxCacheDuration?: number;
+}
+/**
+ * NEAR facilitator implementation for the Exact-Direct payment scheme.
+ * Verifies transaction proofs and confirms payments.
+ */
+declare class ExactDirectNearFacilitator implements SchemeNetworkFacilitator {
+    private readonly signer;
+    readonly scheme = "exact-direct";
+    readonly caipFamily = "near:*";
+    private readonly config;
+    private usedTxs;
+    constructor(signer: FacilitatorNearSigner, config?: ExactDirectNearFacilitatorConfig);
+    /**
+     * Get extra data for a supported kind
+     */
+    getExtra(network: Network): Record<string, unknown> | undefined;
+    /**
+     * Get signer addresses for a network
+     */
+    getSigners(network: Network): string[];
+    /**
+     * Verify a payment payload
+     */
+    verify(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Settle a payment - for exact-direct, the transfer is already complete
+     */
+    settle(payload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
+    /**
+     * Check if a transaction has been used
+     */
+    private isTxUsed;
+    /**
+     * Mark a transaction as used
+     */
+    private markTxUsed;
+    /**
+     * Start the cleanup interval for used transactions
+     */
+    private startCleanupInterval;
+}
+
+/**
+ * Registration function for NEAR Exact-Direct facilitator
+ */
+
+/**
+ * Configuration options for registering NEAR schemes to a t402Facilitator
+ */
+interface NearFacilitatorConfig {
+    /**
+     * The NEAR signer for facilitator operations (verify and settle)
+     */
+    signer: FacilitatorNearSigner;
+    /**
+     * Networks to register (single network or array of networks)
+     * Examples: "near:mainnet", ["near:mainnet", "near:testnet"]
+     */
+    networks: Network | Network[];
+    /**
+     * Optional scheme configuration
+     */
+    schemeConfig?: ExactDirectNearFacilitatorConfig;
+}
+/**
+ * Registers NEAR exact-direct payment schemes to a t402Facilitator instance.
+ *
+ * @param facilitator - The t402Facilitator instance to register schemes to
+ * @param config - Configuration for NEAR facilitator registration
+ * @returns The facilitator instance for chaining
+ *
+ * @example
+ * ```typescript
+ * import { registerExactDirectNearFacilitator } from "@t402/near/exact-direct/facilitator";
+ * import { t402Facilitator } from "@t402/core/facilitator";
+ *
+ * const facilitator = new t402Facilitator();
+ *
+ * // Single network
+ * registerExactDirectNearFacilitator(facilitator, {
+ *   signer: myNearSigner,
+ *   networks: "near:mainnet"
+ * });
+ *
+ * // Multiple networks
+ * registerExactDirectNearFacilitator(facilitator, {
+ *   signer: myNearSigner,
+ *   networks: ["near:mainnet", "near:testnet"]
+ * });
+ * ```
+ */
+declare function registerExactDirectNearFacilitator(facilitator: t402Facilitator, config: NearFacilitatorConfig): t402Facilitator;
+
+export { ExactDirectNearFacilitator, type ExactDirectNearFacilitatorConfig, type NearFacilitatorConfig, registerExactDirectNearFacilitator };

package/dist/esm/exact-direct/facilitator/index.mjs

@@ -0,0 +1,11 @@
+import {
+  ExactDirectNearFacilitator,
+  registerExactDirectNearFacilitator
+} from "../../chunk-BU2BQECZ.mjs";
+import "../../chunk-G35SAYZI.mjs";
+import "../../chunk-WANNPL6S.mjs";
+export {
+  ExactDirectNearFacilitator,
+  registerExactDirectNearFacilitator
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/exact-direct/facilitator/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/exact-direct/server/index.d.mts

@@ -0,0 +1,129 @@
+import { SchemeNetworkServer, MoneyParser, Price, Network, AssetAmount, PaymentRequirements } from '@t402/core/types';
+import { t402ResourceServer } from '@t402/core/server';
+
+/**
+ * NEAR Server Scheme Implementation - Exact Direct
+ *
+ * Handles price parsing and payment requirement enhancement for
+ * NEAR NEP-141 payments using the exact-direct scheme.
+ */
+
+/**
+ * Configuration options for ExactDirectNearServer
+ */
+interface ExactDirectNearServerConfig {
+    /** Preferred token symbol (e.g., "USDC"). Defaults to network's highest priority token. */
+    preferredToken?: string;
+}
+/**
+ * NEAR server implementation for the Exact-Direct payment scheme.
+ * Handles price parsing and converts user-friendly amounts to token amounts.
+ */
+declare class ExactDirectNearServer implements SchemeNetworkServer {
+    readonly scheme = "exact-direct";
+    private moneyParsers;
+    private config;
+    constructor(config?: ExactDirectNearServerConfig);
+    /**
+     * Register a custom money parser in the parser chain.
+     * Multiple parsers can be registered - they will be tried in registration order.
+     * Each parser receives a decimal amount (e.g., 1.50 for $1.50).
+     * If a parser returns null, the next parser in the chain will be tried.
+     * The default parser is always the final fallback.
+     *
+     * @param parser - Custom function to convert amount to AssetAmount (or null to skip)
+     * @returns The server instance for chaining
+     */
+    registerMoneyParser(parser: MoneyParser): ExactDirectNearServer;
+    /**
+     * Parses a price into an asset amount.
+     * If price is already an AssetAmount, returns it directly.
+     * If price is Money (string | number), parses to decimal and tries custom parsers.
+     * Falls back to default conversion if all custom parsers return null.
+     *
+     * @param price - The price to parse
+     * @param network - The network to use
+     * @returns Promise that resolves to the parsed asset amount
+     */
+    parsePrice(price: Price, network: Network): Promise<AssetAmount>;
+    /**
+     * Build payment requirements for this scheme/network combination.
+     *
+     * @param paymentRequirements - Base payment requirements with amount/asset already set
+     * @param supportedKind - The supported kind from facilitator's /supported endpoint
+     * @param extensionKeys - Extensions supported by the facilitator
+     * @returns Enhanced payment requirements ready to be sent to clients
+     */
+    enhancePaymentRequirements(paymentRequirements: PaymentRequirements, supportedKind: {
+        t402Version: number;
+        scheme: string;
+        network: Network;
+        extra?: Record<string, unknown>;
+    }, extensionKeys: string[]): Promise<PaymentRequirements>;
+    /**
+     * Parse Money (string | number) to a decimal number.
+     * Handles formats like "$1.50", "1.50", 1.50, etc.
+     */
+    private parseMoneyToDecimal;
+    /**
+     * Default money conversion implementation.
+     * Converts decimal amount to the preferred token on the specified network.
+     */
+    private defaultMoneyConversion;
+    /**
+     * Get the default asset info for a network.
+     * Priority: configured preferredToken > network default
+     */
+    private getDefaultAsset;
+    /**
+     * Get all supported networks
+     */
+    static getSupportedNetworks(): string[];
+    /**
+     * Check if a network is supported
+     */
+    static isNetworkSupported(network: string): boolean;
+}
+
+/**
+ * Registration function for NEAR Exact-Direct server
+ */
+
+/**
+ * Configuration options for registering NEAR schemes to a t402ResourceServer
+ */
+interface NearResourceServerConfig {
+    /**
+     * Optional specific networks to register
+     * If not provided, registers wildcard support (near:*)
+     */
+    networks?: Network[];
+    /**
+     * Optional scheme configuration (preferred token, etc.)
+     */
+    schemeConfig?: ExactDirectNearServerConfig;
+}
+/**
+ * Registers NEAR exact-direct payment schemes to a t402ResourceServer instance.
+ *
+ * @param server - The t402ResourceServer instance to register schemes to
+ * @param config - Configuration for NEAR resource server registration
+ * @returns The server instance for chaining
+ *
+ * @example
+ * ```typescript
+ * import { registerExactDirectNearServer } from "@t402/near/exact-direct/server";
+ * import { t402ResourceServer } from "@t402/core/server";
+ *
+ * const server = new t402ResourceServer(facilitatorClient);
+ * registerExactDirectNearServer(server, {});
+ *
+ * // Or with specific token preference
+ * registerExactDirectNearServer(server, {
+ *   schemeConfig: { preferredToken: "USDT" }
+ * });
+ * ```
+ */
+declare function registerExactDirectNearServer(server: t402ResourceServer, config?: NearResourceServerConfig): t402ResourceServer;
+
+export { ExactDirectNearServer, type ExactDirectNearServerConfig, type NearResourceServerConfig, registerExactDirectNearServer };

package/dist/esm/exact-direct/server/index.mjs

@@ -0,0 +1,11 @@
+import {
+  ExactDirectNearServer,
+  registerExactDirectNearServer
+} from "../../chunk-B3RHERRA.mjs";
+import "../../chunk-G35SAYZI.mjs";
+import "../../chunk-WANNPL6S.mjs";
+export {
+  ExactDirectNearServer,
+  registerExactDirectNearServer
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/exact-direct/server/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/index.d.mts

@@ -0,0 +1,226 @@
+import { N as NearRpcRequest, T as TransactionResult, F as FtTransferArgs } from './types-Ca7ztL_f.mjs';
+export { C as ClientNearSigner, E as ExactDirectNearPayload, f as FacilitatorNearSigner, c as FunctionCallAction, e as NearRpcResponse, d as NearTransaction, b as TransactionOutcome, a as TransactionStatus, V as VerifyTransactionResult } from './types-Ca7ztL_f.mjs';
+export { ExactDirectNearClient, ExactDirectNearClientConfig, NearClientConfig, registerExactDirectNearClient } from './exact-direct/client/index.mjs';
+export { ExactDirectNearServer, ExactDirectNearServerConfig, NearResourceServerConfig, registerExactDirectNearServer } from './exact-direct/server/index.mjs';
+export { ExactDirectNearFacilitator, ExactDirectNearFacilitatorConfig, NearFacilitatorConfig, registerExactDirectNearFacilitator } from './exact-direct/facilitator/index.mjs';
+import '@t402/core/types';
+import '@t402/core/client';
+import '@t402/core/server';
+import '@t402/core/facilitator';
+
+/**
+ * NEAR Network Constants
+ *
+ * This module provides constants for NEAR blockchain integration including:
+ * - CAIP-2 network identifiers
+ * - RPC endpoints
+ * - NEP-141 function names
+ * - Default gas amounts
+ */
+/**
+ * CAIP-2 Network Identifiers for NEAR
+ */
+declare const NEAR_MAINNET_CAIP2 = "near:mainnet";
+declare const NEAR_TESTNET_CAIP2 = "near:testnet";
+/**
+ * Supported NEAR networks
+ */
+declare const NEAR_NETWORKS: readonly ["near:mainnet", "near:testnet"];
+type NearNetwork = (typeof NEAR_NETWORKS)[number];
+/**
+ * NEAR network IDs (for wallet connection)
+ */
+declare const NEAR_NETWORK_IDS: Record<string, string>;
+/**
+ * Default RPC endpoints
+ */
+declare const NEAR_MAINNET_RPC = "https://rpc.mainnet.near.org";
+declare const NEAR_TESTNET_RPC = "https://rpc.testnet.near.org";
+/**
+ * Network RPC endpoint mapping
+ */
+declare const NETWORK_RPC_ENDPOINTS: Record<string, string>;
+/**
+ * NEP-141 Fungible Token Standard function names
+ * @see https://nomicon.io/Standards/Tokens/FungibleToken/Core
+ */
+declare const NEP141_FT_TRANSFER = "ft_transfer";
+declare const NEP141_FT_BALANCE_OF = "ft_balance_of";
+declare const NEP141_STORAGE_DEPOSIT = "storage_deposit";
+declare const NEP141_STORAGE_BALANCE_OF = "storage_balance_of";
+/**
+ * Default gas amounts for NEP-141 transfers
+ * NEAR gas is measured in TGas (1 TGas = 10^12 gas)
+ */
+declare const DEFAULT_FT_TRANSFER_GAS = "30000000000000";
+declare const DEFAULT_STORAGE_DEPOSIT_GAS = "10000000000000";
+/**
+ * Required deposits for NEP-141 operations
+ * ft_transfer requires 1 yoctoNEAR attached deposit
+ */
+declare const FT_TRANSFER_DEPOSIT = "1";
+declare const DEFAULT_STORAGE_DEPOSIT = "1250000000000000000000";
+/**
+ * Scheme identifier for exact-direct payments
+ */
+declare const SCHEME_EXACT_DIRECT = "exact-direct";
+/**
+ * Default timeout for payment validity (in seconds)
+ */
+declare const DEFAULT_VALIDITY_DURATION = 3600;
+/**
+ * Maximum transaction age to accept (in milliseconds)
+ */
+declare const MAX_TRANSACTION_AGE: number;
+/**
+ * CAIP-2 namespace for NEAR
+ */
+declare const NEAR_CAIP2_NAMESPACE = "near";
+
+/**
+ * NEAR Token Registry
+ *
+ * Defines supported tokens (NEP-141 fungible tokens) for each NEAR network.
+ */
+/**
+ * Token configuration
+ */
+interface TokenConfig {
+    /** Contract address/account ID */
+    contractId: string;
+    /** Token symbol */
+    symbol: string;
+    /** Token name */
+    name: string;
+    /** Decimal places */
+    decimals: number;
+    /** Priority for selection (lower = higher priority) */
+    priority: number;
+}
+/**
+ * Token registry by network
+ */
+declare const TOKEN_REGISTRY: Record<string, TokenConfig[]>;
+/**
+ * Get token configuration by symbol
+ * @param network - CAIP-2 network identifier
+ * @param symbol - Token symbol (e.g., "USDC")
+ * @returns Token configuration or undefined
+ */
+declare function getTokenConfig(network: string, symbol: string): TokenConfig | undefined;
+/**
+ * Get token configuration by contract ID
+ * @param network - CAIP-2 network identifier
+ * @param contractId - Token contract account ID
+ * @returns Token configuration or undefined
+ */
+declare function getTokenByContract(network: string, contractId: string): TokenConfig | undefined;
+/**
+ * Get the default token for a network
+ * Returns the token with highest priority (lowest priority number)
+ * @param network - CAIP-2 network identifier
+ * @returns Default token configuration or undefined
+ */
+declare function getDefaultToken(network: string): TokenConfig | undefined;
+/**
+ * Get all tokens for a network
+ * @param network - CAIP-2 network identifier
+ * @returns Array of token configurations
+ */
+declare function getNetworkTokens(network: string): TokenConfig[];
+/**
+ * Check if a network is supported
+ * @param network - CAIP-2 network identifier
+ */
+declare function isNetworkSupported(network: string): boolean;
+
+/**
+ * NEAR Utility Functions
+ *
+ * Helper functions for NEAR address validation, network normalization,
+ * and RPC interactions.
+ */
+
+/**
+ * Normalize a network identifier to CAIP-2 format
+ * @param network - Network identifier (e.g., "mainnet", "near:mainnet")
+ * @returns CAIP-2 formatted network identifier
+ */
+declare function normalizeNetwork(network: string): NearNetwork;
+/**
+ * Extract network ID from CAIP-2 identifier
+ * @param network - CAIP-2 network identifier
+ * @returns Network ID (e.g., "mainnet")
+ */
+declare function extractNetworkId(network: string): string;
+/**
+ * Validate a NEAR account ID
+ * NEAR account IDs must:
+ * - Be 2-64 characters
+ * - Contain only lowercase alphanumeric, underscores, hyphens
+ * - Not start with a hyphen or underscore
+ * @param accountId - Account ID to validate
+ * @returns Whether the account ID is valid
+ */
+declare function isValidAccountId(accountId: string): boolean;
+/**
+ * Get RPC endpoint for a network
+ * @param network - CAIP-2 network identifier
+ * @returns RPC endpoint URL
+ */
+declare function getRpcEndpoint(network: string): string;
+/**
+ * Make a JSON-RPC call to NEAR
+ * @param network - CAIP-2 network identifier
+ * @param method - RPC method name
+ * @param params - Method parameters
+ * @returns RPC response result
+ */
+declare function rpcCall<T>(network: string, method: string, params: NearRpcRequest["params"]): Promise<T>;
+/**
+ * Query a transaction by hash
+ * @param network - CAIP-2 network identifier
+ * @param txHash - Transaction hash
+ * @param senderAccountId - Sender account ID
+ * @returns Transaction result
+ */
+declare function queryTransaction(network: string, txHash: string, senderAccountId: string): Promise<TransactionResult>;
+/**
+ * Query token balance
+ * @param network - CAIP-2 network identifier
+ * @param accountId - Account to query
+ * @param tokenContract - Token contract address
+ * @returns Balance as bigint
+ */
+declare function queryTokenBalance(network: string, accountId: string, tokenContract: string): Promise<bigint>;
+/**
+ * Parse ft_transfer args from base64 encoded string
+ * @param argsBase64 - Base64 encoded JSON arguments
+ * @returns Parsed ft_transfer arguments
+ */
+declare function parseFtTransferArgs(argsBase64: string): FtTransferArgs | null;
+/**
+ * Check if a transaction succeeded
+ * @param status - Transaction status
+ * @returns Whether the transaction succeeded
+ */
+declare function isTransactionSuccessful(status: {
+    SuccessValue?: string;
+    Failure?: unknown;
+}): boolean;
+/**
+ * Format amount for display (with decimals)
+ * @param amount - Amount in smallest units
+ * @param decimals - Number of decimal places
+ * @returns Formatted amount string
+ */
+declare function formatAmount(amount: bigint, decimals: number): string;
+/**
+ * Convert decimal amount to token units
+ * @param decimalAmount - Amount with decimals (e.g., "1.50")
+ * @param decimals - Token decimals
+ * @returns Amount in smallest units
+ */
+declare function toTokenUnits(decimalAmount: string | number, decimals: number): bigint;
+
+export { DEFAULT_FT_TRANSFER_GAS, DEFAULT_STORAGE_DEPOSIT, DEFAULT_STORAGE_DEPOSIT_GAS, DEFAULT_VALIDITY_DURATION, FT_TRANSFER_DEPOSIT, FtTransferArgs, MAX_TRANSACTION_AGE, NEAR_CAIP2_NAMESPACE, NEAR_MAINNET_CAIP2, NEAR_MAINNET_RPC, NEAR_NETWORKS, NEAR_NETWORK_IDS, NEAR_TESTNET_CAIP2, NEAR_TESTNET_RPC, NEP141_FT_BALANCE_OF, NEP141_FT_TRANSFER, NEP141_STORAGE_BALANCE_OF, NEP141_STORAGE_DEPOSIT, NETWORK_RPC_ENDPOINTS, type NearNetwork, NearRpcRequest, SCHEME_EXACT_DIRECT, TOKEN_REGISTRY, type TokenConfig, TransactionResult, extractNetworkId, formatAmount, getDefaultToken, getNetworkTokens, getRpcEndpoint, getTokenByContract, getTokenConfig, isNetworkSupported, isTransactionSuccessful, isValidAccountId, normalizeNetwork, parseFtTransferArgs, queryTokenBalance, queryTransaction, rpcCall, toTokenUnits };