@swapkit/wallet-hardware 6.0.0 → 6.1.0

package/dist/types/trezor/rippleSigner.d.ts

@@ -0,0 +1,23 @@
+import { type DerivationPathArray } from "@swapkit/helpers";
+import type { RippleTransaction } from "@swapkit/toolboxes/ripple";
+export declare function toTrezorRippleTransaction(transaction: RippleTransaction): {
+    fee: string;
+    flags: number | undefined;
+    maxLedgerVersion: number | undefined;
+    payment: {
+        amount: string;
+        destination: string;
+        destinationTag: number | undefined;
+    };
+    sequence: number;
+};
+export declare function getRippleSigner({ derivationPath }: {
+    derivationPath: DerivationPathArray;
+}): {
+    getAddress: () => Promise<string>;
+    signTransaction: (transaction: RippleTransaction) => Promise<{
+        hash: string;
+        tx_blob: string;
+    }>;
+};
+//# sourceMappingURL=rippleSigner.d.ts.map

package/dist/types/trezor/rippleSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rippleSigner.d.ts","sourceRoot":"","sources":["../../../src/trezor/rippleSigner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,mBAAmB,EAAwC,MAAM,kBAAkB,CAAC;AACzG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAqBnE,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,iBAAiB;;WA2BpD,MAAM,GAAG,SAAS;sBACM,MAAM,GAAG,SAAS;;;;wBAC6B,MAAM,GAAG,SAAS;;;EAG5G;AAED,wBAAgB,eAAe,CAAC,EAAE,cAAc,EAAE,EAAE;IAAE,cAAc,EAAE,mBAAmB,CAAA;CAAE;;mCAqB7C,iBAAiB;;;;EAsB9D"}

package/dist/types/trezor/solanaSigner.d.ts

@@ -0,0 +1,17 @@
+import { PublicKey, type Transaction, type VersionedTransaction } from "@solana/web3.js";
+import { type DerivationPathArray } from "@swapkit/helpers";
+type SolanaTransaction = Transaction | VersionedTransaction;
+export declare function getSolanaSigner({ address, derivationPath, }: {
+    address?: string;
+    derivationPath: DerivationPathArray;
+}): {
+    connect: () => Promise<{
+        publicKey: PublicKey;
+    }>;
+    disconnect: () => Promise<void>;
+    getAddress: () => Promise<string>;
+    readonly publicKey: PublicKey | null;
+    signTransaction: <T extends SolanaTransaction>(transaction: T) => Promise<T>;
+};
+export {};
+//# sourceMappingURL=solanaSigner.d.ts.map

package/dist/types/trezor/solanaSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solanaSigner.d.ts","sourceRoot":"","sources":["../../../src/trezor/solanaSigner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACzF,OAAO,EAAS,KAAK,mBAAmB,EAAwC,MAAM,kBAAkB,CAAC;AAEzG,KAAK,iBAAiB,GAAG,WAAW,GAAG,oBAAoB,CAAC;AAoD5D,wBAAgB,eAAe,CAAC,EAC9B,OAAO,EACP,cAAc,GACf,EAAE;IACD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,mBAAmB,CAAC;CACrC;;;;;;;sBAuCgC,CAAC,SAAS,iBAAiB,eAAe,CAAC;EA0B3E"}

package/dist/types/trezor/stellarSigner.d.ts

@@ -0,0 +1,99 @@
+import { type DerivationPathArray } from "@swapkit/helpers";
+import type { StellarSigner, StellarTransaction } from "@swapkit/toolboxes/stellar";
+export declare function toTrezorStellarTransaction(transaction: StellarTransaction): {
+    networkPassphrase: string;
+    transaction: {
+        fee: number;
+        memo: {
+            text: string;
+            type: 1;
+            id?: undefined;
+            hash?: undefined;
+        } | {
+            id: string;
+            type: 2;
+            text?: undefined;
+            hash?: undefined;
+        } | {
+            hash: string;
+            type: 4 | 3;
+            text?: undefined;
+            id?: undefined;
+        } | undefined;
+        operations: ({
+            amount: string;
+            asset: {
+                type: "NATIVE";
+                code?: undefined;
+                issuer?: undefined;
+            } | {
+                code: string;
+                issuer: string | undefined;
+                type: "ALPHANUM4" | "ALPHANUM12";
+            };
+            destination: string;
+            type: "payment";
+            source: string;
+        } | {
+            amount: string;
+            asset: {
+                type: "NATIVE";
+                code?: undefined;
+                issuer?: undefined;
+            } | {
+                code: string;
+                issuer: string | undefined;
+                type: "ALPHANUM4" | "ALPHANUM12";
+            };
+            destination: string;
+            type: "payment";
+            source?: undefined;
+        } | {
+            destination: string;
+            startingBalance: string;
+            type: "createAccount";
+            source: string;
+        } | {
+            destination: string;
+            startingBalance: string;
+            type: "createAccount";
+            source?: undefined;
+        } | {
+            limit: string;
+            line: {
+                type: "NATIVE";
+                code?: undefined;
+                issuer?: undefined;
+            } | {
+                code: string;
+                issuer: string | undefined;
+                type: "ALPHANUM4" | "ALPHANUM12";
+            };
+            type: "changeTrust";
+            source: string;
+        } | {
+            limit: string;
+            line: {
+                type: "NATIVE";
+                code?: undefined;
+                issuer?: undefined;
+            } | {
+                code: string;
+                issuer: string | undefined;
+                type: "ALPHANUM4" | "ALPHANUM12";
+            };
+            type: "changeTrust";
+            source?: undefined;
+        })[];
+        sequence: string;
+        source: string;
+        timebounds: {
+            maxTime: number;
+            minTime: number;
+        };
+    };
+};
+export declare function getStellarSigner({ derivationPath }: {
+    derivationPath: DerivationPathArray;
+}): StellarSigner;
+//# sourceMappingURL=stellarSigner.d.ts.map

