@swapkit/wallet-hardware 6.0.0 → 6.1.0

package/dist/chunk-3h1f3hyp.js

@@ -0,0 +1,4 @@
+import{$d as f}from"./chunk-nhva847d.js";import{Chain as i,derivationPathToString as g,SwapKitError as c}from"@swapkit/helpers";var w=7,y=4294967295n,_={credit_alphanum4:"ALPHANUM4",credit_alphanum12:"ALPHANUM12",native:"NATIVE"},d={hash:3,id:2,return:4,text:1};function n(e){return new c({errorKey:"wallet_trezor_method_not_supported",info:{chain:i.Stellar,reason:e}})}function m(e){let t=/^(\d+)(?:\.(\d{1,7}))?$/.exec(e);if(!t)throw n(`Invalid Stellar amount: ${e}`);let[,r="0",a=""]=t;return BigInt(`${r}${a.padEnd(w,"0")}`).toString()}function h(e){if(!/^\d+$/.test(e)||BigInt(e)>y)throw n(`Unsupported Stellar time bound: ${e}`);return Number(e)}function S(e){let t=_[e.getAssetType()];if(!t||!("getCode"in e))throw n("Trezor does not support liquidity pool assets");return t==="NATIVE"?{type:t}:{code:e.getCode(),issuer:e.getIssuer(),type:t}}function A({source:e,...t}){let r=e?{source:e}:{};switch(t.type){case"payment":return{...r,amount:m(t.amount),asset:S(t.asset),destination:t.destination,type:"payment"};case"createAccount":return{...r,destination:t.destination,startingBalance:m(t.startingBalance),type:"createAccount"};case"changeTrust":return{...r,limit:m(t.limit),line:S(t.line),type:"changeTrust"};default:throw n(`Unsupported Stellar operation: ${t.type}`)}}function x(e){if(typeof e==="string")return e;try{return new TextDecoder("utf-8",{fatal:!0,ignoreBOM:!0}).decode(e??void 0)}catch{throw n("Trezor only signs UTF-8 text memos")}}function z({type:e,value:t}){switch(e){case"none":return;case"text":return{text:x(t),type:d.text};case"id":return{id:String(t),type:d.id};case"hash":case"return":return{hash:Buffer.from(t??"").toString("hex"),type:d[e]};default:throw n(`Unsupported Stellar memo type: ${e}`)}}function E(e){if("innerTransaction"in e)throw n("Trezor cannot sign fee bump transactions");if(!e.timeBounds)throw n("Trezor requires transaction time bounds");let{extraSigners:t,ledgerBounds:r,minAccountSequence:a,minAccountSequenceAge:l,minAccountSequenceLedgerGap:s}=e;if([r,a,l,s].some((p)=>p!==void 0)||t?.length)throw n("Trezor cannot sign Stellar transactions with extra preconditions");return{networkPassphrase:e.networkPassphrase,transaction:{fee:Number(e.fee),memo:z(e.memo),operations:e.operations.map(A),sequence:e.sequence,source:e.source,timebounds:{maxTime:h(e.timeBounds.maxTime),minTime:h(e.timeBounds.minTime)}}}}function B({derivationPath:e}){if(e[3]||e[4])throw new c({errorKey:"wallet_trezor_derivation_path_not_supported",info:{chain:i.Stellar,derivationPath:e,reason:"Stellar only uses m/44'/148'/x'"}});let t=g(e.slice(0,3)),r="";async function a(){if(r)return r;let o=await(await import("@trezor/connect-web")).default.stellarGetAddress({path:t,showOnTrezor:!0});if(!o.success)throw new c({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:i.Stellar,derivationPath:e,error:o.payload.error}});return r=o.payload.address,r}async function l(s){let o=E(s);if(o.transaction.source!==await a())throw n("Transaction source does not match the Trezor address");let u=await(await import("@trezor/connect-web")).default.stellarSignTransaction({path:t,...o});if(!u.success)throw new c({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:i.Stellar,error:u.payload.error}});try{s.addSignature(r,Buffer.from(u.payload.signature,"hex").toString("base64"))}catch(T){throw new c({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:i.Stellar,error:T}})}return s}return{getAddress:a,signTransaction:l}}export{E as toTrezorStellarTransaction,B as getStellarSigner};
+
+//# debugId=8C088525EA29277C64756E2164756E21
+//# sourceMappingURL=chunk-3h1f3hyp.js.map

package/dist/chunk-3h1f3hyp.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/trezor/stellarSigner.ts"],
+  "sourcesContent": [
+    "import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from \"@swapkit/helpers\";\nimport type { StellarSigner, StellarTransaction } from \"@swapkit/toolboxes/stellar\";\n\ntype StellarClassicTransaction = Exclude<StellarTransaction, { innerTransaction: unknown }>;\ntype StellarOperation = StellarClassicTransaction[\"operations\"][number];\ntype StellarAsset = Extract<StellarOperation, { type: \"changeTrust\" }>[\"line\"];\n\nconst STELLAR_DECIMALS = 7;\nconst MAX_UINT32 = 4294967295n;\nconst ASSET_TYPES: Record<string, \"NATIVE\" | \"ALPHANUM4\" | \"ALPHANUM12\"> = {\n  credit_alphanum4: \"ALPHANUM4\",\n  credit_alphanum12: \"ALPHANUM12\",\n  native: \"NATIVE\",\n};\nconst MEMO_TYPES = { hash: 3, id: 2, return: 4, text: 1 } as const;\n\nfunction notSupported(reason: string) {\n  return new SwapKitError({ errorKey: \"wallet_trezor_method_not_supported\", info: { chain: Chain.Stellar, reason } });\n}\n\nfunction toStroops(amount: string) {\n  const match = /^(\\d+)(?:\\.(\\d{1,7}))?$/.exec(amount);\n  if (!match) throw notSupported(`Invalid Stellar amount: ${amount}`);\n\n  const [, whole = \"0\", fraction = \"\"] = match;\n  return BigInt(`${whole}${fraction.padEnd(STELLAR_DECIMALS, \"0\")}`).toString();\n}\n\nfunction toTimeBound(value: string) {\n  if (!/^\\d+$/.test(value) || BigInt(value) > MAX_UINT32) {\n    throw notSupported(`Unsupported Stellar time bound: ${value}`);\n  }\n  return Number(value);\n}\n\nfunction toTrezorAsset(asset: StellarAsset) {\n  const type = ASSET_TYPES[asset.getAssetType()];\n  if (!type || !(\"getCode\" in asset)) throw notSupported(\"Trezor does not support liquidity pool assets\");\n\n  return type === \"NATIVE\" ? { type } : { code: asset.getCode(), issuer: asset.getIssuer(), type };\n}\n\nfunction toTrezorOperation({ source, ...operation }: StellarOperation) {\n  const withSource = source ? { source } : {};\n\n  switch (operation.type) {\n    case \"payment\":\n      return {\n        ...withSource,\n        amount: toStroops(operation.amount),\n        asset: toTrezorAsset(operation.asset),\n        destination: operation.destination,\n        type: \"payment\" as const,\n      };\n    case \"createAccount\":\n      return {\n        ...withSource,\n        destination: operation.destination,\n        startingBalance: toStroops(operation.startingBalance),\n        type: \"createAccount\" as const,\n      };\n    case \"changeTrust\":\n      return {\n        ...withSource,\n        limit: toStroops(operation.limit),\n        line: toTrezorAsset(operation.line),\n        type: \"changeTrust\" as const,\n      };\n    default:\n      throw notSupported(`Unsupported Stellar operation: ${operation.type}`);\n  }\n}\n\nfunction decodeTextMemo(value: StellarClassicTransaction[\"memo\"][\"value\"]) {\n  if (typeof value === \"string\") return value;\n\n  try {\n    return new TextDecoder(\"utf-8\", { fatal: true, ignoreBOM: true }).decode(value ?? undefined);\n  } catch {\n    throw notSupported(\"Trezor only signs UTF-8 text memos\");\n  }\n}\n\nfunction toTrezorMemo({ type, value }: StellarClassicTransaction[\"memo\"]) {\n  switch (type) {\n    case \"none\":\n      return undefined;\n    case \"text\":\n      return { text: decodeTextMemo(value), type: MEMO_TYPES.text };\n    case \"id\":\n      return { id: String(value), type: MEMO_TYPES.id };\n    case \"hash\":\n    case \"return\":\n      return { hash: Buffer.from(value ?? \"\").toString(\"hex\"), type: MEMO_TYPES[type] };\n    default:\n      throw notSupported(`Unsupported Stellar memo type: ${type}`);\n  }\n}\n\nexport function toTrezorStellarTransaction(transaction: StellarTransaction) {\n  if (\"innerTransaction\" in transaction) throw notSupported(\"Trezor cannot sign fee bump transactions\");\n\n  if (!transaction.timeBounds) throw notSupported(\"Trezor requires transaction time bounds\");\n  const { extraSigners, ledgerBounds, minAccountSequence, minAccountSequenceAge, minAccountSequenceLedgerGap } =\n    transaction;\n  const hasPreconditions = [ledgerBounds, minAccountSequence, minAccountSequenceAge, minAccountSequenceLedgerGap].some(\n    (precondition) => precondition !== undefined,\n  );\n  if (hasPreconditions || extraSigners?.length) {\n    throw notSupported(\"Trezor cannot sign Stellar transactions with extra preconditions\");\n  }\n\n  return {\n    networkPassphrase: transaction.networkPassphrase,\n    transaction: {\n      fee: Number(transaction.fee),\n      memo: toTrezorMemo(transaction.memo),\n      operations: transaction.operations.map(toTrezorOperation),\n      sequence: transaction.sequence,\n      source: transaction.source,\n      timebounds: {\n        maxTime: toTimeBound(transaction.timeBounds.maxTime),\n        minTime: toTimeBound(transaction.timeBounds.minTime),\n      },\n    },\n  };\n}\n\nexport function getStellarSigner({ derivationPath }: { derivationPath: DerivationPathArray }): StellarSigner {\n  if (derivationPath[3] || derivationPath[4]) {\n    throw new SwapKitError({\n      errorKey: \"wallet_trezor_derivation_path_not_supported\",\n      info: { chain: Chain.Stellar, derivationPath, reason: \"Stellar only uses m/44'/148'/x'\" },\n    });\n  }\n\n  const path = derivationPathToString(derivationPath.slice(0, 3) as [number, number, number]);\n  let address = \"\";\n\n  async function getAddress() {\n    if (address) return address;\n\n    const TrezorConnect = (await import(\"@trezor/connect-web\")).default;\n    const result = await TrezorConnect.stellarGetAddress({ path, showOnTrezor: true });\n\n    if (!result.success) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_get_address\",\n        info: { chain: Chain.Stellar, derivationPath, error: result.payload.error },\n      });\n    }\n\n    address = result.payload.address;\n    return address;\n  }\n\n  async function signTransaction(transaction: StellarTransaction) {\n    const params = toTrezorStellarTransaction(transaction);\n    if (params.transaction.source !== (await getAddress())) {\n      throw notSupported(\"Transaction source does not match the Trezor address\");\n    }\n\n    const TrezorConnect = (await import(\"@trezor/connect-web\")).default;\n    const result = await TrezorConnect.stellarSignTransaction({ path, ...params });\n\n    if (!result.success) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_sign_transaction\",\n        info: { chain: Chain.Stellar, error: result.payload.error },\n      });\n    }\n\n    try {\n      transaction.addSignature(address, Buffer.from(result.payload.signature, \"hex\").toString(\"base64\"));\n    } catch (error) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_sign_transaction\",\n        info: { chain: Chain.Stellar, error },\n      });\n    }\n\n    return transaction;\n  }\n\n  return { getAddress, signTransaction };\n}\n"
+  ],
+  "mappings": "yCAAA,gBAAS,4BAAiC,kBAAwB,yBAOlE,IAAM,EAAmB,EACnB,EAAa,YACb,EAAqE,CACzE,iBAAkB,YAClB,kBAAmB,aACnB,OAAQ,QACV,EACM,EAAa,CAAE,KAAM,EAAG,GAAI,EAAG,OAAQ,EAAG,KAAM,CAAE,EAExD,SAAS,CAAY,CAAC,EAAgB,CACpC,OAAO,IAAI,EAAa,CAAE,SAAU,qCAAsC,KAAM,CAAE,MAAO,EAAM,QAAS,QAAO,CAAE,CAAC,EAGpH,SAAS,CAAS,CAAC,EAAgB,CACjC,IAAM,EAAQ,0BAA0B,KAAK,CAAM,EACnD,GAAI,CAAC,EAAO,MAAM,EAAa,2BAA2B,GAAQ,EAElE,KAAS,EAAQ,IAAK,EAAW,IAAM,EACvC,OAAO,OAAO,GAAG,IAAQ,EAAS,OAAO,EAAkB,GAAG,GAAG,EAAE,SAAS,EAG9E,SAAS,CAAW,CAAC,EAAe,CAClC,GAAI,CAAC,QAAQ,KAAK,CAAK,GAAK,OAAO,CAAK,EAAI,EAC1C,MAAM,EAAa,mCAAmC,GAAO,EAE/D,OAAO,OAAO,CAAK,EAGrB,SAAS,CAAa,CAAC,EAAqB,CAC1C,IAAM,EAAO,EAAY,EAAM,aAAa,GAC5C,GAAI,CAAC,GAAQ,EAAE,YAAa,GAAQ,MAAM,EAAa,+CAA+C,EAEtG,OAAO,IAAS,SAAW,CAAE,MAAK,EAAI,CAAE,KAAM,EAAM,QAAQ,EAAG,OAAQ,EAAM,UAAU,EAAG,MAAK,EAGjG,SAAS,CAAiB,EAAG,YAAW,GAA+B,CACrE,IAAM,EAAa,EAAS,CAAE,QAAO,EAAI,CAAC,EAE1C,OAAQ,EAAU,UACX,UACH,MAAO,IACF,EACH,OAAQ,EAAU,EAAU,MAAM,EAClC,MAAO,EAAc,EAAU,KAAK,EACpC,YAAa,EAAU,YACvB,KAAM,SACR,MACG,gBACH,MAAO,IACF,EACH,YAAa,EAAU,YACvB,gBAAiB,EAAU,EAAU,eAAe,EACpD,KAAM,eACR,MACG,cACH,MAAO,IACF,EACH,MAAO,EAAU,EAAU,KAAK,EAChC,KAAM,EAAc,EAAU,IAAI,EAClC,KAAM,aACR,UAEA,MAAM,EAAa,kCAAkC,EAAU,MAAM,GAI3E,SAAS,CAAc,CAAC,EAAmD,CACzE,GAAI,OAAO,IAAU,SAAU,OAAO,EAEtC,GAAI,CACF,OAAO,IAAI,YAAY,QAAS,CAAE,MAAO,GAAM,UAAW,EAAK,CAAC,EAAE,OAAO,GAAS,MAAS,EAC3F,KAAM,CACN,MAAM,EAAa,oCAAoC,GAI3D,SAAS,CAAY,EAAG,OAAM,SAA4C,CACxE,OAAQ,OACD,OACH,WACG,OACH,MAAO,CAAE,KAAM,EAAe,CAAK,EAAG,KAAM,EAAW,IAAK,MACzD,KACH,MAAO,CAAE,GAAI,OAAO,CAAK,EAAG,KAAM,EAAW,EAAG,MAC7C,WACA,SACH,MAAO,CAAE,KAAM,OAAO,KAAK,GAAS,EAAE,EAAE,SAAS,KAAK,EAAG,KAAM,EAAW,EAAM,UAEhF,MAAM,EAAa,kCAAkC,GAAM,GAI1D,SAAS,CAA0B,CAAC,EAAiC,CAC1E,GAAI,qBAAsB,EAAa,MAAM,EAAa,0CAA0C,EAEpG,GAAI,CAAC,EAAY,WAAY,MAAM,EAAa,yCAAyC,EACzF,IAAQ,eAAc,eAAc,qBAAoB,wBAAuB,+BAC7E,EAIF,GAHyB,CAAC,EAAc,EAAoB,EAAuB,CAA2B,EAAE,KAC9G,CAAC,IAAiB,IAAiB,MACrC,GACwB,GAAc,OACpC,MAAM,EAAa,kEAAkE,EAGvF,MAAO,CACL,kBAAmB,EAAY,kBAC/B,YAAa,CACX,IAAK,OAAO,EAAY,GAAG,EAC3B,KAAM,EAAa,EAAY,IAAI,EACnC,WAAY,EAAY,WAAW,IAAI,CAAiB,EACxD,SAAU,EAAY,SACtB,OAAQ,EAAY,OACpB,WAAY,CACV,QAAS,EAAY,EAAY,WAAW,OAAO,EACnD,QAAS,EAAY,EAAY,WAAW,OAAO,CACrD,CACF,CACF,EAGK,SAAS,CAAgB,EAAG,kBAA0E,CAC3G,GAAI,EAAe,IAAM,EAAe,GACtC,MAAM,IAAI,EAAa,CACrB,SAAU,8CACV,KAAM,CAAE,MAAO,EAAM,QAAS,iBAAgB,OAAQ,iCAAkC,CAC1F,CAAC,EAGH,IAAM,EAAO,EAAuB,EAAe,MAAM,EAAG,CAAC,CAA6B,EACtF,EAAU,GAEd,eAAe,CAAU,EAAG,CAC1B,GAAI,EAAS,OAAO,EAGpB,IAAM,EAAS,MADQ,KAAa,gCAAwB,QACzB,kBAAkB,CAAE,OAAM,aAAc,EAAK,CAAC,EAEjF,GAAI,CAAC,EAAO,QACV,MAAM,IAAI,EAAa,CACrB,SAAU,sCACV,KAAM,CAAE,MAAO,EAAM,QAAS,iBAAgB,MAAO,EAAO,QAAQ,KAAM,CAC5E,CAAC,EAIH,OADA,EAAU,EAAO,QAAQ,QAClB,EAGT,eAAe,CAAe,CAAC,EAAiC,CAC9D,IAAM,EAAS,EAA2B,CAAW,EACrD,GAAI,EAAO,YAAY,SAAY,MAAM,EAAW,EAClD,MAAM,EAAa,sDAAsD,EAI3E,IAAM,EAAS,MADQ,KAAa,gCAAwB,QACzB,uBAAuB,CAAE,UAAS,CAAO,CAAC,EAE7E,GAAI,CAAC,EAAO,QACV,MAAM,IAAI,EAAa,CACrB,SAAU,2CACV,KAAM,CAAE,MAAO,EAAM,QAAS,MAAO,EAAO,QAAQ,KAAM,CAC5D,CAAC,EAGH,GAAI,CACF,EAAY,aAAa,EAAS,OAAO,KAAK,EAAO,QAAQ,UAAW,KAAK,EAAE,SAAS,QAAQ,CAAC,EACjG,MAAO,EAAO,CACd,MAAM,IAAI,EAAa,CACrB,SAAU,2CACV,KAAM,CAAE,MAAO,EAAM,QAAS,OAAM,CACtC,CAAC,EAGH,OAAO,EAGT,MAAO,CAAE,aAAY,iBAAgB",
+  "debugId": "8C088525EA29277C64756E2164756E21",
+  "names": []
+}

