@pioneer-platform/pioneer-coins 9.3.1 → 9.4.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @pioneer-platform/pioneer-coins
+
+## 9.4.0
+
+### Minor Changes
+
+- Release: minor version bump for all packages
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/loggerdog@8.4.0

package/lib/thorchain.d.ts

@@ -3,6 +3,32 @@ 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;

package/lib/thorchain.js

@@ -4,6 +4,7 @@
     ----------------------
 */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateThorchainSwapMemo = validateThorchainSwapMemo;
 exports.validateMemo = validateMemo;
 exports.normalizeSwapMemo = normalizeSwapMemo;
 exports.createMemo = createMemo;
@@ -199,7 +200,166 @@ 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 {
@@ -450,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,21 +1,13 @@
 {
   "name": "@pioneer-platform/pioneer-coins",
-  "version": "9.3.1",
+  "version": "9.4.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "_moduleAliases": {
     "@coins": "lib/coins"
   },
-  "scripts": {
-    "npm": "pnpm i",
-    "build": "tsc -p .",
-    "test": "pnpm run build && node __tests__/test-module.js",
-    "test-suite": "pnpm run build && node __tests__/tests-common.js",
-    "build:watch": "pnpm run build && onchange 'src/**/*.ts' -- pnpm run build",
-    "prepublish": "pnpm run build"
-  },
   "dependencies": {
-    "@pioneer-platform/loggerdog": "^8.3.1",
+    "@pioneer-platform/loggerdog": "^8.4.0",
     "bignumber.js": "^9.0.1",
     "bs58check": "^3.0.1"
   },
@@ -25,5 +17,13 @@
     "nodemon": "^2.0.3",
     "typescript": "^5.0.4"
   },
-  "gitHead": "a76012f6693a12181c4744e53e977a9eaeef0ed3"
+  "gitHead": "a76012f6693a12181c4744e53e977a9eaeef0ed3",
+  "scripts": {
+    "npm": "pnpm i",
+    "build": "tsc -p .",
+    "test": "pnpm run build && node __tests__/test-module.js",
+    "test-suite": "pnpm run build && node __tests__/tests-common.js",
+    "build:watch": "pnpm run build && onchange 'src/**/*.ts' -- pnpm run build",
+    "prepublish": "pnpm run build"
+  }
 }