package/dist/types/trezor/stellarSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stellarSigner.d.ts","sourceRoot":"","sources":["../../../src/trezor/stellarSigner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,mBAAmB,EAAwC,MAAM,kBAAkB,CAAC;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAkGpF,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BzE;AAED,wBAAgB,gBAAgB,CAAC,EAAE,cAAc,EAAE,EAAE;IAAE,cAAc,EAAE,mBAAmB,CAAA;CAAE,GAAG,aAAa,CAyD3G"}

package/dist/types/trezor/tronSigner.d.ts

@@ -0,0 +1,30 @@
+import { type DerivationPathArray } from "@swapkit/helpers";
+import { type TronSigner, type TronTransaction } from "@swapkit/toolboxes/tron";
+export declare function toTrezorTronContract(transaction: TronTransaction): {
+    parameter: {
+        value: {
+            amount: string;
+            owner_address: string;
+            to_address: string;
+            contract_address?: undefined;
+            data?: undefined;
+        };
+    };
+    type: "TransferContract";
+} | {
+    parameter: {
+        value: {
+            contract_address: string;
+            data: string;
+            owner_address: string;
+            amount?: undefined;
+            to_address?: undefined;
+        };
+    };
+    type: "TriggerSmartContract";
+};
+export declare function getTronSigner({ address: knownAddress, derivationPath, }: {
+    address?: string;
+    derivationPath: DerivationPathArray;
+}): TronSigner;
+//# sourceMappingURL=tronSigner.d.ts.map

package/dist/types/trezor/tronSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tronSigner.d.ts","sourceRoot":"","sources":["../../../src/trezor/tronSigner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,mBAAmB,EAAwC,MAAM,kBAAkB,CAAC;AACzG,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,eAAe,EAErB,MAAM,yBAAyB,CAAC;AAiDjC,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;EAoChE;AAED,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EAAE,YAAY,EACrB,cAAc,GACf,EAAE;IACD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,mBAAmB,CAAC;CACrC,GAAG,UAAU,CAgDb"}

package/package.json

@@ -20,10 +20,12 @@
     "@ledgerhq/hw-transport": "~6.35.7",
     "@near-js/crypto": "~2.5.0",
     "@near-js/transactions": "~2.5.0",
+    "@noble/curves": "2.2.0",
     "@scure/base": "2.2.0",
     "@scure/bip32": "2.2.0",
-    "@swapkit/helpers": "^6.1.1",
-    "@swapkit/toolboxes": "^6.2.0",
+    "@solana/web3.js": "~1.98.4",
+    "@swapkit/helpers": "^6.1.2",
+    "@swapkit/toolboxes": "^6.3.0",
     "@swapkit/utxo-signer": "^3.1.1",
     "@swapkit/wallet-core": "^5.0.10",
     "@trezor/connect-web": "~9.7.3",
@@ -57,6 +59,8 @@
     "@near-js/transactions": "2.5.0",
     "@scure/base": "2.2.0",
     "@scure/bip32": "2.2.0",
+    "@solana/web3.js": "1.98.4",
+    "@stricahq/cbors": "1.0.4",
     "@trezor/connect-web": "9.7.3",
     "bitcoinjs-lib": "6.1.7",
     "ethers": "6.16.0",
@@ -109,5 +113,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "6.0.0"
+  "version": "6.1.0"
 }

package/src/trezor/cardanoSigner.ts

