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

package/es/signing/builders/tokenMint.d.ts

@@ -1,3 +1,3 @@
 import type { TokenMintPayload } from '../../api/tokens/types';
 export type TokenMintUnsigned = Omit<TokenMintPayload, 'signature'>;
-export declare function prepareTokenMintTx(unsigned: TokenMintUnsigned): import("../core").PreparedTx<TokenMintUnsigned, TokenMintPayload>;
+export declare function prepareTokenMintTx(unsigned: TokenMintUnsigned): import("..").PreparedTx<TokenMintUnsigned, TokenMintPayload>;

package/es/signing/builders/tokenPause.d.ts

@@ -1,3 +1,3 @@
 import type { TokenPausePayload } from '../../api/tokens/types';
 export type TokenPauseUnsigned = Omit<TokenPausePayload, 'signature'>;
-export declare function prepareTokenPauseTx(unsigned: TokenPauseUnsigned): import("../core").PreparedTx<TokenPauseUnsigned, TokenPausePayload>;
+export declare function prepareTokenPauseTx(unsigned: TokenPauseUnsigned): import("..").PreparedTx<TokenPauseUnsigned, TokenPausePayload>;

package/es/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './address';
 export * from './encode';
+export * from './memo';
 export * from './safePromise';
 export * from './sign';
 export * from './txHash';

package/es/utils/index.js

