@1money/protocol-ts-sdk 2.0.2 → 2.1.0-beta.0

package/lib/utils/index.js

@@ -116,6 +116,20 @@ PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
 
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -168,7 +182,101 @@ function __spreadArray(to, from, pack) {
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};// concurrent
+};var MEMO_TYPE_MAX_BYTES = 128;
+var MEMO_FORMAT_MAX_BYTES = 64;
+var MEMO_DATA_MAX_BYTES = 256;
+// Currently unreachable given the per-field caps above (128 + 64 + 256 + 16 =
+// 464); retained as a future-proofing guard matching Rust.
+var MEMO_TOTAL_MAX_BYTES = 512;
+// RLP overhead allowance used by the aggregate size check, matching the
+// Rust `Memo::byte_size` constant so JS and Rust accept/reject the same set
+// of inputs.
+var MEMO_RLP_HEADER_ALLOWANCE = 16;
+var MemoValidationError = /** @class */ (function (_super) {
+    __extends(MemoValidationError, _super);
+    function MemoValidationError(code, message) {
+        var _this = _super.call(this, message) || this;
+        _this.code = code;
+        _this.name = 'MemoValidationError';
+        return _this;
+    }
+    return MemoValidationError;
+}(Error));var enc = new TextEncoder();
+// RFC 3986 unreserved + gen-delims + sub-delims + percent. Matches
+// `is_url_safe` in `om-primitives-types/.../memo.rs`.
+var URL_SAFE_RE = /^[A-Za-z0-9\-._~:/?#[\]@!$&'()*+,;=%]*$/;
+function utf8Len(s) {
+    return enc.encode(s).length;
+}
+// Mirrors Rust `Memo::byte_size`: sum of subfield UTF-8 byte lengths plus a
+// fixed 16-byte allowance for RLP framing. Used only by the aggregate cap.
+function byteSize(memo) {
+    var _a, _b, _c;
+    return (utf8Len((_a = memo.type) !== null && _a !== void 0 ? _a : '') +
+        utf8Len((_b = memo.format) !== null && _b !== void 0 ? _b : '') +
+        utf8Len((_c = memo.data) !== null && _c !== void 0 ? _c : '') +
+        MEMO_RLP_HEADER_ALLOWANCE);
+}
+// Validate per the same rules as Rust `Memo::validate()`.
+//
+// Per-field checks fire before the aggregate check, matching Rust ordering
+// — clients should expect the same error code the server would return.
+function validateMemo(memo) {
+    var _a, _b, _c;
+    var t = (_a = memo.type) !== null && _a !== void 0 ? _a : '';
+    if (t.length > 0) {
+        var len = utf8Len(t);
+        if (len > MEMO_TYPE_MAX_BYTES) {
+            throw new MemoValidationError('MEMO_TYPE_TOO_LONG', "memo.type exceeds ".concat(MEMO_TYPE_MAX_BYTES, " bytes (got ").concat(len, ")"));
+        }
+        if (!URL_SAFE_RE.test(t)) {
+            throw new MemoValidationError('MEMO_TYPE_INVALID_CHARS', 'memo.type contains non-URL-safe characters');
+        }
+    }
+    var f = (_b = memo.format) !== null && _b !== void 0 ? _b : '';
+    if (f.length > 0) {
+        var len = utf8Len(f);
+        if (len > MEMO_FORMAT_MAX_BYTES) {
+            throw new MemoValidationError('MEMO_FORMAT_TOO_LONG', "memo.format exceeds ".concat(MEMO_FORMAT_MAX_BYTES, " bytes (got ").concat(len, ")"));
+        }
+        if (!URL_SAFE_RE.test(f)) {
+            throw new MemoValidationError('MEMO_FORMAT_INVALID_CHARS', 'memo.format contains non-URL-safe characters');
+        }
+    }
+    var d = (_c = memo.data) !== null && _c !== void 0 ? _c : '';
+    if (d.length > 0) {
+        var len = utf8Len(d);
+        if (len > MEMO_DATA_MAX_BYTES) {
+            throw new MemoValidationError('MEMO_DATA_TOO_LONG', "memo.data exceeds ".concat(MEMO_DATA_MAX_BYTES, " bytes (got ").concat(len, ")"));
+        }
+        // Reject NUL and any C0/C1 control codepoint (Unicode general category
+        // Cc). Rust's check is `c == '\0' || c.is_control()`.
+        for (var _i = 0, d_1 = d; _i < d_1.length; _i++) {
+            var ch = d_1[_i];
+            var cp = ch.codePointAt(0);
+            if (cp === 0 ||
+                cp <= 0x1f ||
+                (cp >= 0x7f && cp <= 0x9f) ||
+                (cp >= 0xd800 && cp <= 0xdfff)) {
+                throw new MemoValidationError('MEMO_DATA_CONTROL_CHARS', 'memo.data contains null bytes or Unicode control/surrogate codepoints');
+            }
+        }
+    }
+    var total = byteSize(memo);
+    if (total > MEMO_TOTAL_MAX_BYTES) {
+        throw new MemoValidationError('MEMO_TOO_LARGE', "memo object exceeds ".concat(MEMO_TOTAL_MAX_BYTES, " bytes (got ").concat(total, ")"));
+    }
+}// RLP encoding of `Memo` matches the Rust `RlpEncodable` derive: a list of
+// three byte strings in field order [type, format, data]. Empty subfields
+// encode as empty byte strings (RLP `0x80`).
+function memoRlpList(memo) {
+    var _a, _b, _c;
+    return rlpValue.list([
+        rlpValue.string((_a = memo.type) !== null && _a !== void 0 ? _a : ''),
+        rlpValue.string((_b = memo.format) !== null && _b !== void 0 ? _b : ''),
+        rlpValue.string((_c = memo.data) !== null && _c !== void 0 ? _c : ''),
+    ]);
+}// concurrent
 function safePromiseAll(arr) {
     // @ts-expect-error
     if (!arr || !arr.length)
@@ -1022,4 +1130,4 @@ function calcTxHash(payload, signature) {
     encoded.set(pEncode, header.length);
     encoded.set(vrsBytes, header.length + pEncode.length);
     return viem.keccak256(encoded);
-}exports._typeof=_typeof;exports.calcTxHash=calcTxHash;exports.deriveTokenAddress=deriveTokenAddress;exports.encodePayload=encodePayload;exports.encodeRlpPayload=encodeRlpPayload;exports.rlpValue=rlpValue;exports.safePromiseAll=safePromiseAll;exports.safePromiseLine=safePromiseLine;exports.signMessage=signMessage;exports.toHex=toHex;
+}exports.MEMO_DATA_MAX_BYTES=MEMO_DATA_MAX_BYTES;exports.MEMO_FORMAT_MAX_BYTES=MEMO_FORMAT_MAX_BYTES;exports.MEMO_RLP_HEADER_ALLOWANCE=MEMO_RLP_HEADER_ALLOWANCE;exports.MEMO_TOTAL_MAX_BYTES=MEMO_TOTAL_MAX_BYTES;exports.MEMO_TYPE_MAX_BYTES=MEMO_TYPE_MAX_BYTES;exports.MemoValidationError=MemoValidationError;exports._typeof=_typeof;exports.calcTxHash=calcTxHash;exports.deriveTokenAddress=deriveTokenAddress;exports.encodePayload=encodePayload;exports.encodeRlpPayload=encodeRlpPayload;exports.memoRlpList=memoRlpList;exports.rlpValue=rlpValue;exports.safePromiseAll=safePromiseAll;exports.safePromiseLine=safePromiseLine;exports.signMessage=signMessage;exports.toHex=toHex;exports.validateMemo=validateMemo;

package/lib/utils/memo/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './validate';
+export * from './rlp';

package/lib/utils/memo/rlp.d.ts

@@ -0,0 +1,3 @@
+import { type PlpPayload } from '../../utils/index.js';
+import type { Memo } from './types';
+export declare function memoRlpList(memo: Memo): PlpPayload;

package/lib/utils/memo/types.d.ts

@@ -0,0 +1,15 @@
+export interface Memo {
+    type?: string;
+    format?: string;
+    data?: string;
+}
+export declare const MEMO_TYPE_MAX_BYTES = 128;
+export declare const MEMO_FORMAT_MAX_BYTES = 64;
+export declare const MEMO_DATA_MAX_BYTES = 256;
+export declare const MEMO_TOTAL_MAX_BYTES = 512;
+export declare const MEMO_RLP_HEADER_ALLOWANCE = 16;
+export type MemoErrorCode = 'MEMO_TOO_LARGE' | 'MEMO_TYPE_INVALID_CHARS' | 'MEMO_FORMAT_INVALID_CHARS' | 'MEMO_DATA_CONTROL_CHARS' | 'MEMO_TYPE_TOO_LONG' | 'MEMO_FORMAT_TOO_LONG' | 'MEMO_DATA_TOO_LONG';
+export declare class MemoValidationError extends Error {
+    readonly code: MemoErrorCode;
+    constructor(code: MemoErrorCode, message: string);
+}

package/lib/utils/memo/validate.d.ts

@@ -0,0 +1,2 @@
+import { Memo } from './types';
+export declare function validateMemo(memo: Memo): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1money/protocol-ts-sdk",
-  "version": "2.0.2",
+  "version": "2.1.0-beta.0",
   "description": "ts sdk for 1Money protocol network",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -63,7 +63,7 @@
   },
   "peerDependencies": {
     "@ethereumjs/rlp": ">=10.0.0 <11.0.0",
-    "axios": ">=1.12.0 <2.0.0",
+    "axios": ">=1.15.0 <2.0.0",
     "viem": ">=2.0.0 <3.0.0"
   },
   "devDependencies": {
@@ -88,7 +88,7 @@
     "@types/mocha": "10.0.7",
     "@types/node": "~18.19.39",
     "typescript-eslint": "~8.57.1",
-    "axios": "~1.12.0",
+    "axios": "~1.15.1",
     "chai": "4.5.0",
     "cross-env": "^7.0.3",
     "del": "5.1.0",
@@ -125,7 +125,8 @@
       "minimatch@>=9.0.0 <9.0.7": "9.0.7",
       "flatted@<=3.4.1": "3.4.2",
       "serialize-javascript@<=7.0.2": "7.0.4",
-      "basic-ftp@<5.2.0": "5.2.0"
+      "basic-ftp@<5.3.0": "5.3.0",
+      "follow-redirects@<1.16.0": "1.16.0"
     }
   }
 }