@@ -0,0 +1,226 @@
+import { hex } from "@scure/base";
+import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from "@swapkit/helpers";
+import {
+  addCardanoVkeyWitnesses,
+  decodeCardanoTransaction,
+  getCardanoAddressFromBytes,
+  getCardanoPublicKeyHash,
+} from "@swapkit/toolboxes/cardano";
+import type {
+  CardanoAssetGroup,
+  CardanoInput,
+  CardanoOutput,
+  CardanoSignedTxData,
+  CardanoSignTransaction,
+  PROTO,
+} from "@trezor/connect-web";
+
+type CardanoAddressParams = { address: string; path: string; stakingPath: string };
+export type TrezorConnectModule = typeof import("@trezor/connect-web");
+
+function getConnectParams({ CARDANO, PROTO }: TrezorConnectModule) {
+  return {
+    // Trezor Suite default, same as the SwapKit keystore
+    derivationType: PROTO.CardanoDerivationType.ICARUS,
+    mainnet: { networkId: CARDANO.NETWORK_IDS.mainnet, protocolMagic: CARDANO.PROTOCOL_MAGICS.mainnet },
+  };
+}
+
+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 } });
+}
+
+function signFailed(error: string) {
+  return new SwapKitError({
+    errorKey: "wallet_trezor_failed_to_sign_transaction",
+    info: { chain: Chain.Cardano, error },
+  });
+}
+
+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,
+  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 destination =
+    outputAddress === own.address
+      ? {
+          addressParameters: {
+            addressType: proto.CardanoAddressType.BASE,
+            path: own.path,
+            stakingPath: own.stakingPath,
+          },
+        }
+      : { address: outputAddress };
+
+  return {
+    ...destination,
+    amount: toUint(coin, "output amount"),
+    format,
+    ...(multiAsset === undefined ? {} : { tokenBundle: toTokenBundle(multiAsset) }),
+  };
+}
+
+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,
+  connect: TrezorConnectModule,
+): Promise<CardanoSignTransaction> {
+  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);
+
+  return {
+    ...toTrezorInputs(body.get(BODY.INPUTS), own.path),
+    ...mainnet,
+    derivationType,
+    fee: toUint(body.get(BODY.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") }),
+  };
+}
+
+export async function addTrezorWitnesses(
+  txHex: string,
+  { hash, witnesses }: Pick<CardanoSignedTxData, "hash" | "witnesses">,
+  publicKey: string,
+  { PROTO: proto }: TrezorConnectModule,
+) {
+  const { bodyHash } = await decodeCardanoTransaction(txHex);
+
+  if (hash.toLowerCase() !== bodyHash) throw signFailed("Trezor signed a different transaction body");
+
+  const vkeyWitnesses = witnesses.map(({ pubKey, signature, type }) => {
+    if (type !== proto.CardanoTxWitnessType.SHELLEY_WITNESS || pubKey.toLowerCase() !== publicKey) {
+      throw signFailed("Trezor returned a witness for an unexpected key");
+    }
+    return { publicKey: hex.decode(pubKey), signature: hex.decode(signature) };
+  });
+
+  return addCardanoVkeyWitnesses(txHex, vkeyWitnesses);
+}
+
+export async function getCardanoSigner({
+  connect,
+  derivationPath,
+}: {
+  connect: TrezorConnectModule;
+  derivationPath: DerivationPathArray;
+}) {
+  const [purpose, coinType, account, role, index] = derivationPath;
+  if (derivationPath.length !== 5 || role !== 0 || index === undefined) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_derivation_path_not_supported",
+      info: { chain: Chain.Cardano, derivationPath },
+    });
+  }
+
+  const path = derivationPathToString(derivationPath);
+  const stakingPath = derivationPathToString([purpose, coinType, account, 2, 0] as DerivationPathArray);
+  const { derivationType, mainnet } = getConnectParams(connect);
+  const TrezorConnect = connect.default;
+
+  // One device call: a second one right after would need a new Connect popup
+  const keysResult = await TrezorConnect.cardanoGetPublicKey({
+    bundle: [path, stakingPath].map((keyPath) => ({ derivationType, path: keyPath })),
+  });
+  if (!keysResult.success) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_get_address",
+      info: { chain: Chain.Cardano, derivationPath, error: keysResult.payload.error },
+    });
+  }
+
+  const [publicKey, stakingKey] = keysResult.payload.map(({ node }) => Buffer.from(node.public_key, "hex")) as [
+    Buffer,
+    Buffer,
+  ];
+  const publicKeyHash = await getCardanoPublicKeyHash(publicKey);
+  const address = await getCardanoAddressFromBytes(
+    Buffer.concat([Buffer.from([mainnet.networkId]), publicKeyHash, await getCardanoPublicKeyHash(stakingKey)]),
+  );
+
+  async function signTransaction(txHex: string) {
+    const params = await toTrezorCardanoTransaction(txHex, { address, path, stakingPath }, connect);
+    const result = await TrezorConnect.cardanoSignTransaction(params);
+
+    if (!result.success) throw signFailed(result.payload.error);
+
+    return addTrezorWitnesses(txHex, result.payload, publicKey.toString("hex"), connect);
+  }
+
+  return { getAddress: () => address, publicKey, publicKeyHash, signTransaction };
+}