crypto-aio 0.0.2 → 0.1.0

package/dist/adapters/tron/abi.d.ts

@@ -0,0 +1,39 @@
+export declare const SELECTORS: Readonly<{
+    transfer: "a9059cbb";
+    balanceOf: "70a08231";
+    decimals: "313ce567";
+    symbol: "95d89b41";
+}>;
+/** `keccak256("Transfer(address,address,uint256)")`, without `0x`. */
+export declare const TRANSFER_TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+/** An amount outside `uint256` is refused with a fixed text, never wrapped. */
+export declare function encodeTransfer(to: string, amount: bigint): string;
+export declare function encodeBalanceOf(owner: string): string;
+/**
+ * The (to, amount) of `transfer(address,uint256)` call data built the canonical way (12
+ * zero bytes before the address); `null` for anything else.
+ */
+export declare function decodeTransferCall(data: string): {
+    readonly to: string;
+    readonly amount: bigint;
+} | null;
+/** Throws on data that is not exactly one ABI `uint256` word. */
+export declare function decodeUint256(data: string): bigint;
+/**
+ * Throws on data that is not an ABI `string` (offset 32, length, padded UTF-8). The shape is
+ * checked by length and one character class: a repeated-group regex overflows V8's stack
+ * on a few million characters.
+ */
+export declare function decodeString(data: string): string;
+/**
+ * A TRC-20 `Transfer` log's parties (`41…` hex) and amount; `null` for any other log. Tron
+ * logs carry hex without `0x`, and `address` is the 20-byte emitter.
+ */
+export declare function decodeTransferLog(log: {
+    readonly topics: readonly string[];
+    readonly data: string;
+}): {
+    readonly from: string;
+    readonly to: string;
+    readonly amount: bigint;
+} | null;

