@pioneer-platform/pioneer-coins 9.3.0 → 9.3.2

package/lib/thorchain.d.ts

@@ -3,6 +3,33 @@ interface BaseTx {
     asset: string;
     destAddr: string;
 }
+export interface MemoValidation {
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+    normalized?: string;
+    fields?: {
+        chain: string;
+        symbol: string;
+        destination: string;
+        limit?: string;
+        stream?: string;
+        affiliateTag?: string;
+        affiliateBP?: number;
+    };
+    suggestedFix?: string;
+}
+/**
+ * Comprehensive THORChain Swap Memo Validator
+ *
+ * Validates memos of the form:
+ *   =:<CHAIN>.<SYMBOL>:<DEST>[:<limit>[/<stream]][:<affiliateTag>:<affiliateBP>]
+ *
+ * @param memoRaw - The raw memo string to validate
+ * @returns MemoValidation object with validation results
+ */
+export declare function validateThorchainSwapMemo(memoRaw: string): MemoValidation;
+export declare function validateMemo(memo: string): boolean;
 export declare function normalizeSwapMemo(memo: string): string;
 export declare function createMemo(tx: BaseTx): string;
 export declare function parseMemo(memo: string): BaseTx;

package/lib/thorchain.js

@@ -4,6 +4,8 @@
     ----------------------
 */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateThorchainSwapMemo = validateThorchainSwapMemo;
+exports.validateMemo = validateMemo;
 exports.normalizeSwapMemo = normalizeSwapMemo;
 exports.createMemo = createMemo;
 exports.parseMemo = parseMemo;
@@ -198,7 +200,236 @@ function buildNoOpMemo(tx) {
     ];
     return truncateMemo(parts.filter(function (part) { return part; }).join(':'));
 }
