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

package/.claude/settings.local.json

@@ -37,15 +37,11 @@
       "Bash(git commit -m \"$\\(cat <<''EOF''\nchore: upgrade mocha to v11 for security fixes\n\nCo-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>\nEOF\n\\)\")",
       "Bash(npx commitlint:*)",
       "Bash(npm run lint:es:*)",
-      "Bash(ls -la /Users/bobbytalvin/Desktop/Github/1money-protocol-ts-sdk/.env*)",
-      "Bash(ls /Users/bobbytalvin/Desktop/Github/1money-protocol-ts-sdk/.env*)",
-      "Bash(git -C /Users/bobbytalvin/Desktop/Github/1money-protocol-ts-sdk log --all --diff-filter=A -- .env*)",
-      "Bash(git -C /Users/bobbytalvin/Desktop/Github/1money-protocol-ts-sdk log --all --oneline -- '.env.integration')",
-      "Bash(git -C /Users/bobbytalvin/Desktop/Github/1money-protocol-ts-sdk show HEAD:.env)",
-      "Bash(git -C /Users/bobbytalvin/Desktop/Github/1money-protocol-ts-sdk show 95cd175:.env.integration)",
       "Bash(pnpm audit *)",
       "Bash(pnpm test *)",
-      "Bash(git checkout *)"
+      "Bash(git checkout *)",
+      "Bash(git *)",
+      "Bash(cargo test *)"
     ],
     "deny": []
   }

package/es/api/index.js