package/dist/adapters/tron/abi.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSFER_TOPIC = exports.SELECTORS = void 0;
+exports.encodeTransfer = encodeTransfer;
+exports.encodeBalanceOf = encodeBalanceOf;
+exports.decodeTransferCall = decodeTransferCall;
+exports.decodeUint256 = decodeUint256;
+exports.decodeString = decodeString;
+exports.decodeTransferLog = decodeTransferLog;
+/**
+ * The TRC-20 calls and events the driver uses, SDK-free: TRC-20 is ERC-20's ABI on the
+ * TVM, with 20-byte addresses in ABI words (the `41` prefix dropped). Selectors are pinned
+ * by a keccak-256 test.
+ */
+const error_1 = require("../../core/errors/error");
+const bytes_1 = require("../../core/util/bytes");
+const address_1 = require("./address");
+exports.SELECTORS = Object.freeze({
+    transfer: 'a9059cbb',
+    balanceOf: '70a08231',
+    decimals: '313ce567',
+    symbol: '95d89b41',
+});
+/** `keccak256("Transfer(address,address,uint256)")`, without `0x`. */
+exports.TRANSFER_TOPIC = 'ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+const UINT256_MAX = (1n << 256n) - 1n;
+function word(value) {
+    return value.toString(16).padStart(64, '0');
+}
+function addressWord(address) {
+    return (0, address_1.toHexAddress)(address).slice(2).padStart(64, '0');
+}
+/** An amount outside `uint256` is refused with a fixed text, never wrapped. */
+function encodeTransfer(to, amount) {
+    if (amount < 0n || amount > UINT256_MAX) {
+        throw new error_1.ValidationError('INVALID_AMOUNT', 'amount does not fit in a uint256');
+    }
+    return `${exports.SELECTORS.transfer}${addressWord(to)}${word(amount)}`;
+}
+function encodeBalanceOf(owner) {
+    return `${exports.SELECTORS.balanceOf}${addressWord(owner)}`;
+}
+/**
+ * The (to, amount) of `transfer(address,uint256)` call data built the canonical way (12
+ * zero bytes before the address); `null` for anything else.
+ */
+function decodeTransferCall(data) {
+    // A fixed length (selector + two words), checked before any other work, so a long
+    // untrusted input costs one length check.
+    if (data.length !== 136)
+        return null;
+    const hex = data.toLowerCase();
+    if (!/^a9059cbb[0-9a-f]{128}$/.test(hex))
+        return null;
+    const toWord = hex.slice(8, 72);
+    if (!toWord.startsWith('0'.repeat(24)))
+        return null;
+    return { to: `41${toWord.slice(24)}`, amount: BigInt(`0x${hex.slice(72)}`) };
+}
+/** Throws on data that is not exactly one ABI `uint256` word. */
+function decodeUint256(data) {
+    if (!/^[0-9a-fA-F]{64}$/.test(data))
+        throw new TypeError('not one uint256 word');
+    return BigInt(`0x${data}`);
+}
+/** One character class, no repeated group: linear on any input. */
+const HEX_DIGITS = /^[0-9a-fA-F]+$/;
+/**
+ * Throws on data that is not an ABI `string` (offset 32, length, padded UTF-8). The shape is
+ * checked by length and one character class: a repeated-group regex overflows V8's stack
+ * on a few million characters.
+ */
+function decodeString(data) {
+    if (typeof data !== 'string' ||
+        data.length < 128 ||
+        data.length % 64 !== 0 ||
+        !HEX_DIGITS.test(data)) {
+        throw new TypeError('not an ABI string');
+    }
+    if (BigInt(`0x${data.slice(0, 64)}`) !== 32n)
+        throw new TypeError('bad string offset');
+    const length = BigInt(`0x${data.slice(64, 128)}`);
+    const available = BigInt((data.length - 128) / 2);
+    if (length > available || available - length >= 32n) {
+        throw new TypeError('bad string length');
+    }
+    const bytes = (0, bytes_1.fromHex)(data.slice(128, 128 + Number(length) * 2));
+    return (0, bytes_1.bytesToUtf8)(bytes);
+}
+/**
+ * A TRC-20 `Transfer` log's parties (`41…` hex) and amount; `null` for any other log. Tron
+ * logs carry hex without `0x`, and `address` is the 20-byte emitter.
+ */
+function decodeTransferLog(log) {
+    if (log.topics.length !== 3)
+        return null;
+    const [topic, from, to] = log.topics.map((t) => t.toLowerCase());
+    if (topic !== exports.TRANSFER_TOPIC)
+        return null;
+    const party = (value) => value !== undefined && /^0{24}[0-9a-f]{40}$/.test(value)
+        ? `41${value.slice(24)}`
+        : null;
+    const sender = party(from);
+    const recipient = party(to);
+    if (sender === null || recipient === null || !/^[0-9a-fA-F]{64}$/.test(log.data)) {
+        return null;
+    }
+    return { from: sender, to: recipient, amount: BigInt(`0x${log.data}`) };
+}
+//# sourceMappingURL=abi.js.map

