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

package/lib/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) {
@@ -191,6 +205,100 @@ var rlpValue = {
 };
 function encodeRlpPayload(payload) {
     return rlp.encode(innerEncodeRlpPayload(payload));
+}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
@@ -1813,6 +1921,46 @@ function createPreparedTx(params) {
             });
         }); },
     };
+}// 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) {
+    var innerList = rlpValue.list(__spreadArray([
+        rlpValue.uint(opts.unsigned.chain_id),
+        rlpValue.uint(opts.unsigned.nonce)
+    ], opts.payloadFields, true));
+    var memo = opts.unsigned.memo;
+    var rlpBytes;
+    var kind;
+    if (memo == null) {
+        rlpBytes = encodeRlpPayload(innerList);
+        kind = opts.kind;
+    }
+    else {
+        validateMemo(memo);
+        rlpBytes = encodeRlpPayload(rlpValue.list([innerList, memoRlpList(memo)]));
+        kind = "".concat(opts.kind, "_v2");
+    }
+    return createPreparedTx({
+        kind: kind,
+        unsigned: opts.unsigned,
+        rlpBytes: rlpBytes,
+        toRequest: opts.toRequest,
+    });
 }var UINT_STRING_RE = /^\d+$/;
 function fail(name, value) {
     throw new Error("[1Money SDK]: Invalid ".concat(name, ": ").concat(String(value)));
@@ -1862,17 +2010,14 @@ function validateValueToken(unsigned) {
 }function preparePaymentTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
-    var 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: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.recipient),
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenAuthorityTx(unsigned) {
@@ -1880,57 +2025,48 @@ function validateValueToken(unsigned) {
     assertAddress('authority_address', unsigned.authority_address);
     assertAddress('token', unsigned.token);
     assertOptionalUintString('value', unsigned.value);
-    var values = [
-        rlpValue.uint(unsigned.chain_id),
-        rlpValue.uint(unsigned.nonce),
+    var 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));
     }