package/dist/chunk-8m2sn76p.js

@@ -0,0 +1,4 @@
+import{$d as G}from"./chunk-nhva847d.js";import{Chain as k,derivationPathToString as O,SwapKitError as y}from"@swapkit/helpers";import{GlobalFlags as V,hashes as Z,isValidClassicAddress as I}from"xrpl";var q=new Set(["Account","Amount","Destination","DestinationTag","Fee","Flags","LastLedgerSequence","Sequence","SigningPubKey","TransactionType"]);function B(M){return new y({errorKey:"wallet_trezor_method_not_supported",info:{chain:k.Ripple,reason:M}})}function K(M){let j=M;if(j.TransactionType!=="Payment")throw B(`Trezor only signs XRP payments, got ${String(j.TransactionType)}`);let J=Object.keys(j).filter(($)=>j[$]!==void 0&&j[$]!==null&&!q.has($));if(J.length>0)throw B(`Trezor cannot sign XRP payments with ${J.join(", ")}`);let{Amount:N,Destination:Q,DestinationTag:U,Fee:H,Flags:W,LastLedgerSequence:X,Sequence:Y}=j;if(typeof N!=="string"||!/^\d+$/.test(N))throw B("Trezor only signs native XRP amounts");if(typeof Q!=="string")throw B("Missing destination");if(!I(Q))throw B("Destination must be a classic XRP address");if(typeof H!=="string"||typeof Y!=="number")throw B("Transaction is not autofilled");if(W!==void 0&&typeof W!=="number")throw B("Flags must be numeric");if(((W??0)&V.tfInnerBatchTxn)!==0)throw B("Trezor cannot sign Batch inner XRP transactions");return{fee:H,flags:W,maxLedgerVersion:X,payment:{amount:N,destination:Q,destinationTag:U},sequence:Y}}function L({derivationPath:M}){let j=O(M),J="";async function N(){if(J)return J;let H=await(await import("@trezor/connect-web")).default.rippleGetAddress({path:j,showOnTrezor:!0});if(!H.success)throw new y({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:k.Ripple,derivationPath:M,error:H.payload.error}});return J=H.payload.address,J}async function Q(U){let H=K(U);if(U.Account!==await N())throw B("Transaction account does not match the Trezor address");let X=await(await import("@trezor/connect-web")).default.rippleSignTransaction({path:j,transaction:H});if(!X.success)throw new y({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:k.Ripple,error:X.payload.error}});let Y=X.payload.serializedTx.toUpperCase();return{hash:Z.hashSignedTx(Y),tx_blob:Y}}return{getAddress:N,signTransaction:Q}}export{K as toTrezorRippleTransaction,L as getRippleSigner};
+
+//# debugId=22BCF4233EB025AD64756E2164756E21
+//# sourceMappingURL=chunk-8m2sn76p.js.map

package/dist/chunk-8m2sn76p.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/trezor/rippleSigner.ts"],
+  "sourcesContent": [
+    "import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from \"@swapkit/helpers\";\nimport type { RippleTransaction } from \"@swapkit/toolboxes/ripple\";\nimport { GlobalFlags, hashes, isValidClassicAddress } from \"xrpl\";\n\n// Fields Trezor serializes itself; anything else would be dropped from the signed transaction\nconst TREZOR_RIPPLE_FIELDS = new Set([\n  \"Account\",\n  \"Amount\",\n  \"Destination\",\n  \"DestinationTag\",\n  \"Fee\",\n  \"Flags\",\n  \"LastLedgerSequence\",\n  \"Sequence\",\n  \"SigningPubKey\",\n  \"TransactionType\",\n]);\n\nfunction notSupported(reason: string) {\n  return new SwapKitError({ errorKey: \"wallet_trezor_method_not_supported\", info: { chain: Chain.Ripple, reason } });\n}\n\nexport function toTrezorRippleTransaction(transaction: RippleTransaction) {\n  const tx = transaction as unknown as Record<string, unknown>;\n\n  if (tx.TransactionType !== \"Payment\") {\n    throw notSupported(`Trezor only signs XRP payments, got ${String(tx.TransactionType)}`);\n  }\n\n  const unsupportedFields = Object.keys(tx).filter(\n    (field) => tx[field] !== undefined && tx[field] !== null && !TREZOR_RIPPLE_FIELDS.has(field),\n  );\n  if (unsupportedFields.length > 0) {\n    throw notSupported(`Trezor cannot sign XRP payments with ${unsupportedFields.join(\", \")}`);\n  }\n\n  const { Amount, Destination, DestinationTag, Fee, Flags, LastLedgerSequence, Sequence } = tx;\n\n  if (typeof Amount !== \"string\" || !/^\\d+$/.test(Amount)) throw notSupported(\"Trezor only signs native XRP amounts\");\n  if (typeof Destination !== \"string\") throw notSupported(\"Missing destination\");\n  if (!isValidClassicAddress(Destination)) throw notSupported(\"Destination must be a classic XRP address\");\n  if (typeof Fee !== \"string\" || typeof Sequence !== \"number\") throw notSupported(\"Transaction is not autofilled\");\n  if (Flags !== undefined && typeof Flags !== \"number\") throw notSupported(\"Flags must be numeric\");\n  if (((Flags ?? 0) & GlobalFlags.tfInnerBatchTxn) !== 0) {\n    throw notSupported(\"Trezor cannot sign Batch inner XRP transactions\");\n  }\n\n  return {\n    fee: Fee,\n    flags: Flags as number | undefined,\n    maxLedgerVersion: LastLedgerSequence as number | undefined,\n    payment: { amount: Amount, destination: Destination, destinationTag: DestinationTag as number | undefined },\n    sequence: Sequence,\n  };\n}\n\nexport function getRippleSigner({ derivationPath }: { derivationPath: DerivationPathArray }) {\n  const path = derivationPathToString(derivationPath);\n  let address = \"\";\n\n  async function getAddress() {\n    if (address) return address;\n\n    const TrezorConnect = (await import(\"@trezor/connect-web\")).default;\n    const result = await TrezorConnect.rippleGetAddress({ path, showOnTrezor: true });\n\n    if (!result.success) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_get_address\",\n        info: { chain: Chain.Ripple, derivationPath, error: result.payload.error },\n      });\n    }\n\n    address = result.payload.address;\n    return address;\n  }\n\n  async function signTransaction(transaction: RippleTransaction) {\n    const trezorTransaction = toTrezorRippleTransaction(transaction);\n    if (transaction.Account !== (await getAddress())) {\n      throw notSupported(\"Transaction account does not match the Trezor address\");\n    }\n\n    const TrezorConnect = (await import(\"@trezor/connect-web\")).default;\n\n    const result = await TrezorConnect.rippleSignTransaction({ path, transaction: trezorTransaction });\n\n    if (!result.success) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_sign_transaction\",\n        info: { chain: Chain.Ripple, error: result.payload.error },\n      });\n    }\n\n    const tx_blob = result.payload.serializedTx.toUpperCase();\n    return { hash: hashes.hashSignedTx(tx_blob), tx_blob };\n  }\n\n  return { getAddress, signTransaction };\n}\n"
+  ],
+  "mappings": "yCAAA,gBAAS,4BAAiC,kBAAwB,yBAElE,sBAAS,YAAa,2BAAQ,aAG9B,IAAM,EAAuB,IAAI,IAAI,CACnC,UACA,SACA,cACA,iBACA,MACA,QACA,qBACA,WACA,gBACA,iBACF,CAAC,EAED,SAAS,CAAY,CAAC,EAAgB,CACpC,OAAO,IAAI,EAAa,CAAE,SAAU,qCAAsC,KAAM,CAAE,MAAO,EAAM,OAAQ,QAAO,CAAE,CAAC,EAG5G,SAAS,CAAyB,CAAC,EAAgC,CACxE,IAAM,EAAK,EAEX,GAAI,EAAG,kBAAoB,UACzB,MAAM,EAAa,uCAAuC,OAAO,EAAG,eAAe,GAAG,EAGxF,IAAM,EAAoB,OAAO,KAAK,CAAE,EAAE,OACxC,CAAC,IAAU,EAAG,KAAW,QAAa,EAAG,KAAW,MAAQ,CAAC,EAAqB,IAAI,CAAK,CAC7F,EACA,GAAI,EAAkB,OAAS,EAC7B,MAAM,EAAa,wCAAwC,EAAkB,KAAK,IAAI,GAAG,EAG3F,IAAQ,SAAQ,cAAa,iBAAgB,MAAK,QAAO,qBAAoB,YAAa,EAE1F,GAAI,OAAO,IAAW,UAAY,CAAC,QAAQ,KAAK,CAAM,EAAG,MAAM,EAAa,sCAAsC,EAClH,GAAI,OAAO,IAAgB,SAAU,MAAM,EAAa,qBAAqB,EAC7E,GAAI,CAAC,EAAsB,CAAW,EAAG,MAAM,EAAa,2CAA2C,EACvG,GAAI,OAAO,IAAQ,UAAY,OAAO,IAAa,SAAU,MAAM,EAAa,+BAA+B,EAC/G,GAAI,IAAU,QAAa,OAAO,IAAU,SAAU,MAAM,EAAa,uBAAuB,EAChG,KAAM,GAAS,GAAK,EAAY,mBAAqB,EACnD,MAAM,EAAa,iDAAiD,EAGtE,MAAO,CACL,IAAK,EACL,MAAO,EACP,iBAAkB,EAClB,QAAS,CAAE,OAAQ,EAAQ,YAAa,EAAa,eAAgB,CAAqC,EAC1G,SAAU,CACZ,EAGK,SAAS,CAAe,EAAG,kBAA2D,CAC3F,IAAM,EAAO,EAAuB,CAAc,EAC9C,EAAU,GAEd,eAAe,CAAU,EAAG,CAC1B,GAAI,EAAS,OAAO,EAGpB,IAAM,EAAS,MADQ,KAAa,gCAAwB,QACzB,iBAAiB,CAAE,OAAM,aAAc,EAAK,CAAC,EAEhF,GAAI,CAAC,EAAO,QACV,MAAM,IAAI,EAAa,CACrB,SAAU,sCACV,KAAM,CAAE,MAAO,EAAM,OAAQ,iBAAgB,MAAO,EAAO,QAAQ,KAAM,CAC3E,CAAC,EAIH,OADA,EAAU,EAAO,QAAQ,QAClB,EAGT,eAAe,CAAe,CAAC,EAAgC,CAC7D,IAAM,EAAoB,EAA0B,CAAW,EAC/D,GAAI,EAAY,UAAa,MAAM,EAAW,EAC5C,MAAM,EAAa,uDAAuD,EAK5E,IAAM,EAAS,MAFQ,KAAa,gCAAwB,QAEzB,sBAAsB,CAAE,OAAM,YAAa,CAAkB,CAAC,EAEjG,GAAI,CAAC,EAAO,QACV,MAAM,IAAI,EAAa,CACrB,SAAU,2CACV,KAAM,CAAE,MAAO,EAAM,OAAQ,MAAO,EAAO,QAAQ,KAAM,CAC3D,CAAC,EAGH,IAAM,EAAU,EAAO,QAAQ,aAAa,YAAY,EACxD,MAAO,CAAE,KAAM,EAAO,aAAa,CAAO,EAAG,SAAQ,EAGvD,MAAO,CAAE,aAAY,iBAAgB",
+  "debugId": "22BCF4233EB025AD64756E2164756E21",
+  "names": []
+}

package/dist/chunk-qjq7gvyx.js

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,10 @@
+{
+  "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": []
+}

package/dist/chunk-wfbg89d3.js

@@ -0,0 +1,4 @@
+import{$d as N}from"./chunk-nhva847d.js";import{Chain as y,derivationPathToString as g,SwapKitError as I}from"@swapkit/helpers";import{tronAddressToHex as K}from"@swapkit/toolboxes/tron";var P=/^41[0-9a-f]{40}$/i,R=new Set(["contract","data","expiration","fee_limit","ref_block_bytes","ref_block_hash","timestamp"]),V=new Set(["parameter","type"]),b={TransferContract:new Set(["amount","owner_address","to_address"]),TriggerSmartContract:new Set(["contract_address","data","owner_address"])},x=[void 0,null,0,"",!1];function Y(q){return new I({errorKey:"wallet_trezor_method_not_supported",info:{chain:y.Tron,reason:q}})}function X(q,j,J){let G=Object.keys(q).filter((M)=>!j.has(M)&&!x.includes(q[M]));if(G.length>0)throw Y(`Trezor cannot sign Tron ${J} with ${G.join(", ")}`)}function U(q,j){let J=q[j];if(typeof J!=="string"||!J)throw Y(`Missing ${j} in Tron contract`);return J}function D(q){let{amount:j}=q;if(!(typeof j==="number"&&Number.isSafeInteger(j)&&j>0||typeof j==="string"&&/^[1-9]\d*$/.test(j)))throw Y("Invalid amount in Tron contract");return String(j)}function k(q){let[j,...J]=q.raw_data.contract;if(!j||J.length>0)throw Y("Trezor signs Tron transactions with exactly one contract");let G=j.parameter.value,M=b[j.type];if(!M)throw Y(`Unsupported Tron contract type: ${j.type}`);X(q.raw_data,R,"transactions"),X(j,V,"contracts"),X(G,M,j.type);let Q=(B)=>{let Z=U(G,B);if(q.visible!==!1)return K(Z);if(P.test(Z))return Z.toLowerCase();throw Y(`Invalid hex ${B} in Tron contract`)},$=Q("owner_address");if(j.type==="TransferContract")return{parameter:{value:{amount:D(G),owner_address:$,to_address:Q("to_address")}},type:"TransferContract"};return{parameter:{value:{contract_address:Q("contract_address"),data:U(G,"data"),owner_address:$}},type:"TriggerSmartContract"}}function m({address:q,derivationPath:j}){let J=g(j),G=q??"";return{getAddress:async()=>{if(G)return G;let Q=await(await import("@trezor/connect-web")).default.tronGetAddress({path:J,showOnTrezor:!0});if(!Q.success)throw new I({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:y.Tron,derivationPath:j,error:Q.payload.error}});return G=Q.payload.address,G},signTransaction:async(M)=>{let Q=k(M),$=(await import("@trezor/connect-web")).default,{data:B,expiration:Z,fee_limit:z,ref_block_bytes:H,ref_block_hash:L,timestamp:O}=M.raw_data,W=await $.tronSignTransaction({contract:[Q],data:B,expiration:Z,fee_limit:z,path:J,ref_block_bytes:H,ref_block_hash:L,timestamp:O});if(!W.success)throw new I({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:y.Tron,error:W.payload.error}});return{...M,signature:[W.payload.signature.replace(/^0x/,"")]}}}}export{k as toTrezorTronContract,m as getTronSigner};
+
+//# debugId=05733C3ACC69281364756E2164756E21
+//# sourceMappingURL=chunk-wfbg89d3.js.map

