@swapkit/wallet-hardware 6.1.1 → 6.2.0

package/src/ledger/index.ts

@@ -1,12 +1,13 @@
 import type Transport from "@ledgerhq/hw-transport";
 import { hex } from "@scure/base";
 import {
-  type AssetValue,
+  AssetValue,
   Chain,
   type DerivationPathArray,
   derivationPathToString,
   FeeOption,
   filterSupportedChains,
+  type GenericTransferParams,
   getUTXOScriptTypeForPath,
   NetworkDerivationPath,
   SwapKitError,
@@ -14,6 +15,7 @@ import {
   UTXOScriptType,
   WalletOption,
 } from "@swapkit/helpers";
+import type { TONTransactionInput } from "@swapkit/toolboxes/ton";
 import {
   addInputsAndOutputs,
   assertDerivationIndex,
@@ -92,6 +94,7 @@ const LEDGER_SUPPORTED_CHAINS_CONFIG = [
   Chain.BinanceSmartChain,
   Chain.Bitcoin,
   Chain.BitcoinCash,
+  Chain.Cardano,
   Chain.Cosmos,
   Chain.Dash,
   Chain.Dogecoin,
@@ -103,8 +106,11 @@ const LEDGER_SUPPORTED_CHAINS_CONFIG = [
   Chain.Optimism,
   Chain.Polygon,
   Chain.Ripple,
+  Chain.Robinhood,
+  Chain.Stellar,
   Chain.Sui,
   Chain.THORChain,
+  Chain.Ton,
   Chain.XLayer,
   Chain.Tron,
   Chain.Zcash,
@@ -134,6 +140,7 @@ const LEDGER_EVM_CHAINS = [
   Chain.Aurora,
   Chain.Gnosis,
   Chain.Monad,
+  Chain.Robinhood,
   Chain.XLayer,
 ] as const satisfies readonly LedgerSupportedChain[];
 
@@ -169,35 +176,26 @@ export const ledgerWallet = createWallet({
 
       return true;
     },
-  directSigningSupport: {
-    [Chain.Arbitrum]: true,
-    [Chain.Arc]: true,
-    [Chain.Aurora]: true,
-    [Chain.Avalanche]: true,
-    [Chain.Base]: true,
-    [Chain.Berachain]: true,
-    [Chain.BinanceSmartChain]: true,
-    [Chain.Ethereum]: true,
-    [Chain.Gnosis]: true,
-    [Chain.Monad]: true,
-    [Chain.Bitcoin]: true,
-    [Chain.BitcoinCash]: true,
-    [Chain.Cosmos]: true,
-    [Chain.Dash]: true,
-    [Chain.Dogecoin]: true,
-    [Chain.Litecoin]: true,
-    [Chain.Near]: true,
-    [Chain.Optimism]: true,
-    [Chain.Polygon]: true,
-    [Chain.Ripple]: true,
-    [Chain.Sui]: true,
-    [Chain.THORChain]: true,
-    [Chain.Tron]: true,
-    [Chain.XLayer]: true,
-    // ZEC transparent transfers use DSK, but route-level PCZT signing remains unsupported.
-  },
   getExtendedPublicKey: getLedgerExtendedPublicKey,
   name: "connectLedger",
+  signingSupport: {
+    ...Object.fromEntries(LEDGER_EVM_CHAINS.map((chain) => [chain, { direct: true, typedData: true }])),
+    [Chain.Bitcoin]: { direct: true },
+    [Chain.BitcoinCash]: { direct: true },
+    [Chain.Cardano]: { direct: true },
+    [Chain.Cosmos]: { direct: true },
+    [Chain.Dash]: { direct: true },
+    [Chain.Dogecoin]: { direct: true },
+    [Chain.Litecoin]: { direct: true },
+    [Chain.Near]: { direct: true },
+    [Chain.Ripple]: { direct: true },
+    [Chain.Stellar]: { direct: true },
+    [Chain.Sui]: { direct: true },
+    [Chain.THORChain]: { direct: true },
+    [Chain.Ton]: { direct: true },
+    [Chain.Tron]: { direct: true },
+    // ZEC transparent transfers use DSK, but route-level PCZT signing remains unsupported.
+  },
   supportedChains: [...LEDGER_SUPPORTED_CHAINS_CONFIG],
   walletType: WalletOption.LEDGER,
 });
@@ -649,6 +647,21 @@ async function getNearWalletMethods({
   return { ...toolbox, address: accountId };
 }
 
+async function getCardanoWalletMethods({
+  chain,
+  derivationPath,
+  dmkSession,
+  onDeviceActionState,
+  transport,
+}: WalletMethodsParams<Chain.Cardano>) {
+  const { getCardanoToolbox } = await import("@swapkit/toolboxes/cardano");
+  const signer = await getLedgerClient({ chain, derivationPath, dmkSession, onDeviceActionState, transport });
+  const address = signer.getAddress();
+  const toolbox = getCardanoToolbox({ signer });
+
+  return { ...toolbox, address };
+}
+
 async function getRippleWalletMethods({
   chain,
   derivationPath,
@@ -664,6 +677,21 @@ async function getRippleWalletMethods({
   return { ...toolbox, address };
 }
 
+async function getStellarWalletMethods({
+  chain,
+  derivationPath,
+  dmkSession,
+  onDeviceActionState,
+  transport,
+}: WalletMethodsParams<Chain.Stellar>) {
+  const { getStellarToolbox } = await import("@swapkit/toolboxes/stellar");
+  const signer = await getLedgerClient({ chain, derivationPath, dmkSession, onDeviceActionState, transport });
+  const address = await getLedgerAddress({ chain, ledgerClient: signer });
+  const toolbox = getStellarToolbox({ signer });
+
+  return { ...toolbox, address };
+}
+
 async function getTronWalletMethods({
   chain,
   derivationPath,
@@ -694,6 +722,47 @@ async function getSuiWalletMethods({
   return { ...toolbox, address };
 }
 
+async function getTONWalletMethods({
+  chain,
+  derivationPath,
+  dmkSession,
+  onDeviceActionState,
+  transport,
+}: WalletMethodsParams<Chain.Ton>) {
+  const { getTONToolbox } = await import("@swapkit/toolboxes/ton");
+  const signer = await getLedgerClient({ chain, derivationPath, dmkSession, onDeviceActionState, transport });
+  const address = await getLedgerAddress({ chain, ledgerClient: signer });
+  // Signerless toolbox: it builds messages and reads balances, the device signs the external message.
+  const toolbox = getTONToolbox();
+
+  const signAndBroadcastTransaction = async (transaction: TONTransactionInput) =>
+    toolbox.broadcastTransaction(await signer.signTransaction(transaction));
+
+  const transfer = async ({ assetValue, memo, recipient, sweep }: GenericTransferParams) =>
+    signAndBroadcastTransaction(
+      await toolbox.createTransaction({ assetValue, memo, recipient, sender: address, sweep }),
+    );
+
+  // Same budget as TON Connect: the signerless toolbox underestimates jetton fees
+  const estimateTransactionFee = ({ assetValue }: GenericTransferParams) =>
+    Promise.resolve(AssetValue.from({ chain: Chain.Ton, value: assetValue.isGasAsset ? "0.01" : "0.06" }));
+
+  const sign = () => {
+    throw new SwapKitError("wallet_ledger_method_not_supported", { method: "sign", wallet: WalletOption.LEDGER });
+  };
+
+  return {
+    ...toolbox,
+    address,
+    estimateTransactionFee,
+    getAddress: () => address,
+    getBalance: () => toolbox.getBalance(address),
+    sign,
+    signAndBroadcastTransaction,
+    transfer,
+  };
+}
+
 function getWalletMethods(params: WalletMethodsParams) {
   if (!isLedgerSupportedChain(params.chain)) {
     throw new SwapKitError("wallet_ledger_chain_not_supported", { chain: params.chain });
@@ -706,8 +775,11 @@ function getWalletMethods(params: WalletMethodsParams) {
     .with(Chain.THORChain, (chain) => getTHORChainWalletMethods({ ...params, chain }))
     .with(Chain.Near, (chain) => getNearWalletMethods({ ...params, chain }))
     .with(Chain.Ripple, (chain) => getRippleWalletMethods({ ...params, chain }))
+    .with(Chain.Stellar, (chain) => getStellarWalletMethods({ ...params, chain }))
+    .with(Chain.Cardano, (chain) => getCardanoWalletMethods({ ...params, chain }))
     .with(Chain.Tron, (chain) => getTronWalletMethods({ ...params, chain }))
     .with(Chain.Sui, (chain) => getSuiWalletMethods({ ...params, chain }))
+    .with(Chain.Ton, (chain) => getTONWalletMethods({ ...params, chain }))
     .exhaustive();
 }
 

package/src/ledger/types.ts

@@ -13,6 +13,7 @@ import type {
   MonadLedger,
   OptimismLedger,
   PolygonLedger,
+  RobinhoodLedger,
   XLayerLedger,
 } from "./clients/evm";
 import type { SuiLedger } from "./clients/sui";
@@ -42,6 +43,7 @@ export type EVMLedgerClients =
   | ReturnType<typeof MonadLedger>
   | ReturnType<typeof OptimismLedger>
   | ReturnType<typeof PolygonLedger>
+  | ReturnType<typeof RobinhoodLedger>
   | ReturnType<typeof XLayerLedger>;
 export type TronLedgerClient = ReturnType<typeof TronLedger>;
 export type SuiLedgerClient = ReturnType<typeof SuiLedger>;

package/src/trezor/cardanoSigner.ts

@@ -8,13 +8,13 @@ import {
 } from "@swapkit/toolboxes/cardano";
 import type {
   CardanoAssetGroup,
-  CardanoInput,
   CardanoOutput,
   CardanoSignedTxData,
   CardanoSignTransaction,
-  PROTO,
 } from "@trezor/connect-web";
 
+import { type CardanoOutputFields, readCardanoBody } from "../helpers/cardano";
+
 type CardanoAddressParams = { address: string; path: string; stakingPath: string };
 export type TrezorConnectModule = typeof import("@trezor/connect-web");
 
@@ -26,9 +26,6 @@ function getConnectParams({ CARDANO, PROTO }: TrezorConnectModule) {
   };
 }
 
-const BODY = { AUXILIARY_DATA_HASH: 7, FEE: 2, INPUTS: 0, OUTPUTS: 1, TTL: 3, VALIDITY_INTERVAL_START: 8 } as const;
-const SET_TAG = 258;
-
 function notSupported(reason: string) {
   return new SwapKitError({ errorKey: "wallet_trezor_method_not_supported", info: { chain: Chain.Cardano, reason } });
 }
@@ -40,50 +37,12 @@ function signFailed(error: string) {
   });
 }
 
-function toUint(value: unknown, field: string) {
-  const isBigNumber = typeof value === "object" && value !== null && "toFixed" in value;
-  const text = isBigNumber || Number.isSafeInteger(value) ? String((value as number).toFixed()) : "";
-  if (!/^\d+$/.test(text)) throw notSupported(`Invalid ${field} in Cardano transaction`);
-  return text;
-}
-
-function toTokenBundle(multiAsset: Map<Uint8Array, Map<Uint8Array, unknown>>): CardanoAssetGroup[] {
-  return [...multiAsset].map(([policyId, assets]) => ({
-    policyId: hex.encode(policyId),
-    tokenAmounts: [...assets].map(([assetName, amount]) => ({
-      amount: toUint(amount, "token amount"),
-      assetNameBytes: hex.encode(assetName),
-    })),
-  }));
-}
-
 async function toTrezorOutput(
-  output: unknown,
+  { address, amount, format, tokenGroups }: CardanoOutputFields,
   own: CardanoAddressParams,
   proto: TrezorConnectModule["PROTO"],
 ): Promise<CardanoOutput> {
-  let address: unknown;
-  let value: unknown;
-  let format: PROTO.CardanoTxOutputSerializationFormat;
-
-  if (Array.isArray(output)) {
-    if (output.length !== 2) throw notSupported("Trezor cannot sign Cardano outputs with a datum");
-    [address, value] = output;
-    format = proto.CardanoTxOutputSerializationFormat.ARRAY_LEGACY;
-  } else if (output instanceof Map) {
-    if (output.has(2)) throw notSupported("Trezor cannot sign Cardano outputs with a datum");
-    if (output.has(3)) throw notSupported("Trezor cannot sign Cardano outputs with a reference script");
-    if (output.size !== 2) throw notSupported("Unsupported field in Cardano output");
-    address = output.get(0);
-    value = output.get(1);
-    format = proto.CardanoTxOutputSerializationFormat.MAP_BABBAGE;
-  } else {
-    throw notSupported("Invalid Cardano output");
-  }
-
-  if (Array.isArray(value) && value.length !== 2) throw notSupported("Invalid Cardano output value");
-  const [coin, multiAsset] = Array.isArray(value) ? value : [value];
-  const outputAddress = await getCardanoAddressFromBytes(address as Uint8Array);
+  const outputAddress = await getCardanoAddressFromBytes(address);
   const destination =
     outputAddress === own.address
       ? {
@@ -94,29 +53,22 @@ async function toTrezorOutput(
           },
         }
       : { address: outputAddress };
+  const tokenBundle: CardanoAssetGroup[] | undefined = tokenGroups?.map(({ policyId, tokens }) => ({
+    policyId: hex.encode(policyId),
+    tokenAmounts: tokens.map(({ amount, assetName }) => ({ amount, assetNameBytes: hex.encode(assetName) })),
+  }));
 
   return {
     ...destination,
-    amount: toUint(coin, "output amount"),
-    format,
-    ...(multiAsset === undefined ? {} : { tokenBundle: toTokenBundle(multiAsset) }),
+    amount,
+    format:
+      format === "legacy"
+        ? proto.CardanoTxOutputSerializationFormat.ARRAY_LEGACY
+        : proto.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
+    ...(tokenBundle === undefined ? {} : { tokenBundle }),
   };
 }
 
-function toTrezorInputs(inputs: unknown, path: string) {
-  const isTagged =
-    typeof inputs === "object" && inputs !== null && "tag" in inputs && inputs.tag === SET_TAG && "value" in inputs;
-  const list = (isTagged ? inputs.value : inputs) as unknown[][];
-
-  const trezorInputs: CardanoInput[] = list.map((input) => {
-    if (input.length !== 2) throw notSupported("Invalid Cardano input");
-    const [txHash, index] = input as [Uint8Array, unknown];
-    return { path, prev_hash: hex.encode(txHash), prev_index: Number(toUint(index, "input index")) };
-  });
-
-  return { inputs: trezorInputs, tagCborSets: isTagged };
-}
-
 export async function toTrezorCardanoTransaction(
   txHex: string,
   own: CardanoAddressParams,
@@ -125,31 +77,23 @@ export async function toTrezorCardanoTransaction(
   const { body } = await decodeCardanoTransaction(txHex);
   const { derivationType, mainnet } = getConnectParams(connect);
   const { PROTO: proto } = connect;
-
-  const supportedFields: unknown[] = Object.values(BODY);
-  const unsupported = [...body.keys()].filter((field) => !supportedFields.includes(field));
-  if (unsupported.length > 0) {
-    throw notSupported(`Trezor cannot sign Cardano transactions with body fields ${unsupported.join(", ")}`);
-  }
-
-  const outputs = body.get(BODY.OUTPUTS) as unknown[];
-  const auxiliaryDataHash = body.get(BODY.AUXILIARY_DATA_HASH) as Uint8Array | undefined;
-
-  const ttl = body.get(BODY.TTL);
-  const validityIntervalStart = body.get(BODY.VALIDITY_INTERVAL_START);
+  const { auxiliaryDataHash, fee, inputs, outputs, tagCborSets, ttl, validityIntervalStart } = readCardanoBody(
+    body,
+    "Trezor",
+    notSupported,
+  );
 
   return {
-    ...toTrezorInputs(body.get(BODY.INPUTS), own.path),
+    inputs: inputs.map(({ index, txHash }) => ({ path: own.path, prev_hash: hex.encode(txHash), prev_index: index })),
+    tagCborSets,
     ...mainnet,
     derivationType,
-    fee: toUint(body.get(BODY.FEE), "fee"),
+    fee,
     outputs: await Promise.all(outputs.map((output) => toTrezorOutput(output, own, proto))),
     signingMode: proto.CardanoTxSigningMode.ORDINARY_TRANSACTION,
     ...(auxiliaryDataHash ? { auxiliaryData: { hash: hex.encode(auxiliaryDataHash) } } : {}),
-    ...(ttl === undefined ? {} : { ttl: toUint(ttl, "ttl") }),
-    ...(validityIntervalStart === undefined
-      ? {}
-      : { validityIntervalStart: toUint(validityIntervalStart, "validity interval start") }),
+    ...(ttl === undefined ? {} : { ttl }),
+    ...(validityIntervalStart === undefined ? {} : { validityIntervalStart }),
   };
 }
 

package/src/trezor/index.ts

@@ -486,6 +486,35 @@ async function buildZcashTxOutputsForTrezor({
   return outputs;
 }
 
+type ZcashTrezorSignRequest = {
+  branchId: number;
+  expiry: number;
+  inputs: { amount: string; prev_hash: string; prev_index: number }[];
+  locktime: number;
+  outputs: { address?: string; amount: string; script_type: string }[];
+  version: number;
+  versionGroupId: number;
+};
+
+function describeZcashSignRequest({ inputs, outputs, ...header }: ZcashTrezorSignRequest) {
+  const sum = (amounts: { amount: string }[]) => amounts.reduce((total, { amount }) => total + BigInt(amount), 0n);
+  const inputTotal = sum(inputs);
+  const outputTotal = sum(outputs);
+
+  return {
+    ...header,
+    fee: (inputTotal - outputTotal).toString(),
+    inputAmounts: inputs.map(({ amount }) => amount),
+    inputs: inputs.map(({ prev_hash, prev_index }) => `${prev_hash}:${prev_index}`),
+    inputTotal: inputTotal.toString(),
+    outputs: outputs.map(({ address, amount, script_type }) => ({
+      amount,
+      kind: script_type === "PAYTOOPRETURN" ? "op_return" : address ? "external" : "change",
+    })),
+    outputTotal: outputTotal.toString(),
+  };
+}
+
 async function buildUtxoOutputsForTrezor(
   tx: Transaction,
   network: BTCNetwork,
@@ -657,11 +686,12 @@ async function getTrezorWallet<T extends Chain>({
     case Chain.Zcash: {
       const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
+      const coin = chain.toLowerCase();
       const derivationPathStr = derivationPathToString(derivationPath);
 
       const getAddress = async () => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
-        const { success, payload } = await TrezorConnect.getAddress({ coin: "zcash", path: derivationPathStr });
+        const { success, payload } = await TrezorConnect.getAddress({ coin, path: derivationPathStr });
 
         if (!success) {
           throw new SwapKitError({
@@ -675,37 +705,41 @@ async function getTrezorWallet<T extends Chain>({
 
       const address = providedAddress ?? (await getAddress());
 
-      const signPCZTWithSerializedTx = async (pczt: PCZT) => {
+      const signWithTrezor = async (request: ZcashTrezorSignRequest, signingPath: "pczt" | "transaction") => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
+        const result = await TrezorConnect.signTransaction({ ...request, coin, overwintered: true } as Parameters<
+          typeof TrezorConnect.signTransaction
+        >[0]);
+
+        if (!result.success) {
+          throw new SwapKitError({
+            errorKey: "wallet_trezor_failed_to_sign_transaction",
+            info: { ...result.payload, chain, derivationPath, request: describeZcashSignRequest(request), signingPath },
+          });
+        }
+
+        return result.payload.serializedTx;
+      };
+
+      const signPCZTWithSerializedTx = async (pczt: PCZT) => {
         const { hex: hexEncode } = await import("@scure/base");
         const address_n = hardenDerivationPath(derivationPath);
         const global = pczt.getGlobal();
 
         const inputs = buildPCZTInputsForTrezor(pczt, address_n, hexEncode);
         const outputs = await buildPCZTOutputsForTrezor(pczt, address_n, address, chain);
-        const result = await TrezorConnect.signTransaction({
+        const request = {
           branchId: global.consensusBranchId,
-          coin: "zcash",
           expiry: global.expiryHeight,
           inputs,
           locktime: global.lockTime,
-          outputs: outputs as any,
-          overwintered: true,
+          outputs,
           version: global.txVersion,
           versionGroupId: global.versionGroupId,
-        });
-
-        if (!result.success) {
-          throw new SwapKitError({
-            errorKey: "wallet_trezor_failed_to_sign_transaction",
-            info: { chain, error: (result.payload as { error: string; code?: string }).error },
-          });
-        }
-
-        return {
-          serializedTx: result.payload.serializedTx,
-          signedPczt: await extractSignaturesFromSignedTx(result.payload.serializedTx, pczt),
         };
+        const serializedTx = await signWithTrezor(request, "pczt");
+
+        return { serializedTx, signedPczt: await extractSignaturesFromSignedTx(serializedTx, pczt) };
       };
 
       const parseSignedZcashTransaction = async (signedTxHex: string) => {
@@ -714,7 +748,6 @@ async function getTrezorWallet<T extends Chain>({
       };
 
       const signZcashTransactionWithSerializedTx = async (tx: ZcashTransaction) => {
-        const TrezorConnect = (await import("@trezor/connect-web")).default;
         const { hex: hexEncode } = await import("@scure/base");
         const { NETWORKS, ZcashVersionGroupId } = await import("@swapkit/utxo-signer");
         const address_n = hardenDerivationPath(derivationPath);
@@ -728,29 +761,18 @@ async function getTrezorWallet<T extends Chain>({
           tx,
         });
 
-        const result = await TrezorConnect.signTransaction({
+        const request = {
           branchId: tx.consensusBranchId,
-          coin: "zcash",
           expiry: 0,
           inputs,
           locktime: 0,
-          outputs: outputs as any,
-          overwintered: true,
+          outputs,
           version: 4,
           versionGroupId: ZcashVersionGroupId.SAPLING,
-        });
-
-        if (result.success) {
-          return {
-            serializedTx: result.payload.serializedTx,
-            signedTx: await parseSignedZcashTransaction(result.payload.serializedTx),
-          };
-        }
+        };
+        const serializedTx = await signWithTrezor(request, "transaction");
 
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: { chain, error: (result.payload as { error: string; code?: string }).error },
-        });
+        return { serializedTx, signedTx: await parseSignedZcashTransaction(serializedTx) };
       };
 
       const signer = {
@@ -1427,7 +1449,7 @@ export async function getTrezorExtendedPublicKey(
   const { TrezorConnect } = await initTrezorConnect();
   const utxoChain = chain as UTXOChain;
   const resolvedDerivationPath = derivationPath ?? (NetworkDerivationPath[chain] as DerivationPathArray);
-  const coin = chain === Chain.Zcash ? "zcash" : chain.toLowerCase();
+  const coin = chain.toLowerCase();
 
   const resolvedAccountPath = getUTXOAccountPath({
     accountIndex,
@@ -1531,36 +1553,36 @@ export const trezorWallet = createWallet({
 
       return true;
     },
-  directSigningSupport: {
-    [Chain.Arbitrum]: true,
-    [Chain.Arc]: true,
-    [Chain.Aurora]: true,
-    [Chain.Avalanche]: true,
-    [Chain.Base]: true,
-    [Chain.Berachain]: true,
-    [Chain.BinanceSmartChain]: true,
-    [Chain.Bitcoin]: true,
-    [Chain.BitcoinCash]: true,
-    [Chain.Cardano]: true,
-    [Chain.Dash]: true,
-    [Chain.Ethereum]: true,
-    [Chain.Gnosis]: true,
-    [Chain.Dogecoin]: true,
-    [Chain.Hyperevm]: true,
-    [Chain.Litecoin]: true,
-    [Chain.Monad]: true,
-    [Chain.Optimism]: true,
-    [Chain.Polygon]: true,
-    [Chain.Ripple]: true,
-    [Chain.Robinhood]: true,
-    [Chain.Solana]: true,
-    [Chain.Stellar]: true,
-    [Chain.Tron]: true,
-    [Chain.XLayer]: true,
-    [Chain.Zcash]: true,
-  },
   getExtendedPublicKey: getTrezorExtendedPublicKey,
   name: "connectTrezor",
+  signingSupport: {
+    [Chain.Arbitrum]: { direct: true, typedData: true },
+    [Chain.Arc]: { direct: true, typedData: true },
+    [Chain.Aurora]: { direct: true, typedData: true },
+    [Chain.Avalanche]: { direct: true, typedData: true },
+    [Chain.Base]: { direct: true, typedData: true },
+    [Chain.Berachain]: { direct: true, typedData: true },
+    [Chain.BinanceSmartChain]: { direct: true, typedData: true },
+    [Chain.Bitcoin]: { direct: true },
+    [Chain.BitcoinCash]: { direct: true },
+    [Chain.Cardano]: { direct: true },
+    [Chain.Dash]: { direct: true },
+    [Chain.Ethereum]: { direct: true, typedData: true },
+    [Chain.Gnosis]: { direct: true, typedData: true },
+    [Chain.Dogecoin]: { direct: true },
+    [Chain.Hyperevm]: { direct: true, typedData: true },
+    [Chain.Litecoin]: { direct: true },
+    [Chain.Monad]: { direct: true, typedData: true },
+    [Chain.Optimism]: { direct: true, typedData: true },
+    [Chain.Polygon]: { direct: true, typedData: true },
+    [Chain.Ripple]: { direct: true },
+    [Chain.Robinhood]: { direct: true, typedData: true },
+    [Chain.Solana]: { direct: true },
+    [Chain.Stellar]: { direct: true },
+    [Chain.Tron]: { direct: true },
+    [Chain.XLayer]: { direct: true, typedData: true },
+    [Chain.Zcash]: { direct: true },
+  },
   supportedChains: [
     Chain.Arbitrum,
     Chain.Arc,

package/dist/chunk-5p3ttw6y.js

@@ -1,4 +0,0 @@
-import{Fa as a,Ga as b,Ha as c}from"./chunk-ds2m83jp.js";import"./chunk-nhva847d.js";export{b as signLegacyPsbtTransaction,a as extractInputsFromPsbt,c as createLegacyPsbtSigner};
-
-//# debugId=F3CCCADD39A261C464756E2164756E21
-//# sourceMappingURL=chunk-5p3ttw6y.js.map

package/dist/chunk-qjq7gvyx.js

@@ -1,4 +0,0 @@
-import"./chunk-nhva847d.js";import{hex as F}from"@scure/base";import{Chain as Y,derivationPathToString as A,SwapKitError as f}from"@swapkit/helpers";import{addCardanoVkeyWitnesses as g,decodeCardanoTransaction as m,getCardanoAddressFromBytes as H,getCardanoPublicKeyHash as O}from"@swapkit/toolboxes/cardano";function K({CARDANO:j,PROTO:q}){return{derivationType:q.CardanoDerivationType.ICARUS,mainnet:{networkId:j.NETWORK_IDS.mainnet,protocolMagic:j.PROTOCOL_MAGICS.mainnet}}}var _={AUXILIARY_DATA_HASH:7,FEE:2,INPUTS:0,OUTPUTS:1,TTL:3,VALIDITY_INTERVAL_START:8},P=258;function G(j){return new f({errorKey:"wallet_trezor_method_not_supported",info:{chain:Y.Cardano,reason:j}})}function B(j){return new f({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:Y.Cardano,error:j}})}function z(j,q){let J=typeof j==="object"&&j!==null&&"toFixed"in j||Number.isSafeInteger(j)?String(j.toFixed()):"";if(!/^\d+$/.test(J))throw G(`Invalid ${q} in Cardano transaction`);return J}function T(j){return[...j].map(([q,L])=>({policyId:F.encode(q),tokenAmounts:[...L].map(([J,M])=>({amount:z(M,"token amount"),assetNameBytes:F.encode(J)}))}))}async function b(j,q,L){let J,M,Q;if(Array.isArray(j)){if(j.length!==2)throw G("Trezor cannot sign Cardano outputs with a datum");[J,M]=j,Q=L.CardanoTxOutputSerializationFormat.ARRAY_LEGACY}else if(j instanceof Map){if(j.has(2))throw G("Trezor cannot sign Cardano outputs with a datum");if(j.has(3))throw G("Trezor cannot sign Cardano outputs with a reference script");if(j.size!==2)throw G("Unsupported field in Cardano output");J=j.get(0),M=j.get(1),Q=L.CardanoTxOutputSerializationFormat.MAP_BABBAGE}else throw G("Invalid Cardano output");if(Array.isArray(M)&&M.length!==2)throw G("Invalid Cardano output value");let[Z,X]=Array.isArray(M)?M:[M],$=await H(J);return{...$===q.address?{addressParameters:{addressType:L.CardanoAddressType.BASE,path:q.path,stakingPath:q.stakingPath}}:{address:$},amount:z(Z,"output amount"),format:Q,...X===void 0?{}:{tokenBundle:T(X)}}}function x(j,q){let L=typeof j==="object"&&j!==null&&"tag"in j&&j.tag===P&&"value"in j;return{inputs:(L?j.value:j).map((Q)=>{if(Q.length!==2)throw G("Invalid Cardano input");let[Z,X]=Q;return{path:q,prev_hash:F.encode(Z),prev_index:Number(z(X,"input index"))}}),tagCborSets:L}}async function v(j,q,L){let{body:J}=await m(j),{derivationType:M,mainnet:Q}=K(L),{PROTO:Z}=L,X=Object.values(_),$=[...J.keys()].filter((V)=>!X.includes(V));if($.length>0)throw G(`Trezor cannot sign Cardano transactions with body fields ${$.join(", ")}`);let W=J.get(_.OUTPUTS),U=J.get(_.AUXILIARY_DATA_HASH),N=J.get(_.TTL),E=J.get(_.VALIDITY_INTERVAL_START);return{...x(J.get(_.INPUTS),q.path),...Q,derivationType:M,fee:z(J.get(_.FEE),"fee"),outputs:await Promise.all(W.map((V)=>b(V,q,Z))),signingMode:Z.CardanoTxSigningMode.ORDINARY_TRANSACTION,...U?{auxiliaryData:{hash:F.encode(U)}}:{},...N===void 0?{}:{ttl:z(N,"ttl")},...E===void 0?{}:{validityIntervalStart:z(E,"validity interval start")}}}async function y(j,{hash:q,witnesses:L},J,{PROTO:M}){let{bodyHash:Q}=await m(j);if(q.toLowerCase()!==Q)throw B("Trezor signed a different transaction body");let Z=L.map(({pubKey:X,signature:$,type:W})=>{if(W!==M.CardanoTxWitnessType.SHELLEY_WITNESS||X.toLowerCase()!==J)throw B("Trezor returned a witness for an unexpected key");return{publicKey:F.decode(X),signature:F.decode($)}});return g(j,Z)}async function d({connect:j,derivationPath:q}){let[L,J,M,Q,Z]=q;if(q.length!==5||Q!==0||Z===void 0)throw new f({errorKey:"wallet_trezor_derivation_path_not_supported",info:{chain:Y.Cardano,derivationPath:q}});let X=A(q),$=A([L,J,M,2,0]),{derivationType:W,mainnet:U}=K(j),N=j.default,E=await N.cardanoGetPublicKey({bundle:[X,$].map((I)=>({derivationType:W,path:I}))});if(!E.success)throw new f({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:Y.Cardano,derivationPath:q,error:E.payload.error}});let[V,S]=E.payload.map(({node:I})=>Buffer.from(I.public_key,"hex")),k=await O(V),D=await H(Buffer.concat([Buffer.from([U.networkId]),k,await O(S)]));async function w(I){let C=await v(I,{address:D,path:X,stakingPath:$},j),R=await N.cardanoSignTransaction(C);if(!R.success)throw B(R.payload.error);return y(I,R.payload,V.toString("hex"),j)}return{getAddress:()=>D,publicKey:V,publicKeyHash:k,signTransaction:w}}export{v as toTrezorCardanoTransaction,d as getCardanoSigner,y as addTrezorWitnesses};
-
-//# debugId=610DAB94A71C5BD564756E2164756E21
-//# sourceMappingURL=chunk-qjq7gvyx.js.map

package/dist/chunk-qjq7gvyx.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/trezor/cardanoSigner.ts"],
-  "sourcesContent": [
-    "import { hex } from \"@scure/base\";\nimport { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from \"@swapkit/helpers\";\nimport {\n  addCardanoVkeyWitnesses,\n  decodeCardanoTransaction,\n  getCardanoAddressFromBytes,\n  getCardanoPublicKeyHash,\n} from \"@swapkit/toolboxes/cardano\";\nimport type {\n  CardanoAssetGroup,\n  CardanoInput,\n  CardanoOutput,\n  CardanoSignedTxData,\n  CardanoSignTransaction,\n  PROTO,\n} from \"@trezor/connect-web\";\n\ntype CardanoAddressParams = { address: string; path: string; stakingPath: string };\nexport type TrezorConnectModule = typeof import(\"@trezor/connect-web\");\n\nfunction getConnectParams({ CARDANO, PROTO }: TrezorConnectModule) {\n  return {\n    // Trezor Suite default, same as the SwapKit keystore\n    derivationType: PROTO.CardanoDerivationType.ICARUS,\n    mainnet: { networkId: CARDANO.NETWORK_IDS.mainnet, protocolMagic: CARDANO.PROTOCOL_MAGICS.mainnet },\n  };\n}\n\nconst BODY = { AUXILIARY_DATA_HASH: 7, FEE: 2, INPUTS: 0, OUTPUTS: 1, TTL: 3, VALIDITY_INTERVAL_START: 8 } as const;\nconst SET_TAG = 258;\n\nfunction notSupported(reason: string) {\n  return new SwapKitError({ errorKey: \"wallet_trezor_method_not_supported\", info: { chain: Chain.Cardano, reason } });\n}\n\nfunction signFailed(error: string) {\n  return new SwapKitError({\n    errorKey: \"wallet_trezor_failed_to_sign_transaction\",\n    info: { chain: Chain.Cardano, error },\n  });\n}\n\nfunction toUint(value: unknown, field: string) {\n  const isBigNumber = typeof value === \"object\" && value !== null && \"toFixed\" in value;\n  const text = isBigNumber || Number.isSafeInteger(value) ? String((value as number).toFixed()) : \"\";\n  if (!/^\\d+$/.test(text)) throw notSupported(`Invalid ${field} in Cardano transaction`);\n  return text;\n}\n\nfunction toTokenBundle(multiAsset: Map<Uint8Array, Map<Uint8Array, unknown>>): CardanoAssetGroup[] {\n  return [...multiAsset].map(([policyId, assets]) => ({\n    policyId: hex.encode(policyId),\n    tokenAmounts: [...assets].map(([assetName, amount]) => ({\n      amount: toUint(amount, \"token amount\"),\n      assetNameBytes: hex.encode(assetName),\n    })),\n  }));\n}\n\nasync function toTrezorOutput(\n  output: unknown,\n  own: CardanoAddressParams,\n  proto: TrezorConnectModule[\"PROTO\"],\n): Promise<CardanoOutput> {\n  let address: unknown;\n  let value: unknown;\n  let format: PROTO.CardanoTxOutputSerializationFormat;\n\n  if (Array.isArray(output)) {\n    if (output.length !== 2) throw notSupported(\"Trezor cannot sign Cardano outputs with a datum\");\n    [address, value] = output;\n    format = proto.CardanoTxOutputSerializationFormat.ARRAY_LEGACY;\n  } else if (output instanceof Map) {\n    if (output.has(2)) throw notSupported(\"Trezor cannot sign Cardano outputs with a datum\");\n    if (output.has(3)) throw notSupported(\"Trezor cannot sign Cardano outputs with a reference script\");\n    if (output.size !== 2) throw notSupported(\"Unsupported field in Cardano output\");\n    address = output.get(0);\n    value = output.get(1);\n    format = proto.CardanoTxOutputSerializationFormat.MAP_BABBAGE;\n  } else {\n    throw notSupported(\"Invalid Cardano output\");\n  }\n\n  if (Array.isArray(value) && value.length !== 2) throw notSupported(\"Invalid Cardano output value\");\n  const [coin, multiAsset] = Array.isArray(value) ? value : [value];\n  const outputAddress = await getCardanoAddressFromBytes(address as Uint8Array);\n  const destination =\n    outputAddress === own.address\n      ? {\n          addressParameters: {\n            addressType: proto.CardanoAddressType.BASE,\n            path: own.path,\n            stakingPath: own.stakingPath,\n          },\n        }\n      : { address: outputAddress };\n\n  return {\n    ...destination,\n    amount: toUint(coin, \"output amount\"),\n    format,\n    ...(multiAsset === undefined ? {} : { tokenBundle: toTokenBundle(multiAsset) }),\n  };\n}\n\nfunction toTrezorInputs(inputs: unknown, path: string) {\n  const isTagged =\n    typeof inputs === \"object\" && inputs !== null && \"tag\" in inputs && inputs.tag === SET_TAG && \"value\" in inputs;\n  const list = (isTagged ? inputs.value : inputs) as unknown[][];\n\n  const trezorInputs: CardanoInput[] = list.map((input) => {\n    if (input.length !== 2) throw notSupported(\"Invalid Cardano input\");\n    const [txHash, index] = input as [Uint8Array, unknown];\n    return { path, prev_hash: hex.encode(txHash), prev_index: Number(toUint(index, \"input index\")) };\n  });\n\n  return { inputs: trezorInputs, tagCborSets: isTagged };\n}\n\nexport async function toTrezorCardanoTransaction(\n  txHex: string,\n  own: CardanoAddressParams,\n  connect: TrezorConnectModule,\n): Promise<CardanoSignTransaction> {\n  const { body } = await decodeCardanoTransaction(txHex);\n  const { derivationType, mainnet } = getConnectParams(connect);\n  const { PROTO: proto } = connect;\n\n  const supportedFields: unknown[] = Object.values(BODY);\n  const unsupported = [...body.keys()].filter((field) => !supportedFields.includes(field));\n  if (unsupported.length > 0) {\n    throw notSupported(`Trezor cannot sign Cardano transactions with body fields ${unsupported.join(\", \")}`);\n  }\n\n  const outputs = body.get(BODY.OUTPUTS) as unknown[];\n  const auxiliaryDataHash = body.get(BODY.AUXILIARY_DATA_HASH) as Uint8Array | undefined;\n\n  const ttl = body.get(BODY.TTL);\n  const validityIntervalStart = body.get(BODY.VALIDITY_INTERVAL_START);\n\n  return {\n    ...toTrezorInputs(body.get(BODY.INPUTS), own.path),\n    ...mainnet,\n    derivationType,\n    fee: toUint(body.get(BODY.FEE), \"fee\"),\n    outputs: await Promise.all(outputs.map((output) => toTrezorOutput(output, own, proto))),\n    signingMode: proto.CardanoTxSigningMode.ORDINARY_TRANSACTION,\n    ...(auxiliaryDataHash ? { auxiliaryData: { hash: hex.encode(auxiliaryDataHash) } } : {}),\n    ...(ttl === undefined ? {} : { ttl: toUint(ttl, \"ttl\") }),\n    ...(validityIntervalStart === undefined\n      ? {}\n      : { validityIntervalStart: toUint(validityIntervalStart, \"validity interval start\") }),\n  };\n}\n\nexport async function addTrezorWitnesses(\n  txHex: string,\n  { hash, witnesses }: Pick<CardanoSignedTxData, \"hash\" | \"witnesses\">,\n  publicKey: string,\n  { PROTO: proto }: TrezorConnectModule,\n) {\n  const { bodyHash } = await decodeCardanoTransaction(txHex);\n\n  if (hash.toLowerCase() !== bodyHash) throw signFailed(\"Trezor signed a different transaction body\");\n\n  const vkeyWitnesses = witnesses.map(({ pubKey, signature, type }) => {\n    if (type !== proto.CardanoTxWitnessType.SHELLEY_WITNESS || pubKey.toLowerCase() !== publicKey) {\n      throw signFailed(\"Trezor returned a witness for an unexpected key\");\n    }\n    return { publicKey: hex.decode(pubKey), signature: hex.decode(signature) };\n  });\n\n  return addCardanoVkeyWitnesses(txHex, vkeyWitnesses);\n}\n\nexport async function getCardanoSigner({\n  connect,\n  derivationPath,\n}: {\n  connect: TrezorConnectModule;\n  derivationPath: DerivationPathArray;\n}) {\n  const [purpose, coinType, account, role, index] = derivationPath;\n  if (derivationPath.length !== 5 || role !== 0 || index === undefined) {\n    throw new SwapKitError({\n      errorKey: \"wallet_trezor_derivation_path_not_supported\",\n      info: { chain: Chain.Cardano, derivationPath },\n    });\n  }\n\n  const path = derivationPathToString(derivationPath);\n  const stakingPath = derivationPathToString([purpose, coinType, account, 2, 0] as DerivationPathArray);\n  const { derivationType, mainnet } = getConnectParams(connect);\n  const TrezorConnect = connect.default;\n\n  // One device call: a second one right after would need a new Connect popup\n  const keysResult = await TrezorConnect.cardanoGetPublicKey({\n    bundle: [path, stakingPath].map((keyPath) => ({ derivationType, path: keyPath })),\n  });\n  if (!keysResult.success) {\n    throw new SwapKitError({\n      errorKey: \"wallet_trezor_failed_to_get_address\",\n      info: { chain: Chain.Cardano, derivationPath, error: keysResult.payload.error },\n    });\n  }\n\n  const [publicKey, stakingKey] = keysResult.payload.map(({ node }) => Buffer.from(node.public_key, \"hex\")) as [\n    Buffer,\n    Buffer,\n  ];\n  const publicKeyHash = await getCardanoPublicKeyHash(publicKey);\n  const address = await getCardanoAddressFromBytes(\n    Buffer.concat([Buffer.from([mainnet.networkId]), publicKeyHash, await getCardanoPublicKeyHash(stakingKey)]),\n  );\n\n  async function signTransaction(txHex: string) {\n    const params = await toTrezorCardanoTransaction(txHex, { address, path, stakingPath }, connect);\n    const result = await TrezorConnect.cardanoSignTransaction(params);\n\n    if (!result.success) throw signFailed(result.payload.error);\n\n    return addTrezorWitnesses(txHex, result.payload, publicKey.toString(\"hex\"), connect);\n  }\n\n  return { getAddress: () => address, publicKey, publicKeyHash, signTransaction };\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "610DAB94A71C5BD564756E2164756E21",
-  "names": []
-}