@@ -100,6 +100,94 @@ const rlpValue = {
 };
 function encodeRlpPayload(payload) {
     return encode(innerEncodeRlpPayload(payload));
+}const MEMO_TYPE_MAX_BYTES = 128;
+const MEMO_FORMAT_MAX_BYTES = 64;
+const 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.
+const 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.
+const MEMO_RLP_HEADER_ALLOWANCE = 16;
+class MemoValidationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'MemoValidationError';
+    }
+}const enc = new TextEncoder();
+// RFC 3986 unreserved + gen-delims + sub-delims + percent. Matches
+// `is_url_safe` in `om-primitives-types/.../memo.rs`.
+const 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) {
+    return (utf8Len(memo.type ?? '') +
+        utf8Len(memo.format ?? '') +
+        utf8Len(memo.data ?? '') +
+        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) {
+    const t = memo.type ?? '';
+    if (t.length > 0) {
+        const len = utf8Len(t);
+        if (len > MEMO_TYPE_MAX_BYTES) {
+            throw new MemoValidationError('MEMO_TYPE_TOO_LONG', `memo.type exceeds ${MEMO_TYPE_MAX_BYTES} bytes (got ${len})`);
+        }
+        if (!URL_SAFE_RE.test(t)) {
+            throw new MemoValidationError('MEMO_TYPE_INVALID_CHARS', 'memo.type contains non-URL-safe characters');
+        }
+    }
+    const f = memo.format ?? '';
+    if (f.length > 0) {
+        const len = utf8Len(f);
+        if (len > MEMO_FORMAT_MAX_BYTES) {
+            throw new MemoValidationError('MEMO_FORMAT_TOO_LONG', `memo.format exceeds ${MEMO_FORMAT_MAX_BYTES} bytes (got ${len})`);
+        }
+        if (!URL_SAFE_RE.test(f)) {
+            throw new MemoValidationError('MEMO_FORMAT_INVALID_CHARS', 'memo.format contains non-URL-safe characters');
+        }
+    }
+    const d = memo.data ?? '';
+    if (d.length > 0) {
+        const len = utf8Len(d);
+        if (len > MEMO_DATA_MAX_BYTES) {
+            throw new MemoValidationError('MEMO_DATA_TOO_LONG', `memo.data exceeds ${MEMO_DATA_MAX_BYTES} bytes (got ${len})`);
+        }
+        // Reject NUL and any C0/C1 control codepoint (Unicode general category
+        // Cc). Rust's check is `c == '\0' || c.is_control()`.
+        for (const ch of d) {
+            const 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');
+            }
+        }
+    }
+    const total = byteSize(memo);
+    if (total > MEMO_TOTAL_MAX_BYTES) {
+        throw new MemoValidationError('MEMO_TOO_LARGE', `memo object exceeds ${MEMO_TOTAL_MAX_BYTES} bytes (got ${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) {
+    return rlpValue.list([
+        rlpValue.string(memo.type ?? ''),
+        rlpValue.string(memo.format ?? ''),
+        rlpValue.string(memo.data ?? ''),
+    ]);
 }// concurrent
 function safePromiseAll(arr) {
     // @ts-expect-error
@@ -926,4 +1014,4 @@ function calcTxHash(payload, signature) {
     encoded.set(pEncode, header.length);
     encoded.set(vrsBytes, header.length + pEncode.length);
     return keccak256(encoded);
-}export{_typeof,calcTxHash,deriveTokenAddress,encodePayload,encodeRlpPayload,rlpValue,safePromiseAll,safePromiseLine,signMessage,toHex};
+}export{MEMO_DATA_MAX_BYTES,MEMO_FORMAT_MAX_BYTES,MEMO_RLP_HEADER_ALLOWANCE,MEMO_TOTAL_MAX_BYTES,MEMO_TYPE_MAX_BYTES,MemoValidationError,_typeof,calcTxHash,deriveTokenAddress,encodePayload,encodeRlpPayload,memoRlpList,rlpValue,safePromiseAll,safePromiseLine,signMessage,toHex,validateMemo};

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

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

package/es/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/es/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/es/utils/memo/validate.d.ts

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

package/lib/api/index.js

@@ -14,6 +14,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 __());
+}
 
 var __assign = function() {
     __assign = Object.assign || function __assign(t) {
@@ -79,7 +93,16 @@ function __generator(thisArg, body) {
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};function _typeof(ele) {
+};/** @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));new TextEncoder();function _typeof(ele) {
     if (typeof ele !== 'object')
         return (typeof ele).toLowerCase();
     var typeStr = Object.prototype.toString.call(ele);

package/lib/api/tokens/types.d.ts

@@ -1,5 +1,5 @@
 import type { AddressSchema, BytesSchema, U256Schema } from '../types';
-import type { Signature } from '../../utils/index.js';
+import type { Memo, Signature } from '../../utils/index.js';
 export interface MetaDataKeyValuePair {
     key: string;
     value: string;
@@ -65,6 +65,8 @@ export interface TokenManageListPayload {
     address: string;
     token: string;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenBurnPayload {
     chain_id: number;
@@ -72,6 +74,8 @@ export interface TokenBurnPayload {
     value: string;
     token: string;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenAuthorityPayload {
     chain_id: number;
@@ -82,6 +86,8 @@ export interface TokenAuthorityPayload {
     token: string;
     value?: string;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenIssuePayload {
     chain_id: number;
@@ -96,6 +102,8 @@ export interface TokenIssuePayload {
      */
     clawback_enabled?: boolean;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenMintPayload {
     chain_id: number;
@@ -104,6 +112,8 @@ export interface TokenMintPayload {
     value: string;
     token: string;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenPausePayload {
     chain_id: number;
@@ -111,6 +121,8 @@ export interface TokenPausePayload {
     action: PauseAction;
     token: string;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenMetadataPayload {
     chain_id: number;
@@ -120,6 +132,8 @@ export interface TokenMetadataPayload {
     token: string;
     additional_metadata: KeyValuePair[];
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenBridgeAndMintPayload {
     chain_id: number;
@@ -131,6 +145,8 @@ export interface TokenBridgeAndMintPayload {
     source_tx_hash: string;
     bridge_metadata: string;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenBurnAndBridgePayload {
     chain_id: number;
@@ -144,6 +160,8 @@ export interface TokenBurnAndBridgePayload {
     bridge_metadata: string;
     bridge_param: BytesSchema;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }
 export interface TokenClawbackPayload {
     chain_id: number;
@@ -153,4 +171,6 @@ export interface TokenClawbackPayload {
     recipient: string;
     value: string;
     signature: RestSignature;
+    /** Optional transaction memo (see PaymentPayload.memo). */
+    memo?: Memo;
 }

package/lib/api/transactions/types.d.ts

@@ -1,5 +1,6 @@
 import { AuthorityType, RestSignature } from '../tokens/types';
 import type { AddressSchema, B256Schema, BytesSchema } from '../types';
+import type { Memo } from '../../utils/index.js';
 export interface TransactionReceipt {
     success: boolean;
     transaction_hash: B256Schema;
@@ -24,6 +25,13 @@ export interface PaymentPayload {
     value: string;
     token: AddressSchema;
     signature: RestSignature;
+    /**
+     * Optional transaction memo. When present (even with empty subfields),
+     * the request is routed to the V2 envelope variant on-chain and the
+     * client MUST sign over the WithMemo<PaymentPayload> RLP shape.
+     * When omitted/undefined, the request takes the legacy V1 path.
+     */
+    memo?: Memo;
 }
 export interface TokenCreateData {
     decimals: number;
@@ -127,6 +135,12 @@ interface BaseTransaction {
         s: string;
         v: number;
     };
+    /**
+     * Signed memo attached to the transaction. Populated only for V2
+     * (memo-bearing) envelope variants; omitted when the transaction was
+     * a legacy variant.
+     */
+    memo?: Memo;
 }
 export type Transaction = (BaseTransaction & {
     transaction_type: 'TokenCreate';

package/lib/client/index.js

@@ -14,6 +14,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 __());
+}
 
 var __assign = function() {
     __assign = Object.assign || function __assign(t) {
@@ -79,7 +93,16 @@ function __generator(thisArg, body) {
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};function _typeof(ele) {
+};/** @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));new TextEncoder();function _typeof(ele) {
     if (typeof ele !== 'object')
         return (typeof ele).toLowerCase();
     var typeStr = Object.prototype.toString.call(ele);