@swapkit/wallet-hardware 4.10.0 → 4.11.0

package/src/ledger/helpers/ledgerNetworkInfo.ts

@@ -0,0 +1,127 @@
+import type Transport from "@ledgerhq/hw-transport";
+
+const LEDGER_CAL_SERVICE_URL = "https://crypto-assets-service.api.ledger.com/v1";
+
+const LEDGER_DEVICE_TO_CAL_MODEL: Record<string, string> = {
+  apex: "apexp",
+  europa: "flex",
+  nanoS: "nanos",
+  nanoSP: "nanosp",
+  nanoX: "nanox",
+  stax: "stax",
+};
+
+const APDU_CLA = 0xe0;
+const APDU_CLA_PKI = 0xb0;
+const APDU_INS_LOAD_CERTIFICATE = 0x06;
+const LEDGER_KEY_USAGE_NETWORK = 0x0c;
+const APDU_INS_PROVIDE_NETWORK_INFORMATION = 0x30;
+const APDU_P1_FIRST_CHUNK = 0x01;
+const APDU_P1_FOLLOWING_CHUNK = 0x00;
+const APDU_P2_NETWORK_CONFIG = 0x00;
+const APDU_P2_NETWORK_ICON = 0x01;
+const APDU_MAX_CHUNK_SIZE = 0xff;
+const TLV_TAG_DER_SIGNATURE = 0x15;
+
+export type LedgerNetworkDescriptor = { data: string; icon?: string; signature: string };
+
+type CalNetwork = {
+  chain_id: number;
+  descriptors?: Record<string, { data?: string; signatures?: { prod?: string } }>;
+  icons?: Record<string, string>;
+};
+
+export async function fetchLedgerNetworkCertificate(
+  deviceModelId: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<string | null> {
+  const calModel = LEDGER_DEVICE_TO_CAL_MODEL[deviceModelId];
+  if (!calModel) return null;
+
+  const url = `${LEDGER_CAL_SERVICE_URL}/certificates?output=descriptor&public_key_usage=network&target_device=${calModel}`;
+  const response = await fetchFn(url);
+  if (!response.ok) return null;
+
+  const certificates = (await response.json()) as Array<{
+    descriptor?: { data?: string; signatures?: { prod?: string } };
+  }>;
+  const descriptor = certificates[0]?.descriptor;
+  const signature = descriptor?.signatures?.prod;
+
+  if (!(descriptor?.data && signature)) return null;
+
+  return `${descriptor.data}${appendSignatureTlv(signature)}`;
+}
+
+export async function provideLedgerCertificate(transport: Transport, payloadHex: string) {
+  await transport.send(
+    APDU_CLA_PKI,
+    APDU_INS_LOAD_CERTIFICATE,
+    LEDGER_KEY_USAGE_NETWORK,
+    0x00,
+    Buffer.from(payloadHex, "hex"),
+  );
+}
+
+export async function fetchLedgerNetworkDescriptor(
+  chainId: number,
+  deviceModelId: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<LedgerNetworkDescriptor | null> {
+  const calModel = LEDGER_DEVICE_TO_CAL_MODEL[deviceModelId];
+  if (!calModel) return null;
+
+  const url = `${LEDGER_CAL_SERVICE_URL}/networks?chain_id=${chainId}&output=chain_id,descriptors,icons`;
+  const response = await fetchFn(url);
+  if (!response.ok) return null;
+
+  const networks = (await response.json()) as CalNetwork[];
+  const network = networks.find((entry) => entry.chain_id === chainId);
+  const descriptor = network?.descriptors?.[calModel];
+  const signature = descriptor?.signatures?.prod;
+
+  if (!(descriptor?.data && signature)) return null;
+
+  return { data: descriptor.data, icon: network?.icons?.[calModel], signature };
+}
+
+function appendSignatureTlv(signature: string) {
+  return encodeTlv(TLV_TAG_DER_SIGNATURE, Buffer.from(signature, "hex")).toString("hex");
+}
+
+function encodeTlv(tag: number, value: Buffer) {
+  return Buffer.concat([Buffer.from([tag, value.length]), value]);
+}
+
+export function encodeNetworkInfoPayload({ data, signature }: LedgerNetworkDescriptor) {
+  const tlv = Buffer.concat([
+    Buffer.from(data, "hex"),
+    encodeTlv(TLV_TAG_DER_SIGNATURE, Buffer.from(signature, "hex")),
+  ]);
+  const length = Buffer.alloc(2);
+  length.writeUInt16BE(tlv.length, 0);
+  return Buffer.concat([length, tlv]);
+}
+
+async function sendChunked(transport: Transport, p2: number, payload: Buffer) {
+  for (let offset = 0; offset < payload.length; offset += APDU_MAX_CHUNK_SIZE) {
+    const p1 = offset === 0 ? APDU_P1_FIRST_CHUNK : APDU_P1_FOLLOWING_CHUNK;
+    const chunk = payload.subarray(offset, offset + APDU_MAX_CHUNK_SIZE);
+    await transport.send(APDU_CLA, APDU_INS_PROVIDE_NETWORK_INFORMATION, p1, p2, chunk);
+  }
+}
+
+export async function provideLedgerNetworkInformation(transport: Transport, descriptor: LedgerNetworkDescriptor) {
+  const payload = encodeNetworkInfoPayload(descriptor);
+  await sendChunked(transport, APDU_P2_NETWORK_CONFIG, payload);
+
+  if (!descriptor.icon) return { iconAccepted: false };
+
+  try {
+    await sendChunked(transport, APDU_P2_NETWORK_ICON, Buffer.from(descriptor.icon, "hex"));
+    return { iconAccepted: true };
+  } catch {
+    await sendChunked(transport, APDU_P2_NETWORK_CONFIG, payload);
+    return { iconAccepted: false };
+  }
+}

package/src/trezor/evmSigner.ts

@@ -123,14 +123,13 @@ export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEV
       if (!to) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { to } });
       if (!gasLimit) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasLimit } });
 