@@ -1,4 +1,4 @@
-import'viem';import'@ethereumjs/rlp';import axios from'axios';function _typeof(ele) {
+import'viem';import'@ethereumjs/rlp';import axios from'axios';new TextEncoder();function _typeof(ele) {
     if (typeof ele !== 'object')
         return (typeof ele).toLowerCase();
     const typeStr = Object.prototype.toString.call(ele);

package/es/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/es/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/es/client/index.js

@@ -1,4 +1,4 @@
-import'viem';import'@ethereumjs/rlp';import axios from'axios';function _typeof(ele) {
+import'viem';import'@ethereumjs/rlp';import axios from'axios';new TextEncoder();function _typeof(ele) {
     if (typeof ele !== 'object')
         return (typeof ele).toLowerCase();
     const typeStr = Object.prototype.toString.call(ele);

package/es/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
@@ -1696,6 +1784,47 @@ function createPreparedTx(params) {
         attachSignature,
         sign: async (signer) => attachSignature(await signer.signDigest(signatureHash)),
     };
+}// Build a `PreparedTx` for any transaction shape:
+// 1. Prepend `[chain_id, nonce]` and the caller's `payloadFields` into one
+//    RLP inner list.
+// 2. Branch on `unsigned.memo`:
+//    - V1 (memo absent): RLP-encode `innerList` directly. Bytes are byte-
+//      identical to the pre-memo SDK. `kind` is `<kindV1>`.
+//    - V2 (memo present): validate the memo, then RLP-encode
+//      `[innerList, memoRlpList(memo)]` — the `WithMemo<T>` envelope shape.
+//      `kind` is `<kindV1>_v2`.
+// 3. Wire the result into `createPreparedTx`.
+//
+// `memo == null` deliberately catches both `null` and `undefined` so untyped
+// JS callers behave the same as strict TypeScript callers (whose declared
+// `Memo | undefined` would only ever produce `undefined`).
+//
+// Builders only need to call validators, construct `payloadFields`, and pass
+// `toRequest`.
+function buildTx(opts) {
+    const innerList = rlpValue.list([
+        rlpValue.uint(opts.unsigned.chain_id),
+        rlpValue.uint(opts.unsigned.nonce),
+        ...opts.payloadFields,
+    ]);
+    const memo = opts.unsigned.memo;
+    let rlpBytes;
+    let kind;
+    if (memo == null) {
+        rlpBytes = encodeRlpPayload(innerList);
+        kind = opts.kind;
+    }
+    else {
+        validateMemo(memo);
+        rlpBytes = encodeRlpPayload(rlpValue.list([innerList, memoRlpList(memo)]));
+        kind = `${opts.kind}_v2`;
+    }
+    return createPreparedTx({
+        kind,
+        unsigned: opts.unsigned,
+        rlpBytes,
+        toRequest: opts.toRequest,
+    });
 }const UINT_STRING_RE = /^\d+$/;
 function fail(name, value) {
     throw new Error(`[1Money SDK]: Invalid ${name}: ${String(value)}`);
@@ -1745,17 +1874,14 @@ function validateValueToken(unsigned) {
 }function preparePaymentTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.address(unsigned.recipient),
-        rlpValue.uint(unsigned.value),
-        rlpValue.address(unsigned.token),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'payment',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.recipient),
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1766,22 +1892,19 @@ function validateValueToken(unsigned) {
     assertAddress('authority_address', unsigned.authority_address);
     assertAddress('token', unsigned.token);
     assertOptionalUintString('value', unsigned.value);
-    const values = [
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
+    const payloadFields = [
         rlpValue.string(unsigned.action),
         rlpValue.string(unsigned.authority_type),
         rlpValue.address(unsigned.authority_address),
         rlpValue.address(unsigned.token),
     ];
     if (unsigned.value !== undefined) {
-        values.push(rlpValue.uint(unsigned.value));
+        payloadFields.push(rlpValue.uint(unsigned.value));
     }
-    const rlpBytes = encodeRlpPayload(rlpValue.list(values));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenAuthority',
         unsigned,
-        rlpBytes,
+        payloadFields,
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1791,20 +1914,17 @@ function validateValueToken(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
     assertPositiveInteger('source_chain_id', unsigned.source_chain_id);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.address(unsigned.recipient),
-        rlpValue.uint(unsigned.value),
-        rlpValue.address(unsigned.token),
-        rlpValue.uint(unsigned.source_chain_id),
-        rlpValue.string(unsigned.source_tx_hash),
-        rlpValue.string(unsigned.bridge_metadata),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenBridgeAndMint',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.recipient),
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+            rlpValue.uint(unsigned.source_chain_id),
+            rlpValue.string(unsigned.source_tx_hash),
+            rlpValue.string(unsigned.bridge_metadata),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1813,16 +1933,13 @@ function validateValueToken(unsigned) {
 }function prepareTokenBurnTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateValueToken(unsigned);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.uint(unsigned.value),
-        rlpValue.address(unsigned.token),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenBurn',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1835,22 +1952,19 @@ function validateValueToken(unsigned) {
     assertPositiveInteger('destination_chain_id', unsigned.destination_chain_id);
     assertAddress('destination_address', unsigned.destination_address);
     assertUintString('escrow_fee', unsigned.escrow_fee);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.address(unsigned.sender),
-        rlpValue.uint(unsigned.value),
-        rlpValue.address(unsigned.token),
-        rlpValue.uint(unsigned.destination_chain_id),
-        rlpValue.string(unsigned.destination_address),
-        rlpValue.uint(unsigned.escrow_fee),
-        rlpValue.string(unsigned.bridge_metadata),
-        rlpValue.hex(unsigned.bridge_param),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenBurnAndBridge',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.sender),
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+            rlpValue.uint(unsigned.destination_chain_id),
+            rlpValue.string(unsigned.destination_address),
+            rlpValue.uint(unsigned.escrow_fee),
+            rlpValue.string(unsigned.bridge_metadata),
+            rlpValue.hex(unsigned.bridge_param),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1860,18 +1974,15 @@ function validateValueToken(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
     assertAddress('from', unsigned.from);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.address(unsigned.token),
-        rlpValue.address(unsigned.from),
-        rlpValue.address(unsigned.recipient),
-        rlpValue.uint(unsigned.value),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenClawback',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.token),
+            rlpValue.address(unsigned.from),
+            rlpValue.address(unsigned.recipient),
+            rlpValue.uint(unsigned.value),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1886,20 +1997,17 @@ function validateValueToken(unsigned) {
         ...unsigned,
         clawback_enabled: clawbackEnabled,
     };
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsignedWithDefaults.chain_id),
-        rlpValue.uint(unsignedWithDefaults.nonce),
-        rlpValue.string(unsignedWithDefaults.symbol),
-        rlpValue.string(unsignedWithDefaults.name),
-        rlpValue.uint(unsignedWithDefaults.decimals),
-        rlpValue.address(unsignedWithDefaults.master_authority),
-        rlpValue.bool(unsignedWithDefaults.is_private),
-        rlpValue.bool(clawbackEnabled),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenIssue',
         unsigned: unsignedWithDefaults,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.string(unsignedWithDefaults.symbol),
+            rlpValue.string(unsignedWithDefaults.name),
+            rlpValue.uint(unsignedWithDefaults.decimals),
+            rlpValue.address(unsignedWithDefaults.master_authority),
+            rlpValue.bool(unsignedWithDefaults.is_private),
+            rlpValue.bool(clawbackEnabled),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1909,17 +2017,14 @@ function validateValueToken(unsigned) {
     validateChainAndNonce(unsigned);
     assertAddress('address', unsigned.address);
     assertAddress('token', unsigned.token);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.string(unsigned.action),
-        rlpValue.address(unsigned.address),
-        rlpValue.address(unsigned.token),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenManageList',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.string(unsigned.action),
+            rlpValue.address(unsigned.address),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1928,22 +2033,16 @@ function validateValueToken(unsigned) {
 }function prepareTokenMetadataTx(unsigned) {
     validateChainAndNonce(unsigned);
     assertAddress('token', unsigned.token);
-    const additionalMetadataRlp = unsigned.additional_metadata.map(item => rlpValue.list([
-        rlpValue.string(item.key),
-        rlpValue.string(item.value),
-    ]));
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.string(unsigned.name),
-        rlpValue.string(unsigned.uri),
-        rlpValue.address(unsigned.token),
-        rlpValue.list(additionalMetadataRlp),
-    ]));
-    return createPreparedTx({
+    const additionalMetadataRlp = unsigned.additional_metadata.map((item) => rlpValue.list([rlpValue.string(item.key), rlpValue.string(item.value)]));
+    return buildTx({
         kind: 'tokenMetadata',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.string(unsigned.name),
+            rlpValue.string(unsigned.uri),
+            rlpValue.address(unsigned.token),
+            rlpValue.list(additionalMetadataRlp),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1952,17 +2051,14 @@ function validateValueToken(unsigned) {
 }function prepareTokenMintTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.address(unsigned.recipient),
-        rlpValue.uint(unsigned.value),
-        rlpValue.address(unsigned.token),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenMint',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.recipient),
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -1971,16 +2067,13 @@ function validateValueToken(unsigned) {
 }function prepareTokenPauseTx(unsigned) {
     validateChainAndNonce(unsigned);
     assertAddress('token', unsigned.token);
-    const rlpBytes = encodeRlpPayload(rlpValue.list([
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
-        rlpValue.string(unsigned.action),
-        rlpValue.address(unsigned.token),
-    ]));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenPause',
         unsigned,
-        rlpBytes,
+        payloadFields: [
+            rlpValue.string(unsigned.action),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: (payload, signature) => ({
             ...payload,
             signature,
@@ -2020,4 +2113,4 @@ function createPrivateKeySigner(privateKey) {
 };var index = {
     api,
     client: client$1,
-};export{TransactionBuilder,_typeof,api,calcSignedTxHash,calcTxHash,client$1 as client,createPreparedTx,createPrivateKeySigner,index as default,deriveTokenAddress,encodePayload,encodeRlpPayload,preparePaymentTx,prepareTokenAuthorityTx,prepareTokenBridgeAndMintTx,prepareTokenBurnAndBridgeTx,prepareTokenBurnTx,prepareTokenClawbackTx,prepareTokenIssueTx,prepareTokenManageListTx,prepareTokenMetadataTx,prepareTokenMintTx,prepareTokenPauseTx,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,TransactionBuilder,_typeof,api,calcSignedTxHash,calcTxHash,client$1 as client,createPreparedTx,createPrivateKeySigner,index as default,deriveTokenAddress,encodePayload,encodeRlpPayload,memoRlpList,preparePaymentTx,prepareTokenAuthorityTx,prepareTokenBridgeAndMintTx,prepareTokenBurnAndBridgeTx,prepareTokenBurnTx,prepareTokenClawbackTx,prepareTokenIssueTx,prepareTokenManageListTx,prepareTokenMetadataTx,prepareTokenMintTx,prepareTokenPauseTx,rlpValue,safePromiseAll,safePromiseLine,signMessage,toHex,validateMemo};

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

@@ -0,0 +1,13 @@
+import { type Memo, type PlpPayload, type Signature } from '../../utils/index.js';
+type UnsignedBase = {
+    chain_id: number;
+    nonce: number;
+    memo?: Memo;
+};
+export declare function buildTx<T extends UnsignedBase, R>(opts: {
+    kind: string;
+    unsigned: T;
+    payloadFields: PlpPayload[];
+    toRequest: (payload: T, signature: Signature) => R;
+}): import("../core").PreparedTx<T, R>;
+export {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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