@dynamic-labs-wallet/node-tron 0.0.0 → 1.1.42

package/package.json

@@ -1 +1,36 @@
-{ "name": "@dynamic-labs-wallet/node-tron", "version": "0.0.0" }
+{
+  "name": "@dynamic-labs-wallet/node-tron",
+  "version": "1.1.42",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@dynamic-labs-wallet/node": "1.1.42",
+    "@noble/hashes": "1.7.1",
+    "bs58": "^6.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "sourceRoot": "packages/node-tron/src",
+    "projectType": "library",
+    "name": "node-tron",
+    "targets": {
+      "build": {}
+    }
+  },
+  "main": "./index.cjs",
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.esm.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.cjs"
+    }
+  },
+  "devDependencies": {
+    "@types/http-errors": "^2.0.0"
+  }
+}

package/src/client/client.d.ts

@@ -0,0 +1,178 @@
+import { DynamicWalletClient, type DynamicWalletClientProps, type EcdsaKeygenResult, type EcdsaPublicKey, type Ed25519KeygenResult, type ServerKeyShare, type SignMessageContext, type ThresholdSignatureScheme, type WalletApiKeyCreationResult, type WalletMetadata } from '@dynamic-labs-wallet/node';
+import type { TronTransaction } from '../types.js';
+/**
+ * Wallet client for TRON (SLIP-44 coin type 195, secp256k1 / ECDSA).
+ *
+ * V1 surface: create / signMessage (TIP-191, aka signMessageV2) /
+ * signTransaction / importPrivateKey / exportPrivateKey.
+ *
+ * Networks (Mainnet / Shasta / Nile) share the same address format and
+ * keyshare namespace; the network is selected at the broadcast layer via the
+ * raw_data the caller assembles against the full node of their choice. See
+ * `TRON_NETWORKS` in `./constants`.
+ *
+ * Address derivation: keccak256 of the uncompressed secp256k1 public key
+ * (minus the 0x04 prefix), last 20 bytes, prefixed with 0x41, encoded as
+ * Base58Check (`T...`).
+ *
+ * Transaction signing: SHA-256 of `raw_data_hex` is the digest, sent through
+ * the sign path as a pre-hashed (`isFormatted: true`) payload.
+ *
+ * Message signing (TIP-191): keccak256 of `\x19TRON Signed Message:\n<len><msg>`.
+ */
+export declare class DynamicTronWalletClient extends DynamicWalletClient {
+    readonly chainName = "TRON";
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, debug, enableMPCAccelerator, logger, }: DynamicWalletClientProps);
+    /**
+     * Creates a new wallet account.
+     * @param thresholdSignatureScheme - The threshold signature scheme to use for the wallet.
+     * @param password - The password to use for the wallet.
+     * @param onError - The function to call if an error occurs.
+     * @param backUpToDynamic - Whether to back up the external server key shares to the client share service. By default, it is false.
+     * @returns The walletMetadata, public key hex, raw public key, and external server key shares.
+     */
+    createWalletAccount({ thresholdSignatureScheme, password, onError, backUpToDynamic, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+        backUpToDynamic?: boolean;
+    }): Promise<{
+        walletMetadata: WalletMetadata;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
+        externalServerKeyShares: ServerKeyShare[];
+        externalKeySharesWithBackupStatus: Array<{
+            share: ServerKeyShare;
+            backedUpToClientKeyShareService: boolean;
+        }>;
+    } & WalletApiKeyCreationResult>;
+    /**
+     * TIP-191 personal-sign for TRON. This is the `signMessageV2` surface — there
+     * is no V1 legacy message-sign path for TRON.
+     *
+     * The TIP-191 prefix + keccak256 hashing happens client-side; the resulting
+     * 32-byte digest goes through the sign path as `isFormatted: true` (matches
+     * the browser TRON client and the EVM pre-hashed contract).
+     *
+     * @returns `0x`-prefixed `r || s || v` signature with v normalized to 0/1.
+     */
+    signMessage({ message, walletMetadata, password, externalServerKeyShares, context, onError, }: {
+        message: string;
+        walletMetadata: WalletMetadata;
+        password?: string;
+        externalServerKeyShares?: ServerKeyShare[];
+        context?: SignMessageContext;
+        onError?: (error: Error) => void;
+    }): Promise<`0x${string}`>;
+    /**
+     * Alias for {@link signMessage} — the TIP-191 sign surface is the only
+     * TRON message-sign path (there is no V1 variant for this chain).
+     */
+    signMessageV2(args: Parameters<DynamicTronWalletClient['signMessage']>[0]): Promise<`0x${string}`>;
+    /**
+     * Returns the `0x`-prefixed TIP-191 digest that `signMessage` sends to the
+     * signer — mirrors the browser client's `prepareSignMessage`.
+     */
+    prepareSignMessage({ message }: {
+        message: string;
+    }): string;
+    /**
+     * Sign a TRON transaction.
+     *
+     * The caller supplies the unsigned `raw_data_hex` produced by a TRON full
+     * node (e.g. `/wallet/createtransaction` or `/wallet/triggersmartcontract`),
+     * either as a parsed `TronTransaction` object or as the JSON string that
+     * came back from the full node. The signer hashes those bytes with SHA-256
+     * (the TRON `txID`) and signs the digest.
+     *
+     * Returns the entire signed transaction (with the new signature appended to
+     * `transaction.signature[]`) as a JSON string, ready to be passed to the
+     * full-node `/wallet/broadcasttransaction` endpoint.
+     */
+    signTransaction({ walletMetadata, transaction, password, externalServerKeyShares, context, onError, }: {
+        walletMetadata: WalletMetadata;
+        transaction: TronTransaction | string;
+        password?: string;
+        externalServerKeyShares?: ServerKeyShare[];
+        context?: SignMessageContext;
+        onError?: (error: Error) => void;
+    }): Promise<string>;
+    /**
+     * Exports the private key for a given wallet.
+     * @returns `0x`-prefixed 32-byte hex private key (tronweb / TronLink format).
+     */
+    exportPrivateKey({ walletMetadata, password, externalServerKeyShares, }: {
+        walletMetadata: WalletMetadata;
+        password?: string;
+        externalServerKeyShares?: ServerKeyShare[];
+    }): Promise<`0x${string}`>;
+    /**
+     * `derivationPath` is the JSON-serialized index map that
+     * `walletMetadata.derivationPath` carries (e.g. `'{"0":44,"1":195,"2":0,"3":0,"4":0}'`
+     * or `'[44,195,0,0,0]'`). BIP-32 strings such as `"m/44'/195'/0'/0/0"` are rejected.
+     * Omit it to export without path derivation.
+     */
+    offlineExportPrivateKey({ keyShares, derivationPath, }: {
+        keyShares: (EcdsaKeygenResult | Ed25519KeygenResult)[];
+        derivationPath?: string;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    /**
+     * Imports a private key.
+     * @param privateKey - The private key to import (hex, with or without 0x).
+     * @param chainName - The chain name to use for the wallet.
+     * @param thresholdSignatureScheme - The threshold signature scheme to use for the wallet.
+     * @param password - The password to use for the wallet.
+     * @param onError - The function to call if an error occurs.
+     * @param backUpToDynamic - Whether to back up the external server key shares to the client share service. By default, it is false.
+     * @param publicAddressCheck - Optional TRON address to verify the imported key against.
+     * @returns The walletMetadata, public key hex, raw public key, and external server key shares.
+     */
+    importPrivateKey({ privateKey, thresholdSignatureScheme, password, backUpToDynamic, onError, publicAddressCheck, }: {
+        privateKey: string;
+        /** Ignored — imports always create TRON shares. Kept for parity with sibling clients. */
+        chainName?: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        backUpToDynamic?: boolean;
+        onError?: (error: Error) => void;
+        publicAddressCheck?: string;
+    }): Promise<{
+        walletMetadata: WalletMetadata;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
+        externalServerKeyShares: ServerKeyShare[];
+        externalKeySharesWithBackupStatus: Array<{
+            share: ServerKeyShare;
+            backedUpToClientKeyShareService: boolean;
+        }>;
+    }>;
+    /**
+     * Derives the TRON Base58Check address from an MPC ECDSA public key.
+     */
+    deriveAccountAddress({ rawPublicKey }: {
+        rawPublicKey: EcdsaPublicKey;
+    }): {
+        accountAddress: string;
+        publicKeyHex: string;
+    };
+    /**
+     * Gets all TRON wallets.
+     * @returns Array of TRON wallets
+     */
+    getTronWallets(): Promise<{
+        walletId: string;
+        chainName: string;
+        accountAddress: string;
+        externalServerKeySharesBackupInfo: import("@dynamic-labs-wallet/core").KeyShareBackupInfo;
+        externalServerKeyShares: never[];
+        derivationPath: string | undefined;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+    }[]>;
+    /**
+     * Check if the raw public key is a valid ECDSA public key instance.
+     */
+    private checkRawPublicKeyInstance;
+}
+//# sourceMappingURL=client.d.ts.map

package/src/client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"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"}