-// Main function to create a memo from any transaction type
+// Basic destination sanity check by chain
+function basicDestCheck(chain, dest) {
+    if (chain === 'BTC') {
+        // BTC: accept base58 (1..,3..) or bech32 (bc1.., tb1..)
+        var isB58 = /^[123mn][1-9A-HJ-NP-Za-km-z]{24,}$/;
+        var isBech32 = /^(bc1|tb1)[a-z0-9]{20,}$/;
+        if (!isB58.test(dest) && !isBech32.test(dest)) {
+            return 'destination does not look like a valid BTC address';
+        }
+    }
+    if (chain === 'ETH') {
+        if (!/^0x[a-fA-F0-9]{40}$/.test(dest)) {
+            return 'destination is not a valid Ethereum address';
+        }
+    }
+    if (chain === 'DASH') {
+        if (!/^X[1-9A-HJ-NP-Za-km-z]{33}$/.test(dest)) {
+            return 'destination does not look like a valid DASH address';
+        }
+    }
+    return undefined;
+}
+/**
+ * Comprehensive THORChain Swap Memo Validator
+ *
+ * Validates memos of the form:
+ *   =:<CHAIN>.<SYMBOL>:<DEST>[:<limit>[/<stream]][:<affiliateTag>:<affiliateBP>]
+ *
+ * @param memoRaw - The raw memo string to validate
+ * @returns MemoValidation object with validation results
+ */
+function validateThorchainSwapMemo(memoRaw) {
+    var errors = [];
+    var warnings = [];
+    var MAX_MEMO_LEN = 250;
+    var ASCII_SAFE = /^[\x20-\x7E]+$/; // printable ASCII (no control chars)
+    if (!memoRaw || memoRaw.trim() === '') {
+        return { ok: false, errors: ['memo is empty'], warnings: warnings };
+    }
+    var memo = memoRaw.trim();
+    if (memo.length > MAX_MEMO_LEN) {
+        errors.push("memo exceeds ".concat(MAX_MEMO_LEN, " bytes"));
+    }
+    if (!ASCII_SAFE.test(memo)) {
+        errors.push('memo must be printable ASCII (no control characters)');
+    }
+    if (!memo.startsWith('=:')) {
+        errors.push('memo must start with "=:<CHAIN>.<SYMBOL>:"');
+    }
+    // Early exit if start is wrong
+    if (errors.length)
+        return { ok: false, errors: errors, warnings: warnings };
+    // Split by colon
+    var parts = memo.slice(2).split(':');
+    if (parts.length < 2) {
+        errors.push('memo missing destination segment');
+        return { ok: false, errors: errors, warnings: warnings };
+    }
+    var chainDotSymbol = parts[0];
+    var shorthandFix;
+    // Check if it's a shorthand that needs expansion
+    var maybeSh = chainDotSymbol.toLowerCase();
+    if (assetShortCodeMap[maybeSh]) {
+        // This is a shorthand - it's invalid in the memo itself
+        errors.push("shorthand \"".concat(chainDotSymbol, "\" not allowed - must use full CHAIN.SYMBOL format"));
+        shorthandFix = assetShortCodeMap[maybeSh];
+        if (shorthandFix) {
+            chainDotSymbol = shorthandFix;
+            warnings.push("expanded shorthand \"".concat(parts[0], "\" to \"").concat(shorthandFix, "\""));
+        }
+    }
+    var cs = chainDotSymbol.split('.');
+    if (cs.length !== 2) {
+        errors.push('first segment must be "<CHAIN>.<SYMBOL>" (e.g., BTC.BTC)');
+        if (cs.length === 1 && !assetShortCodeMap[cs[0].toLowerCase()]) {
+            // Not even a valid shorthand
+            errors.push("\"".concat(cs[0], "\" is not a valid chain identifier"));
+        }
+        return { ok: false, errors: errors, warnings: warnings };
+    }
+    var chain = cs[0];
+    var symbol = cs[1];
+    if (!/^[A-Z0-9]+$/.test(chain) || !/^[A-Z0-9\-]+$/.test(symbol)) {
+        errors.push('CHAIN and SYMBOL must be uppercase alphanumerics');
+    }
+    var destination = parts[1];
+    if (!destination)
+        errors.push('destination is empty');
+    // Optional limit/stream
+    var limit;
+    var stream;
+    if (parts[2] !== undefined && parts[2] !== '') {
+        var ls = parts[2].split('/');
+        limit = ls[0];
+        if (limit && !/^\d+$/.test(limit)) {
+            errors.push('limit must be a non-negative integer');
+        }
+        if (ls.length > 1) {
+            stream = ls[1];
+            if (stream && !/^\d+$/.test(stream)) {
+                errors.push('stream must be a non-negative integer');
+            }
+        }
+    }
+    // Optional affiliate
+    var affiliateTag;
+    var affiliateBP;
+    if (parts[3] !== undefined && parts[3] !== '') {
+        affiliateTag = parts[3];
+        if (/\s/.test(affiliateTag))
+            warnings.push('affiliateTag should not contain spaces');
+    }
+    if (parts[4] !== undefined && parts[4] !== '') {
+        if (!/^\d+$/.test(parts[4])) {
+            errors.push('affiliateBP must be integer 0..1000');
+        }
+        else {
+            affiliateBP = Number(parts[4]);
+            if (affiliateBP < 0 || affiliateBP > 1000) {
+                errors.push('affiliateBP out of range (0..1000)');
+            }
+        }
+    }
+    // Destination validation - convert warnings to errors for critical issues
+    var destErr = basicDestCheck(chain, destination);
+    if (destErr) {
+        // For ETH, a bad address is an error, not a warning
+        if (chain === 'ETH' && destination.length < 42) {
+            errors.push(destErr);
+        }
+        else {
+            warnings.push(destErr);
+        }
+    }
+    var normalized = "=:" +
+        "".concat(chain, ".").concat(symbol, ":") +
+        "".concat(destination) +
+        (limit !== undefined || stream !== undefined
+            ? ":".concat(limit !== null && limit !== void 0 ? limit : '0').concat(stream !== undefined ? "/".concat(stream) : '')
+            : '') +
+        (affiliateTag !== undefined
+            ? ":".concat(affiliateTag, ":").concat(affiliateBP !== null && affiliateBP !== void 0 ? affiliateBP : 0)
+            : '');
+    return {
+        ok: errors.length === 0,
+        errors: errors,
+        warnings: warnings,
+        normalized: normalized,
+        fields: {
+            chain: chain,
+            symbol: symbol,
+            destination: destination,
+            limit: limit,
+            stream: stream,
+            affiliateTag: affiliateTag,
+            affiliateBP: affiliateBP,
+        },
+        suggestedFix: shorthandFix ? normalized : undefined,
+    };
+}
+// Validate a THORChain memo - returns true if valid, false otherwise
+function validateMemo(memo) {
+    try {
+        if (!memo || memo.trim() === '')
+            return false;
+        var trimmed = memo.trim();
+        // Check basic format
+        if (!trimmed.startsWith('=:') && !trimmed.startsWith('SWAP:') &&
+            !trimmed.startsWith('DEPOSIT:') && !trimmed.startsWith('WITHDRAW:') &&
+            !trimmed.startsWith('LOAN+:') && !trimmed.startsWith('LOAN-:') &&
+            !trimmed.startsWith('ADD:') && !trimmed.startsWith('WD:') &&
+            !trimmed.startsWith('BOND:') && !trimmed.startsWith('UNBOND:') &&
+            !trimmed.startsWith('MIGRATE:') && !trimmed.startsWith('*NOOP*:')) {
+            return false;
+        }
+        // For swap memos, validate format more strictly
+        if (trimmed.startsWith('=:') || trimmed.startsWith('SWAP:')) {
+            var prefix = trimmed.startsWith('=:') ? '=:' : 'SWAP:';
+            var parts = trimmed.slice(prefix.length).split(':');
+            // Must have at least asset and destination
+            if (parts.length < 2)
+                return false;
+            // Check asset format (must be CHAIN.SYMBOL)
+            var asset = parts[0];
+            // Don't allow single-letter shorthands in validation
+            if (asset.length === 1)
+                return false;
+            var assetParts = asset.split('.');
+            if (assetParts.length !== 2)
+                return false;
+            var chain = assetParts[0], symbol = assetParts[1];
+            // Must be uppercase alphanumeric (symbol can have dash)
+            if (!/^[A-Z0-9]+$/.test(chain))
+                return false;
+            if (!/^[A-Z0-9\-]+$/.test(symbol))
+                return false;
+            // Must have destination
+            var destination = parts[1];
+            if (!destination || destination.trim() === '')
+                return false;
+            // Check optional limit/stream format
+            if (parts[2] && parts[2] !== '') {
+                var limitStream = parts[2].split('/');
+                // Limit must be integer if present
+                if (limitStream[0] && !/^\d+$/.test(limitStream[0]))
+                    return false;
+                // Stream must be integer if present
+                if (limitStream[1] && !/^\d+$/.test(limitStream[1]))
+                    return false;
+            }
+            // Check affiliate BP if present
+            if (parts[4] && parts[4] !== '') {
+                if (!/^\d+$/.test(parts[4]))
+                    return false;
+                var bp = parseInt(parts[4]);
+                if (bp < 0 || bp > 1000)
+                    return false;
+            }
+        }
+        // Check memo length
+        if (Buffer.from(trimmed, 'utf-8').length > 250)
+            return false;
+        // If we made it here, memo is valid
+        return true;
+    }
+    catch (error) {
+        // Any error means invalid memo
+        return false;
+    }
+}
 // Normalize and validate swap memo
 function normalizeSwapMemo(memo) {
     // Ensure "=:" prefix and fully qualified asset
@@ -379,3 +610,31 @@ function parseMemo(memo) {
             throw new Error("Unsupported memo type: ".concat(type));
     }
 }
