ff1-cli 1.0.0

package/dist/src/utilities/address-validator.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Address Validator
+ * Validates Ethereum and Tezos wallet addresses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEthereumAddress = validateEthereumAddress;
+exports.validateTezosAddress = validateTezosAddress;
+exports.validateAddresses = validateAddresses;
+const viem_1 = require("viem");
+/**
+ * Validate Ethereum address format
+ * Uses viem library for EIP-55 checksum validation
+ *
+ * @param {string} address - Address to validate
+ * @returns {Object} Validation result
+ * @returns {boolean} returns.valid - Whether address is valid Ethereum format
+ * @returns {string} [returns.error] - Error message if invalid
+ * @returns {string} [returns.normalized] - Checksummed address if valid
+ * @example
+ * const result = validateEthereumAddress('0x1234567890123456789012345678901234567890');
+ * if (result.valid) console.log(result.normalized);
+ */
+function validateEthereumAddress(address) {
+    if (!address || typeof address !== 'string') {
+        return {
+            valid: false,
+            error: 'Address must be a non-empty string',
+        };
+    }
+    try {
+        // viem's isAddress checks format and returns true/false
+        if (!(0, viem_1.isAddress)(address)) {
+            return {
+                valid: false,
+                error: 'Invalid Ethereum address format. Must be 0x followed by 40 hex characters',
+            };
+        }
+        // getAddress returns the checksummed address
+        const normalized = (0, viem_1.getAddress)(address);
+        return {
+            valid: true,
+            normalized,
+        };
+    }
+    catch (err) {
+        return {
+            valid: false,
+            error: `Address validation failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+/**
+ * Validate Tezos address format
+ * Checks tz1, tz2, tz3, and KT1 address prefixes
+ *
+ * @param {string} address - Address to validate
+ * @returns {Object} Validation result
+ * @returns {boolean} returns.valid - Whether address is valid Tezos format
+ * @returns {string} [returns.error] - Error message if invalid
+ * @returns {string} [returns.type] - Address type (user, contract)
+ * @example
+ * const result = validateTezosAddress('tz1VSUr8wwNhLAzempoch5d6hLKEUNvD14');
+ * if (result.valid) console.log(result.type);
+ */
+function validateTezosAddress(address) {
+    if (!address || typeof address !== 'string') {
+        return {
+            valid: false,
+            error: 'Address must be a non-empty string',
+        };
+    }
+    // Tezos addresses use base58 encoding with specific prefixes
+    // tz1, tz2, tz3: user/implicit accounts (34 chars total, or longer with suffix)
+    // KT1: contracts (34 chars total, or longer with suffix)
+    // Base58 alphabet: 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
+    const userAddressRegex = /^tz[1-3][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{30,}$/;
+    const contractAddressRegex = /^KT1[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{30,}$/;
+    if (userAddressRegex.test(address)) {
+        return {
+            valid: true,
+            type: 'user',
+        };
+    }
+    if (contractAddressRegex.test(address)) {
+        return {
+            valid: true,
+            type: 'contract',
+        };
+    }
+    return {
+        valid: false,
+        error: 'Invalid Tezos address format. Must start with tz1/tz2/tz3 (user) or KT1 (contract)',
+    };
+}
+/**
+ * Validate mixed Ethereum and Tezos addresses, ENS domains, and Tezos domains
+ * Detects address type and applies appropriate validation
+ *
+ * Supported formats:
+ * - Ethereum addresses: 0x followed by 40 hex characters
+ * - Tezos addresses: tz1/tz2/tz3 (user) or KT1 (contract)
+ * - ENS domains: alphanumeric names ending in .eth
+ * - Tezos domains: alphanumeric names ending in .tez
+ *
+ * @param {Array<string>} addresses - Array of addresses to validate
+ * @returns {Object} Validation result
+ * @returns {boolean} returns.valid - Whether all addresses are valid
+ * @returns {Array<Object>} returns.results - Validation result for each address
+ * @returns {Array<string>} returns.errors - List of error messages
+ * @example
+ * const result = validateAddresses(['0x...', 'tz1...', 'reas.eth', 'einstein-rosen.tez']);
+ * if (!result.valid) console.log(result.errors);
+ */
+function validateAddresses(addresses) {
+    const results = [];
+    const errors = [];
+    if (!Array.isArray(addresses)) {
+        errors.push('Input must be an array of addresses');
+        return { valid: false, results, errors };
+    }
+    if (addresses.length === 0) {
+        errors.push('At least one address is required for validation');
+        return { valid: false, results, errors };
+    }
+    for (const address of addresses) {
+        if (typeof address !== 'string') {
+            errors.push(`Invalid input: ${JSON.stringify(address)} is not a string`);
+            results.push({
+                address: String(address),
+                valid: false,
+                type: 'unknown',
+                error: 'Address must be a string',
+            });
+            continue;
+        }
+        const trimmed = address.trim();
+        // Try Ethereum first (starts with 0x)
+        if (trimmed.startsWith('0x')) {
+            const ethResult = validateEthereumAddress(trimmed);
+            if (ethResult.valid) {
+                results.push({
+                    address: trimmed,
+                    valid: true,
+                    type: 'ethereum',
+                    normalized: ethResult.normalized,
+                });
+            }
+            else {
+                const errorMsg = `Invalid Ethereum address "${trimmed}": ${ethResult.error}`;
+                errors.push(errorMsg);
+                results.push({
+                    address: trimmed,
+                    valid: false,
+                    type: 'ethereum',
+                    error: ethResult.error,
+                });
+            }
+        }
+        else if (trimmed.startsWith('tz') || trimmed.startsWith('KT1')) {
+            // Try Tezos
+            const tezResult = validateTezosAddress(trimmed);
+            if (tezResult.valid) {
+                results.push({
+                    address: trimmed,
+                    valid: true,
+                    type: tezResult.type || 'tezos',
+                });
+            }
+            else {
+                const errorMsg = `Invalid Tezos address "${trimmed}": ${tezResult.error}`;
+                errors.push(errorMsg);
+                results.push({
+                    address: trimmed,
+                    valid: false,
+                    type: 'tezos',
+                    error: tezResult.error,
+                });
+            }
+        }
+        else if (trimmed.endsWith('.eth')) {
+            // ENS domain name (Ethereum Name Service)
+            // These are valid owner identifiers that will be resolved to addresses
+            const ensPattern = /^[a-z0-9-]+\.eth$/i;
+            if (ensPattern.test(trimmed)) {
+                results.push({
+                    address: trimmed,
+                    valid: true,
+                    type: 'ens',
+                });
+            }
+            else {
+                const errorMsg = `Invalid ENS domain "${trimmed}". Must be alphanumeric with hyphens ending in .eth`;
+                errors.push(errorMsg);
+                results.push({
+                    address: trimmed,
+                    valid: false,
+                    type: 'ens',
+                    error: 'Invalid ENS domain format',
+                });
+            }
+        }
+        else if (trimmed.endsWith('.tez')) {
+            // Tezos domain name
+            // These are valid owner identifiers that will be resolved to addresses
+            const tezDomainPattern = /^[a-z0-9-]+\.tez$/i;
+            if (tezDomainPattern.test(trimmed)) {
+                results.push({
+                    address: trimmed,
+                    valid: true,
+                    type: 'tezos-domain',
+                });
+            }
+            else {
+                const errorMsg = `Invalid Tezos domain "${trimmed}". Must be alphanumeric with hyphens ending in .tez`;
+                errors.push(errorMsg);
+                results.push({
+                    address: trimmed,
+                    valid: false,
+                    type: 'tezos-domain',
+                    error: 'Invalid Tezos domain format',
+                });
+            }
+        }
+        else {
+            const errorMsg = `Unknown address format "${trimmed}". Must be 0x... (Ethereum), tz/KT1 (Tezos), .eth (ENS), or .tez (Tezos domain)`;
+            errors.push(errorMsg);
+            results.push({
+                address: trimmed,
+                valid: false,
+                type: 'unknown',
+                error: 'Must be Ethereum (0x...), Tezos (tz1/tz2/tz3/KT1), ENS (.eth), or Tezos domain (.tez)',
+            });
+        }
+    }
+    const allValid = results.every((r) => r.valid);
+    return {
+        valid: allValid,
+        results,
+        errors,
+    };
+}

package/dist/src/utilities/domain-resolver.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * Domain Resolution Utilities
+ * Resolves blockchain domain names (ENS, TNS) to their corresponding addresses
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDomain = resolveDomain;
+exports.resolveDomainsBatch = resolveDomainsBatch;
+exports.displayResolutionResults = displayResolutionResults;
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const ens_1 = require("viem/ens");
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+const logger = __importStar(require("../logger"));
+/**
+ * ENS resolver using viem
+ */
+class ENSResolver {
+    client;
+    constructor() {
+        this.client = (0, viem_1.createPublicClient)({
+            chain: chains_1.mainnet,
+            transport: (0, viem_1.http)(),
+        });
+    }
+    /**
+     * Resolve an ENS domain to its Ethereum address
+     *
+     * @param {string} domain - ENS domain (e.g., 'vitalik.eth')
+     * @returns {Promise<string|null>} Resolved address or null
+     */
+    async resolve(domain) {
+        try {
+            const address = await this.client.getEnsAddress({
+                name: (0, ens_1.normalize)(domain),
+            });
+            return address;
+        }
+        catch (error) {
+            logger.debug(`ENS resolution failed for ${domain}: ${error}`);
+            return null;
+        }
+    }
+}
+/**
+ * TNS (Tezos Name Service) resolver using Tezos Domains GraphQL API
+ *
+ * Uses the official Tezos Domains API for reliable resolution
+ * API: https://api.tezos.domains/graphql
+ */
+class TNSResolver {
+    apiUrl;
+    constructor() {
+        this.apiUrl = 'https://api.tezos.domains/graphql';
+    }
+    /**
+     * Resolve a TNS domain to its Tezos address using GraphQL API
+     *
+     * @param {string} domain - TNS domain (e.g., 'alice.tez', 'einstein-rosen.tez')
+     * @returns {Promise<string|null>} Resolved address or null
+     */
+    async resolve(domain) {
+        try {
+            // GraphQL query to resolve domain (using GET request)
+            // Note: API only supports 'address' field, not 'expiry'
+            const query = `{ domain(name: "${domain}") { address } }`;
+            const response = await axios_1.default.get(this.apiUrl, {
+                params: { query },
+                timeout: 10000,
+            });
+            if (response.data?.errors) {
+                logger.debug(`TNS API returned errors for ${domain}: ${JSON.stringify(response.data.errors)}`);
+                return null;
+            }
+            const domainData = response.data?.data?.domain;
+            if (!domainData || !domainData.address) {
+                logger.debug(`TNS domain ${domain} not found - domainData: ${JSON.stringify(domainData)}`);
+                return null;
+            }
+            logger.debug(`TNS resolved ${domain} → ${domainData.address}`);
+            return domainData.address;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`TNS resolution failed for ${domain}: ${errorMessage}`);
+            return null;
+        }
+    }
+}
+/**
+ * Determine domain type based on TLD
+ *
+ * @param {string} domain - Domain name
+ * @returns {string|null} Domain type ('ens', 'tns') or null
+ */
+function getDomainType(domain) {
+    const normalizedDomain = domain.toLowerCase();
+    if (normalizedDomain.endsWith('.eth')) {
+        return 'ens';
+    }
+    else if (normalizedDomain.endsWith('.tez')) {
+        return 'tns';
+    }
+    return null;
+}
+/**
+ * Validate domain name format
+ *
+ * @param {string} domain - Domain to validate
+ * @returns {boolean} Whether domain is valid
+ */
+function isValidDomain(domain) {
+    if (!domain || typeof domain !== 'string') {
+        return false;
+    }
+    const trimmedDomain = domain.trim();
+    if (trimmedDomain.length === 0) {
+        return false;
+    }
+    const domainType = getDomainType(trimmedDomain);
+    return domainType !== null;
+}
+/**
+ * Resolve a single domain to its blockchain address
+ *
+ * @param {string} domain - Domain name to resolve (e.g., 'vitalik.eth', 'alice.tez')
+ * @returns {Promise<DomainResolution>} Resolution result
+ * @example
+ * const result = await resolveDomain('vitalik.eth');
+ * if (result.resolved) {
+ *   console.log(`${result.domain} -> ${result.address}`);
+ * }
+ */
+async function resolveDomain(domain) {
+    const trimmedDomain = domain.trim();
+    // Validate domain
+    if (!isValidDomain(trimmedDomain)) {
+        return {
+            domain: trimmedDomain,
+            address: null,
+            resolved: false,
+            error: `Invalid or unsupported domain: ${trimmedDomain}`,
+        };
+    }
+    const domainType = getDomainType(trimmedDomain);
+    try {
+        let address = null;
+        if (domainType === 'ens') {
+            const ensResolver = new ENSResolver();
+            address = await ensResolver.resolve(trimmedDomain);
+        }
+        else if (domainType === 'tns') {
+            const tnsResolver = new TNSResolver();
+            address = await tnsResolver.resolve(trimmedDomain);
+        }
+        if (!address) {
+            return {
+                domain: trimmedDomain,
+                address: null,
+                resolved: false,
+                error: `Could not resolve ${trimmedDomain}`,
+            };
+        }
+        return {
+            domain: trimmedDomain,
+            address,
+            resolved: true,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error during resolution';
+        logger.debug(`Domain resolution error for ${trimmedDomain}: ${errorMessage}`);
+        return {
+            domain: trimmedDomain,
+            address: null,
+            resolved: false,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Resolve multiple domains in batch (concurrent processing)
+ *
+ * Supports ENS (.eth) and TNS (.tez) domains.
+ * Processes all domains concurrently for optimal performance.
+ *
+ * @param {string[]} domains - Array of domain names to resolve
+ * @returns {Promise<BatchResolutionResult>} Batch resolution result with domain->address map
+ * @example
+ * const result = await resolveDomainsBatch(['vitalik.eth', 'alice.tez']);
+ * if (result.success) {
+ *   console.log(result.domainMap); // { 'vitalik.eth': '0x...', 'alice.tez': 'tz...' }
+ * }
+ */
+async function resolveDomainsBatch(domains) {
+    // Validate input
+    if (!Array.isArray(domains) || domains.length === 0) {
+        return {
+            success: false,
+            resolutions: [],
+            domainMap: {},
+            errors: ['No domains provided for resolution'],
+        };
+    }
+    logger.debug(`Resolving ${domains.length} domains in batch...`);
+    // Resolve all domains concurrently
+    const resolutionPromises = domains.map((domain) => resolveDomain(domain));
+    const resolutions = await Promise.all(resolutionPromises);
+    // Build domain map and collect errors
+    const domainMap = {};
+    const errors = [];
+    for (const resolution of resolutions) {
+        if (resolution.resolved && resolution.address) {
+            domainMap[resolution.domain] = resolution.address;
+        }
+        else if (resolution.error) {
+            errors.push(`${resolution.domain}: ${resolution.error}`);
+        }
+    }
+    const successfulResolutions = resolutions.filter((r) => r.resolved).length;
+    logger.debug(`Batch resolution complete: ${successfulResolutions}/${domains.length} successful`);
+    return {
+        success: successfulResolutions > 0,
+        resolutions,
+        domainMap,
+        errors,
+    };
+}
+/**
+ * Display batch resolution results in a user-friendly format
+ *
+ * @param {BatchResolutionResult} result - Batch resolution result
+ */
+function displayResolutionResults(result) {
+    if (result.resolutions.length === 0) {
+        console.log(chalk_1.default.yellow('No names to resolve'));
+        return;
+    }
+    // Display successful resolutions
+    const successful = result.resolutions.filter((r) => r.resolved);
+    if (successful.length > 0) {
+        successful.forEach((resolution) => {
+            console.log(chalk_1.default.gray(`  ${resolution.domain} → ${resolution.address}`));
+        });
+    }
+    // Display failures (but don't make them too prominent)
+    const failed = result.resolutions.filter((r) => !r.resolved);
+    if (failed.length > 0) {
+        failed.forEach((resolution) => {
+            console.log(chalk_1.default.yellow(`  ✗ ${resolution.domain}: ${resolution.error || 'Could not resolve'}`));
+        });
+    }
+    console.log();
+}