package/src/client/constants.d.ts

@@ -0,0 +1,37 @@
+export declare const ERROR_KEYGEN_FAILED = "Error with keygen";
+export declare const ERROR_CREATE_WALLET_ACCOUNT = "Error creating TRON wallet account";
+export declare const ERROR_IMPORT_PRIVATE_KEY = "Error importing private key";
+export declare const ERROR_EXPORT_PRIVATE_KEY = "Error exporting private key";
+export declare const ERROR_SIGN_MESSAGE = "Error signing message";
+export declare const ERROR_SIGN_TRANSACTION = "Error signing transaction";
+export declare const ERROR_ACCOUNT_ADDRESS_REQUIRED = "Account address is required";
+export declare const ERROR_RAW_DATA_HEX_REQUIRED = "Transaction raw_data_hex is required";
+export declare const ERROR_INVALID_RAW_PUBLIC_KEY = "Invalid raw public key instance";
+/**
+ * TRON network identifiers.
+ *
+ * Mainnet, Shasta, and Nile share the same address format and the same MPC
+ * keyshare namespace (SLIP-44 coin type 195). They only differ at the RPC /
+ * full-node URL level, so the wallet client itself is network-agnostic; the
+ * network passes through transactions via the raw_data the caller assembled
+ * against the appropriate full-node endpoint.
+ */
+export declare const TRON_NETWORKS: {
+    readonly MAINNET: {
+        readonly name: "Mainnet";
+        readonly rpcUrl: "https://api.trongrid.io";
+        readonly chainId: "0x2b6653dc";
+    };
+    readonly SHASTA: {
+        readonly name: "Shasta";
+        readonly rpcUrl: "https://api.shasta.trongrid.io";
+        readonly chainId: "0x94a9059e";
+    };
+    readonly NILE: {
+        readonly name: "Nile";
+        readonly rpcUrl: "https://nile.trongrid.io";
+        readonly chainId: "0xcd8690dc";
+    };
+};
+export type TronNetwork = keyof typeof TRON_NETWORKS;
+//# sourceMappingURL=constants.d.ts.map