package/dist/chunk-wfbg89d3.js.map

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

package/dist/chunk-xn0fnag5.js

@@ -0,0 +1,4 @@
+import{$d as X}from"./chunk-nhva847d.js";import{ed25519 as f}from"@noble/curves/ed25519.js";import{hex as Y}from"@scure/base";import{PublicKey as W}from"@solana/web3.js";import{Chain as F,derivationPathToString as j,SwapKitError as G}from"@swapkit/helpers";function x(q){return new G({errorKey:"wallet_trezor_method_not_supported",info:{chain:F.Solana,reason:q}})}function O(q){if("version"in q){let{header:B,staticAccountKeys:D}=q.message;return{message:q.message.serialize(),signerKeys:D.slice(0,B.numRequiredSignatures)}}return{message:q.serializeMessage(),signerKeys:q.signatures.map(({publicKey:B})=>B)}}function _(q,B){let{message:D,signerKeys:H}=O(q),J=H.find((L)=>L.toBase58()===B);if(!J)throw x("Trezor account is not a required signer of this transaction");return{message:D,signerKey:J}}function A(q,{message:B,signature:D,signerKey:H}){if(D.length!==64)throw new G({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:F.Solana,error:`Invalid signature length: ${D.length}`}});if(!f.verify(D,B,H.toBytes()))throw new G({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:F.Solana,error:"Signature does not match the Trezor account"}});return q.addSignature(H,Buffer.from(D)),q}function E({address:q,derivationPath:B}){let[D,H]=B;if(D!==44||H!==501||B.length>4)throw new G({errorKey:"wallet_trezor_derivation_path_not_supported",info:{chain:F.Solana,derivationPath:B}});let J=j(B,{allHardened:!0}),L=q?new W(q):null,M=null;async function Q(N){if(M)return M.toBase58();let I=await(await import("@trezor/connect-web")).default.solanaGetAddress({path:J,showOnTrezor:N});if(!I.success)throw new G({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:F.Solana,derivationPath:B,error:I.payload.error}});let U=new W(I.payload.address);if(L&&!U.equals(L))throw new G({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:F.Solana,derivationPath:B,error:"Trezor account does not match the restored address"}});return M=U,I.payload.address}async function Z(N){let{message:R,signerKey:I}=_(N,await Q(!1)),V=await(await import("@trezor/connect-web")).default.solanaSignTransaction({path:J,serializedTx:Y.encode(R)});if(!V.success)throw new G({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:F.Solana,error:V.payload.error}});let $=Y.decode(V.payload.signature.replace(/^0x/,""));return A(N,{message:R,signature:$,signerKey:I})}return{connect:async()=>({publicKey:new W(await Q(!0))}),disconnect:()=>Promise.resolve(),getAddress:()=>Q(!0),get publicKey(){return M??L},signTransaction:Z}}export{E as getSolanaSigner};
+
+//# debugId=043ADF8859998D2364756E2164756E21
+//# sourceMappingURL=chunk-xn0fnag5.js.map

package/dist/chunk-xn0fnag5.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/trezor/solanaSigner.ts"],
+  "sourcesContent": [
+    "import { ed25519 } from \"@noble/curves/ed25519.js\";\nimport { hex } from \"@scure/base\";\nimport { PublicKey, type Transaction, type VersionedTransaction } from \"@solana/web3.js\";\nimport { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from \"@swapkit/helpers\";\n\ntype SolanaTransaction = Transaction | VersionedTransaction;\n\nfunction notSupported(reason: string) {\n  return new SwapKitError({ errorKey: \"wallet_trezor_method_not_supported\", info: { chain: Chain.Solana, reason } });\n}\n\nfunction getSigners(transaction: SolanaTransaction) {\n  if (\"version\" in transaction) {\n    const { header, staticAccountKeys } = transaction.message;\n    return {\n      message: transaction.message.serialize(),\n      signerKeys: staticAccountKeys.slice(0, header.numRequiredSignatures),\n    };\n  }\n\n  return {\n    message: transaction.serializeMessage(),\n    signerKeys: transaction.signatures.map(({ publicKey }) => publicKey),\n  };\n}\n\nfunction getSolanaSigningPayload(transaction: SolanaTransaction, address: string) {\n  const { message, signerKeys } = getSigners(transaction);\n  const signerKey = signerKeys.find((key) => key.toBase58() === address);\n\n  if (!signerKey) throw notSupported(\"Trezor account is not a required signer of this transaction\");\n\n  return { message, signerKey };\n}\n\nfunction addSolanaSignature<T extends SolanaTransaction>(\n  transaction: T,\n  { message, signature, signerKey }: { message: Uint8Array; signature: Uint8Array; signerKey: PublicKey },\n) {\n  if (signature.length !== 64) {\n    throw new SwapKitError({\n      errorKey: \"wallet_trezor_failed_to_sign_transaction\",\n      info: { chain: Chain.Solana, error: `Invalid signature length: ${signature.length}` },\n    });\n  }\n\n  if (!ed25519.verify(signature, message, signerKey.toBytes())) {\n    throw new SwapKitError({\n      errorKey: \"wallet_trezor_failed_to_sign_transaction\",\n      info: { chain: Chain.Solana, error: \"Signature does not match the Trezor account\" },\n    });\n  }\n\n  transaction.addSignature(signerKey, Buffer.from(signature));\n  return transaction;\n}\n\nexport function getSolanaSigner({\n  address,\n  derivationPath,\n}: {\n  address?: string;\n  derivationPath: DerivationPathArray;\n}) {\n  // Trezor firmware only accepts m/44'/501' plus up to two more levels.\n  const [purpose, coinType] = derivationPath;\n  if (purpose !== 44 || coinType !== 501 || derivationPath.length > 4) {\n    throw new SwapKitError({\n      errorKey: \"wallet_trezor_derivation_path_not_supported\",\n      info: { chain: Chain.Solana, derivationPath },\n    });\n  }\n\n  const path = derivationPathToString(derivationPath, { allHardened: true });\n  const knownKey = address ? new PublicKey(address) : null;\n  let publicKey: PublicKey | null = null;\n\n  async function loadAddress(showOnTrezor: boolean) {\n    if (publicKey) return publicKey.toBase58();\n\n    const TrezorConnect = (await import(\"@trezor/connect-web\")).default;\n    const result = await TrezorConnect.solanaGetAddress({ path, showOnTrezor });\n\n    if (!result.success) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_get_address\",\n        info: { chain: Chain.Solana, derivationPath, error: result.payload.error },\n      });\n    }\n\n    const deviceKey = new PublicKey(result.payload.address);\n    if (knownKey && !deviceKey.equals(knownKey)) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_get_address\",\n        info: { chain: Chain.Solana, derivationPath, error: \"Trezor account does not match the restored address\" },\n      });\n    }\n\n    publicKey = deviceKey;\n    return result.payload.address;\n  }\n\n  async function signTransaction<T extends SolanaTransaction>(transaction: T) {\n    const { message, signerKey } = getSolanaSigningPayload(transaction, await loadAddress(false));\n    const TrezorConnect = (await import(\"@trezor/connect-web\")).default;\n\n    const result = await TrezorConnect.solanaSignTransaction({ path, serializedTx: hex.encode(message) });\n\n    if (!result.success) {\n      throw new SwapKitError({\n        errorKey: \"wallet_trezor_failed_to_sign_transaction\",\n        info: { chain: Chain.Solana, error: result.payload.error },\n      });\n    }\n\n    const signature = hex.decode(result.payload.signature.replace(/^0x/, \"\"));\n    return addSolanaSignature(transaction, { message, signature, signerKey });\n  }\n\n  return {\n    connect: async () => ({ publicKey: new PublicKey(await loadAddress(true)) }),\n    disconnect: () => Promise.resolve(),\n    getAddress: () => loadAddress(true),\n    get publicKey() {\n      return publicKey ?? knownKey;\n    },\n    signTransaction,\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "043ADF8859998D2364756E2164756E21",
+  "names": []
+}

package/dist/trezor/index.cjs

