@swapkit/wallet-hardware 6.0.0 → 6.1.0

package/src/trezor/stellarSigner.ts

@@ -0,0 +1,186 @@
+import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from "@swapkit/helpers";
+import type { StellarSigner, StellarTransaction } from "@swapkit/toolboxes/stellar";
+
+type StellarClassicTransaction = Exclude<StellarTransaction, { innerTransaction: unknown }>;
+type StellarOperation = StellarClassicTransaction["operations"][number];
+type StellarAsset = Extract<StellarOperation, { type: "changeTrust" }>["line"];
+
+const STELLAR_DECIMALS = 7;
+const MAX_UINT32 = 4294967295n;
+const ASSET_TYPES: Record<string, "NATIVE" | "ALPHANUM4" | "ALPHANUM12"> = {
+  credit_alphanum4: "ALPHANUM4",
+  credit_alphanum12: "ALPHANUM12",
+  native: "NATIVE",
+};
+const MEMO_TYPES = { hash: 3, id: 2, return: 4, text: 1 } as const;
+
+function notSupported(reason: string) {
+  return new SwapKitError({ errorKey: "wallet_trezor_method_not_supported", info: { chain: Chain.Stellar, reason } });
+}
+
+function toStroops(amount: string) {
+  const match = /^(\d+)(?:\.(\d{1,7}))?$/.exec(amount);
+  if (!match) throw notSupported(`Invalid Stellar amount: ${amount}`);
+
+  const [, whole = "0", fraction = ""] = match;
+  return BigInt(`${whole}${fraction.padEnd(STELLAR_DECIMALS, "0")}`).toString();
+}
+
+function toTimeBound(value: string) {
+  if (!/^\d+$/.test(value) || BigInt(value) > MAX_UINT32) {
+    throw notSupported(`Unsupported Stellar time bound: ${value}`);
+  }
+  return Number(value);
+}
+
+function toTrezorAsset(asset: StellarAsset) {
+  const type = ASSET_TYPES[asset.getAssetType()];
+  if (!type || !("getCode" in asset)) throw notSupported("Trezor does not support liquidity pool assets");
+
+  return type === "NATIVE" ? { type } : { code: asset.getCode(), issuer: asset.getIssuer(), type };
+}
+
+function toTrezorOperation({ source, ...operation }: StellarOperation) {
+  const withSource = source ? { source } : {};
+
+  switch (operation.type) {
+    case "payment":
+      return {
+        ...withSource,
+        amount: toStroops(operation.amount),
+        asset: toTrezorAsset(operation.asset),
+        destination: operation.destination,
+        type: "payment" as const,
+      };
+    case "createAccount":
+      return {
+        ...withSource,
+        destination: operation.destination,
+        startingBalance: toStroops(operation.startingBalance),
+        type: "createAccount" as const,
+      };
+    case "changeTrust":
+      return {
+        ...withSource,
+        limit: toStroops(operation.limit),
+        line: toTrezorAsset(operation.line),
+        type: "changeTrust" as const,
+      };
+    default:
+      throw notSupported(`Unsupported Stellar operation: ${operation.type}`);
+  }
+}
+
+function decodeTextMemo(value: StellarClassicTransaction["memo"]["value"]) {
+  if (typeof value === "string") return value;
+
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(value ?? undefined);
+  } catch {
+    throw notSupported("Trezor only signs UTF-8 text memos");
+  }
+}
+
+function toTrezorMemo({ type, value }: StellarClassicTransaction["memo"]) {
+  switch (type) {
+    case "none":
+      return undefined;
+    case "text":
+      return { text: decodeTextMemo(value), type: MEMO_TYPES.text };
+    case "id":
+      return { id: String(value), type: MEMO_TYPES.id };
+    case "hash":
+    case "return":
+      return { hash: Buffer.from(value ?? "").toString("hex"), type: MEMO_TYPES[type] };
+    default:
+      throw notSupported(`Unsupported Stellar memo type: ${type}`);
+  }
+}
+
+export function toTrezorStellarTransaction(transaction: StellarTransaction) {
+  if ("innerTransaction" in transaction) throw notSupported("Trezor cannot sign fee bump transactions");
+
+  if (!transaction.timeBounds) throw notSupported("Trezor requires transaction time bounds");
+  const { extraSigners, ledgerBounds, minAccountSequence, minAccountSequenceAge, minAccountSequenceLedgerGap } =
+    transaction;
+  const hasPreconditions = [ledgerBounds, minAccountSequence, minAccountSequenceAge, minAccountSequenceLedgerGap].some(
+    (precondition) => precondition !== undefined,
+  );
+  if (hasPreconditions || extraSigners?.length) {
+    throw notSupported("Trezor cannot sign Stellar transactions with extra preconditions");
+  }
+
+  return {
+    networkPassphrase: transaction.networkPassphrase,
+    transaction: {
+      fee: Number(transaction.fee),
+      memo: toTrezorMemo(transaction.memo),
+      operations: transaction.operations.map(toTrezorOperation),
+      sequence: transaction.sequence,
+      source: transaction.source,
+      timebounds: {
+        maxTime: toTimeBound(transaction.timeBounds.maxTime),
+        minTime: toTimeBound(transaction.timeBounds.minTime),
+      },
+    },
+  };
+}
+
+export function getStellarSigner({ derivationPath }: { derivationPath: DerivationPathArray }): StellarSigner {
+  if (derivationPath[3] || derivationPath[4]) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_derivation_path_not_supported",
+      info: { chain: Chain.Stellar, derivationPath, reason: "Stellar only uses m/44'/148'/x'" },
+    });
+  }
+
+  const path = derivationPathToString(derivationPath.slice(0, 3) as [number, number, number]);
+  let address = "";
+
+  async function getAddress() {
+    if (address) return address;
+
+    const TrezorConnect = (await import("@trezor/connect-web")).default;
+    const result = await TrezorConnect.stellarGetAddress({ path, showOnTrezor: true });
+
+    if (!result.success) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_get_address",
+        info: { chain: Chain.Stellar, derivationPath, error: result.payload.error },
+      });
+    }
+
+    address = result.payload.address;
+    return address;
+  }
+
+  async function signTransaction(transaction: StellarTransaction) {
+    const params = toTrezorStellarTransaction(transaction);
+    if (params.transaction.source !== (await getAddress())) {
+      throw notSupported("Transaction source does not match the Trezor address");
+    }
+
+    const TrezorConnect = (await import("@trezor/connect-web")).default;
+    const result = await TrezorConnect.stellarSignTransaction({ path, ...params });
+
+    if (!result.success) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_sign_transaction",
+        info: { chain: Chain.Stellar, error: result.payload.error },
+      });
+    }
+
+    try {
+      transaction.addSignature(address, Buffer.from(result.payload.signature, "hex").toString("base64"));
+    } catch (error) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_sign_transaction",
+        info: { chain: Chain.Stellar, error },
+      });
+    }
+
+    return transaction;
+  }
+
+  return { getAddress, signTransaction };
+}

