@1money/protocol-ts-sdk 1.1.2 → 2.0.1

package/es/index.js

@@ -1,4 +1,4 @@
-import {hexToBytes as hexToBytes$1,stringToBytes,keccak256,bytesToHex as bytesToHex$1,numberToHex,stringToHex,boolToHex}from'viem';import {encode}from'@ethereumjs/rlp';import axios from'axios';/**
+import {hexToBytes as hexToBytes$1,stringToBytes,keccak256,bytesToHex as bytesToHex$1,numberToHex,stringToHex,boolToHex,isAddress}from'viem';import {encode,decode}from'@ethereumjs/rlp';import axios from'axios';/**
  * Derives the token account address given the wallet address and mint address.
  *
  * Address is 20 byte, 160 bits. Let's say if we want to support 50 billion
@@ -25,6 +25,81 @@ function deriveTokenAddress(walletAddress, mintAddress) {
     const hashBytes = hexToBytes$1(hashHex);
     const addressBytes = hashBytes.slice(12);
     return bytesToHex$1(addressBytes);
+}const ADDRESS_HEX_RE = /^0x[0-9a-fA-F]{40}$/;
+const BYTES_HEX_RE = /^0x([0-9a-fA-F]{2})*$/;
+function innerEncodeRlpPayload(value) {
+    if (value === null || value === undefined) {
+        return new Uint8Array([]);
+    }
+    switch (value.kind) {
+        case 'string':
+            return new TextEncoder().encode(value.value);
+        case 'uint': {
+            if (typeof value.value === 'string' &&
+                !/^\d+$/.test(value.value)) {
+                throw new Error(`[1Money SDK]: Invalid uint string: ${value.value}`);
+            }
+            const n = typeof value.value === 'bigint'
+                ? value.value
+                : BigInt(value.value);
+            return n === BigInt(0)
+                ? new Uint8Array([])
+                : hexToBytes$1(numberToHex(n));
+        }
+        case 'bool':
+            return value.value
+                ? Uint8Array.from([1])
+                : new Uint8Array([]);
+        case 'bytes':
+            return value.value;
+        case 'list':
+            return value.value.map(v => innerEncodeRlpPayload(v));
+        case 'address':
+        case 'hex':
+            if (!BYTES_HEX_RE.test(value.value)) {
+                throw new Error(`[1Money SDK]: Invalid hex value: ${value.value}`);
+            }
+            if (value.kind === 'address' &&
+                !ADDRESS_HEX_RE.test(value.value)) {
+                throw new Error(`[1Money SDK]: Invalid address value: ${value.value}`);
+            }
+            return value.value === '0x'
+                ? new Uint8Array([])
+                : hexToBytes$1(value.value);
+    }
+}
+const rlpValue = {
+    address: (v) => ({
+        kind: 'address',
+        value: v
+    }),
+    hex: (v) => ({
+        kind: 'hex',
+        value: v
+    }),
+    string: (v) => ({
+        kind: 'string',
+        value: v
+    }),
+    uint: (v) => ({
+        kind: 'uint',
+        value: v
+    }),
+    bool: (v) => ({
+        kind: 'bool',
+        value: v
+    }),
+    bytes: (v) => ({
+        kind: 'bytes',
+        value: v
+    }),
+    list: (v) => ({
+        kind: 'list',
+        value: v
+    })
+};
+function encodeRlpPayload(payload) {
+    return encode(innerEncodeRlpPayload(payload));
 }// concurrent
 function safePromiseAll(arr) {
     // @ts-expect-error
@@ -46,11 +121,6 @@ async function safePromiseLine(arr) {
         }
     }
     return res;
-}function _typeof(ele) {
-    if (typeof ele !== 'object')
-        return (typeof ele).toLowerCase();
-    const typeStr = Object.prototype.toString.call(ele);
-    return typeStr.slice(8, typeStr.length - 1).toLowerCase();
 }/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
 /**
  * 4KB JS implementation of secp256k1 ECDSA / Schnorr signatures & ECDH.
@@ -706,8 +776,15 @@ const wNAF = (n) => {
         }
     }
     return { p, f }; // return both real and fake points for JIT
-};/**
+};function _typeof(ele) {
+    if (typeof ele !== 'object')
+        return (typeof ele).toLowerCase();
+    const typeStr = Object.prototype.toString.call(ele);
+    return typeStr.slice(8, typeStr.length - 1).toLowerCase();
+}/**
  * RLP encode a payload into a digest
+ * @deprecated Prefer the TransactionBuilder flow in `src/signing`
+ * (`prepare*Tx` + `.sign(...)`) to build and sign transactions.
  * @param payload Payload to encode
  * @returns RLP encoded payload
  */