@@ -1,4 +1,4 @@
-var bU=Object.create;var{getPrototypeOf:TU,defineProperty:s,getOwnPropertyNames:$U,getOwnPropertyDescriptor:vU}=Object,MU=Object.prototype.hasOwnProperty;function VU(X){return this[X]}var PU,mU,ZX=(X,j,B)=>{var Z=X!=null&&typeof X==="object";if(Z){var Q=j?PU??=new WeakMap:mU??=new WeakMap,J=Q.get(X);if(J)return J}B=X!=null?bU(TU(X)):{};let q=j||!X||!X.__esModule?s(B,"default",{value:X,enumerable:!0}):B;for(let Y of $U(X))if(!MU.call(q,Y))s(q,Y,{get:VU.bind(X,Y),enumerable:!0});if(Z)Q.set(X,q);return q},IU=(X)=>{var j=(ZU??=new WeakMap).get(X),B;if(j)return j;if(j=s({},"__esModule",{value:!0}),X&&typeof X==="object"||typeof X==="function"){for(var Z of $U(X))if(!MU.call(j,Z))s(j,Z,{get:VU.bind(X,Z),enumerable:!(B=vU(X,Z))||B.enumerable})}return ZU.set(X,j),j},ZU,$X=(X,j)=>()=>(j||X((j={exports:{}}).exports,j),j.exports);var gU=(X)=>X;function yU(X,j){this[X]=gU.bind(null,j)}var NU=(X,j)=>{for(var B in j)s(X,B,{get:j[B],enumerable:!0,configurable:!0,set:yU.bind(j,B)})};var hU=(X,j)=>()=>(X&&(j=X(X=0)),j);var DU={};NU(DU,{getEVMSigner:()=>lU});async function lU({chain:X,derivationPath:j,provider:B}){let{AbstractSigner:Z}=await import("ethers");class Q extends Z{address;chain;derivationPath;provider;constructor({chain:J,derivationPath:q,provider:Y}){super(Y);this.address="",this.chain=J,this.derivationPath=q,this.provider=Y}getAddress=async()=>{if(!this.address){let q=await(await import("@trezor/connect-web")).default.ethereumGetAddress({path:v.derivationPathToString(this.derivationPath),showOnTrezor:!0});if(!q.success)throw new v.SwapKitError({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 Y=await(await import("@trezor/connect-web")).default.ethereumSignMessage({message:J,path:v.derivationPathToString(this.derivationPath)});if(!Y.success)throw new v.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...Y,chain:this.chain,derivationPath:this.derivationPath,message:J}});return Y.payload.signature};signTypedData=async(J,q,Y,M)=>{let D=(await import("@trezor/connect-web")).default,{buildEIP712DomainType:R}=await import("@swapkit/toolboxes/evm"),{TypedDataEncoder:N}=await import("ethers"),{EIP712Domain:G,..._}=q,$=M??N.from(_).primaryType,L=R(J),S={domain:J,message:Y,primaryType:$,types:{EIP712Domain:L,..._}},P=await D.ethereumSignTypedData({data:S,metamask_v4_compat:!0,path:v.derivationPathToString(this.derivationPath)});if(!P.success)throw new v.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,error:P.payload.error}});return P.payload.signature.startsWith("0x")?P.payload.signature:`0x${P.payload.signature}`};signTransaction=async({to:J,gasLimit:q,value:Y,data:M,nonce:D,maxFeePerGas:R,maxPriorityFeePerGas:N,gasPrice:G})=>{if(!J)throw new v.SwapKitError({errorKey:"wallet_missing_params",info:{to:J}});if(!q)throw new v.SwapKitError({errorKey:"wallet_missing_params",info:{gasLimit:q}});let _=R!=null||N!=null;if(_&&!R)throw new v.SwapKitError({errorKey:"wallet_missing_params",info:{maxFeePerGas:R}});if(!(_||G))throw new v.SwapKitError({errorKey:"wallet_missing_params",info:{gasPrice:G}});let $=(await import("@trezor/connect-web")).default,{toHexString:L}=await import("@swapkit/toolboxes/evm"),S=_?{maxFeePerGas:L(BigInt(R?.toString()||0)),maxPriorityFeePerGas:L(BigInt(N?.toString()||0))}:G&&{gasPrice:L(BigInt(G?.toString()||0))}||{gasPrice:"0x0"},P=L(BigInt(D||await this.provider.getTransactionCount(await this.getAddress(),"pending"))),g={chainId:Number.parseInt(v.ChainToChainId[this.chain],10),data:M?.toString()||"0x",gasLimit:L(BigInt(q?.toString()||0)),nonce:P,to:J.toString(),value:L(BigInt(Y?.toString()||0)),...S},{success:h,payload:y}=await $.ethereumSignTransaction({path:v.derivationPathToString(this.derivationPath),transaction:g});if(!h)throw new v.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...y,chain:this.chain,derivationPath:this.derivationPath}});let m=y.serializedTx?y.serializedTx.startsWith("0x")?y.serializedTx:`0x${y.serializedTx}`:void 0;if(!m)throw new v.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,derivationPath:this.derivationPath}});return m};connect=(J)=>{if(!J)throw new v.SwapKitError({errorKey:"wallet_provider_not_found",info:{chain:this.chain,derivationPath:this.derivationPath,wallet:v.WalletOption.TREZOR}});return new Q({chain:this.chain,derivationPath:this.derivationPath,provider:J})}}return new Q({chain:X,derivationPath:j,provider:B})}var v;var LU=hU(()=>{v=require("@swapkit/helpers")});var YX={};NU(YX,{trezorWallet:()=>KU,normalizeTrezorSignature:()=>EU,normalizeTrezorExtendedPublicKey:()=>e,getTrezorExtendedPublicKey:()=>wU,TREZOR_SUPPORTED_CHAINS:()=>QX});module.exports=IU(YX);var BU=require("@scure/base"),n=require("@scure/bip32"),U=require("@swapkit/helpers"),w=require("@swapkit/toolboxes/utxo"),t=require("@swapkit/wallet-core");async function WU({chain:X,indexes:j,publicKey:B,tx:Z}){let{getMissingSpendingMetadata:Q,getNetworkForChain:J}=await import("@swapkit/toolboxes/utxo");for(let{index:q,...Y}of Q({chain:X,indexes:j,network:J(X),publicKey:B,tx:Z}))Z.updateInput(q,Y)}var xU=new Set(["auto","iframe","popup","suite-desktop","suite-web"]),cU=new Set(["BridgeTransport","WebUsbTransport","NodeUsbTransport"]),_U="auto",r={appName:"SwapKit",appUrl:"https://swapkit.dev",email:"support@swapkit.dev"},GU=["WebUsbTransport"],o={keepSession:!0},uU=65,i=new Map,c,pU=[U.Chain.Bitcoin,U.Chain.BitcoinCash,U.Chain.Dash,U.Chain.Dogecoin,U.Chain.Litecoin].map((X)=>w.getNetworkForChain(X).bip32);async function dU(){i.clear();let X=(async()=>{try{await(await import("@trezor/connect-web")).default.dispose()}catch{}})();if(c=X,await X,c===X)c=void 0}function HU(X){return typeof X==="string"&&xU.has(X)?X:void 0}function AU(X){if(!Array.isArray(X))return;let j=X.filter((B)=>typeof B==="string"&&cU.has(B));return j.length>0?j:void 0}function p(X,j){return typeof X==="string"&&X.trim()?X:j}function kU(){return typeof globalThis.location<"u"&&globalThis.location.origin?globalThis.location.origin:r.appUrl}async function sU(){let X=(await import("@trezor/connect-web")).default,j=U.SKConfig.get("integrations").trezor,{connectSrc:B,coreMode:Z,debug:Q,interactionTimeout:J,lazyLoad:q,pendingTransportEvent:Y,popup:M,transportReconnect:D,transports:R,...N}=j??{},G={...N,appName:p(j?.appName,r.appName),appUrl:p(j?.appUrl,kU()),email:p(j?.email,r.email)},_=typeof globalThis.location<"u"&&["localhost","127.0.0.1"].includes(globalThis.location.hostname),$=HU(Z)??_U,L=AU(R)??GU;if(c)await c;if(_)await X.dispose();return await X.init({connectSrc:B,coreMode:$,debug:Q,interactionTimeout:J,lazyLoad:q??!1,manifest:G,pendingTransportEvent:Y,popup:M??!0,transportReconnect:D,transports:L}),{coreMode:$,isLocalhost:_,popup:M??!0,TrezorConnect:X}}function e(X,j){let B=w.getNetworkForChain(j).bip32,Z=[B,...pU.filter((J)=>J.public!==B.public||J.private!==B.private)],Q;for(let J of Z)try{let q=n.HDKey.fromExtendedKey(X,J);if(!(q.publicKey&&q.chainCode))throw Error("Extended key is missing public key data");return new n.HDKey({chainCode:q.chainCode,depth:q.depth,index:q.index,parentFingerprint:q.parentFingerprint,publicKey:q.publicKey,versions:B}).publicExtendedKey}catch(q){Q=q}throw Q instanceof Error?Q:Error("Unable to parse Trezor extended public key")}function FU(X,j){if(!X)return;try{return e(X,j)}catch{return X}}function JU(X){if(X.length<2||X[0]!==106)return null;let j=X[1];if(j===void 0||X.length<2+j)return null;return Buffer.from(X.slice(2,2+j)).toString("hex")}function oU(X,j){switch(j[0]){case 86:return X===U.Chain.Bitcoin?{input:"SPENDTAPROOT",output:"PAYTOTAPROOT",utxo:U.UTXOScriptType.P2TR}:null;case 84:return{input:"SPENDWITNESS",output:"PAYTOWITNESS",utxo:U.UTXOScriptType.P2WPKH};case 49:return{input:"SPENDP2SHWITNESS",output:"PAYTOP2SHWITNESS",utxo:U.UTXOScriptType.P2SH_P2WPKH};case 44:return{input:"SPENDADDRESS",output:"PAYTOADDRESS",utxo:U.UTXOScriptType.P2PKH};default:return null}}function u(X){return X.map((j,B)=>B<3?(j|2147483648)>>>0:j)}function rU(X){return Array.isArray(X)&&X[0]instanceof Uint8Array&&typeof X[1]==="object"&&X[1]!==null&&typeof X[1].fingerprint==="number"&&Array.isArray(X[1].path)}function iU(X){if(!Array.isArray(X.bip32Derivation))return;let[j]=X.bip32Derivation;return rU(j)?j:void 0}function aU(X){if(!(Array.isArray(X)&&X[0]instanceof Uint8Array))return!1;let j=X[1];return Array.isArray(j?.hashes)&&Array.isArray(j?.der?.path)}function nU(X,j){let B=Array.isArray(X.tapBip32Derivation)?X.tapBip32Derivation:[];if(B.length===0)return;let{tapInternalKey:Z}=X,Q=B.filter((Y)=>aU(Y)&&Y[1].hashes.length===0&&(!Z||BU.hex.encode(Y[0])===BU.hex.encode(Z))),[J,q]=Q[0]??[];if(Q.length!==1||!(J&&q))throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:U.Chain.Bitcoin,error:`Input ${j} has no single taproot key-path origin to sign with`}});return{path:q.der.path,xOnlyKey:J}}function OU(X){if(X.witnessUtxo?.amount!==void 0)return X.witnessUtxo.amount.toString();let j=X.index!==void 0?X.nonWitnessUtxo?.outputs?.[X.index]:void 0;if(j?.amount!==void 0)return j.amount.toString();return}function EU(X,j){let B=Buffer.from(X,"hex"),Z=B[1]!==void 0?B[1]+2:void 0;if(Z!==void 0&&B.length===Z)return new Uint8Array([...B,j===U.Chain.BitcoinCash?uU:1]);return new Uint8Array(B)}function tU(X,j,B){let Z=[];for(let Q=0;Q<X.inputsLength;Q++){let J=X.getInput(Q);Z.push({address_n:j,amount:J.value.toString(),prev_hash:B.encode(J.txid),prev_index:J.index,script_type:"SPENDADDRESS"})}return Z}async function eU(X,j,B,Z){let Q=[];for(let J=0;J<X.outputsLength;J++){let q=X.getOutput(J),Y=q.scriptPubkey;if(q.value===0n&&Y?.length>0&&Y[0]===106){let R=JU(Y);if(R){Q.push({amount:"0",op_return_data:R,script_type:"PAYTOOPRETURN"});continue}throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:Z,error:"Malformed OP_RETURN output cannot be signed"}})}let M=await UX(Y);if(!M&&q.value>0n)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:Z,error:"Unable to decode output address from scriptPubkey"}});if(M===B)Q.push({address_n:j,amount:q.value.toString(),script_type:"PAYTOADDRESS"});else Q.push({address:M,amount:q.value.toString(),script_type:"PAYTOADDRESS"})}return Q}async function UX(X){try{let{OutScript:j,Address:B,NETWORKS:Z}=await import("@swapkit/utxo-signer"),Q=j.decode(X);if(Q.type==="pkh"||Q.type==="pk")return B(Z.zcash).encode(Q)}catch{}return}async function XX(X,j){let{ZcashTransaction:B,Script:Z}=await import("@swapkit/utxo-signer"),Q=B.fromHex(X,{allowUnknownOutputs:!0}),J=j.clone();for(let q=0;q<Q.inputsLength;q++){let M=Q.getInput(q).script;if(M&&M.length>0){let D=Z.decode(M);if(D.length>=2)J.addSignature(q,D[1],D[0])}}return J}function jX(X,j,B,Z){let Q=[];for(let J=0;J<X.inputsLength;J++){let q=X.getInput(J),Y=j[J];Q.push({address_n:B,amount:Y?.value?.toString()||q.value?.toString()||"0",prev_hash:q.txid?Z.encode(q.txid):"",prev_index:q.index??0,script_type:"SPENDADDRESS"})}return Q}function qX({addressN:X,chain:j,myAddress:B,network:Z,tx:Q}){let J=[];for(let q=0;q<Q.outputsLength;q++){let Y=Q.getOutput(q),M=Q.getOutputAddress(q,Z),D=Y.script;if(Y.amount===0n&&D?.length>0&&D[0]===106){let G=JU(D);if(G){J.push({amount:"0",op_return_data:G,script_type:"PAYTOOPRETURN"});continue}continue}if(!M&&(Y.amount??0n)>0n)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,error:"Unable to decode output address"}});let N=M===B||!M?{address_n:X}:{address:M};J.push({...N,amount:Y.amount?.toString()||"0",script_type:"PAYTOADDRESS"})}return J}function a(X,j,B,Z,Q,J,q,Y,M){let D=[];for(let R=0;R<X.outputsLength;R++){let N=X.getOutput(R),G=X.getOutputAddress(R,j);if(!G){let S=N.script?JU(N.script):null;if(S!==null||Q){D.push({amount:"0",op_return_data:S??Buffer.from(Q).toString("hex"),script_type:"PAYTOOPRETURN"});continue}throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:J,error:"Unable to decode output address from scriptPubkey"}})}if(N.amount===void 0)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:J,error:"Output amount is missing"}});let _=J===U.Chain.BitcoinCash,$=_?Y(G):G,L=_?M($)===M(Z):$===Z;D.push(L?{address_n:B,amount:N.amount.toString(),script_type:q.output}:{address:$,amount:N.amount.toString(),script_type:"PAYTOADDRESS"})}return D}function qU(X){return X===U.Chain.Bitcoin||X===U.Chain.Litecoin}function BX(X){return X===U.Chain.BitcoinCash||X===U.Chain.Dash||X===U.Chain.Dogecoin}function RU(X,j){if(X!==U.Chain.Dash)return;let B=new Map;for(let Z of j){if(!Z.txHex)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:X,error:`Missing previous transaction hex for ${Z.hash}:${Z.index}`}});B.set(Z.hash,{details:{},hex:Z.txHex,txid:Z.hash})}return[...B.values()]}async function JX({address:X,chain:j,derivationPath:B}){switch(j){case U.Chain.Arbitrum:case U.Chain.Arc:case U.Chain.Aurora:case U.Chain.Avalanche:case U.Chain.Base:case U.Chain.Berachain:case U.Chain.BinanceSmartChain:case U.Chain.Ethereum:case U.Chain.Gnosis:case U.Chain.Hyperevm:case U.Chain.Monad:case U.Chain.Optimism:case U.Chain.Polygon:case U.Chain.Robinhood:case U.Chain.XLayer:{let{getProvider:Z,getEvmToolboxAsync:Q}=await import("@swapkit/toolboxes/evm"),{getEVMSigner:J}=await Promise.resolve().then(() => (LU(),DU)),q=await Z(j),Y=await J({chain:j,derivationPath:B,provider:q}),M=await Y.getAddress();return{...await Q(j,{provider:q,signer:Y}),address:M}}case U.Chain.Zcash:{let{getUtxoToolbox:Z}=await import("@swapkit/toolboxes/utxo"),Q=U.derivationPathToString(B),q=X??await(async()=>{let $=(await import("@trezor/connect-web")).default,{success:L,payload:S}=await $.getAddress({coin:"zcash",path:Q});if(!L)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:j,error:S.error||"Unknown error"}});return S.address})(),Y=async($)=>{let L=(await import("@trezor/connect-web")).default,{hex:S}=await import("@scure/base"),P=u(B),g=$.getGlobal(),h=tU($,P,S),y=await eU($,P,q,j),m=await L.signTransaction({branchId:g.consensusBranchId,coin:"zcash",expiry:g.expiryHeight,inputs:h,locktime:g.lockTime,outputs:y,overwintered:!0,version:g.txVersion,versionGroupId:g.versionGroupId});if(!m.success)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,error:m.payload.error}});return{serializedTx:m.payload.serializedTx,signedPczt:await XX(m.payload.serializedTx,$)}},M=async($)=>{let{ZcashTransaction:L}=await import("@swapkit/utxo-signer");return L.fromHex($,{allowUnknownOutputs:!0})},D=async($)=>{let L=(await import("@trezor/connect-web")).default,{hex:S}=await import("@scure/base"),{NETWORKS:P,ZcashVersionGroupId:g}=await import("@swapkit/utxo-signer"),h=u(B),y=jX($,[],h,S),m=qX({addressN:h,chain:j,myAddress:q,network:P.zcash,tx:$}),l=await L.signTransaction({branchId:$.consensusBranchId,coin:"zcash",expiry:0,inputs:y,locktime:0,outputs:m,overwintered:!0,version:4,versionGroupId:g.SAPLING});if(l.success)return{serializedTx:l.payload.serializedTx,signedTx:await M(l.payload.serializedTx)};throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,error:l.payload.error}})},R={getAddress:async()=>q,signPCZT:async($)=>{return(await Y($)).signedPczt},signTransaction:async($)=>{if("toPCZT"in $){let{serializedTx:L}=await Y($.toPCZT());return M(L)}if("getGlobal"in $){let{serializedTx:L}=await Y($);return M(L)}return(await D($)).signedTx}},N=Z(U.Chain.Zcash,{signer:R}),G=async($)=>{if("toPCZT"in $){let{serializedTx:S}=await Y($.toPCZT());return N.broadcastTx(S)}if("getGlobal"in $){let{serializedTx:S}=await Y($);return N.broadcastTx(S)}let{serializedTx:L}=await D($);return N.broadcastTx(L)},_=async({recipient:$,feeOptionKey:L,feeRate:S,...P})=>{if(!(q&&$))throw new U.SwapKitError({errorKey:"wallet_missing_params",info:{address:q,recipient:$,wallet:U.WalletOption.TREZOR}});let g=S||(await N.getFeeRates())[L||U.FeeOption.Fast],{tx:h}=await N.createTransaction({...P,feeRate:g,fetchTxHex:!1,recipient:$,sender:q}),{serializedTx:y}=await D(h);return N.broadcastTx(y)};return{...N,address:q,signAndBroadcastTransaction:G,signPCZT:R.signPCZT,transfer:_}}case U.Chain.Bitcoin:case U.Chain.BitcoinCash:case U.Chain.Dash:case U.Chain.Dogecoin:case U.Chain.Litecoin:{let CU=function(V={}){return jU(V)},{toCashAddress:Z,getUtxoToolbox:Q,stripPrefix:J}=await import("@swapkit/toolboxes/utxo"),q=j,Y=oU(j,B);if(!Y)throw new U.SwapKitError({errorKey:"wallet_trezor_derivation_path_not_supported",info:{derivationPath:B}});let M=Y,D=Y.utxo===U.UTXOScriptType.P2TR,R={scriptType:Y.utxo},N=j.toLowerCase(),_=X??await(async(V=B)=>{let K=(await import("@trezor/connect-web")).default,F=U.derivationPathToString(V),{success:H,payload:E}=await K.getAddress({coin:N,...o,path:F,showOnTrezor:!1});if(!H)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:j,error:E.error||"Unknown error"}});if(j===U.Chain.BitcoinCash)return J(E.address);return E.address})(),$=Q(j,R),L=async(V,K,F="")=>{let H=(await import("@trezor/connect-web")).default,E=u(B),A=w.getNetworkForChain(j),f=a(V,A,E,_,F,j,M,Z,J),b=K.map(({hash:z,index:T,value:W})=>({address_n:E,amount:W,prev_hash:z,prev_index:T,script_type:M.input})),O=await H.signTransaction({coin:N,inputs:b,outputs:f,refTxs:RU(j,K)});if(O.success)return O.payload.serializedTx;let C=O.payload;throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,code:C?.code??"unknown",error:C?.error??"unknown",payload:C}})},S=async(V)=>{let K=(await import("@trezor/connect-web")).default,{hex:F}=await import("@scure/base"),H=u(B),E=w.getNetworkForChain(j),A;async function f(){if(!A){let W=await jU(),I=n.HDKey.fromExtendedKey(W.xpub,E.bip32).derive(`m/${Number(B[3]??0)}/${Number(B[4]??0)}`);if(!I.publicKey)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_get_public_key",info:{chain:j,error:"Unable to derive Trezor leaf public key from account xpub"}});A=I.publicKey}return[A,{fingerprint:0,path:H}]}let b=[],O=[];async function C(W,k){if(D){let d=nU(k,W);if(!d){let[fU,{path:YU}]=await f();d={path:YU,xOnlyKey:fU.slice(1)},V.updateInput(W,{tapBip32Derivation:[[d.xOnlyKey,{der:{fingerprint:0,path:YU},hashes:[]}]]})}if(!k.tapInternalKey)V.updateInput(W,{tapInternalKey:d.xOnlyKey});return d.path}let I=iU(k),x=I??await f();if(b[W]=x[0],!I)V.updateInput(W,{bip32Derivation:[x]});return await WU({chain:q,indexes:[W],publicKey:x[0],tx:V}),x[1].path}for(let W=0;W<V.inputsLength;W++){let k=V.getInput(W),I=OU(k);if(!k.txid||k.index===void 0||!I)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,error:`Input ${W} is missing prevout data required by Trezor`}});let x=await C(W,k);O.push({address_n:x,amount:I,prev_hash:F.encode(k.txid),prev_index:k.index,script_type:M.input,...k.sequence!==void 0?{sequence:k.sequence}:{}})}let z=a(V,E,H,_,"",j,M,Z,J),T=await K.signTransaction({coin:N,...o,inputs:O,locktime:V.lockTime,outputs:z,version:V.version});if(!T.success){let W=T.payload;throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,code:W?.code??"unknown",error:W?.error??"unknown",payload:W}})}return T.payload.signatures.forEach((W,k)=>{if(!W)return;if(D){V.updateInput(k,{tapKeySig:F.decode(W)});return}let I=b[k];if(!I)return;V.updateInput(k,{partialSig:[[I,EU(W,j)]]})}),V},P=async(V)=>{let K=(await import("@trezor/connect-web")).default,{hex:F}=await import("@scure/base"),H=u(B),E=w.getNetworkForChain(j),A=[];for(let C=0;C<V.inputsLength;C++){let z=V.getInput(C),T=OU(z);if(!z.txid||z.index===void 0||!T)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,error:`Input ${C} is missing prevout data required by Trezor`}});A.push({address_n:H,amount:T,prev_hash:F.encode(z.txid),prev_index:z.index,script_type:M.input,...z.sequence!==void 0?{sequence:z.sequence}:{}})}let f=a(V,E,H,_,"",j,M,Z,J),b=await K.signTransaction({coin:N,inputs:A,locktime:V.lockTime,outputs:f,version:V.version});if(b.success)return b.payload.serializedTx;let O=b.payload;throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,code:O?.code??"unknown",error:O?.error??"unknown",payload:O}})},g=async(V,K,F="")=>{let H=(await import("@trezor/connect-web")).default,E=w.getNetworkForChain(j),A=u(B.slice(0,3)),f=a(V,E,A,_,F,j,M,Z,J),b=K.map(({hash:C,index:z,value:T,derivationIndex:W,isChange:k})=>{let I=k?1:0;return{address_n:[...A,I,W],amount:T,prev_hash:C,prev_index:z,script_type:M.input}}),O=await H.signTransaction({coin:N,inputs:b,outputs:f,refTxs:RU(j,K)});if(O.success)return O.payload.serializedTx;throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:j,error:O.payload.error}})},h=async({utxos:V,recipient:K,assetValue:F,memo:H,feeRate:E,feeOptionKey:A})=>{let f=Q(j,R),b=E||(await f.getFeeRates())[A||U.FeeOption.Fast],{tx:O,inputs:C}=await f.createTransaction({assetValue:F,feeRate:b,fetchTxHex:j===U.Chain.Dash,memo:H,recipient:K,sender:_}),z=C.map((W)=>{let k=V.find((I)=>I.hash===W.hash&&I.index===W.index);return{...W,derivationIndex:k?.derivationIndex??0,isChange:k?.isChange??!1,txHex:k?.txHex}}),T=await g(O,z,H);return f.broadcastTx(T)},y=async({recipient:V,feeOptionKey:K,feeRate:F,memo:H,...E})=>{if(!(_&&V))throw new U.SwapKitError({errorKey:"wallet_missing_params",info:{address:_,memo:H,recipient:V,wallet:U.WalletOption.TREZOR}});let A=Q(j,R),f=F||(await A.getFeeRates())[K||U.FeeOption.Fast],b=A.createTransaction,{tx:O,inputs:C}=await b({...E,feeRate:f,fetchTxHex:j===U.Chain.Dash,memo:H,recipient:V,sender:_}),z=await L(O,C,H);return await A.broadcastTx(z)},m=qU(j)?await Q(q,{...R,signer:{getAddress:async()=>_,signTransaction:S}}):$,l=BX(j)?async(V)=>$.broadcastTx(await P(V)):m.signAndBroadcastTransaction,UU=qU(j)?m.signTransaction:L,XU=qU(j)?m.transfer:y;async function jU({accountIndex:V}={}){let K=(await import("@trezor/connect-web")).default,F=w.getUTXOAccountPath({accountIndex:V,chain:q,derivationPath:B}),H=U.derivationPathToString(F),E=`${j}:${H}`,A=i.get(E);if(A)return A;let f=await K.getPublicKey({coin:N,path:H}),{success:b,payload:O}=f;if(!b)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_get_public_key",info:{chain:j,error:O.error||"Unknown error"}});let C=e(O.xpub,q),z=FU(O.xpubSegwit,q),T={accountIndex:w.getUTXOAccountIndexFromPath(F),chainCode:O.chainCode,depth:O.depth,fingerprint:O.fingerprint,path:O.serializedPath,publicKey:O.publicKey,xpub:C,xpubSegwit:z};return i.set(E,T),T}async function QU({accountIndex:V,index:K,change:F=!1}){w.assertDerivationIndex("index",K);let H=(await import("@trezor/connect-web")).default,E=w.getUTXOAccountPath({accountIndex:V,chain:q,derivationPath:B}),A=`${U.derivationPathToString(E)}/${Number(F)}/${K}`,{success:f,payload:b}=await H.getAddress({coin:N,...o,path:A,showOnTrezor:!1});if(!f)return;let O=b.address;if(j===U.Chain.BitcoinCash)O=(await Q(j)).stripPrefix(b.address);let C=await H.getPublicKey({coin:N,...o,path:A,scriptType:M.input,showOnTrezor:!1}),z=C.success?C.payload.publicKey:"";return{accountIndex:w.getUTXOAccountIndexFromPath(E),address:O,change:F,index:K,path:A,pubkey:z}}async function SU({accountIndex:V,count:K,startIndex:F=0,change:H=!1}){w.assertDerivationIndex("count",K),w.assertDerivationIndex("startIndex",F);let E=(await import("@trezor/connect-web")).default,A=w.getUTXOAccountPath({accountIndex:V,chain:q,derivationPath:B}),f=U.derivationPathToString(A),b=Array.from({length:K},(T,W)=>({coin:N,path:`${f}/${Number(H)}/${F+W}`,showOnTrezor:!1})),{success:O,payload:C}=await E.getAddress({...o,bundle:b});if(!O||!Array.isArray(C))return[];return await Promise.all(C.map(async(T,W)=>{let k=T.address;if(j===U.Chain.BitcoinCash)k=(await Q(j)).stripPrefix(T.address);return{accountIndex:w.getUTXOAccountIndexFromPath(A),address:k,change:H,index:F+W,path:`${f}/${Number(H)}/${F+W}`,pubkey:""}}))}let zU=w.createHDWalletHelpers({chain:j,deriveAddress:QU,getBalance:m.getBalance,getUtxos:(V)=>w.getUtxoApi(j).getUtxos({address:V,fetchTxHex:!0})});return{...m,...zU,address:_,deriveAddressAtIndex:QU,deriveAddresses:SU,getExtendedPublicKey:CU,getExtendedPublicKeyInfo:jU,signAndBroadcastTransaction:l,signTransaction:UU,signTransactionWithMultipleInputs:g,transfer:XU,transferFromMultipleAddresses:h}}default:throw new U.SwapKitError({errorKey:"wallet_chain_not_supported",info:{chain:j,wallet:U.WalletOption.TREZOR}})}}async function wU(X,j,{accountIndex:B}={}){if(![U.Chain.BitcoinCash,U.Chain.Bitcoin,U.Chain.Dash,U.Chain.Dogecoin,U.Chain.Litecoin,U.Chain.Zcash].includes(X))throw new U.SwapKitError({errorKey:"wallet_chain_not_supported",info:{chain:X,wallet:U.WalletOption.TREZOR}});let{TrezorConnect:Z}=await sU(),Q=X,J=j??U.NetworkDerivationPath[X],q=X===U.Chain.Zcash?"zcash":X.toLowerCase(),Y=w.getUTXOAccountPath({accountIndex:B,chain:Q,derivationPath:J}),M=U.derivationPathToString(Y),D=`${X}:${M}`,R=i.get(D);if(R)return R;let{success:N,payload:G}=await Z.getPublicKey({coin:q,path:M,showOnTrezor:!0});if(!N)throw new U.SwapKitError({errorKey:"wallet_trezor_failed_to_get_public_key",info:{chain:X,error:G.error||"Unknown error"}});let _={accountIndex:w.getUTXOAccountIndexFromPath(Y),chainCode:G.chainCode,depth:G.depth,fingerprint:G.fingerprint,path:G.serializedPath,publicKey:G.publicKey,xpub:e(G.xpub,Q),xpubSegwit:FU(G.xpubSegwit,Q)};return i.set(D,_),_}var KU=t.createWallet({connect:({addChain:X,supportedChains:j,walletType:B})=>async function(Q,J,{address:q}={}){let[Y]=U.filterSupportedChains({chains:Q,supportedChains:j,walletType:B});if(!Y)throw new U.SwapKitError({errorKey:"wallet_chain_not_supported",info:{chain:Y,wallet:U.WalletOption.TREZOR}});let M=(await import("@trezor/connect-web")).default,D=U.SKConfig.get("integrations").trezor,{connectSrc:R,coreMode:N,debug:G,interactionTimeout:_,lazyLoad:$,pendingTransportEvent:L,popup:S,transportReconnect:P,transports:g,...h}=D??{},y={...h,appName:p(D?.appName,r.appName),appUrl:p(D?.appUrl,kU()),email:p(D?.email,r.email)},m=typeof globalThis.location<"u"&&["localhost","127.0.0.1"].includes(globalThis.location.hostname),l=HU(N)??_U,UU=AU(g)??GU;if(c)await c;if(m)await M.dispose();await M.init({connectSrc:R,coreMode:l,debug:G,interactionTimeout:_,lazyLoad:$??!1,manifest:y,pendingTransportEvent:L,popup:S??!0,transportReconnect:P,transports:UU});let XU=await JX({address:q,chain:Y,derivationPath:J});return X({...XU,chain:Y,disconnect:dU,walletType:B}),!0},directSigningSupport:{[U.Chain.Arbitrum]:!0,[U.Chain.Arc]:!0,[U.Chain.Aurora]:!0,[U.Chain.Avalanche]:!0,[U.Chain.Base]:!0,[U.Chain.Berachain]:!0,[U.Chain.BinanceSmartChain]:!0,[U.Chain.Bitcoin]:!0,[U.Chain.BitcoinCash]:!0,[U.Chain.Dash]:!0,[U.Chain.Ethereum]:!0,[U.Chain.Gnosis]:!0,[U.Chain.Dogecoin]:!0,[U.Chain.Hyperevm]:!0,[U.Chain.Litecoin]:!0,[U.Chain.Monad]:!0,[U.Chain.Optimism]:!0,[U.Chain.Polygon]:!0,[U.Chain.Robinhood]:!0,[U.Chain.XLayer]:!0,[U.Chain.Zcash]:!0},getExtendedPublicKey:wU,name:"connectTrezor",supportedChains:[U.Chain.Arbitrum,U.Chain.Arc,U.Chain.Aurora,U.Chain.Avalanche,U.Chain.Base,U.Chain.Berachain,U.Chain.BinanceSmartChain,U.Chain.Bitcoin,U.Chain.BitcoinCash,U.Chain.Dash,U.Chain.Dogecoin,U.Chain.Ethereum,U.Chain.Gnosis,U.Chain.Hyperevm,U.Chain.Litecoin,U.Chain.Monad,U.Chain.Optimism,U.Chain.Polygon,U.Chain.Robinhood,U.Chain.XLayer,U.Chain.Zcash],walletType:U.WalletOption.TREZOR}),QX=t.getWalletSupportedChains(KU);
+var A$=Object.create;var{getPrototypeOf:H$,defineProperty:_M,getOwnPropertyNames:CM,getOwnPropertyDescriptor:z$}=Object,IM=Object.prototype.hasOwnProperty;function KM(M){return this[M]}var E$,k$,z4=(M,$,U)=>{var X=M!=null&&typeof M==="object";if(X){var J=$?E$??=new WeakMap:k$??=new WeakMap,Q=J.get(M);if(Q)return Q}U=M!=null?A$(H$(M)):{};let B=$||!M||!M.__esModule?_M(U,"default",{value:M,enumerable:!0}):U;for(let Z of CM(M))if(!IM.call(B,Z))_M(B,Z,{get:KM.bind(M,Z),enumerable:!0});if(X)J.set(M,B);return B},S$=(M)=>{var $=(TM??=new WeakMap).get(M),U;if($)return $;if($=_M({},"__esModule",{value:!0}),M&&typeof M==="object"||typeof M==="function"){for(var X of CM(M))if(!IM.call($,X))_M($,X,{get:KM.bind(M,X),enumerable:!(U=z$(M,X))||U.enumerable})}return TM.set(M,$),$},TM,E4=(M,$)=>()=>($||M(($={exports:{}}).exports,$),$.exports);var m$=(M)=>M;function F$(M,$){this[M]=m$.bind(null,$)}var a=(M,$)=>{for(var U in $)_M(M,U,{get:$[U],enumerable:!0,configurable:!0,set:F$.bind($,U)})};var qM=(M,$)=>()=>(M&&($=M(M=0)),$);var gM={};a(gM,{getEVMSigner:()=>w$});async function w$({chain:M,derivationPath:$,provider:U}){let{AbstractSigner:X}=await import("ethers");class J extends X{address;chain;derivationPath;provider;constructor({chain:Q,derivationPath:B,provider:Z}){super(Z);this.address="",this.chain=Q,this.derivationPath=B,this.provider=Z}getAddress=async()=>{if(!this.address){let B=await(await import("@trezor/connect-web")).default.ethereumGetAddress({path:g.derivationPathToString(this.derivationPath),showOnTrezor:!0});if(!B.success)throw new g.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{...B,chain:this.chain,derivationPath:this.derivationPath}});this.address=B.payload.address}return this.address};signMessage=async(Q)=>{let Z=await(await import("@trezor/connect-web")).default.ethereumSignMessage({message:Q,path:g.derivationPathToString(this.derivationPath)});if(!Z.success)throw new g.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...Z,chain:this.chain,derivationPath:this.derivationPath,message:Q}});return Z.payload.signature};signTypedData=async(Q,B,Z,_)=>{let j=(await import("@trezor/connect-web")).default,{buildEIP712DomainType:W}=await import("@swapkit/toolboxes/evm"),{TypedDataEncoder:N}=await import("ethers"),{EIP712Domain:G,...V}=B,Y=_??N.from(V).primaryType,O=W(Q),F={domain:Q,message:Z,primaryType:Y,types:{EIP712Domain:O,...V}},b=await j.ethereumSignTypedData({data:F,metamask_v4_compat:!0,path:g.derivationPathToString(this.derivationPath)});if(!b.success)throw new g.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,error:b.payload.error}});return b.payload.signature.startsWith("0x")?b.payload.signature:`0x${b.payload.signature}`};signTransaction=async({to:Q,gasLimit:B,value:Z,data:_,nonce:j,maxFeePerGas:W,maxPriorityFeePerGas:N,gasPrice:G})=>{if(!Q)throw new g.SwapKitError({errorKey:"wallet_missing_params",info:{to:Q}});if(!B)throw new g.SwapKitError({errorKey:"wallet_missing_params",info:{gasLimit:B}});let V=W!=null||N!=null;if(V&&!W)throw new g.SwapKitError({errorKey:"wallet_missing_params",info:{maxFeePerGas:W}});if(!(V||G))throw new g.SwapKitError({errorKey:"wallet_missing_params",info:{gasPrice:G}});let Y=(await import("@trezor/connect-web")).default,{toHexString:O}=await import("@swapkit/toolboxes/evm"),F=V?{maxFeePerGas:O(BigInt(W?.toString()||0)),maxPriorityFeePerGas:O(BigInt(N?.toString()||0))}:G&&{gasPrice:O(BigInt(G?.toString()||0))}||{gasPrice:"0x0"},b=O(BigInt(j||await this.provider.getTransactionCount(await this.getAddress(),"pending"))),w={chainId:Number.parseInt(g.ChainToChainId[this.chain],10),data:_?.toString()||"0x",gasLimit:O(BigInt(B?.toString()||0)),nonce:b,to:Q.toString(),value:O(BigInt(Z?.toString()||0)),...F},{success:x,payload:P}=await Y.ethereumSignTransaction({path:g.derivationPathToString(this.derivationPath),transaction:w});if(!x)throw new g.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...P,chain:this.chain,derivationPath:this.derivationPath}});let v=P.serializedTx?P.serializedTx.startsWith("0x")?P.serializedTx:`0x${P.serializedTx}`:void 0;if(!v)throw new g.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,derivationPath:this.derivationPath}});return v};connect=(Q)=>{if(!Q)throw new g.SwapKitError({errorKey:"wallet_provider_not_found",info:{chain:this.chain,derivationPath:this.derivationPath,wallet:g.WalletOption.TREZOR}});return new J({chain:this.chain,derivationPath:this.derivationPath,provider:Q})}}return new J({chain:M,derivationPath:$,provider:U})}var g;var PM=qM(()=>{g=require("@swapkit/helpers")});var xM={};a(xM,{toTrezorCardanoTransaction:()=>vM,getCardanoSigner:()=>b$,addTrezorWitnesses:()=>hM});function yM({CARDANO:M,PROTO:$}){return{derivationType:$.CardanoDerivationType.ICARUS,mainnet:{networkId:M.NETWORK_IDS.mainnet,protocolMagic:M.PROTOCOL_MAGICS.mainnet}}}function r(M){return new l.SwapKitError({errorKey:"wallet_trezor_method_not_supported",info:{chain:l.Chain.Cardano,reason:M}})}function AM(M){return new l.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:l.Chain.Cardano,error:M}})}function UM(M,$){let X=typeof M==="object"&&M!==null&&"toFixed"in M||Number.isSafeInteger(M)?String(M.toFixed()):"";if(!/^\d+$/.test(X))throw r(`Invalid ${$} in Cardano transaction`);return X}function C$(M){return[...M].map(([$,U])=>({policyId:e.hex.encode($),tokenAmounts:[...U].map(([X,J])=>({amount:UM(J,"token amount"),assetNameBytes:e.hex.encode(X)}))}))}async function I$(M,$,U){let X,J,Q;if(Array.isArray(M)){if(M.length!==2)throw r("Trezor cannot sign Cardano outputs with a datum");[X,J]=M,Q=U.CardanoTxOutputSerializationFormat.ARRAY_LEGACY}else if(M instanceof Map){if(M.has(2))throw r("Trezor cannot sign Cardano outputs with a datum");if(M.has(3))throw r("Trezor cannot sign Cardano outputs with a reference script");if(M.size!==2)throw r("Unsupported field in Cardano output");X=M.get(0),J=M.get(1),Q=U.CardanoTxOutputSerializationFormat.MAP_BABBAGE}else throw r("Invalid Cardano output");if(Array.isArray(J)&&J.length!==2)throw r("Invalid Cardano output value");let[B,Z]=Array.isArray(J)?J:[J],_=await u.getCardanoAddressFromBytes(X);return{..._===$.address?{addressParameters:{addressType:U.CardanoAddressType.BASE,path:$.path,stakingPath:$.stakingPath}}:{address:_},amount:UM(B,"output amount"),format:Q,...Z===void 0?{}:{tokenBundle:C$(Z)}}}function K$(M,$){let U=typeof M==="object"&&M!==null&&"tag"in M&&M.tag===T$&&"value"in M;return{inputs:(U?M.value:M).map((Q)=>{if(Q.length!==2)throw r("Invalid Cardano input");let[B,Z]=Q;return{path:$,prev_hash:e.hex.encode(B),prev_index:Number(UM(Z,"input index"))}}),tagCborSets:U}}async function vM(M,$,U){let{body:X}=await u.decodeCardanoTransaction(M),{derivationType:J,mainnet:Q}=yM(U),{PROTO:B}=U,Z=Object.values(t),_=[...X.keys()].filter((V)=>!Z.includes(V));if(_.length>0)throw r(`Trezor cannot sign Cardano transactions with body fields ${_.join(", ")}`);let j=X.get(t.OUTPUTS),W=X.get(t.AUXILIARY_DATA_HASH),N=X.get(t.TTL),G=X.get(t.VALIDITY_INTERVAL_START);return{...K$(X.get(t.INPUTS),$.path),...Q,derivationType:J,fee:UM(X.get(t.FEE),"fee"),outputs:await Promise.all(j.map((V)=>I$(V,$,B))),signingMode:B.CardanoTxSigningMode.ORDINARY_TRANSACTION,...W?{auxiliaryData:{hash:e.hex.encode(W)}}:{},...N===void 0?{}:{ttl:UM(N,"ttl")},...G===void 0?{}:{validityIntervalStart:UM(G,"validity interval start")}}}async function hM(M,{hash:$,witnesses:U},X,{PROTO:J}){let{bodyHash:Q}=await u.decodeCardanoTransaction(M);if($.toLowerCase()!==Q)throw AM("Trezor signed a different transaction body");let B=U.map(({pubKey:Z,signature:_,type:j})=>{if(j!==J.CardanoTxWitnessType.SHELLEY_WITNESS||Z.toLowerCase()!==X)throw AM("Trezor returned a witness for an unexpected key");return{publicKey:e.hex.decode(Z),signature:e.hex.decode(_)}});return u.addCardanoVkeyWitnesses(M,B)}async function b$({connect:M,derivationPath:$}){let[U,X,J,Q,B]=$;if($.length!==5||Q!==0||B===void 0)throw new l.SwapKitError({errorKey:"wallet_trezor_derivation_path_not_supported",info:{chain:l.Chain.Cardano,derivationPath:$}});let Z=l.derivationPathToString($),_=l.derivationPathToString([U,X,J,2,0]),{derivationType:j,mainnet:W}=yM(M),N=M.default,G=await N.cardanoGetPublicKey({bundle:[Z,_].map((w)=>({derivationType:j,path:w}))});if(!G.success)throw new l.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:l.Chain.Cardano,derivationPath:$,error:G.payload.error}});let[V,Y]=G.payload.map(({node:w})=>Buffer.from(w.public_key,"hex")),O=await u.getCardanoPublicKeyHash(V),F=await u.getCardanoAddressFromBytes(Buffer.concat([Buffer.from([W.networkId]),O,await u.getCardanoPublicKeyHash(Y)]));async function b(w){let x=await vM(w,{address:F,path:Z,stakingPath:_},M),P=await N.cardanoSignTransaction(x);if(!P.success)throw AM(P.payload.error);return hM(w,P.payload,V.toString("hex"),M)}return{getAddress:()=>F,publicKey:V,publicKeyHash:O,signTransaction:b}}var e,l,u,t,T$=258;var cM=qM(()=>{e=require("@scure/base"),l=require("@swapkit/helpers"),u=require("@swapkit/toolboxes/cardano");t={AUXILIARY_DATA_HASH:7,FEE:2,INPUTS:0,OUTPUTS:1,TTL:3,VALIDITY_INTERVAL_START:8}});var uM={};a(uM,{toTrezorRippleTransaction:()=>lM,getRippleSigner:()=>P$});function o(M){return new p.SwapKitError({errorKey:"wallet_trezor_method_not_supported",info:{chain:p.Chain.Ripple,reason:M}})}function lM(M){let $=M;if($.TransactionType!=="Payment")throw o(`Trezor only signs XRP payments, got ${String($.TransactionType)}`);let U=Object.keys($).filter((W)=>$[W]!==void 0&&$[W]!==null&&!g$.has(W));if(U.length>0)throw o(`Trezor cannot sign XRP payments with ${U.join(", ")}`);let{Amount:X,Destination:J,DestinationTag:Q,Fee:B,Flags:Z,LastLedgerSequence:_,Sequence:j}=$;if(typeof X!=="string"||!/^\d+$/.test(X))throw o("Trezor only signs native XRP amounts");if(typeof J!=="string")throw o("Missing destination");if(!XM.isValidClassicAddress(J))throw o("Destination must be a classic XRP address");if(typeof B!=="string"||typeof j!=="number")throw o("Transaction is not autofilled");if(Z!==void 0&&typeof Z!=="number")throw o("Flags must be numeric");if(((Z??0)&XM.GlobalFlags.tfInnerBatchTxn)!==0)throw o("Trezor cannot sign Batch inner XRP transactions");return{fee:B,flags:Z,maxLedgerVersion:_,payment:{amount:X,destination:J,destinationTag:Q},sequence:j}}function P$({derivationPath:M}){let $=p.derivationPathToString(M),U="";async function X(){if(U)return U;let B=await(await import("@trezor/connect-web")).default.rippleGetAddress({path:$,showOnTrezor:!0});if(!B.success)throw new p.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:p.Chain.Ripple,derivationPath:M,error:B.payload.error}});return U=B.payload.address,U}async function J(Q){let B=lM(Q);if(Q.Account!==await X())throw o("Transaction account does not match the Trezor address");let _=await(await import("@trezor/connect-web")).default.rippleSignTransaction({path:$,transaction:B});if(!_.success)throw new p.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:p.Chain.Ripple,error:_.payload.error}});let j=_.payload.serializedTx.toUpperCase();return{hash:XM.hashes.hashSignedTx(j),tx_blob:j}}return{getAddress:X,signTransaction:J}}var p,XM,g$;var pM=qM(()=>{p=require("@swapkit/helpers"),XM=require("xrpl"),g$=new Set(["Account","Amount","Destination","DestinationTag","Fee","Flags","LastLedgerSequence","Sequence","SigningPubKey","TransactionType"])});var sM={};a(sM,{getSolanaSigner:()=>c$});function y$(M){return new y.SwapKitError({errorKey:"wallet_trezor_method_not_supported",info:{chain:y.Chain.Solana,reason:M}})}function v$(M){if("version"in M){let{header:$,staticAccountKeys:U}=M.message;return{message:M.message.serialize(),signerKeys:U.slice(0,$.numRequiredSignatures)}}return{message:M.serializeMessage(),signerKeys:M.signatures.map(({publicKey:$})=>$)}}function h$(M,$){let{message:U,signerKeys:X}=v$(M),J=X.find((Q)=>Q.toBase58()===$);if(!J)throw y$("Trezor account is not a required signer of this transaction");return{message:U,signerKey:J}}function x$(M,{message:$,signature:U,signerKey:X}){if(U.length!==64)throw new y.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:y.Chain.Solana,error:`Invalid signature length: ${U.length}`}});if(!dM.ed25519.verify(U,$,X.toBytes()))throw new y.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:y.Chain.Solana,error:"Signature does not match the Trezor account"}});return M.addSignature(X,Buffer.from(U)),M}function c$({address:M,derivationPath:$}){let[U,X]=$;if(U!==44||X!==501||$.length>4)throw new y.SwapKitError({errorKey:"wallet_trezor_derivation_path_not_supported",info:{chain:y.Chain.Solana,derivationPath:$}});let J=y.derivationPathToString($,{allHardened:!0}),Q=M?new VM.PublicKey(M):null,B=null;async function Z(j){if(B)return B.toBase58();let N=await(await import("@trezor/connect-web")).default.solanaGetAddress({path:J,showOnTrezor:j});if(!N.success)throw new y.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:y.Chain.Solana,derivationPath:$,error:N.payload.error}});let G=new VM.PublicKey(N.payload.address);if(Q&&!G.equals(Q))throw new y.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:y.Chain.Solana,derivationPath:$,error:"Trezor account does not match the restored address"}});return B=G,N.payload.address}async function _(j){let{message:W,signerKey:N}=h$(j,await Z(!1)),V=await(await import("@trezor/connect-web")).default.solanaSignTransaction({path:J,serializedTx:HM.hex.encode(W)});if(!V.success)throw new y.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:y.Chain.Solana,error:V.payload.error}});let Y=HM.hex.decode(V.payload.signature.replace(/^0x/,""));return x$(j,{message:W,signature:Y,signerKey:N})}return{connect:async()=>({publicKey:new VM.PublicKey(await Z(!0))}),disconnect:()=>Promise.resolve(),getAddress:()=>Z(!0),get publicKey(){return B??Q},signTransaction:_}}var dM,HM,VM,y;var rM=qM(()=>{dM=require("@noble/curves/ed25519.js"),HM=require("@scure/base"),VM=require("@solana/web3.js"),y=require("@swapkit/helpers")});var aM={};a(aM,{toTrezorStellarTransaction:()=>nM,getStellarSigner:()=>o$});function d(M){return new c.SwapKitError({errorKey:"wallet_trezor_method_not_supported",info:{chain:c.Chain.Stellar,reason:M}})}function EM(M){let $=/^(\d+)(?:\.(\d{1,7}))?$/.exec(M);if(!$)throw d(`Invalid Stellar amount: ${M}`);let[,U="0",X=""]=$;return BigInt(`${U}${X.padEnd(l$,"0")}`).toString()}function oM(M){if(!/^\d+$/.test(M)||BigInt(M)>u$)throw d(`Unsupported Stellar time bound: ${M}`);return Number(M)}function iM(M){let $=p$[M.getAssetType()];if(!$||!("getCode"in M))throw d("Trezor does not support liquidity pool assets");return $==="NATIVE"?{type:$}:{code:M.getCode(),issuer:M.getIssuer(),type:$}}function d$({source:M,...$}){let U=M?{source:M}:{};switch($.type){case"payment":return{...U,amount:EM($.amount),asset:iM($.asset),destination:$.destination,type:"payment"};case"createAccount":return{...U,destination:$.destination,startingBalance:EM($.startingBalance),type:"createAccount"};case"changeTrust":return{...U,limit:EM($.limit),line:iM($.line),type:"changeTrust"};default:throw d(`Unsupported Stellar operation: ${$.type}`)}}function s$(M){if(typeof M==="string")return M;try{return new TextDecoder("utf-8",{fatal:!0,ignoreBOM:!0}).decode(M??void 0)}catch{throw d("Trezor only signs UTF-8 text memos")}}function r$({type:M,value:$}){switch(M){case"none":return;case"text":return{text:s$($),type:zM.text};case"id":return{id:String($),type:zM.id};case"hash":case"return":return{hash:Buffer.from($??"").toString("hex"),type:zM[M]};default:throw d(`Unsupported Stellar memo type: ${M}`)}}function nM(M){if("innerTransaction"in M)throw d("Trezor cannot sign fee bump transactions");if(!M.timeBounds)throw d("Trezor requires transaction time bounds");let{extraSigners:$,ledgerBounds:U,minAccountSequence:X,minAccountSequenceAge:J,minAccountSequenceLedgerGap:Q}=M;if([U,X,J,Q].some((Z)=>Z!==void 0)||$?.length)throw d("Trezor cannot sign Stellar transactions with extra preconditions");return{networkPassphrase:M.networkPassphrase,transaction:{fee:Number(M.fee),memo:r$(M.memo),operations:M.operations.map(d$),sequence:M.sequence,source:M.source,timebounds:{maxTime:oM(M.timeBounds.maxTime),minTime:oM(M.timeBounds.minTime)}}}}function o$({derivationPath:M}){if(M[3]||M[4])throw new c.SwapKitError({errorKey:"wallet_trezor_derivation_path_not_supported",info:{chain:c.Chain.Stellar,derivationPath:M,reason:"Stellar only uses m/44'/148'/x'"}});let $=c.derivationPathToString(M.slice(0,3)),U="";async function X(){if(U)return U;let B=await(await import("@trezor/connect-web")).default.stellarGetAddress({path:$,showOnTrezor:!0});if(!B.success)throw new c.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:c.Chain.Stellar,derivationPath:M,error:B.payload.error}});return U=B.payload.address,U}async function J(Q){let B=nM(Q);if(B.transaction.source!==await X())throw d("Transaction source does not match the Trezor address");let _=await(await import("@trezor/connect-web")).default.stellarSignTransaction({path:$,...B});if(!_.success)throw new c.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:c.Chain.Stellar,error:_.payload.error}});try{Q.addSignature(U,Buffer.from(_.payload.signature,"hex").toString("base64"))}catch(j){throw new c.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:c.Chain.Stellar,error:j}})}return Q}return{getAddress:X,signTransaction:J}}var c,l$=7,u$=4294967295n,p$,zM;var tM=qM(()=>{c=require("@swapkit/helpers"),p$={credit_alphanum4:"ALPHANUM4",credit_alphanum12:"ALPHANUM12",native:"NATIVE"},zM={hash:3,id:2,return:4,text:1}});var q$={};a(q$,{toTrezorTronContract:()=>$$,getTronSigner:()=>$4});function BM(M){return new s.SwapKitError({errorKey:"wallet_trezor_method_not_supported",info:{chain:s.Chain.Tron,reason:M}})}function kM(M,$,U){let X=Object.keys(M).filter((J)=>!$.has(J)&&!e$.includes(M[J]));if(X.length>0)throw BM(`Trezor cannot sign Tron ${U} with ${X.join(", ")}`)}function eM(M,$){let U=M[$];if(typeof U!=="string"||!U)throw BM(`Missing ${$} in Tron contract`);return U}function M4(M){let{amount:$}=M;if(!(typeof $==="number"&&Number.isSafeInteger($)&&$>0||typeof $==="string"&&/^[1-9]\d*$/.test($)))throw BM("Invalid amount in Tron contract");return String($)}function $$(M){let[$,...U]=M.raw_data.contract;if(!$||U.length>0)throw BM("Trezor signs Tron transactions with exactly one contract");let X=$.parameter.value,J=t$[$.type];if(!J)throw BM(`Unsupported Tron contract type: ${$.type}`);kM(M.raw_data,n$,"transactions"),kM($,a$,"contracts"),kM(X,J,$.type);let Q=(Z)=>{let _=eM(X,Z);if(M.visible!==!1)return M$.tronAddressToHex(_);if(i$.test(_))return _.toLowerCase();throw BM(`Invalid hex ${Z} in Tron contract`)},B=Q("owner_address");if($.type==="TransferContract")return{parameter:{value:{amount:M4(X),owner_address:B,to_address:Q("to_address")}},type:"TransferContract"};return{parameter:{value:{contract_address:Q("contract_address"),data:eM(X,"data"),owner_address:B}},type:"TriggerSmartContract"}}function $4({address:M,derivationPath:$}){let U=s.derivationPathToString($),X=M??"";return{getAddress:async()=>{if(X)return X;let Q=await(await import("@trezor/connect-web")).default.tronGetAddress({path:U,showOnTrezor:!0});if(!Q.success)throw new s.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:s.Chain.Tron,derivationPath:$,error:Q.payload.error}});return X=Q.payload.address,X},signTransaction:async(J)=>{let Q=$$(J),B=(await import("@trezor/connect-web")).default,{data:Z,expiration:_,fee_limit:j,ref_block_bytes:W,ref_block_hash:N,timestamp:G}=J.raw_data,V=await B.tronSignTransaction({contract:[Q],data:Z,expiration:_,fee_limit:j,path:U,ref_block_bytes:W,ref_block_hash:N,timestamp:G});if(!V.success)throw new s.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:s.Chain.Tron,error:V.payload.error}});return{...J,signature:[V.payload.signature.replace(/^0x/,"")]}}}}var s,M$,i$,n$,a$,t$,e$;var U$=qM(()=>{s=require("@swapkit/helpers"),M$=require("@swapkit/toolboxes/tron"),i$=/^41[0-9a-f]{40}$/i,n$=new Set(["contract","data","expiration","fee_limit","ref_block_bytes","ref_block_hash","timestamp"]),a$=new Set(["parameter","type"]),t$={TransferContract:new Set(["amount","owner_address","to_address"]),TriggerSmartContract:new Set(["contract_address","data","owner_address"])},e$=[void 0,null,0,"",!1]});var H4={};a(H4,{trezorWallet:()=>G$,normalizeTrezorSignature:()=>W$,normalizeTrezorExtendedPublicKey:()=>fM,getTrezorExtendedPublicKey:()=>L$,TREZOR_SUPPORTED_CHAINS:()=>A4});module.exports=S$(H4);var MM=require("@scure/base"),LM=require("@scure/bip32"),q=require("@swapkit/helpers"),k=require("@swapkit/toolboxes/utxo"),GM=require("@swapkit/wallet-core");async function bM({chain:M,indexes:$,publicKey:U,tx:X}){let{getMissingSpendingMetadata:J,getNetworkForChain:Q}=await import("@swapkit/toolboxes/utxo");for(let{index:B,...Z}of J({chain:M,indexes:$,network:Q(M),publicKey:U,tx:X}))X.updateInput(B,Z)}var q4=new Set(["auto","iframe","popup","suite-desktop","suite-web"]),U4=new Set(["BridgeTransport","WebUsbTransport","NodeUsbTransport"]),Q$="auto",NM={appName:"SwapKit",appUrl:"https://swapkit.dev",email:"support@swapkit.dev"},Z$=["WebUsbTransport"],jM={keepSession:!0},X4=65,YM=new Map,$M,B4=[q.Chain.Bitcoin,q.Chain.BitcoinCash,q.Chain.Dash,q.Chain.Dogecoin,q.Chain.Litecoin].map((M)=>k.getNetworkForChain(M).bip32);async function J4(){YM.clear();let M=(async()=>{try{await(await import("@trezor/connect-web")).default.dispose()}catch{}})();if($M=M,await M,$M===M)$M=void 0}function _$(M){return typeof M==="string"&&q4.has(M)?M:void 0}function j$(M){if(!Array.isArray(M))return;let $=M.filter((U)=>typeof U==="string"&&U4.has(U));return $.length>0?$:void 0}function QM(M,$){return typeof M==="string"&&M.trim()?M:$}function N$(){return typeof globalThis.location<"u"&&globalThis.location.origin?globalThis.location.origin:NM.appUrl}async function Q4(){let M=(await import("@trezor/connect-web")).default,$=q.SKConfig.get("integrations").trezor,{connectSrc:U,coreMode:X,debug:J,interactionTimeout:Q,lazyLoad:B,pendingTransportEvent:Z,popup:_,transportReconnect:j,transports:W,...N}=$??{},G={...N,appName:QM($?.appName,NM.appName),appUrl:QM($?.appUrl,N$()),email:QM($?.email,NM.email)},V=typeof globalThis.location<"u"&&["localhost","127.0.0.1"].includes(globalThis.location.hostname),Y=_$(X)??Q$,O=j$(W)??Z$;if($M)await $M;if(V)await M.dispose();return await M.init({connectSrc:U,coreMode:Y,debug:J,interactionTimeout:Q,lazyLoad:B??!1,manifest:G,pendingTransportEvent:Z,popup:_??!0,transportReconnect:j,transports:O}),{coreMode:Y,isLocalhost:V,popup:_??!0,TrezorConnect:M}}function fM(M,$){let U=k.getNetworkForChain($).bip32,X=[U,...B4.filter((Q)=>Q.public!==U.public||Q.private!==U.private)],J;for(let Q of X)try{let B=LM.HDKey.fromExtendedKey(M,Q);if(!(B.publicKey&&B.chainCode))throw Error("Extended key is missing public key data");return new LM.HDKey({chainCode:B.chainCode,depth:B.depth,index:B.index,parentFingerprint:B.parentFingerprint,publicKey:B.publicKey,versions:U}).publicExtendedKey}catch(B){J=B}throw J instanceof Error?J:Error("Unable to parse Trezor extended public key")}function Y$(M,$){if(!M)return;try{return fM(M,$)}catch{return M}}async function V$(M){let{Script:$}=await import("@swapkit/utxo-signer");try{let[U,X]=$.decode(M),J=X===0?new Uint8Array:X;if(U!=="RETURN"||!(J instanceof Uint8Array))return null;return MM.hex.encode($.encode(["RETURN",J]))===MM.hex.encode(M)?MM.hex.encode(J):null}catch{return null}}async function mM(M,$,U){if($!==0n)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:U,error:"OP_RETURN output carrying value cannot be signed"}});let X=await V$(M);if(X===null)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:U,error:"Malformed OP_RETURN output cannot be signed"}});return{amount:"0",op_return_data:X,script_type:"PAYTOOPRETURN"}}async function X$(M,$,U){if(!$)return;let X=MM.hex.encode(new TextEncoder().encode($));for(let J=0;J<M.outputsLength;J++){let Q=M.getOutput(J).script;if(Q?.[0]===106&&await V$(Q)===X)return}throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:U,error:"Transaction does not carry the provided memo"}})}function Z4(M,$){switch($[0]){case 86:return M===q.Chain.Bitcoin?{input:"SPENDTAPROOT",output:"PAYTOTAPROOT",utxo:q.UTXOScriptType.P2TR}:null;case 84:return{input:"SPENDWITNESS",output:"PAYTOWITNESS",utxo:q.UTXOScriptType.P2WPKH};case 49:return{input:"SPENDP2SHWITNESS",output:"PAYTOP2SHWITNESS",utxo:q.UTXOScriptType.P2SH_P2WPKH};case 44:return{input:"SPENDADDRESS",output:"PAYTOADDRESS",utxo:q.UTXOScriptType.P2PKH};default:return null}}function JM(M){return M.map(($,U)=>U<3?($|2147483648)>>>0:$)}function _4(M){return Array.isArray(M)&&M[0]instanceof Uint8Array&&typeof M[1]==="object"&&M[1]!==null&&typeof M[1].fingerprint==="number"&&Array.isArray(M[1].path)}function j4(M){if(!Array.isArray(M.bip32Derivation))return;let[$]=M.bip32Derivation;return _4($)?$:void 0}function N4(M){if(!(Array.isArray(M)&&M[0]instanceof Uint8Array))return!1;let $=M[1];return Array.isArray($?.hashes)&&Array.isArray($?.der?.path)}function Y4(M,$){let U=Array.isArray(M.tapBip32Derivation)?M.tapBip32Derivation:[];if(U.length===0)return;let{tapInternalKey:X}=M,J=U.filter((Z)=>N4(Z)&&Z[1].hashes.length===0&&(!X||MM.hex.encode(Z[0])===MM.hex.encode(X))),[Q,B]=J[0]??[];if(J.length!==1||!(Q&&B))throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:q.Chain.Bitcoin,error:`Input ${$} has no single taproot key-path origin to sign with`}});return{path:B.der.path,xOnlyKey:Q}}function B$(M){if(M.witnessUtxo?.amount!==void 0)return M.witnessUtxo.amount.toString();let $=M.index!==void 0?M.nonWitnessUtxo?.outputs?.[M.index]:void 0;if($?.amount!==void 0)return $.amount.toString();return}function W$(M,$){let U=Buffer.from(M,"hex"),X=U[1]!==void 0?U[1]+2:void 0;if(X!==void 0&&U.length===X)return new Uint8Array([...U,$===q.Chain.BitcoinCash?X4:1]);return new Uint8Array(U)}function V4(M,$,U){let X=[];for(let J=0;J<M.inputsLength;J++){let Q=M.getInput(J);X.push({address_n:$,amount:Q.value.toString(),prev_hash:U.encode(Q.txid),prev_index:Q.index,script_type:"SPENDADDRESS"})}return X}async function W4(M,$,U,X){let J=[];for(let Q=0;Q<M.outputsLength;Q++){let B=M.getOutput(Q),Z=B.scriptPubkey;if(Z?.[0]===106){J.push(await mM(Z,B.value,X));continue}let _=await L4(Z);if(!_&&B.value>0n)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:X,error:"Unable to decode output address from scriptPubkey"}});if(_===U)J.push({address_n:$,amount:B.value.toString(),script_type:"PAYTOADDRESS"});else J.push({address:_,amount:B.value.toString(),script_type:"PAYTOADDRESS"})}return J}async function L4(M){try{let{OutScript:$,Address:U,NETWORKS:X}=await import("@swapkit/utxo-signer"),J=$.decode(M);if(J.type==="pkh"||J.type==="pk")return U(X.zcash).encode(J)}catch{}return}async function G4(M,$){let{ZcashTransaction:U,Script:X}=await import("@swapkit/utxo-signer"),J=U.fromHex(M,{allowUnknownOutputs:!0}),Q=$.clone();for(let B=0;B<J.inputsLength;B++){let _=J.getInput(B).script;if(_&&_.length>0){let j=X.decode(_);if(j.length>=2)Q.addSignature(B,j[1],j[0])}}return Q}function f4(M,$,U,X){let J=[];for(let Q=0;Q<M.inputsLength;Q++){let B=M.getInput(Q),Z=$[Q];J.push({address_n:U,amount:Z?.value?.toString()||B.value?.toString()||"0",prev_hash:B.txid?X.encode(B.txid):"",prev_index:B.index??0,script_type:"SPENDADDRESS"})}return J}async function O4({addressN:M,chain:$,myAddress:U,network:X,tx:J}){let Q=[];for(let B=0;B<J.outputsLength;B++){let Z=J.getOutput(B),_=J.getOutputAddress(B,X),j=Z.script;if(j?.[0]===106){Q.push(await mM(j,Z.amount,$));continue}if(!_&&(Z.amount??0n)>0n)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,error:"Unable to decode output address"}});let N=_===U||!_?{address_n:M}:{address:_};Q.push({...N,amount:Z.amount?.toString()||"0",script_type:"PAYTOADDRESS"})}return Q}async function WM(M,$,U,X,J,Q,B,Z){let _=[];for(let j=0;j<M.outputsLength;j++){let W=M.getOutput(j),N=M.getOutputAddress(j,$);if(W.script?.[0]===106){_.push(await mM(W.script,W.amount,J));continue}if(!N)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:J,error:"Unable to decode output address from scriptPubkey"}});if(W.amount===void 0)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:J,error:"Output amount is missing"}});let G=J===q.Chain.BitcoinCash,V=G?B(N):N,Y=G?Z(V)===Z(X):V===X;_.push(Y?{address_n:U,amount:W.amount.toString(),script_type:Q.output}:{address:V,amount:W.amount.toString(),script_type:"PAYTOADDRESS"})}return _}function SM(M){return M===q.Chain.Bitcoin||M===q.Chain.Litecoin}function R4(M){return M===q.Chain.BitcoinCash||M===q.Chain.Dash||M===q.Chain.Dogecoin}function J$(M,$){if(M!==q.Chain.Dash)return;let U=new Map;for(let X of $){if(!X.txHex)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:M,error:`Missing previous transaction hex for ${X.hash}:${X.index}`}});U.set(X.hash,{details:{},hex:X.txHex,txid:X.hash})}return[...U.values()]}async function D4({address:M,chain:$,derivationPath:U}){switch($){case q.Chain.Arbitrum:case q.Chain.Arc:case q.Chain.Aurora:case q.Chain.Avalanche:case q.Chain.Base:case q.Chain.Berachain:case q.Chain.BinanceSmartChain:case q.Chain.Ethereum:case q.Chain.Gnosis:case q.Chain.Hyperevm:case q.Chain.Monad:case q.Chain.Optimism:case q.Chain.Polygon:case q.Chain.Robinhood:case q.Chain.XLayer:{let{getProvider:X,getEvmToolboxAsync:J}=await import("@swapkit/toolboxes/evm"),{getEVMSigner:Q}=await Promise.resolve().then(() => (PM(),gM)),B=await X($),Z=await Q({chain:$,derivationPath:U,provider:B}),_=await Z.getAddress();return{...await J($,{provider:B,signer:Z}),address:_}}case q.Chain.Cardano:{let{getCardanoToolbox:X}=await import("@swapkit/toolboxes/cardano"),{getCardanoSigner:J}=await Promise.resolve().then(() => (cM(),xM)),Q=await import("@trezor/connect-web"),B=await J({connect:Q,derivationPath:U}),Z=B.getAddress();return{...X({signer:B}),address:Z}}case q.Chain.Ripple:{let{getRippleToolbox:X}=await import("@swapkit/toolboxes/ripple"),{getRippleSigner:J}=await Promise.resolve().then(() => (pM(),uM)),Q=J({derivationPath:U}),B=M??await Q.getAddress();return{...X({signer:Q}),address:B}}case q.Chain.Solana:{let{getSolanaToolbox:X}=await import("@swapkit/toolboxes/solana"),{getSolanaSigner:J}=await Promise.resolve().then(() => (rM(),sM)),Q=J({address:M,derivationPath:U}),B=M??await Q.getAddress();return{...X({signer:Q}),address:B}}case q.Chain.Stellar:{let{getStellarToolbox:X}=await import("@swapkit/toolboxes/stellar"),{getStellarSigner:J}=await Promise.resolve().then(() => (tM(),aM)),Q=J({derivationPath:U}),B=M??await Q.getAddress();return{...X({signer:Q}),address:B}}case q.Chain.Tron:{let{getTronToolbox:X}=await import("@swapkit/toolboxes/tron"),{getTronSigner:J}=await Promise.resolve().then(() => (U$(),q$)),Q=J({address:M,derivationPath:U}),B=await Q.getAddress();return{...X({signer:Q}),address:B}}case q.Chain.Zcash:{let{getUtxoToolbox:X}=await import("@swapkit/toolboxes/utxo"),J=q.derivationPathToString(U),B=M??await(async()=>{let Y=(await import("@trezor/connect-web")).default,{success:O,payload:F}=await Y.getAddress({coin:"zcash",path:J});if(!O)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:$,error:F.error||"Unknown error"}});return F.address})(),Z=async(Y)=>{let O=(await import("@trezor/connect-web")).default,{hex:F}=await import("@scure/base"),b=JM(U),w=Y.getGlobal(),x=V4(Y,b,F),P=await W4(Y,b,B,$),v=await O.signTransaction({branchId:w.consensusBranchId,coin:"zcash",expiry:w.expiryHeight,inputs:x,locktime:w.lockTime,outputs:P,overwintered:!0,version:w.txVersion,versionGroupId:w.versionGroupId});if(!v.success)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,error:v.payload.error}});return{serializedTx:v.payload.serializedTx,signedPczt:await G4(v.payload.serializedTx,Y)}},_=async(Y)=>{let{ZcashTransaction:O}=await import("@swapkit/utxo-signer");return O.fromHex(Y,{allowUnknownOutputs:!0})},j=async(Y)=>{let O=(await import("@trezor/connect-web")).default,{hex:F}=await import("@scure/base"),{NETWORKS:b,ZcashVersionGroupId:w}=await import("@swapkit/utxo-signer"),x=JM(U),P=f4(Y,[],x,F),v=await O4({addressN:x,chain:$,myAddress:B,network:b.zcash,tx:Y}),i=await O.signTransaction({branchId:Y.consensusBranchId,coin:"zcash",expiry:0,inputs:P,locktime:0,outputs:v,overwintered:!0,version:4,versionGroupId:w.SAPLING});if(i.success)return{serializedTx:i.payload.serializedTx,signedTx:await _(i.payload.serializedTx)};throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,error:i.payload.error}})},W={getAddress:async()=>B,signPCZT:async(Y)=>{return(await Z(Y)).signedPczt},signTransaction:async(Y)=>{if("toPCZT"in Y){let{serializedTx:O}=await Z(Y.toPCZT());return _(O)}if("getGlobal"in Y){let{serializedTx:O}=await Z(Y);return _(O)}return(await j(Y)).signedTx}},N=X(q.Chain.Zcash,{signer:W}),G=async(Y)=>{if("toPCZT"in Y){let{serializedTx:F}=await Z(Y.toPCZT());return N.broadcastTx(F)}if("getGlobal"in Y){let{serializedTx:F}=await Z(Y);return N.broadcastTx(F)}let{serializedTx:O}=await j(Y);return N.broadcastTx(O)},V=async({recipient:Y,feeOptionKey:O,feeRate:F,...b})=>{if(!(B&&Y))throw new q.SwapKitError({errorKey:"wallet_missing_params",info:{address:B,recipient:Y,wallet:q.WalletOption.TREZOR}});let w=F||(await N.getFeeRates())[O||q.FeeOption.Fast],{tx:x}=await N.createTransaction({...b,feeRate:w,fetchTxHex:!1,recipient:Y,sender:B}),{serializedTx:P}=await j(x);return N.broadcastTx(P)};return{...N,address:B,signAndBroadcastTransaction:G,signPCZT:W.signPCZT,transfer:V}}case q.Chain.Bitcoin:case q.Chain.BitcoinCash:case q.Chain.Dash:case q.Chain.Dogecoin:case q.Chain.Litecoin:{let f$=function(L={}){return DM(L)},{toCashAddress:X,getUtxoToolbox:J,stripPrefix:Q}=await import("@swapkit/toolboxes/utxo"),B=$,Z=Z4($,U);if(!Z)throw new q.SwapKitError({errorKey:"wallet_trezor_derivation_path_not_supported",info:{derivationPath:U}});let _=Z,j=Z.utxo===q.UTXOScriptType.P2TR,W={scriptType:Z.utxo},N=$.toLowerCase(),V=M??await(async(L=U)=>{let S=(await import("@trezor/connect-web")).default,z=q.derivationPathToString(L),{success:D,payload:E}=await S.getAddress({coin:N,...jM,path:z,showOnTrezor:!1});if(!D)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_get_address",info:{chain:$,error:E.error||"Unknown error"}});if($===q.Chain.BitcoinCash)return Q(E.address);return E.address})(),Y=J($,W),O=async(L,S,z="")=>{await X$(L,z,$);let D=(await import("@trezor/connect-web")).default,E=JM(U),A=k.getNetworkForChain($),C=await WM(L,A,E,V,$,_,X,Q),I=S.map(({hash:T,index:K,value:f})=>({address_n:E,amount:f,prev_hash:T,prev_index:K,script_type:_.input})),R=await D.signTransaction({coin:N,inputs:I,outputs:C,refTxs:J$($,S)});if(R.success)return R.payload.serializedTx;let m=R.payload;throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,code:m?.code??"unknown",error:m?.error??"unknown",payload:m}})},F=async(L)=>{let S=(await import("@trezor/connect-web")).default,{hex:z}=await import("@scure/base"),D=JM(U),E=k.getNetworkForChain($),A;async function C(){if(!A){let f=await DM(),h=LM.HDKey.fromExtendedKey(f.xpub,E.bip32).derive(`m/${Number(U[3]??0)}/${Number(U[4]??0)}`);if(!h.publicKey)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_get_public_key",info:{chain:$,error:"Unable to derive Trezor leaf public key from account xpub"}});A=h.publicKey}return[A,{fingerprint:0,path:D}]}let I=[],R=[];async function m(f,H){if(j){let ZM=Y4(H,f);if(!ZM){let[D$,{path:wM}]=await C();ZM={path:wM,xOnlyKey:D$.slice(1)},L.updateInput(f,{tapBip32Derivation:[[ZM.xOnlyKey,{der:{fingerprint:0,path:wM},hashes:[]}]]})}if(!H.tapInternalKey)L.updateInput(f,{tapInternalKey:ZM.xOnlyKey});return ZM.path}let h=j4(H),n=h??await C();if(I[f]=n[0],!h)L.updateInput(f,{bip32Derivation:[n]});return await bM({chain:B,indexes:[f],publicKey:n[0],tx:L}),n[1].path}for(let f=0;f<L.inputsLength;f++){let H=L.getInput(f),h=B$(H);if(!H.txid||H.index===void 0||!h)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,error:`Input ${f} is missing prevout data required by Trezor`}});let n=await m(f,H);R.push({address_n:n,amount:h,prev_hash:z.encode(H.txid),prev_index:H.index,script_type:_.input,...H.sequence!==void 0?{sequence:H.sequence}:{}})}let T=await WM(L,E,D,V,$,_,X,Q),K=await S.signTransaction({coin:N,...jM,inputs:R,locktime:L.lockTime,outputs:T,version:L.version});if(!K.success){let f=K.payload;throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,code:f?.code??"unknown",error:f?.error??"unknown",payload:f}})}return K.payload.signatures.forEach((f,H)=>{if(!f)return;if(j){L.updateInput(H,{tapKeySig:z.decode(f)});return}let h=I[H];if(!h)return;L.updateInput(H,{partialSig:[[h,W$(f,$)]]})}),L},b=async(L)=>{let S=(await import("@trezor/connect-web")).default,{hex:z}=await import("@scure/base"),D=JM(U),E=k.getNetworkForChain($),A=[];for(let m=0;m<L.inputsLength;m++){let T=L.getInput(m),K=B$(T);if(!T.txid||T.index===void 0||!K)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,error:`Input ${m} is missing prevout data required by Trezor`}});A.push({address_n:D,amount:K,prev_hash:z.encode(T.txid),prev_index:T.index,script_type:_.input,...T.sequence!==void 0?{sequence:T.sequence}:{}})}let C=await WM(L,E,D,V,$,_,X,Q),I=await S.signTransaction({coin:N,inputs:A,locktime:L.lockTime,outputs:C,version:L.version});if(I.success)return I.payload.serializedTx;let R=I.payload;throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,code:R?.code??"unknown",error:R?.error??"unknown",payload:R}})},w=async(L,S,z="")=>{await X$(L,z,$);let D=(await import("@trezor/connect-web")).default,E=k.getNetworkForChain($),A=JM(U.slice(0,3)),C=await WM(L,E,A,V,$,_,X,Q),I=S.map(({hash:m,index:T,value:K,derivationIndex:f,isChange:H})=>{let h=H?1:0;return{address_n:[...A,h,f],amount:K,prev_hash:m,prev_index:T,script_type:_.input}}),R=await D.signTransaction({coin:N,inputs:I,outputs:C,refTxs:J$($,S)});if(R.success)return R.payload.serializedTx;throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:$,error:R.payload.error}})},x=async({utxos:L,recipient:S,assetValue:z,memo:D,feeRate:E,feeOptionKey:A})=>{let C=J($,W),I=E||(await C.getFeeRates())[A||q.FeeOption.Fast],{tx:R,inputs:m}=await C.createTransaction({assetValue:z,feeRate:I,fetchTxHex:$===q.Chain.Dash,memo:D,recipient:S,sender:V}),T=m.map((f)=>{let H=L.find((h)=>h.hash===f.hash&&h.index===f.index);return{...f,derivationIndex:H?.derivationIndex??0,isChange:H?.isChange??!1,txHex:H?.txHex}}),K=await w(R,T,D);return C.broadcastTx(K)},P=async({recipient:L,feeOptionKey:S,feeRate:z,memo:D,...E})=>{if(!(V&&L))throw new q.SwapKitError({errorKey:"wallet_missing_params",info:{address:V,memo:D,recipient:L,wallet:q.WalletOption.TREZOR}});let A=J($,W),C=z||(await A.getFeeRates())[S||q.FeeOption.Fast],I=A.createTransaction,{tx:R,inputs:m}=await I({...E,feeRate:C,fetchTxHex:$===q.Chain.Dash,memo:D,recipient:L,sender:V}),T=await O(R,m,D);return await A.broadcastTx(T)},v=SM($)?await J(B,{...W,signer:{getAddress:async()=>V,signTransaction:F}}):Y,i=R4($)?async(L)=>Y.broadcastTx(await b(L)):v.signAndBroadcastTransaction,OM=SM($)?v.signTransaction:O,RM=SM($)?v.transfer:P;async function DM({accountIndex:L}={}){let S=(await import("@trezor/connect-web")).default,z=k.getUTXOAccountPath({accountIndex:L,chain:B,derivationPath:U}),D=q.derivationPathToString(z),E=`${$}:${D}`,A=YM.get(E);if(A)return A;let C=await S.getPublicKey({coin:N,path:D}),{success:I,payload:R}=C;if(!I)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_get_public_key",info:{chain:$,error:R.error||"Unknown error"}});let m=fM(R.xpub,B),T=Y$(R.xpubSegwit,B),K={accountIndex:k.getUTXOAccountIndexFromPath(z),chainCode:R.chainCode,depth:R.depth,fingerprint:R.fingerprint,path:R.serializedPath,publicKey:R.publicKey,xpub:m,xpubSegwit:T};return YM.set(E,K),K}async function FM({accountIndex:L,index:S,change:z=!1}){k.assertDerivationIndex("index",S);let D=(await import("@trezor/connect-web")).default,E=k.getUTXOAccountPath({accountIndex:L,chain:B,derivationPath:U}),A=`${q.derivationPathToString(E)}/${Number(z)}/${S}`,{success:C,payload:I}=await D.getAddress({coin:N,...jM,path:A,showOnTrezor:!1});if(!C)return;let R=I.address;if($===q.Chain.BitcoinCash)R=(await J($)).stripPrefix(I.address);let m=await D.getPublicKey({coin:N,...jM,path:A,scriptType:_.input,showOnTrezor:!1}),T=m.success?m.payload.publicKey:"";return{accountIndex:k.getUTXOAccountIndexFromPath(E),address:R,change:z,index:S,path:A,pubkey:T}}async function O$({accountIndex:L,count:S,startIndex:z=0,change:D=!1}){k.assertDerivationIndex("count",S),k.assertDerivationIndex("startIndex",z);let E=(await import("@trezor/connect-web")).default,A=k.getUTXOAccountPath({accountIndex:L,chain:B,derivationPath:U}),C=q.derivationPathToString(A),I=Array.from({length:S},(K,f)=>({coin:N,path:`${C}/${Number(D)}/${z+f}`,showOnTrezor:!1})),{success:R,payload:m}=await E.getAddress({...jM,bundle:I});if(!R||!Array.isArray(m))return[];return await Promise.all(m.map(async(K,f)=>{let H=K.address;if($===q.Chain.BitcoinCash)H=(await J($)).stripPrefix(K.address);return{accountIndex:k.getUTXOAccountIndexFromPath(A),address:H,change:D,index:z+f,path:`${C}/${Number(D)}/${z+f}`,pubkey:""}}))}let R$=k.createHDWalletHelpers({chain:$,deriveAddress:FM,getBalance:v.getBalance,getUtxos:(L)=>k.getUtxoApi($).getUtxos({address:L,fetchTxHex:!0})});return{...v,...R$,address:V,deriveAddressAtIndex:FM,deriveAddresses:O$,getExtendedPublicKey:f$,getExtendedPublicKeyInfo:DM,signAndBroadcastTransaction:i,signTransaction:OM,signTransactionWithMultipleInputs:w,transfer:RM,transferFromMultipleAddresses:x}}default:throw new q.SwapKitError({errorKey:"wallet_chain_not_supported",info:{chain:$,wallet:q.WalletOption.TREZOR}})}}async function L$(M,$,{accountIndex:U}={}){if(![q.Chain.BitcoinCash,q.Chain.Bitcoin,q.Chain.Dash,q.Chain.Dogecoin,q.Chain.Litecoin,q.Chain.Zcash].includes(M))throw new q.SwapKitError({errorKey:"wallet_chain_not_supported",info:{chain:M,wallet:q.WalletOption.TREZOR}});let{TrezorConnect:X}=await Q4(),J=M,Q=$??q.NetworkDerivationPath[M],B=M===q.Chain.Zcash?"zcash":M.toLowerCase(),Z=k.getUTXOAccountPath({accountIndex:U,chain:J,derivationPath:Q}),_=q.derivationPathToString(Z),j=`${M}:${_}`,W=YM.get(j);if(W)return W;let{success:N,payload:G}=await X.getPublicKey({coin:B,path:_,showOnTrezor:!0});if(!N)throw new q.SwapKitError({errorKey:"wallet_trezor_failed_to_get_public_key",info:{chain:M,error:G.error||"Unknown error"}});let V={accountIndex:k.getUTXOAccountIndexFromPath(Z),chainCode:G.chainCode,depth:G.depth,fingerprint:G.fingerprint,path:G.serializedPath,publicKey:G.publicKey,xpub:fM(G.xpub,J),xpubSegwit:Y$(G.xpubSegwit,J)};return YM.set(j,V),V}var G$=GM.createWallet({connect:({addChain:M,supportedChains:$,walletType:U})=>async function(J,Q,{address:B}={}){let[Z]=q.filterSupportedChains({chains:J,supportedChains:$,walletType:U});if(!Z)throw new q.SwapKitError({errorKey:"wallet_chain_not_supported",info:{chain:Z,wallet:q.WalletOption.TREZOR}});let _=(await import("@trezor/connect-web")).default,j=q.SKConfig.get("integrations").trezor,{connectSrc:W,coreMode:N,debug:G,interactionTimeout:V,lazyLoad:Y,pendingTransportEvent:O,popup:F,transportReconnect:b,transports:w,...x}=j??{},P={...x,appName:QM(j?.appName,NM.appName),appUrl:QM(j?.appUrl,N$()),email:QM(j?.email,NM.email)},v=typeof globalThis.location<"u"&&["localhost","127.0.0.1"].includes(globalThis.location.hostname),i=_$(N)??Q$,OM=j$(w)??Z$;if($M)await $M;if(v)await _.dispose();await _.init({connectSrc:W,coreMode:i,debug:G,interactionTimeout:V,lazyLoad:Y??!1,manifest:P,pendingTransportEvent:O,popup:F??!0,transportReconnect:b,transports:OM});let RM=await D4({address:B,chain:Z,derivationPath:Q});return M({...RM,chain:Z,disconnect:J4,walletType:U}),!0},directSigningSupport:{[q.Chain.Arbitrum]:!0,[q.Chain.Arc]:!0,[q.Chain.Aurora]:!0,[q.Chain.Avalanche]:!0,[q.Chain.Base]:!0,[q.Chain.Berachain]:!0,[q.Chain.BinanceSmartChain]:!0,[q.Chain.Bitcoin]:!0,[q.Chain.BitcoinCash]:!0,[q.Chain.Cardano]:!0,[q.Chain.Dash]:!0,[q.Chain.Ethereum]:!0,[q.Chain.Gnosis]:!0,[q.Chain.Dogecoin]:!0,[q.Chain.Hyperevm]:!0,[q.Chain.Litecoin]:!0,[q.Chain.Monad]:!0,[q.Chain.Optimism]:!0,[q.Chain.Polygon]:!0,[q.Chain.Ripple]:!0,[q.Chain.Robinhood]:!0,[q.Chain.Solana]:!0,[q.Chain.Stellar]:!0,[q.Chain.Tron]:!0,[q.Chain.XLayer]:!0,[q.Chain.Zcash]:!0},getExtendedPublicKey:L$,name:"connectTrezor",supportedChains:[q.Chain.Arbitrum,q.Chain.Arc,q.Chain.Aurora,q.Chain.Avalanche,q.Chain.Base,q.Chain.Berachain,q.Chain.BinanceSmartChain,q.Chain.Bitcoin,q.Chain.BitcoinCash,q.Chain.Cardano,q.Chain.Dash,q.Chain.Dogecoin,q.Chain.Ethereum,q.Chain.Gnosis,q.Chain.Hyperevm,q.Chain.Litecoin,q.Chain.Monad,q.Chain.Optimism,q.Chain.Polygon,q.Chain.Ripple,q.Chain.Robinhood,q.Chain.Solana,q.Chain.Stellar,q.Chain.Tron,q.Chain.XLayer,q.Chain.Zcash],walletType:q.WalletOption.TREZOR}),A4=GM.getWalletSupportedChains(G$);
 
-//# debugId=A6CC78AD0B00B22F64756E2164756E21
+//# debugId=CBDA9F4428A5BBCD64756E2164756E21
 //# sourceMappingURL=index.cjs.map