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

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

@@ -1,5 +1,5 @@
 import { AuthorityType, RestSignature } from '../tokens/types';
-import { AddressSchema, B256Schema } from '../types';
+import type { AddressSchema, B256Schema, BytesSchema } from '../types';
 export interface TransactionReceipt {
     success: boolean;
     transaction_hash: B256Schema;
@@ -71,18 +71,24 @@ export interface TokenBridgeAndMintData {
     value: string;
 }
 export interface TokenBurnData {
-    recipient: AddressSchema;
     token: AddressSchema;
     value: string;
 }
 export interface TokenBurnAndBridgeData {
-    bridge_metadata: string | null;
-    destination_address: AddressSchema;
+    value: string;
+    sender: AddressSchema;
     destination_chain_id: number;
+    destination_address: AddressSchema;
     escrow_fee: string;
-    sender: AddressSchema;
+    bridge_metadata: string | null;
+    bridge_param: BytesSchema;
     token: AddressSchema;
+}
+export interface TokenClawbackData {
+    from: AddressSchema;
+    recipient: AddressSchema;
     value: string;
+    token: AddressSchema;
 }
 export interface TokenCloseAccountData {
     token: AddressSchema;
@@ -152,6 +158,9 @@ export type Transaction = (BaseTransaction & {
 }) | (BaseTransaction & {
     transaction_type: 'TokenBurnAndBridge';
     data: TokenBurnAndBridgeData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenClawback';
+    data: TokenClawbackData;
 }) | (BaseTransaction & {
     transaction_type: 'TokenCloseAccount';
     data: TokenCloseAccountData;

package/es/client/index.js

@@ -46,7 +46,7 @@ import'viem';import'@ethereumjs/rlp';import axios from'axios';function _typeof(e
             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;
@@ -61,7 +61,7 @@ import'viem';import'@ethereumjs/rlp';import axios from'axios';function _typeof(e
                     }
                 });
                 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;
@@ -110,7 +110,7 @@ class Request {
     }
     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) {
@@ -266,7 +266,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 {

package/es/index.d.ts

@@ -1,6 +1,7 @@
 import { api } from './api/index.js';
 export { api } from './api/index.js';
 export { default as client } from './client/index.js';
+export * from './signing';
 export * from './utils/index.js';
 export type { AxiosStatic } from 'axios';
 export type { InitConfig, Options, ParsedError, PromiseWrapper } from './client/core';

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;
@@ -954,7 +1034,7 @@ class Request {
     }
     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) {
@@ -1110,7 +1190,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 +1469,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 +1510,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 +1548,7 @@ var AuthorityType;
     AuthorityType["ManageList"] = "ManageList";
     AuthorityType["UpdateMetadata"] = "UpdateMetadata";
     AuthorityType["Bridge"] = "Bridge";
+    AuthorityType["Clawback"] = "Clawback";
 })(AuthorityType || (AuthorityType = {}));
 var AuthorityAction;
 (function (AuthorityAction) {
@@ -1528,7 +1615,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};