-    var rlpBytes = encodeRlpPayload(rlpValue.list(values));
-    return createPreparedTx({
+    return buildTx({
         kind: 'tokenAuthority',
         unsigned: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: payloadFields,
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenBridgeAndMintTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
     assertPositiveInteger('source_chain_id', unsigned.source_chain_id);
-    var 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: unsigned,
-        rlpBytes: 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: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenBurnTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateValueToken(unsigned);
-    var 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: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: [
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenBurnAndBridgeTx(unsigned) {
@@ -1940,40 +2076,34 @@ function validateValueToken(unsigned) {
     assertPositiveInteger('destination_chain_id', unsigned.destination_chain_id);
     assertAddress('destination_address', unsigned.destination_address);
     assertUintString('escrow_fee', unsigned.escrow_fee);
-    var 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: unsigned,
-        rlpBytes: 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: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenClawbackTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
     assertAddress('from', unsigned.from);
-    var 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: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.token),
+            rlpValue.address(unsigned.from),
+            rlpValue.address(unsigned.recipient),
+            rlpValue.uint(unsigned.value),
+        ],
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenIssueTx(unsigned) {
@@ -1983,91 +2113,73 @@ function validateValueToken(unsigned) {
     assertAddress('master_authority', unsigned.master_authority);
     var clawbackEnabled = (_a = unsigned.clawback_enabled) !== null && _a !== void 0 ? _a : true;
     var unsignedWithDefaults = __assign(__assign({}, unsigned), { clawback_enabled: clawbackEnabled });
-    var 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: 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: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenManageListTx(unsigned) {
     validateChainAndNonce(unsigned);
     assertAddress('address', unsigned.address);
     assertAddress('token', unsigned.token);
-    var 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: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: [
+            rlpValue.string(unsigned.action),
+            rlpValue.address(unsigned.address),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenMetadataTx(unsigned) {
     validateChainAndNonce(unsigned);
     assertAddress('token', unsigned.token);
     var additionalMetadataRlp = unsigned.additional_metadata.map(function (item) {
-        return rlpValue.list([
-            rlpValue.string(item.key),
-            rlpValue.string(item.value),
-        ]);
+        return rlpValue.list([rlpValue.string(item.key), rlpValue.string(item.value)]);
     });
-    var 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({
+    return buildTx({
         kind: 'tokenMetadata',
         unsigned: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: [
+            rlpValue.string(unsigned.name),
+            rlpValue.string(unsigned.uri),
+            rlpValue.address(unsigned.token),
+            rlpValue.list(additionalMetadataRlp),
+        ],
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenMintTx(unsigned) {
     validateChainAndNonce(unsigned);
     validateRecipientValueToken(unsigned);
-    var 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: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: [
+            rlpValue.address(unsigned.recipient),
+            rlpValue.uint(unsigned.value),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }function prepareTokenPauseTx(unsigned) {
     validateChainAndNonce(unsigned);
     assertAddress('token', unsigned.token);
-    var 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: unsigned,
-        rlpBytes: rlpBytes,
+        payloadFields: [
+            rlpValue.string(unsigned.action),
+            rlpValue.address(unsigned.token),
+        ],
         toRequest: function (payload, signature) { return (__assign(__assign({}, payload), { signature: signature })); },
     });
 }var DIGEST_HEX_RE = /^0x[0-9a-fA-F]{64}$/;
@@ -2113,4 +2225,4 @@ function createPrivateKeySigner(privateKey) {
 };var index = {
     api: api,
     client: client$1,
-};exports.TransactionBuilder=TransactionBuilder;exports._typeof=_typeof;exports.api=api;exports.calcSignedTxHash=calcSignedTxHash;exports.calcTxHash=calcTxHash;exports.client=client$1;exports.createPreparedTx=createPreparedTx;exports.createPrivateKeySigner=createPrivateKeySigner;exports.default=index;exports.deriveTokenAddress=deriveTokenAddress;exports.encodePayload=encodePayload;exports.encodeRlpPayload=encodeRlpPayload;exports.preparePaymentTx=preparePaymentTx;exports.prepareTokenAuthorityTx=prepareTokenAuthorityTx;exports.prepareTokenBridgeAndMintTx=prepareTokenBridgeAndMintTx;exports.prepareTokenBurnAndBridgeTx=prepareTokenBurnAndBridgeTx;exports.prepareTokenBurnTx=prepareTokenBurnTx;exports.prepareTokenClawbackTx=prepareTokenClawbackTx;exports.prepareTokenIssueTx=prepareTokenIssueTx;exports.prepareTokenManageListTx=prepareTokenManageListTx;exports.prepareTokenMetadataTx=prepareTokenMetadataTx;exports.prepareTokenMintTx=prepareTokenMintTx;exports.prepareTokenPauseTx=prepareTokenPauseTx;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.TransactionBuilder=TransactionBuilder;exports._typeof=_typeof;exports.api=api;exports.calcSignedTxHash=calcSignedTxHash;exports.calcTxHash=calcTxHash;exports.client=client$1;exports.createPreparedTx=createPreparedTx;exports.createPrivateKeySigner=createPrivateKeySigner;exports.default=index;exports.deriveTokenAddress=deriveTokenAddress;exports.encodePayload=encodePayload;exports.encodeRlpPayload=encodeRlpPayload;exports.memoRlpList=memoRlpList;exports.preparePaymentTx=preparePaymentTx;exports.prepareTokenAuthorityTx=prepareTokenAuthorityTx;exports.prepareTokenBridgeAndMintTx=prepareTokenBridgeAndMintTx;exports.prepareTokenBurnAndBridgeTx=prepareTokenBurnAndBridgeTx;exports.prepareTokenBurnTx=prepareTokenBurnTx;exports.prepareTokenClawbackTx=prepareTokenClawbackTx;exports.prepareTokenIssueTx=prepareTokenIssueTx;exports.prepareTokenManageListTx=prepareTokenManageListTx;exports.prepareTokenMetadataTx=prepareTokenMetadataTx;exports.prepareTokenMintTx=prepareTokenMintTx;exports.prepareTokenPauseTx=prepareTokenPauseTx;exports.rlpValue=rlpValue;exports.safePromiseAll=safePromiseAll;exports.safePromiseLine=safePromiseLine;exports.signMessage=signMessage;exports.toHex=toHex;exports.validateMemo=validateMemo;

package/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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>;

package/lib/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/lib/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/lib/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';