package/src/client/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/client/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,uCAAuC,CAAC;AAEhF,eAAO,MAAM,wBAAwB,gCAAgC,CAAC;AAEtE,eAAO,MAAM,wBAAwB,gCAAgC,CAAC;AAEtE,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AAE1D,eAAO,MAAM,sBAAsB,8BAA8B,CAAC;AAElE,eAAO,MAAM,8BAA8B,gCAAgC,CAAC;AAE5E,eAAO,MAAM,2BAA2B,yCAAyC,CAAC;AAElF,eAAO,MAAM,4BAA4B,oCAAoC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,aAAa,CAAC"}

package/src/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client.js';
+export * from './constants.js';
+//# sourceMappingURL=index.d.ts.map

package/src/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export { DynamicTronWalletClient } from './client/index.js';
+export { ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_EXPORT_PRIVATE_KEY, ERROR_IMPORT_PRIVATE_KEY, ERROR_INVALID_RAW_PUBLIC_KEY, ERROR_KEYGEN_FAILED, ERROR_RAW_DATA_HEX_REQUIRED, ERROR_SIGN_MESSAGE, ERROR_SIGN_TRANSACTION, TRON_NETWORKS, } from './client/index.js';
+export type { TronNetwork } from './client/index.js';
+export { TRON_ADDRESS_PREFIX, deriveTronAddress, isValidTronAddress, decodeTronAddress, tronAddressToHex, TRON_SIGN_MESSAGE_PREFIX, toTronMessageBytes, formatTronMessage, getTronTxId, getTronTxIdHex, serializeECDSASignature, } from './utils/index.js';
+export type { TronTransaction } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,4BAA4B,EAC5B,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,GACd,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,uBAAuB,GACxB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/src/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unsigned TRON transaction shape, matching the JSON returned by full-node
+ * endpoints like `/wallet/createtransaction` or `/wallet/triggersmartcontract`.
+ *
+ * The wallet client only needs `raw_data_hex` to sign — the rest of the
+ * fields are forwarded back to the caller (and on to a TRON full node) so
+ * the signed transaction can be broadcast unchanged.
+ */
+export interface TronTransaction {
+    /** Pre-computed by the TRON full node; SHA256 of `raw_data_hex` */
+    txID?: string;
+    /** JSON view of the protobuf raw_data — passthrough for the consumer */
+    raw_data?: any;
+    /** Hex-encoded protobuf-serialized raw_data (this is what we sign) */
+    raw_data_hex: string;
+    /** Signatures already attached to the transaction (multi-sig flows) */
+    signature?: string[];
+    /** Visible flag for TRON address auto-conversion */
+    visible?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../packages/src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oDAAoD;IACpD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/src/utils/deriveTronAddress/deriveTronAddress.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Mainnet address prefix byte for TRON addresses. Shasta and Nile testnets
+ * use the same prefix; the network is disambiguated at the node/relay layer
+ * (TRON does not embed a network byte into the address).
+ *
+ * @see https://github.com/tronprotocol/tips/blob/master/tip-21.md
+ */
+export declare const TRON_ADDRESS_PREFIX = 65;
+/**
+ * Derive a TRON Base58Check ("T...") address from a secp256k1 public key.
+ *
+ * TRON addresses are the keccak256 hash of the uncompressed public key
+ * (with the leading 0x04 byte stripped), taking the last 20 bytes, prefixed
+ * with 0x41, then encoded as Base58Check (SHA256d checksum).
+ *
+ * @see https://github.com/tronprotocol/tips/blob/master/tip-21.md
+ */
+export declare const deriveTronAddress: ({ publicKeyHex }: {
+    publicKeyHex: string;
+}) => string;
+/**
+ * Validate a TRON Base58Check address.
+ *
+ * Performs the full decode + checksum + prefix check, so it rejects EVM
+ * `0x...` addresses, malformed Base58, and addresses whose checksum was
+ * tampered with.
+ */
+export declare const isValidTronAddress: (address: string) => boolean;
+/**
+ * Decode a TRON Base58Check address to its 21-byte payload (prefix + 20-byte
+ * hash). Throws if the checksum doesn't validate.
+ */
+export declare const decodeTronAddress: (address: string) => Uint8Array;
+/**
+ * Convert a TRON Base58Check address to its 0x41-prefixed hex form (used in
+ * raw transactions).
+ */
+export declare const tronAddressToHex: (address: string) => string;
+//# sourceMappingURL=deriveTronAddress.d.ts.map

package/src/utils/deriveTronAddress/deriveTronAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveTronAddress.d.ts","sourceRoot":"","sources":["../../../src/utils/deriveTronAddress/deriveTronAddress.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,KAAO,CAAC;AAkBxC;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,qBAAsB;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,KAAG,MA+B9E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,YAAa,MAAM,KAAG,OAsBpD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,YAAa,MAAM,KAAG,UAKnD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,YAAa,MAAM,KAAG,MAGlD,CAAC"}

package/src/utils/deriveTronAddress/index.d.ts

@@ -0,0 +1,2 @@
+export { TRON_ADDRESS_PREFIX, deriveTronAddress, isValidTronAddress, decodeTronAddress, tronAddressToHex, } from './deriveTronAddress.js';
+//# sourceMappingURL=index.d.ts.map

package/src/utils/deriveTronAddress/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/deriveTronAddress/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,wBAAwB,CAAC"}

package/src/utils/formatTronMessage/formatTronMessage.d.ts

@@ -0,0 +1,35 @@
+/**
+ * TIP-191 personal-sign prefix used by TRON for signed messages.
+ *
+ * The hash that gets signed is:
+ *   keccak256("\x19TRON Signed Message:\n" || len(message) || message)
+ *
+ * where `message` is the raw bytes the user agreed to sign.
+ *
+ * @see https://github.com/tronprotocol/tips/blob/master/tip-191.md
+ */
+export declare const TRON_SIGN_MESSAGE_PREFIX = "\u0019TRON Signed Message:\n";
+/**
+ * Convert a user-supplied message into the bytes that TIP-191 expects to be
+ * hashed.
+ *
+ * - `string` starting with `0x` → treated as hex bytes
+ * - `string` otherwise → treated as utf-8 bytes
+ * - `Uint8Array` → passed through
+ * - `{ raw: ... }` → mirrors viem's `{ raw }` escape hatch for already-hashed payloads
+ */
+export declare const toTronMessageBytes: (message: string | Uint8Array | {
+    raw: string | Uint8Array;
+}) => Uint8Array;
+/**
+ * Apply the TIP-191 prefix and return the keccak256 hash that should be
+ * signed by the MPC ECDSA flow.
+ *
+ * Returns a `Uint8Array` (32 bytes). The wallet client hands this to
+ * `sign(...)` with `isFormatted: true` so the forward-MPC path sees a
+ * pre-hashed payload.
+ */
+export declare const formatTronMessage: (message: string | Uint8Array | {
+    raw: string | Uint8Array;
+}) => Uint8Array;
+//# sourceMappingURL=formatTronMessage.d.ts.map

package/src/utils/formatTronMessage/formatTronMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatTronMessage.d.ts","sourceRoot":"","sources":["../../../src/utils/formatTronMessage/formatTronMessage.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,iCAA+B,CAAC;AAWrE;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,YAAa,MAAM,GAAG,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,KAAG,UAOhG,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,YAAa,MAAM,GAAG,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,KAAG,UAO/F,CAAC"}

package/src/utils/formatTronMessage/index.d.ts

@@ -0,0 +1,2 @@
+export { TRON_SIGN_MESSAGE_PREFIX, toTronMessageBytes, formatTronMessage } from './formatTronMessage.js';
+//# sourceMappingURL=index.d.ts.map

package/src/utils/formatTronMessage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/formatTronMessage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC"}

package/src/utils/getTronTxId/getTronTxId.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TRON transactions are signed over `sha256(raw_data_hex_bytes)`, where
+ * `raw_data_hex` is the protobuf-encoded `Transaction.raw` produced by the
+ * TRON full node when the unsigned transaction is created.
+ *
+ * The MPC client never reconstructs the protobuf itself — the caller passes
+ * the already-serialized `raw_data_hex` and we hash it deterministically here.
+ *
+ * @see https://developers.tron.network/docs/transactions
+ */
+export declare const getTronTxId: (rawDataHex: string) => Uint8Array;
+/**
+ * Convenience wrapper that returns the txID as a 0x-prefixed hex string
+ * (matching the form returned by the TRON full node `/wallet/gettransactioninfobyid`).
+ */
+export declare const getTronTxIdHex: (rawDataHex: string) => string;
+//# sourceMappingURL=getTronTxId.d.ts.map

package/src/utils/getTronTxId/getTronTxId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTronTxId.d.ts","sourceRoot":"","sources":["../../../src/utils/getTronTxId/getTronTxId.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,eAAgB,MAAM,KAAG,UAOhD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,eAAgB,MAAM,KAAG,MAGnD,CAAC"}

package/src/utils/getTronTxId/index.d.ts

@@ -0,0 +1,2 @@
+export { getTronTxId, getTronTxIdHex } from './getTronTxId.js';
+//# sourceMappingURL=index.d.ts.map

package/src/utils/getTronTxId/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/getTronTxId/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { TRON_ADDRESS_PREFIX, deriveTronAddress, isValidTronAddress, decodeTronAddress, tronAddressToHex, } from './deriveTronAddress/index.js';
+export { TRON_SIGN_MESSAGE_PREFIX, toTronMessageBytes, formatTronMessage } from './formatTronMessage/index.js';
+export { getTronTxId, getTronTxIdHex } from './getTronTxId/index.js';
+export { serializeECDSASignature } from './serializeECDSASignature/index.js';
+//# sourceMappingURL=index.d.ts.map

package/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC/G,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC"}

package/src/utils/serializeECDSASignature/index.d.ts

@@ -0,0 +1,2 @@
+export { serializeECDSASignature } from './serializeECDSASignature.js';
+//# sourceMappingURL=index.d.ts.map

package/src/utils/serializeECDSASignature/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/serializeECDSASignature/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC"}

package/src/utils/serializeECDSASignature/serializeECDSASignature.d.ts

@@ -0,0 +1,13 @@
+import type { EcdsaSignature } from '@dynamic-labs-wallet/node';
+/**
+ * Serialize an MPC-produced ECDSA signature into the 65-byte
+ * `r || s || v` hex form that TRON full nodes expect on
+ * `Transaction.signature[0]` and TIP-191 signed messages.
+ *
+ * TRON canonicalises v to 0 / 1 on the wire (recovery id), while the MPC
+ * relay returns v as 27 / 28 (Ethereum legacy convention). We strip the +27
+ * offset here so the output is directly usable by TRON tooling without
+ * the consumer having to remember the convention.
+ */
+export declare const serializeECDSASignature: (signature: EcdsaSignature) => `0x${string}`;
+//# sourceMappingURL=serializeECDSASignature.d.ts.map

package/src/utils/serializeECDSASignature/serializeECDSASignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeECDSASignature.d.ts","sourceRoot":"","sources":["../../../src/utils/serializeECDSASignature/serializeECDSASignature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,cAAe,cAAc,KAAG,KAAK,MAAM,EAgB9E,CAAC"}