package/dist/adapters/tron/abi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.js","sourceRoot":"","sources":["../../../src/adapters/tron/abi.ts"],"names":[],"mappings":";;;AA+BA,wCAKC;AAED,0CAEC;AAMD,gDAWC;AAGD,sCAGC;AAUD,oCAiBC;AAMD,8CAiBC;AAjHD;;;;GAIG;AACH,mDAA0D;AAC1D,iDAA6D;AAC7D,uCAAyC;AAE5B,QAAA,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,QAAQ,EAAE,UAAU;IACpB,SAAS,EAAE,UAAU;IACrB,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,UAAU;CACnB,CAAC,CAAC;AAEH,sEAAsE;AACzD,QAAA,cAAc,GACzB,kEAAkE,CAAC;AAErE,MAAM,WAAW,GAAG,CAAC,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;AAEtC,SAAS,IAAI,CAAC,KAAa;IACzB,OAAO,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AAC9C,CAAC;AAED,SAAS,WAAW,CAAC,OAAe;IAClC,OAAO,IAAA,sBAAY,EAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AAC1D,CAAC;AAED,+EAA+E;AAC/E,SAAgB,cAAc,CAAC,EAAU,EAAE,MAAc;IACvD,IAAI,MAAM,GAAG,EAAE,IAAI,MAAM,GAAG,WAAW,EAAE,CAAC;QACxC,MAAM,IAAI,uBAAe,CAAC,gBAAgB,EAAE,kCAAkC,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,GAAG,iBAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;AAClE,CAAC;AAED,SAAgB,eAAe,CAAC,KAAa;IAC3C,OAAO,GAAG,iBAAS,CAAC,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;AACvD,CAAC;AAED;;;GAGG;AACH,SAAgB,kBAAkB,CAChC,IAAY;IAEZ,kFAAkF;IAClF,0CAA0C;IAC1C,IAAI,IAAI,CAAC,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC/B,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACtD,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAChC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACpD,OAAO,EAAE,EAAE,EAAE,KAAK,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAC/E,CAAC;AAED,iEAAiE;AACjE,SAAgB,aAAa,CAAC,IAAY;IACxC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,sBAAsB,CAAC,CAAC;IACjF,OAAO,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAEpC;;;;GAIG;AACH,SAAgB,YAAY,CAAC,IAAY;IACvC,IACE,OAAO,IAAI,KAAK,QAAQ;QACxB,IAAI,CAAC,MAAM,GAAG,GAAG;QACjB,IAAI,CAAC,MAAM,GAAG,EAAE,KAAK,CAAC;QACtB,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EACtB,CAAC;QACD,MAAM,IAAI,SAAS,CAAC,mBAAmB,CAAC,CAAC;IAC3C,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,GAAG;QAAE,MAAM,IAAI,SAAS,CAAC,mBAAmB,CAAC,CAAC;IACvF,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IAClD,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAClD,IAAI,MAAM,GAAG,SAAS,IAAI,SAAS,GAAG,MAAM,IAAI,GAAG,EAAE,CAAC;QACpD,MAAM,IAAI,SAAS,CAAC,mBAAmB,CAAC,CAAC;IAC3C,CAAC;IACD,MAAM,KAAK,GAAG,IAAA,eAAO,EAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACjE,OAAO,IAAA,mBAAW,EAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED;;;GAGG;AACH,SAAgB,iBAAiB,CAAC,GAGjC;IACC,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACzC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;IACjE,IAAI,KAAK,KAAK,sBAAc;QAAE,OAAO,IAAI,CAAC;IAC1C,MAAM,KAAK,GAAG,CAAC,KAAyB,EAAiB,EAAE,CACzD,KAAK,KAAK,SAAS,IAAI,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC;QACtD,CAAC,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;QACxB,CAAC,CAAC,IAAI,CAAC;IACX,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,MAAM,SAAS,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;IAC5B,IAAI,MAAM,KAAK,IAAI,IAAI,SAAS,KAAK,IAAI,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACjF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,GAAG,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;AAC1E,CAAC","sourcesContent":["/**\n * The TRC-20 calls and events the driver uses, SDK-free: TRC-20 is ERC-20's ABI on the\n * TVM, with 20-byte addresses in ABI words (the `41` prefix dropped). Selectors are pinned\n * by a keccak-256 test.\n */\nimport { ValidationError } from '../../core/errors/error';\nimport { bytesToUtf8, fromHex } from '../../core/util/bytes';\nimport { toHexAddress } from './address';\n\nexport const SELECTORS = Object.freeze({\n  transfer: 'a9059cbb',\n  balanceOf: '70a08231',\n  decimals: '313ce567',\n  symbol: '95d89b41',\n});\n\n/** `keccak256(\"Transfer(address,address,uint256)\")`, without `0x`. */\nexport const TRANSFER_TOPIC =\n  'ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';\n\nconst UINT256_MAX = (1n << 256n) - 1n;\n\nfunction word(value: bigint): string {\n  return value.toString(16).padStart(64, '0');\n}\n\nfunction addressWord(address: string): string {\n  return toHexAddress(address).slice(2).padStart(64, '0');\n}\n\n/** An amount outside `uint256` is refused with a fixed text, never wrapped. */\nexport function encodeTransfer(to: string, amount: bigint): string {\n  if (amount < 0n || amount > UINT256_MAX) {\n    throw new ValidationError('INVALID_AMOUNT', 'amount does not fit in a uint256');\n  }\n  return `${SELECTORS.transfer}${addressWord(to)}${word(amount)}`;\n}\n\nexport function encodeBalanceOf(owner: string): string {\n  return `${SELECTORS.balanceOf}${addressWord(owner)}`;\n}\n\n/**\n * The (to, amount) of `transfer(address,uint256)` call data built the canonical way (12\n * zero bytes before the address); `null` for anything else.\n */\nexport function decodeTransferCall(\n  data: string,\n): { readonly to: string; readonly amount: bigint } | null {\n  // A fixed length (selector + two words), checked before any other work, so a long\n  // untrusted input costs one length check.\n  if (data.length !== 136) return null;\n  const hex = data.toLowerCase();\n  if (!/^a9059cbb[0-9a-f]{128}$/.test(hex)) return null;\n  const toWord = hex.slice(8, 72);\n  if (!toWord.startsWith('0'.repeat(24))) return null;\n  return { to: `41${toWord.slice(24)}`, amount: BigInt(`0x${hex.slice(72)}`) };\n}\n\n/** Throws on data that is not exactly one ABI `uint256` word. */\nexport function decodeUint256(data: string): bigint {\n  if (!/^[0-9a-fA-F]{64}$/.test(data)) throw new TypeError('not one uint256 word');\n  return BigInt(`0x${data}`);\n}\n\n/** One character class, no repeated group: linear on any input. */\nconst HEX_DIGITS = /^[0-9a-fA-F]+$/;\n\n/**\n * Throws on data that is not an ABI `string` (offset 32, length, padded UTF-8). The shape is\n * checked by length and one character class: a repeated-group regex overflows V8's stack\n * on a few million characters.\n */\nexport function decodeString(data: string): string {\n  if (\n    typeof data !== 'string' ||\n    data.length < 128 ||\n    data.length % 64 !== 0 ||\n    !HEX_DIGITS.test(data)\n  ) {\n    throw new TypeError('not an ABI string');\n  }\n  if (BigInt(`0x${data.slice(0, 64)}`) !== 32n) throw new TypeError('bad string offset');\n  const length = BigInt(`0x${data.slice(64, 128)}`);\n  const available = BigInt((data.length - 128) / 2);\n  if (length > available || available - length >= 32n) {\n    throw new TypeError('bad string length');\n  }\n  const bytes = fromHex(data.slice(128, 128 + Number(length) * 2));\n  return bytesToUtf8(bytes);\n}\n\n/**\n * A TRC-20 `Transfer` log's parties (`41…` hex) and amount; `null` for any other log. Tron\n * logs carry hex without `0x`, and `address` is the 20-byte emitter.\n */\nexport function decodeTransferLog(log: {\n  readonly topics: readonly string[];\n  readonly data: string;\n}): { readonly from: string; readonly to: string; readonly amount: bigint } | null {\n  if (log.topics.length !== 3) return null;\n  const [topic, from, to] = log.topics.map((t) => t.toLowerCase());\n  if (topic !== TRANSFER_TOPIC) return null;\n  const party = (value: string | undefined): string | null =>\n    value !== undefined && /^0{24}[0-9a-f]{40}$/.test(value)\n      ? `41${value.slice(24)}`\n      : null;\n  const sender = party(from);\n  const recipient = party(to);\n  if (sender === null || recipient === null || !/^[0-9a-fA-F]{64}$/.test(log.data)) {\n    return null;\n  }\n  return { from: sender, to: recipient, amount: BigInt(`0x${log.data}`) };\n}\n"]}

package/dist/adapters/tron/address.d.ts

@@ -0,0 +1,20 @@
+import type { AddressCodec } from '../../core/driver/types';
+import type { AddressFormatter, NormalizedAddress } from '../../core/model/address';
+/** The 21 address bytes of a base58check or `41…` hex address; throws INVALID_ADDRESS. */
+export declare function addressBytes(value: string): Uint8Array;
+/** Lower-case `41…` hex form (what the HTTP API takes with `visible: false`). */
+export declare function toHexAddress(value: string): string;
+/** Base58check `T…` form, the canonical one. */
+export declare function toBase58Address(value: string): string;
+export declare function isTronAddress(value: string): boolean;
+/** Only a 33-byte compressed or 65-byte `0x04` point on the curve; returns 65 bytes. */
+export declare function uncompressedPublicKey(publicKey: Uint8Array): Uint8Array;
+export declare function addressFromPublicKey(publicKey: Uint8Array): string;
+/**
+ * `variant.hex` is part of the intent hash. It is a pure function of `canonical`
+ * (a JSON string), so a recipient typed in base58 or in hex hashes the same.
+ */
+export declare function normalizeTronAddress(value: string): NormalizedAddress;
+/** `address.format({ hex: true })` renders the `41…` hex form; otherwise base58. */
+export declare const formatTronAddress: AddressFormatter;
+export declare const tronAddressCodec: AddressCodec;

package/dist/adapters/tron/address.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tronAddressCodec = exports.formatTronAddress = void 0;
+exports.addressBytes = addressBytes;
+exports.toHexAddress = toHexAddress;
+exports.toBase58Address = toBase58Address;
+exports.isTronAddress = isTronAddress;
+exports.uncompressedPublicKey = uncompressedPublicKey;
+exports.addressFromPublicKey = addressFromPublicKey;
+exports.normalizeTronAddress = normalizeTronAddress;
+/**
+ * Tron addresses, SDK-free: `0x41` + the last 20 bytes of the keccak-256 hash of
+ * the uncompressed public key, shown as base58check (`T…`, canonical) or as 42 hex digits
+ * (the `hex` variant). Decoding is strict: base58check with the right checksum, exactly 21
+ * bytes and the `0x41` prefix, or `41` + 40 hex digits. Public keys must be 33- or 65-byte
+ * points on the curve; tronweb's `computeAddress` would hash other lengths as is.
+ */
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const sha3_1 = require("@noble/hashes/sha3");
+const sha256_1 = require("@noble/hashes/sha256");
+const base_1 = require("@scure/base");
+const error_1 = require("../../core/errors/error");
+const bytes_1 = require("../../core/util/bytes");
+const base58check = (0, base_1.createBase58check)(sha256_1.sha256);
+const HEX_ADDRESS = /^41[0-9a-fA-F]{40}$/;
+/** Every base58check form of 21 bytes starting `0x41` has exactly 34 characters. */
+const BASE58_LENGTH = 34;
+const BASE58_ALPHABET = /^T[1-9A-HJ-NP-Za-km-z]*$/;
+function invalid() {
+    return new error_1.ValidationError('INVALID_ADDRESS', 'not a Tron address');
+}
+/** The 21 address bytes of a base58check or `41…` hex address; throws INVALID_ADDRESS. */
+function addressBytes(value) {
+    if (typeof value !== 'string')
+        throw invalid();
+    if (HEX_ADDRESS.test(value))
+        return (0, bytes_1.fromHex)(value);
+    // Base58 decoding is quadratic (10,000 characters block the event loop for about a
+    // minute), so this length check is the one gate before the decoder; the alphabet
+    // check deliberately leaves the length to it.
+    if (value.length !== BASE58_LENGTH || !BASE58_ALPHABET.test(value))
+        throw invalid();
+    let bytes;
+    try {
+        bytes = base58check.decode(value);
+    }
+    catch {
+        throw invalid();
+    }
+    if (bytes.length !== 21 || bytes[0] !== 0x41)
+        throw invalid();
+    return bytes;
+}
+/** Lower-case `41…` hex form (what the HTTP API takes with `visible: false`). */
+function toHexAddress(value) {
+    return (0, bytes_1.toHex)(addressBytes(value));
+}
+/** Base58check `T…` form, the canonical one. */
+function toBase58Address(value) {
+    return base58check.encode(addressBytes(value));
+}
+function isTronAddress(value) {
+    try {
+        addressBytes(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Only a 33-byte compressed or 65-byte `0x04` point on the curve; returns 65 bytes. */
+function uncompressedPublicKey(publicKey) {
+    const prefix = publicKey instanceof Uint8Array ? publicKey[0] : undefined;
+    const shaped = ((prefix === 0x02 || prefix === 0x03) && publicKey.length === 33) ||
+        (prefix === 0x04 && publicKey.length === 65);
+    try {
+        if (shaped)
+            return secp256k1_1.secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(false);
+    }
+    catch {
+        // Not a point on the curve.
+    }
+    throw new error_1.ValidationError('INVALID_ADDRESS', 'public key must be a 33- or 65-byte secp256k1 point');
+}
+function addressFromPublicKey(publicKey) {
+    const hash = (0, sha3_1.keccak_256)(uncompressedPublicKey(publicKey).subarray(1));
+    const bytes = new Uint8Array(21);
+    bytes[0] = 0x41;
+    bytes.set(hash.subarray(12), 1);
+    return base58check.encode(bytes);
+}
+/**
+ * `variant.hex` is part of the intent hash. It is a pure function of `canonical`
+ * (a JSON string), so a recipient typed in base58 or in hex hashes the same.
+ */
+function normalizeTronAddress(value) {
+    const bytes = addressBytes(value);
+    const canonical = base58check.encode(bytes);
+    return { canonical, display: canonical, variant: { hex: (0, bytes_1.toHex)(bytes) } };
+}
+/** `address.format({ hex: true })` renders the `41…` hex form; otherwise base58. */
+const formatTronAddress = (address, options) => options?.hex === true ? toHexAddress(address.canonical) : address.canonical;
+exports.formatTronAddress = formatTronAddress;
+exports.tronAddressCodec = {
+    validate: isTronAddress,
+    normalize: normalizeTronAddress,
+    fromPublicKey: (publicKey) => normalizeTronAddress(addressFromPublicKey(publicKey)),
+    format: exports.formatTronAddress,
+};
+//# sourceMappingURL=address.js.map

package/dist/adapters/tron/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../../../src/adapters/tron/address.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tron addresses, SDK-free: `0x41` + the last 20 bytes of the keccak-256 hash of\n * the uncompressed public key, shown as base58check (`T…`, canonical) or as 42 hex digits\n * (the `hex` variant). Decoding is strict: base58check with the right checksum, exactly 21\n * bytes and the `0x41` prefix, or `41` + 40 hex digits. Public keys must be 33- or 65-byte\n * points on the curve; tronweb's `computeAddress` would hash other lengths as is.\n */\nimport { secp256k1 } from '@noble/curves/secp256k1';\nimport { keccak_256 } from '@noble/hashes/sha3';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { createBase58check } from '@scure/base';\nimport type { AddressCodec } from '../../core/driver/types';\nimport { ValidationError } from '../../core/errors/error';\nimport type { AddressFormatter, NormalizedAddress } from '../../core/model/address';\nimport { fromHex, toHex } from '../../core/util/bytes';\n\nconst base58check = createBase58check(sha256);\nconst HEX_ADDRESS = /^41[0-9a-fA-F]{40}$/;\n/** Every base58check form of 21 bytes starting `0x41` has exactly 34 characters. */\nconst BASE58_LENGTH = 34;\nconst BASE58_ALPHABET = /^T[1-9A-HJ-NP-Za-km-z]*$/;\n\nfunction invalid(): ValidationError {\n  return new ValidationError('INVALID_ADDRESS', 'not a Tron address');\n}\n\n/** The 21 address bytes of a base58check or `41…` hex address; throws INVALID_ADDRESS. */\nexport function addressBytes(value: string): Uint8Array {\n  if (typeof value !== 'string') throw invalid();\n  if (HEX_ADDRESS.test(value)) return fromHex(value);\n  // Base58 decoding is quadratic (10,000 characters block the event loop for about a\n  // minute), so this length check is the one gate before the decoder; the alphabet\n  // check deliberately leaves the length to it.\n  if (value.length !== BASE58_LENGTH || !BASE58_ALPHABET.test(value)) throw invalid();\n  let bytes: Uint8Array;\n  try {\n    bytes = base58check.decode(value);\n  } catch {\n    throw invalid();\n  }\n  if (bytes.length !== 21 || bytes[0] !== 0x41) throw invalid();\n  return bytes;\n}\n\n/** Lower-case `41…` hex form (what the HTTP API takes with `visible: false`). */\nexport function toHexAddress(value: string): string {\n  return toHex(addressBytes(value));\n}\n\n/** Base58check `T…` form, the canonical one. */\nexport function toBase58Address(value: string): string {\n  return base58check.encode(addressBytes(value));\n}\n\nexport function isTronAddress(value: string): boolean {\n  try {\n    addressBytes(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Only a 33-byte compressed or 65-byte `0x04` point on the curve; returns 65 bytes. */\nexport function uncompressedPublicKey(publicKey: Uint8Array): Uint8Array {\n  const prefix = publicKey instanceof Uint8Array ? publicKey[0] : undefined;\n  const shaped =\n    ((prefix === 0x02 || prefix === 0x03) && publicKey.length === 33) ||\n    (prefix === 0x04 && publicKey.length === 65);\n  try {\n    if (shaped) return secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(false);\n  } catch {\n    // Not a point on the curve.\n  }\n  throw new ValidationError(\n    'INVALID_ADDRESS',\n    'public key must be a 33- or 65-byte secp256k1 point',\n  );\n}\n\nexport function addressFromPublicKey(publicKey: Uint8Array): string {\n  const hash = keccak_256(uncompressedPublicKey(publicKey).subarray(1));\n  const bytes = new Uint8Array(21);\n  bytes[0] = 0x41;\n  bytes.set(hash.subarray(12), 1);\n  return base58check.encode(bytes);\n}\n\n/**\n * `variant.hex` is part of the intent hash. It is a pure function of `canonical`\n * (a JSON string), so a recipient typed in base58 or in hex hashes the same.\n */\nexport function normalizeTronAddress(value: string): NormalizedAddress {\n  const bytes = addressBytes(value);\n  const canonical = base58check.encode(bytes);\n  return { canonical, display: canonical, variant: { hex: toHex(bytes) } };\n}\n\n/** `address.format({ hex: true })` renders the `41…` hex form; otherwise base58. */\nexport const formatTronAddress: AddressFormatter = (address, options) =>\n  options?.hex === true ? toHexAddress(address.canonical) : address.canonical;\n\nexport const tronAddressCodec: AddressCodec = {\n  validate: isTronAddress,\n  normalize: normalizeTronAddress,\n  fromPublicKey: (publicKey) => normalizeTronAddress(addressFromPublicKey(publicKey)),\n  format: formatTronAddress,\n};\n"]}

package/dist/adapters/tron/builder.d.ts

@@ -0,0 +1,12 @@
+import type { Broadcaster, TxBuilder } from '../../core/driver/types';
+import { type TronContext } from './reader';
+/**
+ * java-tron's bandwidth for a transaction whose `raw_data` is `rawBytes` long
+ * (`BandwidthProcessor.consume`): the signed size without `ret` (field 1 with its length and
+ * the raw bytes, field 2 with its length and one 65-byte signature) plus 64 result bytes.
+ */
+export declare function bandwidthOf(rawBytes: number): bigint;
+export declare function createTronBuilder(ctx: TronContext): {
+    readonly builder: TxBuilder;
+    readonly broadcaster: Broadcaster;
+};