+/**
+ * Thorchain Swap Memo Validator
+ *
+ * Supports memos of the form:
+ *   =:<CHAIN>.<SYMBOL>:<DEST>[:<limit>[/<stream]][:<affiliateTag>:<affiliateBP>]
+ *
+ * Examples:
+ *   =:BTC.BTC:bc1qxyz...
+ *   =:BTC.BTC:bc1qxyz...:120000
+ *   =:BTC.BTC:1JNYtQ...:120000/30
+ *   =:ETH.ETH:0xabc...:0:agg:25
+ */
+var SHORTHANDS = {
+    'b': 'BTC.BTC',
+    'btc': 'BTC.BTC',
+    'e': 'ETH.ETH',
+    'eth': 'ETH.ETH',
+    'r': 'THOR.RUNE',
+    'd': 'DOGE.DOGE',
+    'l': 'LTC.LTC',
+    'c': 'BCH.BCH',
+    'a': 'AVAX.AVAX',
+    's': 'BSC.BNB',
+    'n': 'BNB.BNB',
+    'g': 'GAIA.ATOM',
+};
+var MAX_MEMO_LEN = 250;
+var ASCII_SAFE = /^[\x20-\x7E]+$/; // printable ASCII (no control chars)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-coins",
-  "version": "9.3.0",
+  "version": "9.3.2",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "_moduleAliases": {