@dynamic-labs-wallet/tron 0.0.0 → 1.0.1

package/package.json

@@ -1 +1,35 @@
-{ "name": "@dynamic-labs-wallet/tron", "version": "0.0.0" }
+{
+  "name": "@dynamic-labs-wallet/tron",
+  "version": "1.0.1",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@dynamic-labs-wallet/browser": "1.0.1",
+    "@dynamic-labs/sdk-api-core": "^0.0.984",
+    "@noble/hashes": "1.7.1",
+    "bs58": "^6.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "sourceRoot": "packages/tron/src",
+    "projectType": "library",
+    "name": "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",
+      "default": "./index.esm.js"
+    }
+  }
+}

package/src/client/client.d.ts

@@ -0,0 +1,149 @@
+import { DynamicWalletClient, type DynamicWalletClientInternalOptions, type DynamicWalletClientProps, type EcdsaKeygenResult, type EcdsaPublicKey, type Ed25519KeygenResult, type RequestWithElevatedAccessToken, type ThresholdSignatureScheme, type TraceContext } from '@dynamic-labs-wallet/browser';
+import type { SignMessageContext } from '@dynamic-labs/sdk-api-core';
+import type { TronSignMessageContext, TronTransaction } from '../types.js';
+/**
+ * Wallet client for TRON (SLIP-44 coin type 195, secp256k1 / ECDSA).
+ *
+ * V1 surface (matches the locked Wave C-1 handoff):
+ *  - create / signMessageV2 / signTransaction / importPrivateKey / exportPrivateKey
+ *  - No legacy V1 message signing (`signMessage` returns a TIP-191 result;
+ *    consumers should call `signMessageV2`).
+ *  - 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 forward-MPC 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, authToken, backupServiceAuthToken, baseApiUrl, baseMPCRelayApiUrl, storageKey, debug, featureFlags, authMode, sdkVersion, forwardMPCClient, logger, }: DynamicWalletClientProps, internalOptions?: DynamicWalletClientInternalOptions);
+    /**
+     * Create a new TRON wallet account using MPC key generation.
+     */
+    createWalletAccount({ thresholdSignatureScheme, password, onError, signedSessionId, traceContext, }: {
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+        signedSessionId: string;
+        traceContext?: TraceContext;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
+    }>;
+    /**
+     * TIP-191 personal-sign for TRON. This is the `signMessageV2` surface
+     * referenced in the rollout — there is no V1 legacy message-sign path.
+     *
+     * The TIP-191 prefix + keccak256 hashing happens client-side; the resulting
+     * 32-byte digest is sent to the forward-MPC relay as `isFormatted: true`
+     * (matches the EVM/TEMPO forward-MPC contract).
+     */
+    signMessage({ message, accountAddress, password, signedSessionId, mfaToken, elevatedAccessToken, context, onError, traceContext, }: {
+        message: string;
+        accountAddress: string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        elevatedAccessToken?: string;
+        context?: SignMessageContext;
+        onError?: (error: Error) => void;
+        traceContext?: TraceContext;
+    }): Promise<`0x${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 MPC 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. Returning a string
+     * (rather than the object) matches the SDK's iframe `signTransaction`
+     * contract, which only carries strings over message transport.
+     */
+    signTransaction({ senderAddress, transaction, password, signedSessionId, mfaToken, elevatedAccessToken, context, onError, traceContext, }: {
+        senderAddress: string;
+        transaction: TronTransaction | string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        elevatedAccessToken?: string;
+        context?: TronSignMessageContext;
+        onError?: (error: Error) => void;
+        traceContext?: TraceContext;
+    }): Promise<string>;
+    /**
+     * Derive account address from ECDSA public key.
+     *
+     * TRON addresses are the keccak256 hash of the uncompressed pubkey (minus
+     * the 0x04 prefix), last 20 bytes, prefixed with 0x41, then Base58Check
+     * encoded.
+     */
+    deriveAccountAddress({ rawPublicKey }: {
+        rawPublicKey: EcdsaPublicKey;
+    }): {
+        accountAddress: string;
+        publicKeyHex: string;
+    };
+    /**
+     * Export private key from MPC key shares.
+     *
+     * TRON uses the raw hex (no encoded prefix) for its private key format,
+     * matching what tronweb / TronLink expose. We return it as 0x-prefixed
+     * so it round-trips cleanly through `importPrivateKey`.
+     */
+    exportPrivateKey({ accountAddress, password, signedSessionId, mfaToken, elevatedAccessToken, traceContext, }: RequestWithElevatedAccessToken<{
+        accountAddress: string;
+        password?: string;
+        signedSessionId: string;
+        mfaToken?: string;
+        traceContext?: TraceContext;
+    }>): Promise<string>;
+    /**
+     * Offline export of private key from key shares.
+     */
+    offlineExportPrivateKey({ keyShares, derivationPath, }: {
+        keyShares: (EcdsaKeygenResult | Ed25519KeygenResult)[];
+        derivationPath?: string;
+    }): Promise<{
+        derivedPrivateKey: string | undefined;
+    }>;
+    /**
+     * Import an existing TRON private key into MPC.
+     */
+    importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password, onError, signedSessionId, publicAddressCheck, legacyWalletId, }: {
+        privateKey: string;
+        chainName: string;
+        thresholdSignatureScheme: ThresholdSignatureScheme;
+        password?: string;
+        onError?: (error: Error) => void;
+        signedSessionId: string;
+        publicAddressCheck?: string;
+        legacyWalletId?: string;
+    }): Promise<{
+        accountAddress: string;
+        publicKeyHex: string;
+        rawPublicKey: EcdsaPublicKey | Uint8Array | string | undefined;
+    }>;
+    /**
+     * Get all TRON wallets known to this client.
+     */
+    getTronWallets(): Promise<any>;
+    /**
+     * 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,40 @@
+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.
+ *
+ * Chain IDs match TRON's reserved chainId space and are exposed mainly so
+ * consumers can build provider configs without re-declaring the constants.
+ */
+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;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,aAAa,CAAC"}

package/src/client/index.d.ts

@@ -0,0 +1,2 @@
+export { DynamicTronWalletClient } from './client.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,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC"}

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export { DynamicTronWalletClient } 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, TronTransactionContext, TronSignMessageContext } from './types.js';
+export * as sdkApiCore from '@dynamic-labs/sdk-api-core';
+//# 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,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,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAClG,OAAO,KAAK,UAAU,MAAM,4BAA4B,CAAC"}

package/src/types.d.ts

@@ -0,0 +1,39 @@
+import type { SignMessageContext } from '@dynamic-labs/sdk-api-core';
+/**
+ * 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;
+}
+/**
+ * Context fields forwarded to policy validation for TRON transactions.
+ * Kept small in V1 — wallet-service is enum-only for TRON today, so this is
+ * mostly informational for client-side logging until validators land.
+ */
+export interface TronTransactionContext {
+    /** Hex-encoded raw_data bytes that were hashed */
+    rawDataHex: string;
+    /** txID (SHA256 of raw_data) as a 0x-prefixed hex string */
+    txid: string;
+}
+/**
+ * Sign-message context with TRON-specific transaction details attached.
+ */
+export interface TronSignMessageContext extends SignMessageContext {
+    tronTransaction?: TronTransactionContext;
+}
+//# 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,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wEAAwE;IAExE,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;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,eAAe,CAAC,EAAE,sBAAsB,CAAC;CAC1C"}

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

@@ -0,0 +1,30 @@
+/**
+ * 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;
+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;AA8BxC,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,37 @@
+import type { ILogger } from '@dynamic-labs-wallet/browser';
+/**
+ * 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. Mirrors the shape of `formatTempoMessage` so the wallet client can
+ * treat both chains uniformly.
+ *
+ * - `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 converts this into a
+ * `MessageHash` (`isFormatted: true`) before handing it to `sign(...)` so
+ * the forward-MPC path sees a pre-hashed payload.
+ */
+export declare const formatTronMessage: (message: string | Uint8Array | {
+    raw: string | Uint8Array;
+}, logger: ILogger) => 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":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAG5D;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,iCAA+B,CAAC;AAWrE;;;;;;;;;GASG;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,YACnB,MAAM,GAAG,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,UACnD,OAAO,KACd,UAYF,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, ILogger } from '@dynamic-labs-wallet/browser';
+/**
+ * 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, logger: ILogger) => `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,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,cAAe,cAAc,UAAU,OAAO,KAAG,KAAK,MAAM,EAwB/F,CAAC"}