-      const isEIP1559 = maxFeePerGas && maxPriorityFeePerGas;
+      // Check presence, not truthiness: a zero-wei tip is legitimate on chains with a negligible
+      // priority fee, such as Arc, where it used to be read as missing fee data.
+      const isEIP1559 = maxFeePerGas != null || maxPriorityFeePerGas != null;
 
       if (isEIP1559 && !maxFeePerGas) {
         throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxFeePerGas } });
       }
-      if (isEIP1559 && !maxPriorityFeePerGas) {
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxPriorityFeePerGas } });
-      }
       if (!(isEIP1559 || gasPrice)) {
         throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasPrice } });
       }

package/src/trezor/index.ts

@@ -498,6 +498,7 @@ async function getTrezorWallet<T extends Chain>({
 }) {
   switch (chain) {
     case Chain.Arbitrum:
+    case Chain.Arc:
     case Chain.Aurora:
     case Chain.Avalanche:
     case Chain.Base:
@@ -1358,6 +1359,7 @@ export const trezorWallet = createWallet({
     },
   directSigningSupport: {
     [Chain.Arbitrum]: true,
+    [Chain.Arc]: true,
     [Chain.Aurora]: true,
     [Chain.Avalanche]: true,
     [Chain.Base]: true,
@@ -1380,6 +1382,7 @@ export const trezorWallet = createWallet({
   name: "connectTrezor",
   supportedChains: [
     Chain.Arbitrum,
+    Chain.Arc,
     Chain.Aurora,
     Chain.Avalanche,
     Chain.Base,

package/dist/chunk-qs60k0yv.js

@@ -1,4 +0,0 @@
-import{d as Q}from"./chunk-n05bv2n5.js";import{ChainToChainId as b,derivationPathToString as $,SwapKitError as B,WalletOption as K}from"@swapkit/helpers";async function G({chain:_,derivationPath:f,provider:C}){let{AbstractSigner:H}=await import("ethers");class A extends H{address;chain;derivationPath;provider;constructor({chain:j,derivationPath:q,provider:J}){super(J);this.address="",this.chain=j,this.derivationPath=q,this.provider=J}getAddress=async()=>{if(!this.address){let q=await(await import("@trezor/connect-web")).default.ethereumGetAddress({path:$(this.derivationPath),showOnTrezor:!0});if(!q.success)throw new B({errorKey:"wallet_trezor_failed_to_get_address",info:{...q,chain:this.chain,derivationPath:this.derivationPath}});this.address=q.payload.address}return this.address};signMessage=async(j)=>{let J=await(await import("@trezor/connect-web")).default.ethereumSignMessage({message:j,path:$(this.derivationPath)});if(!J.success)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...J,chain:this.chain,derivationPath:this.derivationPath,message:j}});return J.payload.signature};signTypedData=async(j,q,J,N)=>{let O=(await import("@trezor/connect-web")).default,{buildEIP712DomainType:V}=await import("@swapkit/toolboxes/evm"),{TypedDataEncoder:X}=await import("ethers"),{EIP712Domain:Y,...R}=q,W=N??X.from(R).primaryType,M=V(j),D={domain:j,message:J,primaryType:W,types:{EIP712Domain:M,...R}},U=await O.ethereumSignTypedData({data:D,metamask_v4_compat:!0,path:$(this.derivationPath)});if(!U.success)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,error:U.payload.error}});return U.payload.signature.startsWith("0x")?U.payload.signature:`0x${U.payload.signature}`};signTransaction=async({to:j,gasLimit:q,value:J,data:N,nonce:O,maxFeePerGas:V,maxPriorityFeePerGas:X,gasPrice:Y})=>{if(!j)throw new B({errorKey:"wallet_missing_params",info:{to:j}});if(!q)throw new B({errorKey:"wallet_missing_params",info:{gasLimit:q}});let R=V&&X;if(R&&!V)throw new B({errorKey:"wallet_missing_params",info:{maxFeePerGas:V}});if(R&&!X)throw new B({errorKey:"wallet_missing_params",info:{maxPriorityFeePerGas:X}});if(!(R||Y))throw new B({errorKey:"wallet_missing_params",info:{gasPrice:Y}});let W=(await import("@trezor/connect-web")).default,{toHexString:M}=await import("@swapkit/toolboxes/evm"),D=R?{maxFeePerGas:M(BigInt(V?.toString()||0)),maxPriorityFeePerGas:M(BigInt(X?.toString()||0))}:Y&&{gasPrice:M(BigInt(Y?.toString()||0))}||{gasPrice:"0x0"},U=M(BigInt(O||await this.provider.getTransactionCount(await this.getAddress(),"pending"))),I={chainId:Number.parseInt(b[this.chain],10),data:N?.toString()||"0x",gasLimit:M(BigInt(q?.toString()||0)),nonce:U,to:j.toString(),value:M(BigInt(J?.toString()||0)),...D},{success:L,payload:Z}=await W.ethereumSignTransaction({path:$(this.derivationPath),transaction:I});if(!L)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...Z,chain:this.chain,derivationPath:this.derivationPath}});let k=Z.serializedTx?Z.serializedTx.startsWith("0x")?Z.serializedTx:`0x${Z.serializedTx}`:void 0;if(!k)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,derivationPath:this.derivationPath}});return k};connect=(j)=>{if(!j)throw new B({errorKey:"wallet_provider_not_found",info:{chain:this.chain,derivationPath:this.derivationPath,wallet:K.TREZOR}});return new A({chain:this.chain,derivationPath:this.derivationPath,provider:j})}}return new A({chain:_,derivationPath:f,provider:C})}export{G as getEVMSigner};
-
-//# debugId=654BE0775B0291CD64756E2164756E21
-//# sourceMappingURL=chunk-qs60k0yv.js.map