@@ -715,9 +792,9 @@ function encodePayload(payload) {
     if (_typeof(payload) === 'array') {
         const formatted = payload.map((v) => {
             if (_typeof(v) === 'string') {
-                if (/^0x[0-9a-fA-F]+$/.test(v)) {
+                if (/^0x([0-9a-fA-F]{2})*$/.test(v)) {
                     // hex-encoded data → raw bytes
-                    return hexToBytes$1(v);
+                    return v === '0x' ? new Uint8Array([]) : hexToBytes$1(v);
                 }
                 else if (/^\d+$/.test(v)) {
                     // number-like string → hex → bytes
@@ -749,6 +826,9 @@ function encodePayload(payload) {
 }
 /**
  * Sign a message using the provided private key
+ * @deprecated Prefer the TransactionBuilder flow in `src/signing`
+ * (`prepare*Tx` + `.sign(createPrivateKeySigner(privateKey))`)
+ * for transaction signing.
  * @param payload Payload to sign
  * @param privateKey Private key to sign with
  * @returns Signature object with r, s, v components
@@ -809,7 +889,7 @@ function toHex(value) {
         }
     }
     catch (e) {
-        console.error('[1Money toHex]: ', e);
+        console.error('[1Money SDK]: toHex error:', e);
         return '0x';
     }
 }function encodeRlpListHeader(length) {
@@ -890,7 +970,7 @@ function calcTxHash(payload, signature) {
             this._restScope = scope || this._restScope;
             // @ts-ignore
             if (this._restScope.length === 0) {
-                console.warn('[1Money client]: The ".rest(cb, scope)" scope is empty and will never be triggered!');
+                console.warn('[1Money SDK]: The ".rest(cb, scope)" scope is empty and will never be triggered!');
             }
             else {
                 let deletedCounter = 0;
@@ -905,7 +985,7 @@ function calcTxHash(payload, signature) {
                     }
                 });
                 if (deletedCounter === this._restScope.length) {
-                    console.warn(`[1Money client]: The "${this._restScope.join(', ')}" had been called and the "rest" will never be triggered!`);
+                    console.warn(`[1Money SDK]: The "${this._restScope.join(', ')}" had been called and the "rest" will never be triggered!`);
                 }
             }
             return wrapper;
@@ -952,9 +1032,26 @@ class Request {
             data
         };
     }
+    mergeSignals(...signals) {
+        const controller = new AbortController();
+        const onAbort = () => controller.abort();
+        const cleanups = [];
+        for (const signal of signals) {
+            if (signal.aborted) {
+                controller.abort();
+                break;
+            }
+            signal.addEventListener('abort', onAbort);
+            cleanups.push(() => signal.removeEventListener('abort', onAbort));
+        }
+        return {
+            signal: controller.signal,
+            cleanup: () => cleanups.forEach(fn => fn()),
+        };
+    }
     setting(config) {
         if (!config)
-            return console.warn('[1Money client]: setting method required correct parameters!');
+            return console.warn('[1Money SDK]: setting method required correct parameters!');
         this._config = { ...this._config, ...config };
     }
     request(options) {
@@ -1052,18 +1149,33 @@ class Request {
             let timer = null;
             let isTimeout = false;
             const _timeout = timeout ?? initTimeout;
+            const controller = new AbortController();
+            let signalCleanup = null;
+            if (options.signal) {
+                const merged = this.mergeSignals(options.signal, controller.signal);
+                options.signal = merged.signal;
+                signalCleanup = merged.cleanup;
+            }
+            else {
+                options.signal = controller.signal;
+            }
             // Cleanup function for timeout
             const cleanup = () => {
                 if (timer !== null) {
                     clearTimeout(timer);
                     timer = null;
                 }
+                if (signalCleanup) {
+                    signalCleanup();
+                    signalCleanup = null;
+                }
             };
             if (_timeout) {
                 timer = setTimeout(async () => {
                     try {
                         isTimeout = true;
                         cleanup();
+                        controller.abort();
                         let err = this.parseError('timeout');
                         // @ts-ignore
                         const res = await Promise.resolve(callbacks.timeout(err, options.headers ?? {}));
@@ -1110,7 +1222,7 @@ class Request {
                     return;
                 cleanup();
                 const data = err.response?.data ?? {};
-                console.error(`[1Money client]: Error(${err.status ?? 500}, ${err.code ?? 'UNKNOWN'}), Message: ${err.message}, Config: ${err.config?.method}, ${err.config?.baseURL ?? ''}, ${err.config?.url ?? ''}, ${JSON.stringify(err.config?.headers ?? {})}, Request: ${JSON.stringify(err.config?.data ?? {})}, Response: ${JSON.stringify(data)};`);
+                console.error(`[1Money SDK]: Error(${err.status ?? 500}, ${err.code ?? 'UNKNOWN'}), Message: ${err.message}, Config: ${err.config?.method}, ${err.config?.baseURL ?? ''}, ${err.config?.url ?? ''}, ${JSON.stringify(err.config?.headers ?? {})}, Request: ${JSON.stringify(err.config?.data ?? {})}, Response: ${JSON.stringify(data)};`);
                 const status = err.response?.status ?? 500;
                 const headers = err.response?.headers ?? {};
                 try {
@@ -1389,6 +1501,14 @@ const tokensApi = {
      */
     burnAndBridge: (payload) => {
         return post(`${API_PREFIX$2}/burn_and_bridge`, payload, { withCredentials: false });
+    },
+    /**
+     * Claw back tokens from a wallet
+     * @param payload Token clawback request payload
+     * @returns Promise with transaction hash response
+     */
+    clawbackToken: (payload) => {
+        return post(`${API_PREFIX$2}/clawback`, payload, { withCredentials: false });
     }
 };const API_PREFIX$1 = `/${API_VERSION}/transactions`;
 /**
@@ -1422,15 +1542,13 @@ const transactionsApi = {
     /**
      * Estimate transaction fee
      * @param from Address of the transaction author
+     * @param to Address of the transaction recipient
      * @param value Value of the transaction
-     * @param token Optional token address
+     * @param token Token address
      * @returns Promise with fee estimate response
      */
-    estimateFee: (from, value, token) => {
-        let url = `${API_PREFIX$1}/estimate_fee?from=${from}&value=${value}`;
-        if (token) {
-            url += `&token=${token}`;
-        }
+    estimateFee: (from, to, value, token) => {
+        const url = `${API_PREFIX$1}/estimate_fee?from=${from}&value=${value}&to=${to}&token=${token}`;
         return get(url, { withCredentials: false });
     },
     /**
@@ -1462,6 +1580,7 @@ var AuthorityType;
     AuthorityType["ManageList"] = "ManageList";
     AuthorityType["UpdateMetadata"] = "UpdateMetadata";
     AuthorityType["Bridge"] = "Bridge";
+    AuthorityType["Clawback"] = "Clawback";
 })(AuthorityType || (AuthorityType = {}));
 var AuthorityAction;
 (function (AuthorityAction) {
@@ -1528,7 +1647,379 @@ function api(options) {
          */
         chain: chainApi,
     };
-}var index = {
+}// secp256k1 curve order / 2 (maximum value for low-S signatures)
+// This prevents signature malleability by ensuring S is in the lower half of the curve order
+const SECP256K1_N_DIV_2 = BigInt('0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0');
+function validateSignature(signature) {
+    // Validate that S value is in the lower half of the curve order
+    // This prevents signature malleability attacks
+    const s = BigInt(signature.s);
+    if (s > SECP256K1_N_DIV_2) {
+        throw new Error('[1Money SDK]: Invalid signature - high S value detected (potential malleability)');
+    }
+}
+function calcSignedTxHash(payloadRlpBytes, signature) {
+    // Decode the payload to get the transaction fields
+    const payloadFields = decode(payloadRlpBytes);
+    // Prepare v value based on its type
+    const v = typeof signature.v === 'boolean'
+        ? signature.v
+            ? Uint8Array.from([1])
+            : new Uint8Array([])
+        : BigInt(signature.v);
+    // Use library's encode to create the signed transaction structure: [[fields], v, r, s]
+    const encoded = encode([
+        payloadFields,
+        v,
+        hexToBytes$1(signature.r),
+        hexToBytes$1(signature.s),
+    ]);
+    return keccak256(encoded);
+}
+function createPreparedTx(params) {
+    const signatureHash = keccak256(params.rlpBytes);
+    const attachSignature = (signature) => {
+        // Validate signature to prevent malleability attacks
+        validateSignature(signature);
+        return {
+            kind: params.kind,
+            unsigned: params.unsigned,
+            signatureHash,
+            txHash: calcSignedTxHash(params.rlpBytes, signature),
+            signature,
+            toRequest: () => params.toRequest(params.unsigned, signature),
+        };
+    };
+    return {
+        kind: params.kind,
+        unsigned: params.unsigned,
+        rlpBytes: params.rlpBytes,
+        signatureHash,
+        attachSignature,
+        sign: async (signer) => attachSignature(await signer.signDigest(signatureHash)),
+    };
+}const UINT_STRING_RE = /^\d+$/;
+function fail(name, value) {
+    throw new Error(`[1Money SDK]: Invalid ${name}: ${String(value)}`);
+}
+function assertPositiveInteger(name, value) {
+    if (!Number.isSafeInteger(value) ||
+        value <= 0) {
+        fail(name, value);
+    }
+}
+function assertNonNegativeInteger(name, value) {
+    if (!Number.isSafeInteger(value) ||
+        value < 0) {
+        fail(name, value);
+    }
+}
+function assertUintString(name, value) {
+    if (!UINT_STRING_RE.test(value)) {
+        fail(name, value);
+    }
+}
+function assertOptionalUintString(name, value) {
+    if (value === undefined)
+        return;
+    assertUintString(name, value);
+}
+function assertAddress(name, value) {
+    // viem's isAddress validates both format and EIP-55 checksum
+    // It accepts: lowercase, uppercase, and correctly checksummed addresses
+    // It rejects: invalid format or incorrect checksum (when mixed case is used)
+    if (!isAddress(value)) {
+        fail(name, value);
+    }
+}
+function validateChainAndNonce(unsigned) {
+    assertPositiveInteger('chain_id', unsigned.chain_id);
+    assertNonNegativeInteger('nonce', unsigned.nonce);
+}
+function validateRecipientValueToken(unsigned) {
+    assertAddress('recipient', unsigned.recipient);
+    assertUintString('value', unsigned.value);
+    assertAddress('token', unsigned.token);
+}
+function validateValueToken(unsigned) {
+    assertUintString('value', unsigned.value);
+    assertAddress('token', unsigned.token);
+}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({
+        kind: 'payment',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}function prepareTokenAuthorityTx(unsigned) {
+    validateChainAndNonce(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),
+        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));
+    }
+    const rlpBytes = encodeRlpPayload(rlpValue.list(values));
+    return createPreparedTx({
+        kind: 'tokenAuthority',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}function prepareTokenBridgeAndMintTx(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({
+        kind: 'tokenBridgeAndMint',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}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({
+        kind: 'tokenBurn',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}function prepareTokenBurnAndBridgeTx(unsigned) {
+    validateChainAndNonce(unsigned);
+    assertAddress('sender', unsigned.sender);
+    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({
+        kind: 'tokenBurnAndBridge',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}function prepareTokenClawbackTx(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({
+        kind: 'tokenClawback',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}function prepareTokenIssueTx(unsigned) {
+    validateChainAndNonce(unsigned);
+    assertNonNegativeInteger('decimals', unsigned.decimals);
+    assertAddress('master_authority', unsigned.master_authority);
+    const clawbackEnabled = unsigned.clawback_enabled ?? true;
+    const unsignedWithDefaults = {
+        ...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({
+        kind: 'tokenIssue',
+        unsigned: unsignedWithDefaults,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}function prepareTokenManageListTx(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({
+        kind: 'tokenManageList',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}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({
+        kind: 'tokenMetadata',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}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({
+        kind: 'tokenMint',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}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({
+        kind: 'tokenPause',
+        unsigned,
+        rlpBytes,
+        toRequest: (payload, signature) => ({
+            ...payload,
+            signature,
+        }),
+    });
+}const DIGEST_HEX_RE = /^0x[0-9a-fA-F]{64}$/;
+function createPrivateKeySigner(privateKey) {
+    const privateKeyBytes = hexToBytes$1(privateKey);
+    return {
+        signDigest: async (digest) => {
+            if (!DIGEST_HEX_RE.test(digest)) {
+                throw new Error(`[1Money SDK]: Invalid digest: ${digest}`);
+            }
+            const signature = await signAsync(hexToBytes$1(digest), privateKeyBytes, { lowS: true });
+            const compact = signature.toCompactRawBytes();
+            const rBytes = compact.subarray(0, 32);
+            const sBytes = compact.subarray(32, 64);
+            return {
+                r: bytesToHex$1(rBytes),
+                s: bytesToHex$1(sBytes),
+                v: signature.recovery,
+            };
+        },
+    };
+}const TransactionBuilder = {
+    payment: preparePaymentTx,
+    tokenManageList: prepareTokenManageListTx,
+    tokenBurn: prepareTokenBurnTx,
+    tokenAuthority: prepareTokenAuthorityTx,
+    tokenIssue: prepareTokenIssueTx,
+    tokenMint: prepareTokenMintTx,
+    tokenPause: prepareTokenPauseTx,
+    tokenMetadata: prepareTokenMetadataTx,
+    tokenBridgeAndMint: prepareTokenBridgeAndMintTx,
+    tokenBurnAndBridge: prepareTokenBurnAndBridgeTx,
+    tokenClawback: prepareTokenClawbackTx,
+};var index = {
     api,
     client: client$1,
-};export{_typeof,api,calcTxHash,client$1 as client,index as default,deriveTokenAddress,encodePayload,safePromiseAll,safePromiseLine,signMessage,toHex};
+};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};

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

@@ -0,0 +1,11 @@
+export * from './payment';
+export * from './tokenAuthority';
+export * from './tokenBridgeAndMint';
+export * from './tokenBurn';
+export * from './tokenBurnAndBridge';
+export * from './tokenClawback';
+export * from './tokenIssue';
+export * from './tokenManageList';
+export * from './tokenMetadata';
+export * from './tokenMint';
+export * from './tokenPause';

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

@@ -0,0 +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>;

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

@@ -0,0 +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>;

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

@@ -0,0 +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>;

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

@@ -0,0 +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>;

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

@@ -0,0 +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>;