package/src/trezor/tronSigner.ts

@@ -0,0 +1,148 @@
+import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from "@swapkit/helpers";
+import {
+  type TronSignedTransaction,
+  type TronSigner,
+  type TronTransaction,
+  tronAddressToHex,
+} from "@swapkit/toolboxes/tron";
+
+type TronFields = Record<string, unknown>;
+
+const TRON_HEX_ADDRESS = /^41[0-9a-f]{40}$/i;
+// Fields Trezor rebuilds itself; anything else would change the bytes it signs
+const RAW_DATA_FIELDS = new Set([
+  "contract",
+  "data",
+  "expiration",
+  "fee_limit",
+  "ref_block_bytes",
+  "ref_block_hash",
+  "timestamp",
+]);
+const CONTRACT_FIELDS = new Set(["parameter", "type"]);
+const CONTRACT_VALUE_FIELDS: Record<string, Set<string>> = {
+  TransferContract: new Set(["amount", "owner_address", "to_address"]),
+  TriggerSmartContract: new Set(["contract_address", "data", "owner_address"]),
+};
+const PROTOBUF_DEFAULTS: unknown[] = [undefined, null, 0, "", false];
+
+function notSupported(reason: string) {
+  return new SwapKitError({ errorKey: "wallet_trezor_method_not_supported", info: { chain: Chain.Tron, reason } });
+}
+
+function assertKnownFields(fields: TronFields, allowed: Set<string>, scope: string) {
+  const unknown = Object.keys(fields).filter(
+    (field) => !allowed.has(field) && !PROTOBUF_DEFAULTS.includes(fields[field]),
+  );
+  if (unknown.length > 0) throw notSupported(`Trezor cannot sign Tron ${scope} with ${unknown.join(", ")}`);
+}
+
+function getStringField(value: TronFields, field: string) {
+  const fieldValue = value[field];
+  if (typeof fieldValue !== "string" || !fieldValue) throw notSupported(`Missing ${field} in Tron contract`);
+  return fieldValue;
+}
+
+function getAmount(value: TronFields) {
+  const { amount } = value;
+  const isValid =
+    (typeof amount === "number" && Number.isSafeInteger(amount) && amount > 0) ||
+    (typeof amount === "string" && /^[1-9]\d*$/.test(amount));
+
+  if (!isValid) throw notSupported("Invalid amount in Tron contract");
+  return String(amount);
+}
+
+export function toTrezorTronContract(transaction: TronTransaction) {
+  const [contract, ...rest] = transaction.raw_data.contract;
+  if (!contract || rest.length > 0) throw notSupported("Trezor signs Tron transactions with exactly one contract");
+
+  const value = contract.parameter.value;
+  const allowedValueFields = CONTRACT_VALUE_FIELDS[contract.type];
+  if (!allowedValueFields) throw notSupported(`Unsupported Tron contract type: ${contract.type}`);
+
+  assertKnownFields(transaction.raw_data as unknown as TronFields, RAW_DATA_FIELDS, "transactions");
+  assertKnownFields(contract as unknown as TronFields, CONTRACT_FIELDS, "contracts");
+  assertKnownFields(value, allowedValueFields, contract.type);
+
+  // `visible: false` means the node already returned the addresses in hex
+  const toHexAddress = (field: string) => {
+    const address = getStringField(value, field);
+    if (transaction.visible !== false) return tronAddressToHex(address);
+    if (TRON_HEX_ADDRESS.test(address)) return address.toLowerCase();
+
+    throw notSupported(`Invalid hex ${field} in Tron contract`);
+  };
+
+  const owner_address = toHexAddress("owner_address");
+
+  if (contract.type === "TransferContract") {
+    return {
+      parameter: { value: { amount: getAmount(value), owner_address, to_address: toHexAddress("to_address") } },
+      type: "TransferContract" as const,
+    };
+  }
+
+  return {
+    parameter: {
+      value: { contract_address: toHexAddress("contract_address"), data: getStringField(value, "data"), owner_address },
+    },
+    type: "TriggerSmartContract" as const,
+  };
+}
+
+export function getTronSigner({
+  address: knownAddress,
+  derivationPath,
+}: {
+  address?: string;
+  derivationPath: DerivationPathArray;
+}): TronSigner {
+  const path = derivationPathToString(derivationPath);
+  let address = knownAddress ?? "";
+
+  return {
+    getAddress: async () => {
+      if (address) return address;
+
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+      const result = await TrezorConnect.tronGetAddress({ path, showOnTrezor: true });
+
+      if (!result.success) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_get_address",
+          info: { chain: Chain.Tron, derivationPath, error: result.payload.error },
+        });
+      }
+
+      address = result.payload.address;
+      return address;
+    },
+
+    signTransaction: async (transaction: TronTransaction): Promise<TronSignedTransaction> => {
+      const contract = toTrezorTronContract(transaction);
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+      const { data, expiration, fee_limit, ref_block_bytes, ref_block_hash, timestamp } = transaction.raw_data;
+
+      const result = await TrezorConnect.tronSignTransaction({
+        contract: [contract],
+        data,
+        expiration,
+        fee_limit,
+        path,
+        ref_block_bytes,
+        ref_block_hash,
+        timestamp,
+      });
+
+      if (!result.success) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain: Chain.Tron, error: result.payload.error },
+        });
+      }
+
+      return { ...transaction, signature: [result.payload.signature.replace(/^0x/, "")] };
+    },
+  };
+}