npm - @ledgerhq/context-module - Versions diffs - 2.0.0 → 2.2.0 - Mend

@ledgerhq/context-module 2.0.0 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (468) hide show

package/lib/esm/src/modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader.ts"],
-  "sourcesContent": ["import {\n  DeviceModelId,\n  type HexaString,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { type GatedDescriptorDataSource } from \"@/modules/ethereum/gated-signing/data/GatedDescriptorDataSource\";\nimport { gatedSigningTypes } from \"@/modules/ethereum/gated-signing/di/gatedSigningTypes\";\nimport type { TypedDataSchema } from \"@/modules/ethereum/model/TypedDataContext\";\nimport type { ProxyDataSource } from \"@/modules/ethereum/proxy/data/ProxyDataSource\";\nimport { proxyTypes } from \"@/modules/ethereum/proxy/di/proxyTypes\";\nimport { getSchemaHash } from \"@/modules/ethereum/typed-data/utils/getSchemaHash\";\nimport { pkiTypes } from \"@/modules/multichain/pki/di/pkiTypes\";\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { KeyId } from \"@/modules/multichain/pki/model/KeyId\";\nimport { KeyUsage } from \"@/modules/multichain/pki/model/KeyUsage\";\nimport { ContextLoader } from \"@/shared/domain/ContextLoader\";\nimport {\n  ClearSignContext,\n  ClearSignContextType,\n} from \"@/shared/model/ClearSignContext\";\n\nconst ZERO_ADDRESS = \"0x0000000000000000000000000000000000000000\";\n\nexport type GatedSigningTypedDataContextInput = {\n  data: {\n    types: TypedDataSchema;\n    domain?: { verifyingContract?: string };\n  };\n  chainId: number;\n  deviceModelId: DeviceModelId;\n  challenge: string;\n};\n\nconst SUPPORTED_TYPES: ClearSignContextType[] = [\n  ClearSignContextType.ETHEREUM_GATED_SIGNING,\n];\n\nfunction hasTypedDataShape(\n  data: unknown,\n): data is { types: TypedDataSchema; domain?: { verifyingContract?: string } } {\n  if (!data || typeof data !== \"object\") return false;\n  const obj = data as Record<string, unknown>;\n  if (\n    !obj[\"types\"] ||\n    typeof obj[\"types\"] !== \"object\" ||\n    Array.isArray(obj[\"types\"])\n  ) {\n    return false;\n  }\n  const types = obj[\"types\"] as Record<string, unknown>;\n  for (const key of Object.keys(types)) {\n    if (typeof key !== \"string\") return false;\n    const value = types[key];\n    if (!Array.isArray(value)) return false;\n    for (const item of value) {\n      if (\n        !item ||\n        typeof item !== \"object\" ||\n        typeof (item as { name?: unknown }).name !== \"string\" ||\n        typeof (item as { type?: unknown }).type !== \"string\"\n      ) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\n@injectable()\nexport class GatedSigningTypedDataContextLoader\n  implements ContextLoader<GatedSigningTypedDataContextInput>\n{\n  constructor(\n    @inject(gatedSigningTypes.GatedDescriptorDataSource)\n    private readonly _dataSource: GatedDescriptorDataSource,\n    @inject(pkiTypes.PkiCertificateLoader)\n    private readonly _certificateLoader: PkiCertificateLoader,\n    @inject(proxyTypes.ProxyDataSource)\n    private readonly _proxyDataSource: ProxyDataSource,\n  ) {}\n\n  canHandle(\n    input: unknown,\n    expectedTypes: ClearSignContextType[],\n  ): input is GatedSigningTypedDataContextInput {\n    return (\n      SUPPORTED_TYPES.every((type) => expectedTypes.includes(type)) &&\n      typeof input === \"object\" &&\n      input !== null &&\n      \"data\" in input &&\n      hasTypedDataShape((input as GatedSigningTypedDataContextInput).data) &&\n      \"chainId\" in input &&\n      \"deviceModelId\" in input &&\n      (input as GatedSigningTypedDataContextInput).deviceModelId !==\n        undefined &&\n      \"challenge\" in input &&\n      typeof (input as GatedSigningTypedDataContextInput).challenge === \"string\"\n    );\n  }\n\n  async load({\n    data,\n    chainId,\n    deviceModelId,\n    challenge,\n  }: GatedSigningTypedDataContextInput): Promise<ClearSignContext[]> {\n    const raw = data.domain?.verifyingContract?.toLowerCase() ?? ZERO_ADDRESS;\n    const verifyingContract: HexaString = raw.startsWith(\"0x\")\n      ? (raw as HexaString)\n      : (`0x${raw}` as HexaString);\n    const schemaHash = getSchemaHash(data.types);\n\n    const directResult = await this._dataSource.getGatedDescriptorForTypedData({\n      contractAddress: verifyingContract,\n      schemaHash,\n      chainId,\n    });\n\n    if (directResult.isRight()) {\n      const { signedDescriptor } = directResult.unsafeCoerce();\n      const certificate = await this._certificateLoader.loadCertificate({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: deviceModelId,\n      });\n      return [\n        {\n          type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n          payload: signedDescriptor,\n          certificate,\n        },\n      ];\n    }\n\n    const firstError: Error = directResult.caseOf({\n      Left: (error) => error,\n      Right: () => new Error(\"unreachable\"),\n    });\n\n    const proxyResult =\n      await this._proxyDataSource.getProxyImplementationAddress({\n        proxyAddress: verifyingContract,\n        chainId,\n        challenge,\n        calldata: \"0x\",\n      });\n\n    if (proxyResult.isLeft()) {\n      return [\n        {\n          type: ClearSignContextType.ERROR,\n          error: firstError,\n        },\n      ];\n    }\n\n    const proxyData = proxyResult.unsafeCoerce();\n    const implRaw = proxyData.implementationAddress.toLowerCase();\n    const implementationAddress: HexaString = implRaw.startsWith(\"0x\")\n      ? (implRaw as HexaString)\n      : (`0x${implRaw}` as HexaString);\n\n    const implGatedResult =\n      await this._dataSource.getGatedDescriptorForTypedData({\n        contractAddress: implementationAddress,\n        schemaHash,\n        chainId,\n      });\n\n    if (implGatedResult.isLeft()) {\n      return [\n        {\n          type: ClearSignContextType.ERROR,\n          error: firstError,\n        },\n      ];\n    }\n\n    const { signedDescriptor } = implGatedResult.unsafeCoerce();\n    const [proxyCertificate, gatedCertificate] = await Promise.all([\n      this._certificateLoader.loadCertificate({\n        keyId: proxyData.keyId,\n        keyUsage: proxyData.keyUsage,\n        targetDevice: deviceModelId,\n      }),\n      this._certificateLoader.loadCertificate({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: deviceModelId,\n      }),\n    ]);\n\n    return [\n      {\n        type: ClearSignContextType.ETHEREUM_PROXY_INFO,\n        payload: proxyData.signedDescriptor,\n        certificate: proxyCertificate,\n      },\n      {\n        type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n        payload: signedDescriptor,\n        certificate: gatedCertificate,\n      },\n    ];\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["inject", "injectable", "gatedSigningTypes", "proxyTypes", "getSchemaHash", "pkiTypes", "KeyId", "KeyUsage", "ClearSignContextType", "ZERO_ADDRESS", "SUPPORTED_TYPES", "ClearSignContextType", "hasTypedDataShape", "data", "obj", "types", "key", "value", "item", "GatedSigningTypedDataContextLoader", "_dataSource", "_certificateLoader", "_proxyDataSource", "input", "expectedTypes", "type", "chainId", "deviceModelId", "challenge", "raw", "verifyingContract", "schemaHash", "getSchemaHash", "directResult", "signedDescriptor", "certificate", "KeyId", "KeyUsage", "firstError", "error", "proxyResult", "proxyData", "implRaw", "implementationAddress", "implGatedResult", "proxyCertificate", "gatedCertificate", "__decorateClass", "injectable", "__decorateParam", "inject", "gatedSigningTypes", "pkiTypes", "proxyTypes"]
+  "sourcesContent": ["import {\n  DeviceModelId,\n  type HexaString,\n  LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { configTypes } from \"@/config/di/configTypes\";\nimport { type GatedDescriptorDataSource } from \"@/modules/ethereum/gated-signing/data/GatedDescriptorDataSource\";\nimport { gatedSigningTypes } from \"@/modules/ethereum/gated-signing/di/gatedSigningTypes\";\nimport type { TypedDataSchema } from \"@/modules/ethereum/model/TypedDataContext\";\nimport type { ProxyDataSource } from \"@/modules/ethereum/proxy/data/ProxyDataSource\";\nimport { proxyTypes } from \"@/modules/ethereum/proxy/di/proxyTypes\";\nimport { getSchemaHash } from \"@/modules/ethereum/typed-data/utils/getSchemaHash\";\nimport { pkiTypes } from \"@/modules/multichain/pki/di/pkiTypes\";\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { KeyId } from \"@/modules/multichain/pki/model/KeyId\";\nimport { KeyUsage } from \"@/modules/multichain/pki/model/KeyUsage\";\nimport { ContextLoader } from \"@/shared/domain/ContextLoader\";\nimport {\n  ClearSignContext,\n  ClearSignContextType,\n} from \"@/shared/model/ClearSignContext\";\n\nconst ZERO_ADDRESS = \"0x0000000000000000000000000000000000000000\";\n\nexport type GatedSigningTypedDataContextInput = {\n  data: {\n    types: TypedDataSchema;\n    domain?: { verifyingContract?: string };\n  };\n  chainId: number;\n  deviceModelId: DeviceModelId;\n  challenge: string;\n};\n\nconst SUPPORTED_TYPES: ClearSignContextType[] = [\n  ClearSignContextType.ETHEREUM_GATED_SIGNING,\n];\n\nfunction hasTypedDataShape(\n  data: unknown,\n): data is { types: TypedDataSchema; domain?: { verifyingContract?: string } } {\n  if (!data || typeof data !== \"object\") return false;\n  const obj = data as Record<string, unknown>;\n  if (\n    !obj[\"types\"] ||\n    typeof obj[\"types\"] !== \"object\" ||\n    Array.isArray(obj[\"types\"])\n  ) {\n    return false;\n  }\n  const types = obj[\"types\"] as Record<string, unknown>;\n  for (const key of Object.keys(types)) {\n    if (typeof key !== \"string\") return false;\n    const value = types[key];\n    if (!Array.isArray(value)) return false;\n    for (const item of value) {\n      if (\n        !item ||\n        typeof item !== \"object\" ||\n        typeof (item as { name?: unknown }).name !== \"string\" ||\n        typeof (item as { type?: unknown }).type !== \"string\"\n      ) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\n@injectable()\nexport class GatedSigningTypedDataContextLoader\n  implements ContextLoader<GatedSigningTypedDataContextInput>\n{\n  private readonly logger: LoggerPublisherService;\n\n  constructor(\n    @inject(gatedSigningTypes.GatedDescriptorDataSource)\n    private readonly _dataSource: GatedDescriptorDataSource,\n    @inject(pkiTypes.PkiCertificateLoader)\n    private readonly _certificateLoader: PkiCertificateLoader,\n    @inject(proxyTypes.ProxyDataSource)\n    private readonly _proxyDataSource: ProxyDataSource,\n    @inject(configTypes.ContextModuleLoggerFactory)\n    loggerFactory: (tag: string) => LoggerPublisherService,\n  ) {\n    this.logger = loggerFactory(\"GatedSigningTypedDataContextLoader\");\n  }\n\n  canHandle(\n    input: unknown,\n    expectedTypes: ClearSignContextType[],\n  ): input is GatedSigningTypedDataContextInput {\n    return (\n      SUPPORTED_TYPES.every((type) => expectedTypes.includes(type)) &&\n      typeof input === \"object\" &&\n      input !== null &&\n      \"data\" in input &&\n      hasTypedDataShape((input as GatedSigningTypedDataContextInput).data) &&\n      \"chainId\" in input &&\n      \"deviceModelId\" in input &&\n      (input as GatedSigningTypedDataContextInput).deviceModelId !==\n        undefined &&\n      \"challenge\" in input &&\n      typeof (input as GatedSigningTypedDataContextInput).challenge === \"string\"\n    );\n  }\n\n  async load({\n    data,\n    chainId,\n    deviceModelId,\n    challenge,\n  }: GatedSigningTypedDataContextInput): Promise<ClearSignContext[]> {\n    const raw = data.domain?.verifyingContract?.toLowerCase() ?? ZERO_ADDRESS;\n    const verifyingContract: HexaString = raw.startsWith(\"0x\")\n      ? (raw as HexaString)\n      : (`0x${raw}` as HexaString);\n    const schemaHash = getSchemaHash(data.types);\n\n    const directResult = await this._dataSource.getGatedDescriptorForTypedData({\n      contractAddress: verifyingContract,\n      schemaHash,\n      chainId,\n    });\n\n    if (directResult.isRight()) {\n      const { signedDescriptor } = directResult.unsafeCoerce();\n      const certificate = await this._certificateLoader.loadCertificate({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: deviceModelId,\n      });\n      this.logger.debug(\"load result\", {\n        data: {\n          path: \"direct\",\n          verifyingContract,\n          schemaHash,\n          chainId,\n          contextTypes: [ClearSignContextType.ETHEREUM_GATED_SIGNING],\n        },\n      });\n      return [\n        {\n          type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n          payload: signedDescriptor,\n          certificate,\n        },\n      ];\n    }\n\n    const firstError: Error = directResult.caseOf({\n      Left: (error) => error,\n      Right: () => new Error(\"unreachable\"),\n    });\n\n    const proxyResult =\n      await this._proxyDataSource.getProxyImplementationAddress({\n        proxyAddress: verifyingContract,\n        chainId,\n        challenge,\n        calldata: \"0x\",\n      });\n\n    if (proxyResult.isLeft()) {\n      const proxyError = proxyResult.extract() as Error;\n      this.logger.warn(\n        \"Direct gated descriptor lookup failed and proxy resolution failed\",\n        {\n          data: {\n            verifyingContract,\n            schemaHash,\n            chainId,\n            directError: firstError.message,\n            proxyError: proxyError.message,\n          },\n        },\n      );\n      return [\n        {\n          type: ClearSignContextType.ERROR,\n          error: firstError,\n        },\n      ];\n    }\n\n    const proxyData = proxyResult.unsafeCoerce();\n    const implRaw = proxyData.implementationAddress.toLowerCase();\n    const implementationAddress: HexaString = implRaw.startsWith(\"0x\")\n      ? (implRaw as HexaString)\n      : (`0x${implRaw}` as HexaString);\n\n    const implGatedResult =\n      await this._dataSource.getGatedDescriptorForTypedData({\n        contractAddress: implementationAddress,\n        schemaHash,\n        chainId,\n      });\n\n    if (implGatedResult.isLeft()) {\n      const implError = implGatedResult.extract() as Error;\n      this.logger.warn(\n        \"No gated descriptor found for proxy implementation address\",\n        {\n          data: {\n            verifyingContract,\n            implementationAddress,\n            schemaHash,\n            chainId,\n            directError: firstError.message,\n            implError: implError.message,\n          },\n        },\n      );\n      return [\n        {\n          type: ClearSignContextType.ERROR,\n          error: firstError,\n        },\n      ];\n    }\n\n    const { signedDescriptor } = implGatedResult.unsafeCoerce();\n    const [proxyCertificate, gatedCertificate] = await Promise.all([\n      this._certificateLoader.loadCertificate({\n        keyId: proxyData.keyId,\n        keyUsage: proxyData.keyUsage,\n        targetDevice: deviceModelId,\n      }),\n      this._certificateLoader.loadCertificate({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: deviceModelId,\n      }),\n    ]);\n\n    this.logger.debug(\"load result\", {\n      data: {\n        path: \"proxy\",\n        verifyingContract,\n        implementationAddress,\n        schemaHash,\n        chainId,\n        contextTypes: [\n          ClearSignContextType.ETHEREUM_PROXY_INFO,\n          ClearSignContextType.ETHEREUM_GATED_SIGNING,\n        ],\n      },\n    });\n    return [\n      {\n        type: ClearSignContextType.ETHEREUM_PROXY_INFO,\n        payload: proxyData.signedDescriptor,\n        certificate: proxyCertificate,\n      },\n      {\n        type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n        payload: signedDescriptor,\n        certificate: gatedCertificate,\n      },\n    ];\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["inject", "injectable", "configTypes", "gatedSigningTypes", "proxyTypes", "getSchemaHash", "pkiTypes", "KeyId", "KeyUsage", "ClearSignContextType", "ZERO_ADDRESS", "SUPPORTED_TYPES", "ClearSignContextType", "hasTypedDataShape", "data", "obj", "types", "key", "value", "item", "GatedSigningTypedDataContextLoader", "_dataSource", "_certificateLoader", "_proxyDataSource", "loggerFactory", "input", "expectedTypes", "type", "chainId", "deviceModelId", "challenge", "raw", "verifyingContract", "schemaHash", "getSchemaHash", "directResult", "signedDescriptor", "certificate", "KeyId", "KeyUsage", "firstError", "error", "proxyResult", "proxyError", "proxyData", "implRaw", "implementationAddress", "implGatedResult", "implError", "proxyCertificate", "gatedCertificate", "__decorateClass", "injectable", "__decorateParam", "inject", "gatedSigningTypes", "pkiTypes", "proxyTypes", "configTypes"]
 }

package/lib/esm/src/modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{DeviceModelId as i}from"@ledgerhq/device-management-kit";import{Left as g,Right as s}from"purify-ts";import{GatedSigningTypedDataContextLoader as u}from"../../../../modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader";import{KeyId as m}from"../../../../modules/multichain/pki/model/KeyId";import{KeyUsage as f}from"../../../../modules/multichain/pki/model/KeyUsage";import{ClearSignContextType as r}from"../../../../shared/model/ClearSignContext";describe("GatedSigningTypedDataContextLoader",()=>{const a={getGatedDescriptor:vi.fn(),getGatedDescriptorForTypedData:vi.fn()},c={loadCertificate:vi.fn()},l={getProxyImplementationAddress:vi.fn()},t=new u(a,c,l),h={keyUsageNumber:1,payload:new Uint8Array([1,2,3])},n=[r.ETHEREUM_GATED_SIGNING],e={data:{types:{EIP712Domain:[{name:"name",type:"string"},{name:"chainId",type:"uint256"}],Mail:[{name:"subject",type:"string"}]},domain:{verifyingContract:"0x1111111254fb6c44bac0bed2854e76f90643097d"}},chainId:1,deviceModelId:i.STAX,challenge:"test-challenge"};beforeEach(()=>{vi.resetAllMocks(),vi.spyOn(c,"loadCertificate").mockResolvedValue(h)}),describe("canHandle",()=>{it("should return true for valid typed data input",()=>{expect(t.canHandle(e,n)).toBe(!0)}),it("should return false when expected types do not include GATED_SIGNING",()=>{expect(t.canHandle(e,[r.ETHEREUM_TOKEN])).toBe(!1),expect(t.canHandle(e,[r.ETHEREUM_DYNAMIC_NETWORK])).toBe(!1)}),it.each([[null,"null input"],[void 0,"undefined input"],[{},"empty object"],["string","string input"]])("should return false for %s",(d,o)=>{expect(t.canHandle(d,n)).toBe(!1)}),it("should return false for transaction-style input (selector, to)",()=>{const d={to:"0x1111111254fb6c44bac0bed2854e76f90643097d",selector:"0xa1251d75",chainId:1,deviceModelId:i.STAX};expect(t.canHandle(d,n)).toBe(!1)}),it("should return false when data is missing",()=>{expect(t.canHandle({chainId:1,deviceModelId:i.STAX},n)).toBe(!1)}),it("should return false when data.types is not a valid schema",()=>{expect(t.canHandle({data:{types:"not-an-object"},chainId:1,deviceModelId:i.STAX,challenge:e.challenge},n)).toBe(!1),expect(t.canHandle({data:{types:{}},chainId:1,deviceModelId:i.STAX,challenge:e.challenge},n)).toBe(!0)}),it("should return false when chainId or deviceModelId is missing",()=>{expect(t.canHandle({data:e.data,deviceModelId:i.STAX,challenge:e.challenge},n)).toBe(!1),expect(t.canHandle({data:e.data,chainId:1,challenge:e.challenge},n)).toBe(!1)}),it("should return false when challenge is missing",()=>{expect(t.canHandle({data:e.data,chainId:1,deviceModelId:i.STAX},n)).toBe(!1)})}),describe("load",()=>{const d="010122020101222a30783131313131313235346662366334346261633062656432383534653736663930363433303937642308000000000000000140086131323531643735150100";it("should return error context when getGatedDescriptorForTypedData returns Left and proxy resolution fails",async()=>{const o=new Error("No gated descriptor for schema hash");vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(g(o)),vi.spyOn(l,"getProxyImplementationAddress").mockResolvedValue(g(new Error("Not a proxy")));const p=await t.load(e);expect(p).toEqual([{type:r.ERROR,error:o}]),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledWith({contractAddress:e.data.domain.verifyingContract.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId}),expect(l.getProxyImplementationAddress).toHaveBeenCalledWith({proxyAddress:e.data.domain.verifyingContract.toLowerCase(),chainId:e.chainId,challenge:e.challenge,calldata:"0x"}),expect(c.loadCertificate).not.toHaveBeenCalled()}),it("should return gated signing context when getGatedDescriptorForTypedData succeeds",async()=>{vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d}));const o=await t.load(e);expect(o).toHaveLength(1),expect(o[0]).toMatchObject({type:r.ETHEREUM_GATED_SIGNING,payload:d,certificate:h}),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledWith({contractAddress:e.data.domain.verifyingContract.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId}),expect(c.loadCertificate).toHaveBeenCalledWith({keyId:m.CalGatedSigning,keyUsage:f.GatedSigning,targetDevice:e.deviceModelId})}),it("should use zero address when domain.verifyingContract is missing",async()=>{vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d})),await t.load({data:{types:e.data.types},chainId:e.chainId,deviceModelId:e.deviceModelId,challenge:e.challenge}),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledWith(expect.objectContaining({contractAddress:"0x0000000000000000000000000000000000000000"}))}),it("should request certificate for correct device model",async()=>{vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d})),await t.load({...e,deviceModelId:i.FLEX}),expect(c.loadCertificate).toHaveBeenCalledWith({keyId:m.CalGatedSigning,keyUsage:f.GatedSigning,targetDevice:i.FLEX})}),it("should reject when certificate loading fails",async()=>{const o=new Error("Certificate loading failed");vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d})),vi.spyOn(c,"loadCertificate").mockRejectedValue(o),await expect(t.load(e)).rejects.toThrow(o)}),it("should return PROXY_INFO and GATED_SIGNING when verifying contract is proxy and gated descriptor exists for implementation",async()=>{const o="0xabcdef1234567890abcdef1234567890abcdef12",p="0xproxy-descriptor";vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValueOnce(g(new Error("No gated descriptor"))).mockResolvedValueOnce(s({signedDescriptor:d})),vi.spyOn(l,"getProxyImplementationAddress").mockResolvedValue(s({implementationAddress:o,signedDescriptor:p,keyId:"domain-metadata",keyUsage:"trusted-name"}));const y=await t.load(e);expect(y).toHaveLength(2),expect(y[0]).toMatchObject({type:r.ETHEREUM_PROXY_INFO,payload:p}),expect(y[1]).toMatchObject({type:r.ETHEREUM_GATED_SIGNING,payload:d}),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledTimes(2),expect(a.getGatedDescriptorForTypedData).toHaveBeenNthCalledWith(1,{contractAddress:e.data.domain.verifyingContract.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId}),expect(a.getGatedDescriptorForTypedData).toHaveBeenNthCalledWith(2,{contractAddress:o.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId})})})});
+import{DeviceModelId as r}from"@ledgerhq/device-management-kit";import{Left as g,Right as s}from"purify-ts";import{GatedSigningTypedDataContextLoader as x}from"../../../../modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader";import{KeyId as f}from"../../../../modules/multichain/pki/model/KeyId";import{KeyUsage as m}from"../../../../modules/multichain/pki/model/KeyUsage";import{ClearSignContextType as i}from"../../../../shared/model/ClearSignContext";describe("GatedSigningTypedDataContextLoader",()=>{const a={getGatedDescriptor:vi.fn(),getGatedDescriptorForTypedData:vi.fn()},c={loadCertificate:vi.fn()},l={getProxyImplementationAddress:vi.fn()},u=()=>({debug:vi.fn(),info:vi.fn(),warn:vi.fn(),error:vi.fn(),subscribers:[]}),t=new x(a,c,l,u),h={keyUsageNumber:1,payload:new Uint8Array([1,2,3])},n=[i.ETHEREUM_GATED_SIGNING],e={data:{types:{EIP712Domain:[{name:"name",type:"string"},{name:"chainId",type:"uint256"}],Mail:[{name:"subject",type:"string"}]},domain:{verifyingContract:"0x1111111254fb6c44bac0bed2854e76f90643097d"}},chainId:1,deviceModelId:r.STAX,challenge:"test-challenge"};beforeEach(()=>{vi.resetAllMocks(),vi.spyOn(c,"loadCertificate").mockResolvedValue(h)}),describe("canHandle",()=>{it("should return true for valid typed data input",()=>{expect(t.canHandle(e,n)).toBe(!0)}),it("should return false when expected types do not include GATED_SIGNING",()=>{expect(t.canHandle(e,[i.ETHEREUM_TOKEN])).toBe(!1),expect(t.canHandle(e,[i.ETHEREUM_DYNAMIC_NETWORK])).toBe(!1)}),it.each([[null,"null input"],[void 0,"undefined input"],[{},"empty object"],["string","string input"]])("should return false for %s",(d,o)=>{expect(t.canHandle(d,n)).toBe(!1)}),it("should return false for transaction-style input (selector, to)",()=>{const d={to:"0x1111111254fb6c44bac0bed2854e76f90643097d",selector:"0xa1251d75",chainId:1,deviceModelId:r.STAX};expect(t.canHandle(d,n)).toBe(!1)}),it("should return false when data is missing",()=>{expect(t.canHandle({chainId:1,deviceModelId:r.STAX},n)).toBe(!1)}),it("should return false when data.types is not a valid schema",()=>{expect(t.canHandle({data:{types:"not-an-object"},chainId:1,deviceModelId:r.STAX,challenge:e.challenge},n)).toBe(!1),expect(t.canHandle({data:{types:{}},chainId:1,deviceModelId:r.STAX,challenge:e.challenge},n)).toBe(!0)}),it("should return false when chainId or deviceModelId is missing",()=>{expect(t.canHandle({data:e.data,deviceModelId:r.STAX,challenge:e.challenge},n)).toBe(!1),expect(t.canHandle({data:e.data,chainId:1,challenge:e.challenge},n)).toBe(!1)}),it("should return false when challenge is missing",()=>{expect(t.canHandle({data:e.data,chainId:1,deviceModelId:r.STAX},n)).toBe(!1)})}),describe("load",()=>{const d="010122020101222a30783131313131313235346662366334346261633062656432383534653736663930363433303937642308000000000000000140086131323531643735150100";it("should return error context when getGatedDescriptorForTypedData returns Left and proxy resolution fails",async()=>{const o=new Error("No gated descriptor for schema hash");vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(g(o)),vi.spyOn(l,"getProxyImplementationAddress").mockResolvedValue(g(new Error("Not a proxy")));const p=await t.load(e);expect(p).toEqual([{type:i.ERROR,error:o}]),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledWith({contractAddress:e.data.domain.verifyingContract.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId}),expect(l.getProxyImplementationAddress).toHaveBeenCalledWith({proxyAddress:e.data.domain.verifyingContract.toLowerCase(),chainId:e.chainId,challenge:e.challenge,calldata:"0x"}),expect(c.loadCertificate).not.toHaveBeenCalled()}),it("should return gated signing context when getGatedDescriptorForTypedData succeeds",async()=>{vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d}));const o=await t.load(e);expect(o).toHaveLength(1),expect(o[0]).toMatchObject({type:i.ETHEREUM_GATED_SIGNING,payload:d,certificate:h}),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledWith({contractAddress:e.data.domain.verifyingContract.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId}),expect(c.loadCertificate).toHaveBeenCalledWith({keyId:f.CalGatedSigning,keyUsage:m.GatedSigning,targetDevice:e.deviceModelId})}),it("should use zero address when domain.verifyingContract is missing",async()=>{vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d})),await t.load({data:{types:e.data.types},chainId:e.chainId,deviceModelId:e.deviceModelId,challenge:e.challenge}),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledWith(expect.objectContaining({contractAddress:"0x0000000000000000000000000000000000000000"}))}),it("should request certificate for correct device model",async()=>{vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d})),await t.load({...e,deviceModelId:r.FLEX}),expect(c.loadCertificate).toHaveBeenCalledWith({keyId:f.CalGatedSigning,keyUsage:m.GatedSigning,targetDevice:r.FLEX})}),it("should reject when certificate loading fails",async()=>{const o=new Error("Certificate loading failed");vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValue(s({signedDescriptor:d})),vi.spyOn(c,"loadCertificate").mockRejectedValue(o),await expect(t.load(e)).rejects.toThrow(o)}),it("should return PROXY_INFO and GATED_SIGNING when verifying contract is proxy and gated descriptor exists for implementation",async()=>{const o="0xabcdef1234567890abcdef1234567890abcdef12",p="0xproxy-descriptor";vi.spyOn(a,"getGatedDescriptorForTypedData").mockResolvedValueOnce(g(new Error("No gated descriptor"))).mockResolvedValueOnce(s({signedDescriptor:d})),vi.spyOn(l,"getProxyImplementationAddress").mockResolvedValue(s({implementationAddress:o,signedDescriptor:p,keyId:"domain-metadata",keyUsage:"trusted-name"}));const y=await t.load(e);expect(y).toHaveLength(2),expect(y[0]).toMatchObject({type:i.ETHEREUM_PROXY_INFO,payload:p}),expect(y[1]).toMatchObject({type:i.ETHEREUM_GATED_SIGNING,payload:d}),expect(a.getGatedDescriptorForTypedData).toHaveBeenCalledTimes(2),expect(a.getGatedDescriptorForTypedData).toHaveBeenNthCalledWith(1,{contractAddress:e.data.domain.verifyingContract.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId}),expect(a.getGatedDescriptorForTypedData).toHaveBeenNthCalledWith(2,{contractAddress:o.toLowerCase(),schemaHash:expect.any(String),chainId:e.chainId})})})});
 //# sourceMappingURL=GatedSigningTypedDataContextLoader.test.js.map

package/lib/esm/src/modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader.test.ts"],
-  "sourcesContent": ["import { DeviceModelId } from \"@ledgerhq/device-management-kit\";\nimport { Left, Right } from \"purify-ts\";\n\nimport { type GatedDescriptorDataSource } from \"@/modules/ethereum/gated-signing/data/GatedDescriptorDataSource\";\nimport {\n  type GatedSigningTypedDataContextInput,\n  GatedSigningTypedDataContextLoader,\n} from \"@/modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader\";\nimport type { ProxyDataSource } from \"@/modules/ethereum/proxy/data/ProxyDataSource\";\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { KeyId } from \"@/modules/multichain/pki/model/KeyId\";\nimport { KeyUsage } from \"@/modules/multichain/pki/model/KeyUsage\";\nimport { type PkiCertificate } from \"@/modules/multichain/pki/model/PkiCertificate\";\nimport { ClearSignContextType } from \"@/shared/model/ClearSignContext\";\n\ndescribe(\"GatedSigningTypedDataContextLoader\", () => {\n  const mockGatedDescriptorDataSource: GatedDescriptorDataSource = {\n    getGatedDescriptor: vi.fn(),\n    getGatedDescriptorForTypedData: vi.fn(),\n  };\n\n  const mockCertificateLoader: PkiCertificateLoader = {\n    loadCertificate: vi.fn(),\n  };\n\n  const mockProxyDataSource: ProxyDataSource = {\n    getProxyImplementationAddress: vi.fn(),\n  };\n\n  const loader = new GatedSigningTypedDataContextLoader(\n    mockGatedDescriptorDataSource,\n    mockCertificateLoader,\n    mockProxyDataSource,\n  );\n\n  const mockCertificate: PkiCertificate = {\n    keyUsageNumber: 1,\n    payload: new Uint8Array([0x01, 0x02, 0x03]),\n  };\n\n  const SUPPORTED_TYPES: ClearSignContextType[] = [\n    ClearSignContextType.ETHEREUM_GATED_SIGNING,\n  ];\n\n  const validInput: GatedSigningTypedDataContextInput = {\n    data: {\n      types: {\n        EIP712Domain: [\n          { name: \"name\", type: \"string\" },\n          { name: \"chainId\", type: \"uint256\" },\n        ],\n        Mail: [{ name: \"subject\", type: \"string\" }],\n      },\n      domain: {\n        verifyingContract: \"0x1111111254fb6c44bac0bed2854e76f90643097d\",\n      },\n    },\n    chainId: 1,\n    deviceModelId: DeviceModelId.STAX,\n    challenge: \"test-challenge\",\n  };\n\n  beforeEach(() => {\n    vi.resetAllMocks();\n    vi.spyOn(mockCertificateLoader, \"loadCertificate\").mockResolvedValue(\n      mockCertificate,\n    );\n  });\n\n  describe(\"canHandle\", () => {\n    it(\"should return true for valid typed data input\", () => {\n      expect(loader.canHandle(validInput, SUPPORTED_TYPES)).toBe(true);\n    });\n\n    it(\"should return false when expected types do not include GATED_SIGNING\", () => {\n      expect(\n        loader.canHandle(validInput, [ClearSignContextType.ETHEREUM_TOKEN]),\n      ).toBe(false);\n      expect(\n        loader.canHandle(validInput, [\n          ClearSignContextType.ETHEREUM_DYNAMIC_NETWORK,\n        ]),\n      ).toBe(false);\n    });\n\n    it.each([\n      [null, \"null input\"],\n      [undefined, \"undefined input\"],\n      [{}, \"empty object\"],\n      [\"string\", \"string input\"],\n    ])(\"should return false for %s\", (input, _description) => {\n      expect(loader.canHandle(input, SUPPORTED_TYPES)).toBe(false);\n    });\n\n    it(\"should return false for transaction-style input (selector, to)\", () => {\n      const transactionInput = {\n        to: \"0x1111111254fb6c44bac0bed2854e76f90643097d\",\n        selector: \"0xa1251d75\",\n        chainId: 1,\n        deviceModelId: DeviceModelId.STAX,\n      };\n      expect(loader.canHandle(transactionInput, SUPPORTED_TYPES)).toBe(false);\n    });\n\n    it(\"should return false when data is missing\", () => {\n      expect(\n        loader.canHandle(\n          { chainId: 1, deviceModelId: DeviceModelId.STAX },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n    });\n\n    it(\"should return false when data.types is not a valid schema\", () => {\n      expect(\n        loader.canHandle(\n          {\n            data: { types: \"not-an-object\" },\n            chainId: 1,\n            deviceModelId: DeviceModelId.STAX,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n      expect(\n        loader.canHandle(\n          {\n            data: { types: {} },\n            chainId: 1,\n            deviceModelId: DeviceModelId.STAX,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(true);\n    });\n\n    it(\"should return false when chainId or deviceModelId is missing\", () => {\n      expect(\n        loader.canHandle(\n          {\n            data: validInput.data,\n            deviceModelId: DeviceModelId.STAX,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n      expect(\n        loader.canHandle(\n          {\n            data: validInput.data,\n            chainId: 1,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n    });\n\n    it(\"should return false when challenge is missing\", () => {\n      expect(\n        loader.canHandle(\n          {\n            data: validInput.data,\n            chainId: 1,\n            deviceModelId: DeviceModelId.STAX,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n    });\n  });\n\n  describe(\"load\", () => {\n    const signedDescriptor =\n      \"010122020101222a30783131313131313235346662366334346261633062656432383534653736663930363433303937642308000000000000000140086131323531643735150100\";\n\n    it(\"should return error context when getGatedDescriptorForTypedData returns Left and proxy resolution fails\", async () => {\n      const error = new Error(\"No gated descriptor for schema hash\");\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Left(error));\n      vi.spyOn(\n        mockProxyDataSource,\n        \"getProxyImplementationAddress\",\n      ).mockResolvedValue(Left(new Error(\"Not a proxy\")));\n\n      const result = await loader.load(validInput);\n\n      expect(result).toEqual([\n        {\n          type: ClearSignContextType.ERROR,\n          error,\n        },\n      ]);\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledWith({\n        contractAddress:\n          validInput.data.domain!.verifyingContract!.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n      expect(\n        mockProxyDataSource.getProxyImplementationAddress,\n      ).toHaveBeenCalledWith({\n        proxyAddress: validInput.data.domain!.verifyingContract!.toLowerCase(),\n        chainId: validInput.chainId,\n        challenge: validInput.challenge,\n        calldata: \"0x\",\n      });\n      expect(mockCertificateLoader.loadCertificate).not.toHaveBeenCalled();\n    });\n\n    it(\"should return gated signing context when getGatedDescriptorForTypedData succeeds\", async () => {\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n\n      const result = await loader.load(validInput);\n\n      expect(result).toHaveLength(1);\n      expect(result[0]).toMatchObject({\n        type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n        payload: signedDescriptor,\n        certificate: mockCertificate,\n      });\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledWith({\n        contractAddress:\n          validInput.data.domain!.verifyingContract!.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n      expect(mockCertificateLoader.loadCertificate).toHaveBeenCalledWith({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: validInput.deviceModelId,\n      });\n    });\n\n    it(\"should use zero address when domain.verifyingContract is missing\", async () => {\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n\n      await loader.load({\n        data: { types: validInput.data.types },\n        chainId: validInput.chainId,\n        deviceModelId: validInput.deviceModelId,\n        challenge: validInput.challenge,\n      });\n\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledWith(\n        expect.objectContaining({\n          contractAddress: \"0x0000000000000000000000000000000000000000\",\n        }),\n      );\n    });\n\n    it(\"should request certificate for correct device model\", async () => {\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n\n      await loader.load({\n        ...validInput,\n        deviceModelId: DeviceModelId.FLEX,\n      });\n\n      expect(mockCertificateLoader.loadCertificate).toHaveBeenCalledWith({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: DeviceModelId.FLEX,\n      });\n    });\n\n    it(\"should reject when certificate loading fails\", async () => {\n      const certificateError = new Error(\"Certificate loading failed\");\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n      vi.spyOn(mockCertificateLoader, \"loadCertificate\").mockRejectedValue(\n        certificateError,\n      );\n\n      await expect(loader.load(validInput)).rejects.toThrow(certificateError);\n    });\n\n    it(\"should return PROXY_INFO and GATED_SIGNING when verifying contract is proxy and gated descriptor exists for implementation\", async () => {\n      const implementationAddress =\n        \"0xabcdef1234567890abcdef1234567890abcdef12\";\n      const proxySignedDescriptor = \"0xproxy-descriptor\";\n      vi.spyOn(mockGatedDescriptorDataSource, \"getGatedDescriptorForTypedData\")\n        .mockResolvedValueOnce(Left(new Error(\"No gated descriptor\")))\n        .mockResolvedValueOnce(Right({ signedDescriptor }));\n      vi.spyOn(\n        mockProxyDataSource,\n        \"getProxyImplementationAddress\",\n      ).mockResolvedValue(\n        Right({\n          implementationAddress,\n          signedDescriptor: proxySignedDescriptor,\n          keyId: \"domain-metadata\",\n          keyUsage: \"trusted-name\",\n        }),\n      );\n\n      const result = await loader.load(validInput);\n\n      expect(result).toHaveLength(2);\n      expect(result[0]).toMatchObject({\n        type: ClearSignContextType.ETHEREUM_PROXY_INFO,\n        payload: proxySignedDescriptor,\n      });\n      expect(result[1]).toMatchObject({\n        type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n        payload: signedDescriptor,\n      });\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledTimes(2);\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenNthCalledWith(1, {\n        contractAddress:\n          validInput.data.domain!.verifyingContract!.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenNthCalledWith(2, {\n        contractAddress: implementationAddress.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": ["DeviceModelId", "Left", "Right", "GatedSigningTypedDataContextLoader", "KeyId", "KeyUsage", "ClearSignContextType", "mockGatedDescriptorDataSource", "mockCertificateLoader", "mockProxyDataSource", "loader", "mockCertificate", "SUPPORTED_TYPES", "validInput", "input", "_description", "transactionInput", "signedDescriptor", "error", "result", "certificateError", "implementationAddress", "proxySignedDescriptor"]
+  "sourcesContent": ["import { DeviceModelId } from \"@ledgerhq/device-management-kit\";\nimport { Left, Right } from \"purify-ts\";\n\nimport { type GatedDescriptorDataSource } from \"@/modules/ethereum/gated-signing/data/GatedDescriptorDataSource\";\nimport {\n  type GatedSigningTypedDataContextInput,\n  GatedSigningTypedDataContextLoader,\n} from \"@/modules/ethereum/gated-signing/domain/GatedSigningTypedDataContextLoader\";\nimport type { ProxyDataSource } from \"@/modules/ethereum/proxy/data/ProxyDataSource\";\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { KeyId } from \"@/modules/multichain/pki/model/KeyId\";\nimport { KeyUsage } from \"@/modules/multichain/pki/model/KeyUsage\";\nimport { type PkiCertificate } from \"@/modules/multichain/pki/model/PkiCertificate\";\nimport { ClearSignContextType } from \"@/shared/model/ClearSignContext\";\n\ndescribe(\"GatedSigningTypedDataContextLoader\", () => {\n  const mockGatedDescriptorDataSource: GatedDescriptorDataSource = {\n    getGatedDescriptor: vi.fn(),\n    getGatedDescriptorForTypedData: vi.fn(),\n  };\n\n  const mockCertificateLoader: PkiCertificateLoader = {\n    loadCertificate: vi.fn(),\n  };\n\n  const mockProxyDataSource: ProxyDataSource = {\n    getProxyImplementationAddress: vi.fn(),\n  };\n\n  const mockLoggerFactory = () => ({\n    debug: vi.fn(),\n    info: vi.fn(),\n    warn: vi.fn(),\n    error: vi.fn(),\n    subscribers: [],\n  });\n\n  const loader = new GatedSigningTypedDataContextLoader(\n    mockGatedDescriptorDataSource,\n    mockCertificateLoader,\n    mockProxyDataSource,\n    mockLoggerFactory,\n  );\n\n  const mockCertificate: PkiCertificate = {\n    keyUsageNumber: 1,\n    payload: new Uint8Array([0x01, 0x02, 0x03]),\n  };\n\n  const SUPPORTED_TYPES: ClearSignContextType[] = [\n    ClearSignContextType.ETHEREUM_GATED_SIGNING,\n  ];\n\n  const validInput: GatedSigningTypedDataContextInput = {\n    data: {\n      types: {\n        EIP712Domain: [\n          { name: \"name\", type: \"string\" },\n          { name: \"chainId\", type: \"uint256\" },\n        ],\n        Mail: [{ name: \"subject\", type: \"string\" }],\n      },\n      domain: {\n        verifyingContract: \"0x1111111254fb6c44bac0bed2854e76f90643097d\",\n      },\n    },\n    chainId: 1,\n    deviceModelId: DeviceModelId.STAX,\n    challenge: \"test-challenge\",\n  };\n\n  beforeEach(() => {\n    vi.resetAllMocks();\n    vi.spyOn(mockCertificateLoader, \"loadCertificate\").mockResolvedValue(\n      mockCertificate,\n    );\n  });\n\n  describe(\"canHandle\", () => {\n    it(\"should return true for valid typed data input\", () => {\n      expect(loader.canHandle(validInput, SUPPORTED_TYPES)).toBe(true);\n    });\n\n    it(\"should return false when expected types do not include GATED_SIGNING\", () => {\n      expect(\n        loader.canHandle(validInput, [ClearSignContextType.ETHEREUM_TOKEN]),\n      ).toBe(false);\n      expect(\n        loader.canHandle(validInput, [\n          ClearSignContextType.ETHEREUM_DYNAMIC_NETWORK,\n        ]),\n      ).toBe(false);\n    });\n\n    it.each([\n      [null, \"null input\"],\n      [undefined, \"undefined input\"],\n      [{}, \"empty object\"],\n      [\"string\", \"string input\"],\n    ])(\"should return false for %s\", (input, _description) => {\n      expect(loader.canHandle(input, SUPPORTED_TYPES)).toBe(false);\n    });\n\n    it(\"should return false for transaction-style input (selector, to)\", () => {\n      const transactionInput = {\n        to: \"0x1111111254fb6c44bac0bed2854e76f90643097d\",\n        selector: \"0xa1251d75\",\n        chainId: 1,\n        deviceModelId: DeviceModelId.STAX,\n      };\n      expect(loader.canHandle(transactionInput, SUPPORTED_TYPES)).toBe(false);\n    });\n\n    it(\"should return false when data is missing\", () => {\n      expect(\n        loader.canHandle(\n          { chainId: 1, deviceModelId: DeviceModelId.STAX },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n    });\n\n    it(\"should return false when data.types is not a valid schema\", () => {\n      expect(\n        loader.canHandle(\n          {\n            data: { types: \"not-an-object\" },\n            chainId: 1,\n            deviceModelId: DeviceModelId.STAX,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n      expect(\n        loader.canHandle(\n          {\n            data: { types: {} },\n            chainId: 1,\n            deviceModelId: DeviceModelId.STAX,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(true);\n    });\n\n    it(\"should return false when chainId or deviceModelId is missing\", () => {\n      expect(\n        loader.canHandle(\n          {\n            data: validInput.data,\n            deviceModelId: DeviceModelId.STAX,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n      expect(\n        loader.canHandle(\n          {\n            data: validInput.data,\n            chainId: 1,\n            challenge: validInput.challenge,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n    });\n\n    it(\"should return false when challenge is missing\", () => {\n      expect(\n        loader.canHandle(\n          {\n            data: validInput.data,\n            chainId: 1,\n            deviceModelId: DeviceModelId.STAX,\n          },\n          SUPPORTED_TYPES,\n        ),\n      ).toBe(false);\n    });\n  });\n\n  describe(\"load\", () => {\n    const signedDescriptor =\n      \"010122020101222a30783131313131313235346662366334346261633062656432383534653736663930363433303937642308000000000000000140086131323531643735150100\";\n\n    it(\"should return error context when getGatedDescriptorForTypedData returns Left and proxy resolution fails\", async () => {\n      const error = new Error(\"No gated descriptor for schema hash\");\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Left(error));\n      vi.spyOn(\n        mockProxyDataSource,\n        \"getProxyImplementationAddress\",\n      ).mockResolvedValue(Left(new Error(\"Not a proxy\")));\n\n      const result = await loader.load(validInput);\n\n      expect(result).toEqual([\n        {\n          type: ClearSignContextType.ERROR,\n          error,\n        },\n      ]);\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledWith({\n        contractAddress:\n          validInput.data.domain!.verifyingContract!.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n      expect(\n        mockProxyDataSource.getProxyImplementationAddress,\n      ).toHaveBeenCalledWith({\n        proxyAddress: validInput.data.domain!.verifyingContract!.toLowerCase(),\n        chainId: validInput.chainId,\n        challenge: validInput.challenge,\n        calldata: \"0x\",\n      });\n      expect(mockCertificateLoader.loadCertificate).not.toHaveBeenCalled();\n    });\n\n    it(\"should return gated signing context when getGatedDescriptorForTypedData succeeds\", async () => {\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n\n      const result = await loader.load(validInput);\n\n      expect(result).toHaveLength(1);\n      expect(result[0]).toMatchObject({\n        type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n        payload: signedDescriptor,\n        certificate: mockCertificate,\n      });\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledWith({\n        contractAddress:\n          validInput.data.domain!.verifyingContract!.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n      expect(mockCertificateLoader.loadCertificate).toHaveBeenCalledWith({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: validInput.deviceModelId,\n      });\n    });\n\n    it(\"should use zero address when domain.verifyingContract is missing\", async () => {\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n\n      await loader.load({\n        data: { types: validInput.data.types },\n        chainId: validInput.chainId,\n        deviceModelId: validInput.deviceModelId,\n        challenge: validInput.challenge,\n      });\n\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledWith(\n        expect.objectContaining({\n          contractAddress: \"0x0000000000000000000000000000000000000000\",\n        }),\n      );\n    });\n\n    it(\"should request certificate for correct device model\", async () => {\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n\n      await loader.load({\n        ...validInput,\n        deviceModelId: DeviceModelId.FLEX,\n      });\n\n      expect(mockCertificateLoader.loadCertificate).toHaveBeenCalledWith({\n        keyId: KeyId.CalGatedSigning,\n        keyUsage: KeyUsage.GatedSigning,\n        targetDevice: DeviceModelId.FLEX,\n      });\n    });\n\n    it(\"should reject when certificate loading fails\", async () => {\n      const certificateError = new Error(\"Certificate loading failed\");\n      vi.spyOn(\n        mockGatedDescriptorDataSource,\n        \"getGatedDescriptorForTypedData\",\n      ).mockResolvedValue(Right({ signedDescriptor }));\n      vi.spyOn(mockCertificateLoader, \"loadCertificate\").mockRejectedValue(\n        certificateError,\n      );\n\n      await expect(loader.load(validInput)).rejects.toThrow(certificateError);\n    });\n\n    it(\"should return PROXY_INFO and GATED_SIGNING when verifying contract is proxy and gated descriptor exists for implementation\", async () => {\n      const implementationAddress =\n        \"0xabcdef1234567890abcdef1234567890abcdef12\";\n      const proxySignedDescriptor = \"0xproxy-descriptor\";\n      vi.spyOn(mockGatedDescriptorDataSource, \"getGatedDescriptorForTypedData\")\n        .mockResolvedValueOnce(Left(new Error(\"No gated descriptor\")))\n        .mockResolvedValueOnce(Right({ signedDescriptor }));\n      vi.spyOn(\n        mockProxyDataSource,\n        \"getProxyImplementationAddress\",\n      ).mockResolvedValue(\n        Right({\n          implementationAddress,\n          signedDescriptor: proxySignedDescriptor,\n          keyId: \"domain-metadata\",\n          keyUsage: \"trusted-name\",\n        }),\n      );\n\n      const result = await loader.load(validInput);\n\n      expect(result).toHaveLength(2);\n      expect(result[0]).toMatchObject({\n        type: ClearSignContextType.ETHEREUM_PROXY_INFO,\n        payload: proxySignedDescriptor,\n      });\n      expect(result[1]).toMatchObject({\n        type: ClearSignContextType.ETHEREUM_GATED_SIGNING,\n        payload: signedDescriptor,\n      });\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenCalledTimes(2);\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenNthCalledWith(1, {\n        contractAddress:\n          validInput.data.domain!.verifyingContract!.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n      expect(\n        mockGatedDescriptorDataSource.getGatedDescriptorForTypedData,\n      ).toHaveBeenNthCalledWith(2, {\n        contractAddress: implementationAddress.toLowerCase(),\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        schemaHash: expect.any(String),\n        chainId: validInput.chainId,\n      });\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["DeviceModelId", "Left", "Right", "GatedSigningTypedDataContextLoader", "KeyId", "KeyUsage", "ClearSignContextType", "mockGatedDescriptorDataSource", "mockCertificateLoader", "mockProxyDataSource", "mockLoggerFactory", "loader", "mockCertificate", "SUPPORTED_TYPES", "validInput", "input", "_description", "transactionInput", "signedDescriptor", "error", "result", "certificateError", "implementationAddress", "proxySignedDescriptor"]
 }

package/lib/esm/src/modules/multichain/pki/model/KeyId.js CHANGED Viewed

@@ -1,2 +1,2 @@
-var e=(a=>(a.Test="test",a.PersoV2="persov2",a.LedgerRootV3="ledger_root_v3",a.PluginSelectorKey="plugin_selector_key",a.NftMetadataKey="nft_metadata_key",a.PartnerMetadataKey="partner_metadata_key",a.Erc20MetadataKey="erc20_metadata_key",a.DomainMetadataKey="domain_metadata_key",a.CalCalldataKey="cal_calldata_key",a.CalTrustedNameKey="cal_trusted_name_key",a.CalNetwork="cal_network",a.CalGatedSigning="cal_gated_signing",a.SwapTemplateKey="swap_template_key",a))(e||{});export{e as KeyId};
+var e=(a=>(a.Test="test",a.PersoV2="persov2",a.LedgerRootV3="ledger_root_v3",a.PluginSelectorKey="plugin_selector_key",a.NftMetadataKey="nft_metadata_key",a.TokenMetadataKey="token_metadata_key",a.PartnerMetadataKey="partner_metadata_key",a.Erc20MetadataKey="erc20_metadata_key",a.DomainMetadataKey="domain_metadata_key",a.CalCalldataKey="cal_calldata_key",a.CalTrustedNameKey="cal_trusted_name_key",a.CalNetwork="cal_network",a.CalGatedSigning="cal_gated_signing",a.SwapTemplateKey="swap_template_key",a))(e||{});export{e as KeyId};
 //# sourceMappingURL=KeyId.js.map

package/lib/esm/src/modules/multichain/pki/model/KeyId.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/modules/multichain/pki/model/KeyId.ts"],
-  "sourcesContent": ["export enum KeyId {\n  Test = \"test\",\n  PersoV2 = \"persov2\",\n  LedgerRootV3 = \"ledger_root_v3\",\n  PluginSelectorKey = \"plugin_selector_key\",\n  NftMetadataKey = \"nft_metadata_key\",\n  PartnerMetadataKey = \"partner_metadata_key\",\n  Erc20MetadataKey = \"erc20_metadata_key\",\n  DomainMetadataKey = \"domain_metadata_key\",\n  CalCalldataKey = \"cal_calldata_key\",\n  CalTrustedNameKey = \"cal_trusted_name_key\",\n  CalNetwork = \"cal_network\",\n  CalGatedSigning = \"cal_gated_signing\",\n  SwapTemplateKey = \"swap_template_key\",\n}\n"],
-  "mappings": "AAAO,IAAKA,OACVA,EAAA,KAAO,OACPA,EAAA,QAAU,UACVA,EAAA,aAAe,iBACfA,EAAA,kBAAoB,sBACpBA,EAAA,eAAiB,mBACjBA,EAAA,mBAAqB,uBACrBA,EAAA,iBAAmB,qBACnBA,EAAA,kBAAoB,sBACpBA,EAAA,eAAiB,mBACjBA,EAAA,kBAAoB,uBACpBA,EAAA,WAAa,cACbA,EAAA,gBAAkB,oBAClBA,EAAA,gBAAkB,oBAbRA,OAAA",
+  "sourcesContent": ["export enum KeyId {\n  Test = \"test\",\n  PersoV2 = \"persov2\",\n  LedgerRootV3 = \"ledger_root_v3\",\n  PluginSelectorKey = \"plugin_selector_key\",\n  NftMetadataKey = \"nft_metadata_key\",\n  TokenMetadataKey = \"token_metadata_key\",\n  PartnerMetadataKey = \"partner_metadata_key\",\n  Erc20MetadataKey = \"erc20_metadata_key\",\n  DomainMetadataKey = \"domain_metadata_key\",\n  CalCalldataKey = \"cal_calldata_key\",\n  CalTrustedNameKey = \"cal_trusted_name_key\",\n  CalNetwork = \"cal_network\",\n  CalGatedSigning = \"cal_gated_signing\",\n  SwapTemplateKey = \"swap_template_key\",\n}\n"],
+  "mappings": "AAAO,IAAKA,OACVA,EAAA,KAAO,OACPA,EAAA,QAAU,UACVA,EAAA,aAAe,iBACfA,EAAA,kBAAoB,sBACpBA,EAAA,eAAiB,mBACjBA,EAAA,iBAAmB,qBACnBA,EAAA,mBAAqB,uBACrBA,EAAA,iBAAmB,qBACnBA,EAAA,kBAAoB,sBACpBA,EAAA,eAAiB,mBACjBA,EAAA,kBAAoB,uBACpBA,EAAA,WAAa,cACbA,EAAA,gBAAkB,oBAClBA,EAAA,gBAAkB,oBAdRA,OAAA",
   "names": ["KeyId"]
 }

package/lib/esm/src/modules/multichain/transaction-check/loaders/SolanaTransactionCheckLoader.js CHANGED Viewed

@@ -1,2 +1,2 @@
-var T=Object.defineProperty;var k=Object.getOwnPropertyDescriptor;var m=(a,t,o,e)=>{for(var r=e>1?void 0:e?k(t,o):t,n=a.length-1,i;n>=0;n--)(i=a[n])&&(r=(e?i(t,o,r):i(r))||r);return e&&r&&T(t,o,r),r},s=(a,t)=>(o,e)=>t(o,e,a);import{DeviceModelId as C}from"@ledgerhq/device-management-kit";import{inject as d,injectable as y}from"inversify";import{Codec as f,exactly as l,number as x,oneOf as A,string as u}from"purify-ts";import{configTypes as I}from"../../../../config/di/configTypes";import{pkiTypes as L}from"../../../../modules/multichain/pki/di/pkiTypes";import{KeyUsage as v}from"../../../../modules/multichain/pki/model/KeyUsage";import{transactionCheckTypes as P}from"../../../../modules/multichain/transaction-check/di/transactionCheckTypes";import{TransactionCheckPaths as N}from"../../../../modules/multichain/transaction-check/utils/constants";import{ClearSignContextType as h}from"../../../../shared/model/ClearSignContext";const O=[h.SOLANA_TRANSACTION_CHECK],R=f.interface({deviceModelId:A([l(C.NANO_X),l(C.NANO_SP),l(C.STAX),l(C.FLEX)]),transactionCheck:f.interface({from:u,rawTx:u,chain:x})});let p=class{constructor(t,o,e){this.transactionCheckDataSource=t;this.certificateLoader=o;this.logger=e("SolanaTransactionCheckLoader")}logger;canHandle(t,o){return O.every(e=>o.includes(e))?R.decode(t).caseOf({Left:()=>!1,Right:({transactionCheck:{from:e,rawTx:r}})=>e.length>0&&r.length>0}):!1}async load(t){const{from:o,rawTx:e,chain:r}=t.transactionCheck,g=[await(await this.transactionCheckDataSource.check({path:N.SOLANA_TRANSACTION,body:{tx:{from:o,raw:e},chain:r}})).caseOf({Left:c=>Promise.resolve({type:h.ERROR,error:c}),Right:async c=>{const S=await this.certificateLoader.loadCertificate({keyId:c.publicKeyId,keyUsage:v.TxSimulationSigner,targetDevice:t.deviceModelId});return{type:h.SOLANA_TRANSACTION_CHECK,payload:{descriptor:c.descriptor},certificate:S}}})];return this.logger.debug("load result",{data:{result:g}}),g}};p=m([y(),s(0,d(P.TransactionCheckDataSource)),s(1,d(L.PkiCertificateLoader)),s(2,d(I.ContextModuleLoggerFactory))],p);export{p as SolanaTransactionCheckLoader};
+var g=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var h=(i,t,r,e)=>{for(var n=e>1?void 0:e?f(t,r):t,o=i.length-1,c;o>=0;o--)(c=i[o])&&(n=(e?c(t,r,n):c(n))||n);return e&&n&&g(t,r,n),n},d=(i,t)=>(r,e)=>t(r,e,i);import{inject as C,injectable as y}from"inversify";import{Codec as S,number as T,string as A}from"purify-ts";import{configTypes as k}from"../../../../config/di/configTypes";import{pkiTypes as x}from"../../../../modules/multichain/pki/di/pkiTypes";import{KeyUsage as E}from"../../../../modules/multichain/pki/model/KeyUsage";import{transactionCheckTypes as R}from"../../../../modules/multichain/transaction-check/di/transactionCheckTypes";import{TransactionCheckPaths as I}from"../../../../modules/multichain/transaction-check/utils/constants";import{ClearSignContextType as u}from"../../../../shared/model/ClearSignContext";import{DefaultBs58Encoder as L}from"../../../../shared/utils/bs58Encoder";import{deviceModelIdCodec as N}from"../../../../shared/utils/deviceModelIdCodec";import{uint8ArrayCodec as O}from"../../../../shared/utils/uint8ArrayCodec";const _=[u.SOLANA_TRANSACTION_CHECK],v=64,m=64,w=128,b=128,M=127,P=7,U=S.interface({deviceModelId:N,transactionCheck:S.interface({from:A,transactionBytes:O,chain:T})});let l=class{constructor(t,r,e,n=L){this.transactionCheckDataSource=t;this.certificateLoader=r;this.bs58Encoder=n;this.logger=e("SolanaTransactionCheckLoader")}logger;canHandle(t,r){return _.every(e=>r.includes(e))?U.decode(t).caseOf({Left:()=>!1,Right:({transactionCheck:{from:e,transactionBytes:n}})=>e.length>0&&n.length>0}):!1}async load(t){const{from:r,transactionBytes:e,chain:n}=t.transactionCheck;let o;try{o=this.bs58Encoder.encode(this.wrapMessageAsTransaction(e))}catch(a){const s=[{type:u.ERROR,error:a instanceof Error?a:new Error(String(a))}];return this.logger.debug("load result",{data:{result:s}}),s}const p=[await(await this.transactionCheckDataSource.check({path:I.SOLANA_TRANSACTION,body:{tx:{from:r,raw:o},chain:n}})).caseOf({Left:a=>Promise.resolve({type:u.ERROR,error:a}),Right:async a=>{const s=await this.certificateLoader.loadCertificate({keyId:a.publicKeyId,keyUsage:E.TxSimulationSigner,targetDevice:t.deviceModelId});return{type:u.SOLANA_TRANSACTION_CHECK,payload:{descriptor:a.descriptor},certificate:s}}})];return this.logger.debug("load result",{data:{result:p}}),p}wrapMessageAsTransaction(t){const r=this.readNumRequiredSignatures(t),e=this.encodeShortVec(r),n=r*v,o=new Uint8Array(e.length+n+t.length);return o.set(e,0),o.set(t,e.length+n),o}readNumRequiredSignatures(t){const r=t[0];if(r===void 0)throw new Error("[ContextModule] SolanaTransactionCheckLoader: empty transaction bytes");const n=(r&w)!==0?1:0,o=t[n];if(o===void 0)throw new Error("[ContextModule] SolanaTransactionCheckLoader: malformed message header");if(o>m)throw new Error(`[ContextModule] SolanaTransactionCheckLoader: numRequiredSignatures (${o}) exceeds SOLANA_MAX_SIGNATURES (${m})`);return o}encodeShortVec(t){const r=[];let e=t;for(;;){const n=e&M;if(e>>>=P,e===0){r.push(n);break}r.push(n|b)}return Uint8Array.from(r)}};l=h([y(),d(0,C(R.TransactionCheckDataSource)),d(1,C(x.PkiCertificateLoader)),d(2,C(k.ContextModuleLoggerFactory))],l);export{l as SolanaTransactionCheckLoader};
 //# sourceMappingURL=SolanaTransactionCheckLoader.js.map

package/lib/esm/src/modules/multichain/transaction-check/loaders/SolanaTransactionCheckLoader.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/modules/multichain/transaction-check/loaders/SolanaTransactionCheckLoader.ts"],
-  "sourcesContent": ["import {\n  DeviceModelId,\n  LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\nimport { Codec, exactly, number, oneOf, string } from \"purify-ts\";\n\nimport { configTypes } from \"@/config/di/configTypes\";\nimport { pkiTypes } from \"@/modules/multichain/pki/di/pkiTypes\";\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { KeyUsage } from \"@/modules/multichain/pki/model/KeyUsage\";\nimport { type TransactionCheckDataSource } from \"@/modules/multichain/transaction-check/data/TransactionCheckDataSource\";\nimport { transactionCheckTypes } from \"@/modules/multichain/transaction-check/di/transactionCheckTypes\";\nimport { type TransactionCheckLoader } from \"@/modules/multichain/transaction-check/loaders/TransactionCheckLoader\";\nimport { TransactionCheckPaths } from \"@/modules/multichain/transaction-check/utils/constants\";\nimport {\n  ClearSignContext,\n  ClearSignContextType,\n} from \"@/shared/model/ClearSignContext\";\n\nexport type SolanaTransactionCheckRequest = {\n  from: string;\n  rawTx: string;\n  chain: number;\n};\n\nexport type SolanaTransactionCheckContextInput = {\n  deviceModelId: DeviceModelId;\n  transactionCheck: SolanaTransactionCheckRequest;\n};\n\nconst SUPPORTED_TYPES: ClearSignContextType[] = [\n  ClearSignContextType.SOLANA_TRANSACTION_CHECK,\n];\n\nconst solanaTransactionCheckInputCodec = Codec.interface({\n  deviceModelId: oneOf([\n    exactly(DeviceModelId.NANO_X),\n    exactly(DeviceModelId.NANO_SP),\n    exactly(DeviceModelId.STAX),\n    exactly(DeviceModelId.FLEX),\n  ]),\n  transactionCheck: Codec.interface({\n    from: string,\n    rawTx: string,\n    chain: number,\n  }),\n});\n\n@injectable()\nexport class SolanaTransactionCheckLoader\n  implements TransactionCheckLoader<SolanaTransactionCheckContextInput>\n{\n  private readonly logger: LoggerPublisherService;\n\n  constructor(\n    @inject(transactionCheckTypes.TransactionCheckDataSource)\n    private readonly transactionCheckDataSource: TransactionCheckDataSource,\n    @inject(pkiTypes.PkiCertificateLoader)\n    private readonly certificateLoader: PkiCertificateLoader,\n    @inject(configTypes.ContextModuleLoggerFactory)\n    loggerFactory: (tag: string) => LoggerPublisherService,\n  ) {\n    this.logger = loggerFactory(\"SolanaTransactionCheckLoader\");\n  }\n\n  canHandle(\n    input: unknown,\n    expectedType: ClearSignContextType[],\n  ): input is SolanaTransactionCheckContextInput {\n    if (!SUPPORTED_TYPES.every((type) => expectedType.includes(type)))\n      return false;\n    return solanaTransactionCheckInputCodec.decode(input).caseOf({\n      Left: () => false,\n      Right: ({ transactionCheck: { from, rawTx } }) =>\n        from.length > 0 && rawTx.length > 0,\n    });\n  }\n\n  async load(\n    ctx: SolanaTransactionCheckContextInput,\n  ): Promise<ClearSignContext[]> {\n    const { from, rawTx, chain } = ctx.transactionCheck;\n\n    const txCheck = await this.transactionCheckDataSource.check({\n      path: TransactionCheckPaths.SOLANA_TRANSACTION,\n      body: { tx: { from, raw: rawTx }, chain },\n    });\n\n    const context = await txCheck.caseOf<Promise<ClearSignContext>>({\n      Left: (error) =>\n        Promise.resolve({\n          type: ClearSignContextType.ERROR,\n          error,\n        }),\n      Right: async (data) => {\n        const certificate = await this.certificateLoader.loadCertificate({\n          keyId: data.publicKeyId,\n          keyUsage: KeyUsage.TxSimulationSigner,\n          targetDevice: ctx.deviceModelId,\n        });\n\n        return {\n          type: ClearSignContextType.SOLANA_TRANSACTION_CHECK,\n          payload: { descriptor: data.descriptor },\n          certificate,\n        };\n      },\n    });\n\n    const result = [context];\n    this.logger.debug(\"load result\", { data: { result } });\n    return result;\n  }\n}\n"],
-  "mappings": "iOAAA,OACE,iBAAAA,MAEK,kCACP,OAAS,UAAAC,EAAQ,cAAAC,MAAkB,YACnC,OAAS,SAAAC,EAAO,WAAAC,EAAS,UAAAC,EAAQ,SAAAC,EAAO,UAAAC,MAAc,YAEtD,OAAS,eAAAC,MAAmB,0BAC5B,OAAS,YAAAC,MAAgB,uCAEzB,OAAS,YAAAC,MAAgB,0CAEzB,OAAS,yBAAAC,MAA6B,kEAEtC,OAAS,yBAAAC,MAA6B,yDACtC,OAEE,wBAAAC,MACK,kCAaP,MAAMC,EAA0C,CAC9CC,EAAqB,wBACvB,EAEMC,EAAmCC,EAAM,UAAU,CACvD,cAAeC,EAAM,CACnBC,EAAQC,EAAc,MAAM,EAC5BD,EAAQC,EAAc,OAAO,EAC7BD,EAAQC,EAAc,IAAI,EAC1BD,EAAQC,EAAc,IAAI,CAC5B,CAAC,EACD,iBAAkBH,EAAM,UAAU,CAChC,KAAMI,EACN,MAAOA,EACP,MAAOC,CACT,CAAC,CACH,CAAC,EAGM,IAAMC,EAAN,KAEP,CAGE,YAEmBC,EAEAC,EAEjBC,EACA,CALiB,gCAAAF,EAEA,uBAAAC,EAIjB,KAAK,OAASC,EAAc,8BAA8B,CAC5D,CAXiB,OAajB,UACEC,EACAC,EAC6C,CAC7C,OAAKd,EAAgB,MAAOe,GAASD,EAAa,SAASC,CAAI,CAAC,EAEzDb,EAAiC,OAAOW,CAAK,EAAE,OAAO,CAC3D,KAAM,IAAM,GACZ,MAAO,CAAC,CAAE,iBAAkB,CAAE,KAAAG,EAAM,MAAAC,CAAM,CAAE,IAC1CD,EAAK,OAAS,GAAKC,EAAM,OAAS,CACtC,CAAC,EALQ,EAMX,CAEA,MAAM,KACJC,EAC6B,CAC7B,KAAM,CAAE,KAAAF,EAAM,MAAAC,EAAO,MAAAE,CAAM,EAAID,EAAI,iBA4B7BE,EAAS,CArBC,MALA,MAAM,KAAK,2BAA2B,MAAM,CAC1D,KAAMC,EAAsB,mBAC5B,KAAM,CAAE,GAAI,CAAE,KAAAL,EAAM,IAAKC,CAAM,EAAG,MAAAE,CAAM,CAC1C,CAAC,GAE6B,OAAkC,CAC9D,KAAOG,GACL,QAAQ,QAAQ,CACd,KAAMrB,EAAqB,MAC3B,MAAAqB,CACF,CAAC,EACH,MAAO,MAAOC,GAAS,CACrB,MAAMC,EAAc,MAAM,KAAK,kBAAkB,gBAAgB,CAC/D,MAAOD,EAAK,YACZ,SAAUE,EAAS,mBACnB,aAAcP,EAAI,aACpB,CAAC,EAED,MAAO,CACL,KAAMjB,EAAqB,yBAC3B,QAAS,CAAE,WAAYsB,EAAK,UAAW,EACvC,YAAAC,CACF,CACF,CACF,CAAC,CAEsB,EACvB,YAAK,OAAO,MAAM,cAAe,CAAE,KAAM,CAAE,OAAAJ,CAAO,CAAE,CAAC,EAC9CA,CACT,CACF,EAhEaX,EAANiB,EAAA,CADNC,EAAW,EAOPC,EAAA,EAAAC,EAAOC,EAAsB,0BAA0B,GAEvDF,EAAA,EAAAC,EAAOE,EAAS,oBAAoB,GAEpCH,EAAA,EAAAC,EAAOG,EAAY,0BAA0B,IAVrCvB",
-  "names": ["DeviceModelId", "inject", "injectable", "Codec", "exactly", "number", "oneOf", "string", "configTypes", "pkiTypes", "KeyUsage", "transactionCheckTypes", "TransactionCheckPaths", "ClearSignContextType", "SUPPORTED_TYPES", "ClearSignContextType", "solanaTransactionCheckInputCodec", "Codec", "oneOf", "exactly", "DeviceModelId", "string", "number", "SolanaTransactionCheckLoader", "transactionCheckDataSource", "certificateLoader", "loggerFactory", "input", "expectedType", "type", "from", "rawTx", "ctx", "chain", "result", "TransactionCheckPaths", "error", "data", "certificate", "KeyUsage", "__decorateClass", "injectable", "__decorateParam", "inject", "transactionCheckTypes", "pkiTypes", "configTypes"]
+  "sourcesContent": ["import {\n  type DeviceModelId,\n  LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\nimport { Codec, number, string } from \"purify-ts\";\n\nimport { configTypes } from \"@/config/di/configTypes\";\nimport { pkiTypes } from \"@/modules/multichain/pki/di/pkiTypes\";\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { KeyUsage } from \"@/modules/multichain/pki/model/KeyUsage\";\nimport { type TransactionCheckDataSource } from \"@/modules/multichain/transaction-check/data/TransactionCheckDataSource\";\nimport { transactionCheckTypes } from \"@/modules/multichain/transaction-check/di/transactionCheckTypes\";\nimport { type TransactionCheckLoader } from \"@/modules/multichain/transaction-check/loaders/TransactionCheckLoader\";\nimport { TransactionCheckPaths } from \"@/modules/multichain/transaction-check/utils/constants\";\nimport {\n  ClearSignContext,\n  ClearSignContextType,\n} from \"@/shared/model/ClearSignContext\";\nimport {\n  type Bs58Encoder,\n  DefaultBs58Encoder,\n} from \"@/shared/utils/bs58Encoder\";\nimport { deviceModelIdCodec } from \"@/shared/utils/deviceModelIdCodec\";\nimport { uint8ArrayCodec } from \"@/shared/utils/uint8ArrayCodec\";\n\nexport type SolanaTransactionCheckRequest = {\n  from: string;\n  transactionBytes: Uint8Array;\n  chain: number;\n};\n\nexport type SolanaTransactionCheckContextInput = {\n  deviceModelId: DeviceModelId;\n  transactionCheck: SolanaTransactionCheckRequest;\n};\n\nconst SUPPORTED_TYPES: ClearSignContextType[] = [\n  ClearSignContextType.SOLANA_TRANSACTION_CHECK,\n];\n\nconst SOLANA_SIGNATURE_LENGTH = 64;\nconst SOLANA_MAX_SIGNATURES = 64;\nconst VERSIONED_MESSAGE_PREFIX_MASK = 0x80;\nconst SHORTVEC_CONTINUATION_BIT = 0x80;\nconst SHORTVEC_DATA_MASK = 0x7f;\nconst SHORTVEC_DATA_BITS = 7;\n\nconst solanaTransactionCheckInputCodec = Codec.interface({\n  deviceModelId: deviceModelIdCodec,\n  transactionCheck: Codec.interface({\n    from: string,\n    transactionBytes: uint8ArrayCodec,\n    chain: number,\n  }),\n});\n\n@injectable()\nexport class SolanaTransactionCheckLoader\n  implements TransactionCheckLoader<SolanaTransactionCheckContextInput>\n{\n  private readonly logger: LoggerPublisherService;\n\n  constructor(\n    @inject(transactionCheckTypes.TransactionCheckDataSource)\n    private readonly transactionCheckDataSource: TransactionCheckDataSource,\n    @inject(pkiTypes.PkiCertificateLoader)\n    private readonly certificateLoader: PkiCertificateLoader,\n    @inject(configTypes.ContextModuleLoggerFactory)\n    loggerFactory: (tag: string) => LoggerPublisherService,\n    private readonly bs58Encoder: Bs58Encoder = DefaultBs58Encoder,\n  ) {\n    this.logger = loggerFactory(\"SolanaTransactionCheckLoader\");\n  }\n\n  canHandle(\n    input: unknown,\n    expectedType: ClearSignContextType[],\n  ): input is SolanaTransactionCheckContextInput {\n    if (!SUPPORTED_TYPES.every((type) => expectedType.includes(type)))\n      return false;\n    return solanaTransactionCheckInputCodec.decode(input).caseOf({\n      Left: () => false,\n      Right: ({ transactionCheck: { from, transactionBytes } }) =>\n        from.length > 0 && transactionBytes.length > 0,\n    });\n  }\n\n  async load(\n    ctx: SolanaTransactionCheckContextInput,\n  ): Promise<ClearSignContext[]> {\n    const { from, transactionBytes, chain } = ctx.transactionCheck;\n\n    let rawTx: string;\n    try {\n      rawTx = this.bs58Encoder.encode(\n        this.wrapMessageAsTransaction(transactionBytes),\n      );\n    } catch (error) {\n      const result: ClearSignContext[] = [\n        {\n          type: ClearSignContextType.ERROR,\n          error: error instanceof Error ? error : new Error(String(error)),\n        },\n      ];\n      this.logger.debug(\"load result\", { data: { result } });\n      return result;\n    }\n\n    const txCheck = await this.transactionCheckDataSource.check({\n      path: TransactionCheckPaths.SOLANA_TRANSACTION,\n      body: { tx: { from, raw: rawTx }, chain },\n    });\n\n    const context = await txCheck.caseOf<Promise<ClearSignContext>>({\n      Left: (error) =>\n        Promise.resolve({\n          type: ClearSignContextType.ERROR,\n          error,\n        }),\n      Right: async (data) => {\n        const certificate = await this.certificateLoader.loadCertificate({\n          keyId: data.publicKeyId,\n          keyUsage: KeyUsage.TxSimulationSigner,\n          targetDevice: ctx.deviceModelId,\n        });\n\n        return {\n          type: ClearSignContextType.SOLANA_TRANSACTION_CHECK,\n          payload: { descriptor: data.descriptor },\n          certificate,\n        };\n      },\n    });\n\n    const result = [context];\n    this.logger.debug(\"load result\", { data: { result } });\n    return result;\n  }\n\n  /**\n   * Wrap a serialized Solana Message into a serialized Transaction expected\n   * by the web3checks endpoint, by prepending a compact-u16 signature count\n   * and the matching number of zero-filled signature placeholders.\n   *\n   * Supports legacy and versioned messages: versioned messages start with a\n   * version prefix byte (high bit set), shifting `numRequiredSignatures` by\n   * one position.\n   */\n  private wrapMessageAsTransaction(message: Uint8Array): Uint8Array {\n    const numRequiredSignatures = this.readNumRequiredSignatures(message);\n    const sigCount = this.encodeShortVec(numRequiredSignatures);\n    const placeholdersLength = numRequiredSignatures * SOLANA_SIGNATURE_LENGTH;\n\n    const wrapped = new Uint8Array(\n      sigCount.length + placeholdersLength + message.length,\n    );\n    wrapped.set(sigCount, 0);\n    wrapped.set(message, sigCount.length + placeholdersLength);\n    return wrapped;\n  }\n\n  private readNumRequiredSignatures(message: Uint8Array): number {\n    const firstByte = message[0];\n    if (firstByte === undefined) {\n      throw new Error(\n        \"[ContextModule] SolanaTransactionCheckLoader: empty transaction bytes\",\n      );\n    }\n    const isVersioned = (firstByte & VERSIONED_MESSAGE_PREFIX_MASK) !== 0;\n    const headerOffset = isVersioned ? 1 : 0;\n    const numRequiredSignatures = message[headerOffset];\n    if (numRequiredSignatures === undefined) {\n      throw new Error(\n        \"[ContextModule] SolanaTransactionCheckLoader: malformed message header\",\n      );\n    }\n    if (numRequiredSignatures > SOLANA_MAX_SIGNATURES) {\n      throw new Error(\n        `[ContextModule] SolanaTransactionCheckLoader: numRequiredSignatures (${numRequiredSignatures}) exceeds SOLANA_MAX_SIGNATURES (${SOLANA_MAX_SIGNATURES})`,\n      );\n    }\n    return numRequiredSignatures;\n  }\n\n  private encodeShortVec(value: number): Uint8Array {\n    const bytes: number[] = [];\n    let remaining = value;\n    while (true) {\n      const lowBits = remaining & SHORTVEC_DATA_MASK;\n      remaining >>>= SHORTVEC_DATA_BITS;\n      if (remaining === 0) {\n        bytes.push(lowBits);\n        break;\n      }\n      bytes.push(lowBits | SHORTVEC_CONTINUATION_BIT);\n    }\n    return Uint8Array.from(bytes);\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["inject", "injectable", "Codec", "number", "string", "configTypes", "pkiTypes", "KeyUsage", "transactionCheckTypes", "TransactionCheckPaths", "ClearSignContextType", "DefaultBs58Encoder", "deviceModelIdCodec", "uint8ArrayCodec", "SUPPORTED_TYPES", "ClearSignContextType", "SOLANA_SIGNATURE_LENGTH", "SOLANA_MAX_SIGNATURES", "VERSIONED_MESSAGE_PREFIX_MASK", "SHORTVEC_CONTINUATION_BIT", "SHORTVEC_DATA_MASK", "SHORTVEC_DATA_BITS", "solanaTransactionCheckInputCodec", "Codec", "deviceModelIdCodec", "string", "uint8ArrayCodec", "number", "SolanaTransactionCheckLoader", "transactionCheckDataSource", "certificateLoader", "loggerFactory", "bs58Encoder", "DefaultBs58Encoder", "input", "expectedType", "type", "from", "transactionBytes", "ctx", "chain", "rawTx", "error", "result", "TransactionCheckPaths", "data", "certificate", "KeyUsage", "message", "numRequiredSignatures", "sigCount", "placeholdersLength", "wrapped", "firstByte", "headerOffset", "value", "bytes", "remaining", "lowBits", "__decorateClass", "injectable", "__decorateParam", "inject", "transactionCheckTypes", "pkiTypes", "configTypes"]
 }

package/lib/esm/src/modules/multichain/transaction-check/loaders/SolanaTransactionCheckLoader.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{DeviceModelId as o}from"@ledgerhq/device-management-kit";import d from"bs58";import{Left as A,Right as l}from"purify-ts";import{TransactionCheckPaths as p}from"../../../../modules/multichain/transaction-check/utils/constants";import{SolanaTransactionScanChainId as i}from"../../../../modules/solana/model/SolanaTransactionScanChainId";import{ClearSignContextType as n}from"../../../../shared/model/ClearSignContext";import{SolanaTransactionCheckLoader as f}from"./SolanaTransactionCheckLoader";const N={debug:vi.fn(),info:vi.fn(),warn:vi.fn(),error:vi.fn(),subscribers:[]},y=()=>N,s={loadCertificate:vi.fn()};let r,a;beforeEach(()=>{vi.resetAllMocks(),r={check:vi.fn()},a=new f(r,s,y)});describe("SolanaTransactionCheckLoader",()=>{describe("canHandle",()=>{const e={deviceModelId:o.NANO_X,transactionCheck:{from:"signer",transactionBytes:new Uint8Array([1,0,3,222]),chain:1}};it("returns true for a valid Solana transaction-check input",()=>{expect(a.canHandle(e,[n.SOLANA_TRANSACTION_CHECK])).toBe(!0)}),it("returns false when expected types do not include SOLANA_TRANSACTION_CHECK",()=>{expect(a.canHandle(e,[n.SOLANA_TOKEN])).toBe(!1)}),it("returns false when transactionBytes is not a Uint8Array",()=>{expect(a.canHandle({...e,transactionCheck:{...e.transactionCheck,transactionBytes:"0xdead"}},[n.SOLANA_TRANSACTION_CHECK])).toBe(!1)}),it("returns false when transactionBytes is empty",()=>{expect(a.canHandle({...e,transactionCheck:{...e.transactionCheck,transactionBytes:new Uint8Array}},[n.SOLANA_TRANSACTION_CHECK])).toBe(!1)}),it("returns false when from is empty",()=>{expect(a.canHandle({...e,transactionCheck:{...e.transactionCheck,from:""}},[n.SOLANA_TRANSACTION_CHECK])).toBe(!1)}),it("returns false for unsupported device models (NANO_S)",()=>{expect(a.canHandle({...e,deviceModelId:o.NANO_S},[n.SOLANA_TRANSACTION_CHECK])).toBe(!1)})}),describe("load \u2014 wire format",()=>{beforeEach(()=>{r.check.mockResolvedValue(l({publicKeyId:"pk",descriptor:"aabb"})),s.loadCertificate.mockResolvedValue({payload:new Uint8Array([204]),keyUsageNumber:14})}),it("wraps a legacy message with zero-filled signature placeholders before bs58-encoding",async()=>{const e=new Uint8Array([2,0,3,170,187,204]),t=new Uint8Array(1+264+e.length);t[0]=2,t.set(e,1+264),await a.load({deviceModelId:o.NANO_X,transactionCheck:{from:"signer",transactionBytes:e,chain:i.MAINNET}});const c=r.check.mock.calls[0][0];expect(c.path).toBe(p.SOLANA_TRANSACTION),expect(c.body.tx.from).toBe("signer"),expect(c.body.chain).toBe(i.MAINNET),expect(Array.from(d.decode(c.body.tx.raw))).toEqual(Array.from(t)),expect(c.body.tx.raw).toBe(d.encode(t))}),it("wraps a versioned (v0) message with signature placeholders",async()=>{const e=new Uint8Array([128,1,0,3,222,173]),t=new Uint8Array(1+164+e.length);t[0]=1,t.set(e,1+164),await a.load({deviceModelId:o.NANO_X,transactionCheck:{from:"signer",transactionBytes:e,chain:i.MAINNET}});const c=r.check.mock.calls[0][0].body.tx.raw;expect(Array.from(d.decode(c))).toEqual(Array.from(t))})}),describe("load \u2014 result mapping",()=>{it("returns a SOLANA_TRANSACTION_CHECK context with descriptor and certificate on success",async()=>{r.check.mockResolvedValue(l({publicKeyId:"pk-1",descriptor:"deadbeef"}));const e={payload:new Uint8Array([153]),keyUsageNumber:14};s.loadCertificate.mockResolvedValue(e);const[t]=await a.load({deviceModelId:o.NANO_X,transactionCheck:{from:"signer",transactionBytes:new Uint8Array([1,0,3,170]),chain:i.MAINNET}});expect(t).toEqual({type:n.SOLANA_TRANSACTION_CHECK,payload:{descriptor:"deadbeef"},certificate:e})}),it("returns an ERROR context when the data source returns Left",async()=>{const e=new Error("network fail");r.check.mockResolvedValue(A(e));const[t]=await a.load({deviceModelId:o.NANO_X,transactionCheck:{from:"signer",transactionBytes:new Uint8Array([1,0,3,170]),chain:i.MAINNET}});expect(t).toEqual({type:n.ERROR,error:e}),expect(s.loadCertificate).not.toHaveBeenCalled()}),it("returns an ERROR context when numRequiredSignatures exceeds the 64-signature limit",async()=>{const e=new Uint8Array([65,0,3,170]),[t]=await a.load({deviceModelId:o.NANO_X,transactionCheck:{from:"signer",transactionBytes:e,chain:i.MAINNET}});expect(t).toMatchObject({type:n.ERROR,error:expect.objectContaining({message:expect.stringContaining("exceeds SOLANA_MAX_SIGNATURES")})}),expect(r.check).not.toHaveBeenCalled()})})});
2	+ //# sourceMappingURL=SolanaTransactionCheckLoader.test.js.map

package/lib/esm/src/modules/multichain/transaction-check/loaders/SolanaTransactionCheckLoader.test.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/multichain/transaction-check/loaders/SolanaTransactionCheckLoader.test.ts"],
+  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { DeviceModelId } from \"@ledgerhq/device-management-kit\";\nimport bs58 from \"bs58\";\nimport { Left, Right } from \"purify-ts\";\n\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { type TransactionCheckDataSource } from \"@/modules/multichain/transaction-check/data/TransactionCheckDataSource\";\nimport { TransactionCheckPaths } from \"@/modules/multichain/transaction-check/utils/constants\";\nimport { SolanaTransactionScanChainId } from \"@/modules/solana/model/SolanaTransactionScanChainId\";\nimport { ClearSignContextType } from \"@/shared/model/ClearSignContext\";\n\nimport { SolanaTransactionCheckLoader } from \"./SolanaTransactionCheckLoader\";\n\nconst loggerMock = {\n  debug: vi.fn(),\n  info: vi.fn(),\n  warn: vi.fn(),\n  error: vi.fn(),\n  subscribers: [],\n};\nconst loggerFactory = () => loggerMock;\n\nconst certificateLoaderMock: PkiCertificateLoader = {\n  loadCertificate: vi.fn(),\n};\n\nlet dataSourceMock: { check: ReturnType<typeof vi.fn> };\nlet loader: SolanaTransactionCheckLoader;\n\nbeforeEach(() => {\n  vi.resetAllMocks();\n  dataSourceMock = { check: vi.fn() };\n  loader = new SolanaTransactionCheckLoader(\n    dataSourceMock as unknown as TransactionCheckDataSource,\n    certificateLoaderMock,\n    loggerFactory,\n  );\n});\n\ndescribe(\"SolanaTransactionCheckLoader\", () => {\n  describe(\"canHandle\", () => {\n    const validInput = {\n      deviceModelId: DeviceModelId.NANO_X,\n      transactionCheck: {\n        from: \"signer\",\n        transactionBytes: new Uint8Array([1, 0, 3, 0xde]),\n        chain: 1,\n      },\n    };\n\n    it(\"returns true for a valid Solana transaction-check input\", () => {\n      expect(\n        loader.canHandle(validInput, [\n          ClearSignContextType.SOLANA_TRANSACTION_CHECK,\n        ]),\n      ).toBe(true);\n    });\n\n    it(\"returns false when expected types do not include SOLANA_TRANSACTION_CHECK\", () => {\n      expect(\n        loader.canHandle(validInput, [ClearSignContextType.SOLANA_TOKEN]),\n      ).toBe(false);\n    });\n\n    it(\"returns false when transactionBytes is not a Uint8Array\", () => {\n      expect(\n        loader.canHandle(\n          {\n            ...validInput,\n            transactionCheck: {\n              ...validInput.transactionCheck,\n              transactionBytes: \"0xdead\" as unknown as Uint8Array,\n            },\n          },\n          [ClearSignContextType.SOLANA_TRANSACTION_CHECK],\n        ),\n      ).toBe(false);\n    });\n\n    it(\"returns false when transactionBytes is empty\", () => {\n      expect(\n        loader.canHandle(\n          {\n            ...validInput,\n            transactionCheck: {\n              ...validInput.transactionCheck,\n              transactionBytes: new Uint8Array(),\n            },\n          },\n          [ClearSignContextType.SOLANA_TRANSACTION_CHECK],\n        ),\n      ).toBe(false);\n    });\n\n    it(\"returns false when from is empty\", () => {\n      expect(\n        loader.canHandle(\n          {\n            ...validInput,\n            transactionCheck: { ...validInput.transactionCheck, from: \"\" },\n          },\n          [ClearSignContextType.SOLANA_TRANSACTION_CHECK],\n        ),\n      ).toBe(false);\n    });\n\n    it(\"returns false for unsupported device models (NANO_S)\", () => {\n      expect(\n        loader.canHandle(\n          { ...validInput, deviceModelId: DeviceModelId.NANO_S },\n          [ClearSignContextType.SOLANA_TRANSACTION_CHECK],\n        ),\n      ).toBe(false);\n    });\n  });\n\n  describe(\"load \u2014 wire format\", () => {\n    beforeEach(() => {\n      dataSourceMock.check.mockResolvedValue(\n        Right({ publicKeyId: \"pk\", descriptor: \"aabb\" }),\n      );\n      (certificateLoaderMock.loadCertificate as any).mockResolvedValue({\n        payload: new Uint8Array([0xcc]),\n        keyUsageNumber: 14,\n      });\n    });\n\n    it(\"wraps a legacy message with zero-filled signature placeholders before bs58-encoding\", async () => {\n      // message[0] = 2 \u2192 numRequiredSignatures = 2 (legacy, high bit clear)\n      const message = new Uint8Array([2, 0, 3, 0xaa, 0xbb, 0xcc]);\n      // expected: compact-u16(2) + 2*64 zero bytes + message\n      const expected = new Uint8Array(1 + 2 * 64 + message.length);\n      expected[0] = 2; // compact-u16 encoding of 2\n      expected.set(message, 1 + 2 * 64);\n\n      await loader.load({\n        deviceModelId: DeviceModelId.NANO_X,\n        transactionCheck: {\n          from: \"signer\",\n          transactionBytes: message,\n          chain: SolanaTransactionScanChainId.MAINNET,\n        },\n      });\n\n      const sent = dataSourceMock.check.mock.calls[0]![0];\n\n      expect(sent.path).toBe(TransactionCheckPaths.SOLANA_TRANSACTION);\n      expect(sent.body.tx.from).toBe(\"signer\");\n      expect(sent.body.chain).toBe(SolanaTransactionScanChainId.MAINNET);\n      expect(Array.from(bs58.decode(sent.body.tx.raw))).toEqual(\n        Array.from(expected),\n      );\n      expect(sent.body.tx.raw).toBe(bs58.encode(expected));\n    });\n\n    it(\"wraps a versioned (v0) message with signature placeholders\", async () => {\n      // message[0] = 0x80 \u2192 versioned prefix; message[1] = 1 \u2192 numRequiredSignatures = 1\n      const message = new Uint8Array([0x80, 1, 0, 3, 0xde, 0xad]);\n      // expected: compact-u16(1) + 1*64 zero bytes + message\n      const expected = new Uint8Array(1 + 1 * 64 + message.length);\n      expected[0] = 1; // compact-u16 encoding of 1\n      expected.set(message, 1 + 1 * 64);\n\n      await loader.load({\n        deviceModelId: DeviceModelId.NANO_X,\n        transactionCheck: {\n          from: \"signer\",\n          transactionBytes: message,\n          chain: SolanaTransactionScanChainId.MAINNET,\n        },\n      });\n\n      const raw = dataSourceMock.check.mock.calls[0]![0].body.tx.raw;\n\n      expect(Array.from(bs58.decode(raw))).toEqual(Array.from(expected));\n    });\n  });\n\n  describe(\"load \u2014 result mapping\", () => {\n    it(\"returns a SOLANA_TRANSACTION_CHECK context with descriptor and certificate on success\", async () => {\n      dataSourceMock.check.mockResolvedValue(\n        Right({ publicKeyId: \"pk-1\", descriptor: \"deadbeef\" }),\n      );\n      const cert = { payload: new Uint8Array([0x99]), keyUsageNumber: 14 };\n      (certificateLoaderMock.loadCertificate as any).mockResolvedValue(cert);\n\n      const [ctx] = await loader.load({\n        deviceModelId: DeviceModelId.NANO_X,\n        transactionCheck: {\n          from: \"signer\",\n          transactionBytes: new Uint8Array([1, 0, 3, 0xaa]),\n          chain: SolanaTransactionScanChainId.MAINNET,\n        },\n      });\n\n      expect(ctx).toEqual({\n        type: ClearSignContextType.SOLANA_TRANSACTION_CHECK,\n        payload: { descriptor: \"deadbeef\" },\n        certificate: cert,\n      });\n    });\n\n    it(\"returns an ERROR context when the data source returns Left\", async () => {\n      const error = new Error(\"network fail\");\n      dataSourceMock.check.mockResolvedValue(Left(error));\n\n      const [ctx] = await loader.load({\n        deviceModelId: DeviceModelId.NANO_X,\n        transactionCheck: {\n          from: \"signer\",\n          transactionBytes: new Uint8Array([1, 0, 3, 0xaa]),\n          chain: SolanaTransactionScanChainId.MAINNET,\n        },\n      });\n\n      expect(ctx).toEqual({ type: ClearSignContextType.ERROR, error });\n      expect(certificateLoaderMock.loadCertificate).not.toHaveBeenCalled();\n    });\n\n    it(\"returns an ERROR context when numRequiredSignatures exceeds the 64-signature limit\", async () => {\n      // message[0] = 65 \u2192 numRequiredSignatures = 65 (legacy, high bit clear), which exceeds SOLANA_MAX_SIGNATURES\n      const message = new Uint8Array([65, 0, 3, 0xaa]);\n\n      const [ctx] = await loader.load({\n        deviceModelId: DeviceModelId.NANO_X,\n        transactionCheck: {\n          from: \"signer\",\n          transactionBytes: message,\n          chain: SolanaTransactionScanChainId.MAINNET,\n        },\n      });\n\n      expect(ctx).toMatchObject({\n        type: ClearSignContextType.ERROR,\n        error: expect.objectContaining({\n          message: expect.stringContaining(\"exceeds SOLANA_MAX_SIGNATURES\"),\n        }),\n      });\n      expect(dataSourceMock.check).not.toHaveBeenCalled();\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["DeviceModelId", "bs58", "Left", "Right", "TransactionCheckPaths", "SolanaTransactionScanChainId", "ClearSignContextType", "SolanaTransactionCheckLoader", "loggerMock", "loggerFactory", "certificateLoaderMock", "dataSourceMock", "loader", "validInput", "message", "expected", "sent", "raw", "cert", "ctx", "error"]
+}

package/lib/esm/src/modules/solana/alt-resolution/data/AltResolutionDataSource.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ //# sourceMappingURL=AltResolutionDataSource.js.map

package/lib/esm/src/modules/solana/alt-resolution/data/AltResolutionDataSource.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/lib/esm/src/modules/solana/alt-resolution/data/HttpAltResolutionDataSource.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ var f=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var c=(n,o,e,i)=>{for(var r=i>1?void 0:i?d(o,e):o,s=n.length-1,t;s>=0;s--)(t=n[s])&&(r=(i?t(o,e,r):t(r))\|\|r);return i&&r&&f(o,e,r),r},u=(n,o)=>(e,i)=>o(e,i,n);import{inject as m,injectable as R}from"inversify";import{Left as a,Right as y}from"purify-ts";import{configTypes as D}from"../../../../config/di/configTypes";import{networkTypes as h}from"../../../../shared/network/di/networkTypes";import{HexStringUtils as C}from"../../../../shared/utils/HexStringUtils";import{signedDescriptorDtoCodec as k}from"../../../../shared/utils/signedDescriptorDto";import{u8Codec as $}from"../../../../shared/utils/uIntCodec";let p=class{constructor(o,e){this.config=o;this.http=e}async getAltResolution({altAddress:o,entryIndex:e,challenge:i}){const r=$.decode(e);if(r.isLeft())return a(new Error(`[ContextModule] HttpAltResolutionDataSource: invalid entryIndex (got ${e}): ${r.leftOrDefault("")}`));let s;try{s=await this.http.get(`${this.config.metadataServiceDomain.url}/v2/solana/alt-resolution/${o}/${e}`,{params:{challenge:i}})}catch(t){const l=t instanceof Error?t.message:String(t);return a(new Error(`[ContextModule] HttpAltResolutionDataSource: Failed to fetch ALT resolution: ${l}`))}return k.decode(s).caseOf({Left:t=>a(new Error(`[ContextModule] HttpAltResolutionDataSource: malformed response for (${o}, ${e}): ${t}`)),Right:t=>{let l;try{l=C.hexToBytes(t.signedDescriptor)}catch(g){return a(new Error(`[ContextModule] HttpAltResolutionDataSource: invalid hex in signedDescriptor for (${o}, ${e}): ${g.message}`))}return y({altAddress:o,entryIndex:e,descriptor:l,keyId:t.keyId,keyUsage:t.keyUsage})}})}};p=c([R(),u(0,m(D.Config)),u(1,m(h.NetworkClient))],p);export{p as HttpAltResolutionDataSource};
2	+ //# sourceMappingURL=HttpAltResolutionDataSource.js.map

package/lib/esm/src/modules/solana/alt-resolution/data/HttpAltResolutionDataSource.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/alt-resolution/data/HttpAltResolutionDataSource.ts"],
+  "sourcesContent": ["import { DmkNetworkClient } from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\nimport { Either, Left, Right } from \"purify-ts\";\n\nimport { configTypes } from \"@/config/di/configTypes\";\nimport { type ContextModuleServiceConfig } from \"@/config/model/ContextModuleConfig\";\nimport { networkTypes } from \"@/shared/network/di/networkTypes\";\nimport { HexStringUtils } from \"@/shared/utils/HexStringUtils\";\nimport { signedDescriptorDtoCodec } from \"@/shared/utils/signedDescriptorDto\";\nimport { u8Codec } from \"@/shared/utils/uIntCodec\";\n\nimport {\n  type AltResolutionDataSource,\n  type AltResolutionResult,\n  type GetAltResolutionParams,\n} from \"./AltResolutionDataSource\";\n\ntype AltResolutionResponseDto = {\n  descriptorType?: string;\n  descriptorVersion?: string;\n  alt_address?: string;\n  entry_index?: number;\n  resolved_address?: string;\n  signedDescriptor: string;\n  keyId: string;\n  keyUsage: string;\n};\n\n@injectable()\nexport class HttpAltResolutionDataSource implements AltResolutionDataSource {\n  constructor(\n    @inject(configTypes.Config)\n    private readonly config: ContextModuleServiceConfig,\n    @inject(networkTypes.NetworkClient)\n    private readonly http: DmkNetworkClient,\n  ) {}\n\n  public async getAltResolution({\n    altAddress,\n    entryIndex,\n    challenge,\n  }: GetAltResolutionParams): Promise<Either<Error, AltResolutionResult>> {\n    const entryIndexResult = u8Codec.decode(entryIndex);\n    if (entryIndexResult.isLeft()) {\n      return Left(\n        new Error(\n          `[ContextModule] HttpAltResolutionDataSource: invalid entryIndex (got ${entryIndex}): ${entryIndexResult.leftOrDefault(\"\")}`,\n        ),\n      );\n    }\n\n    let dto: AltResolutionResponseDto;\n    try {\n      dto = (await this.http.get(\n        `${this.config.metadataServiceDomain.url}/v2/solana/alt-resolution/${altAddress}/${entryIndex}`,\n        { params: { challenge } },\n      )) as AltResolutionResponseDto;\n    } catch (error) {\n      const reason = error instanceof Error ? error.message : String(error);\n      return Left(\n        new Error(\n          `[ContextModule] HttpAltResolutionDataSource: Failed to fetch ALT resolution: ${reason}`,\n        ),\n      );\n    }\n\n    return signedDescriptorDtoCodec\n      .decode(dto)\n      .caseOf<Either<Error, AltResolutionResult>>({\n        Left: (error) =>\n          Left(\n            new Error(\n              `[ContextModule] HttpAltResolutionDataSource: malformed response for (${altAddress}, ${entryIndex}): ${error}`,\n            ),\n          ),\n        Right: (validated) => {\n          let descriptor: Uint8Array;\n          try {\n            descriptor = HexStringUtils.hexToBytes(validated.signedDescriptor);\n          } catch (error) {\n            return Left(\n              new Error(\n                `[ContextModule] HttpAltResolutionDataSource: invalid hex in signedDescriptor for (${altAddress}, ${entryIndex}): ${(error as Error).message}`,\n              ),\n            );\n          }\n\n          return Right({\n            altAddress,\n            entryIndex,\n            descriptor,\n            keyId: validated.keyId,\n            keyUsage: validated.keyUsage,\n          });\n        },\n      });\n  }\n}\n"],
+  "mappings": "iOACA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YACnC,OAAiB,QAAAC,EAAM,SAAAC,MAAa,YAEpC,OAAS,eAAAC,MAAmB,0BAE5B,OAAS,gBAAAC,MAAoB,mCAC7B,OAAS,kBAAAC,MAAsB,gCAC/B,OAAS,4BAAAC,MAAgC,qCACzC,OAAS,WAAAC,MAAe,2BAoBjB,IAAMC,EAAN,KAAqE,CAC1E,YAEmBC,EAEAC,EACjB,CAHiB,YAAAD,EAEA,UAAAC,CAChB,CAEH,MAAa,iBAAiB,CAC5B,WAAAC,EACA,WAAAC,EACA,UAAAC,CACF,EAAwE,CACtE,MAAMC,EAAmBC,EAAQ,OAAOH,CAAU,EAClD,GAAIE,EAAiB,OAAO,EAC1B,OAAOE,EACL,IAAI,MACF,wEAAwEJ,CAAU,MAAME,EAAiB,cAAc,EAAE,CAAC,EAC5H,CACF,EAGF,IAAIG,EACJ,GAAI,CACFA,EAAO,MAAM,KAAK,KAAK,IACrB,GAAG,KAAK,OAAO,sBAAsB,GAAG,6BAA6BN,CAAU,IAAIC,CAAU,GAC7F,CAAE,OAAQ,CAAE,UAAAC,CAAU,CAAE,CAC1B,CACF,OAASK,EAAO,CACd,MAAMC,EAASD,aAAiB,MAAQA,EAAM,QAAU,OAAOA,CAAK,EACpE,OAAOF,EACL,IAAI,MACF,gFAAgFG,CAAM,EACxF,CACF,CACF,CAEA,OAAOC,EACJ,OAAOH,CAAG,EACV,OAA2C,CAC1C,KAAOC,GACLF,EACE,IAAI,MACF,wEAAwEL,CAAU,KAAKC,CAAU,MAAMM,CAAK,EAC9G,CACF,EACF,MAAQG,GAAc,CACpB,IAAIC,EACJ,GAAI,CACFA,EAAaC,EAAe,WAAWF,EAAU,gBAAgB,CACnE,OAASH,EAAO,CACd,OAAOF,EACL,IAAI,MACF,qFAAqFL,CAAU,KAAKC,CAAU,MAAOM,EAAgB,OAAO,EAC9I,CACF,CACF,CAEA,OAAOM,EAAM,CACX,WAAAb,EACA,WAAAC,EACA,WAAAU,EACA,MAAOD,EAAU,MACjB,SAAUA,EAAU,QACtB,CAAC,CACH,CACF,CAAC,CACL,CACF,EApEab,EAANiB,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAY,MAAM,GAEzBF,EAAA,EAAAC,EAAOE,EAAa,aAAa,IAJzBtB",
+  "names": ["inject", "injectable", "Left", "Right", "configTypes", "networkTypes", "HexStringUtils", "signedDescriptorDtoCodec", "u8Codec", "HttpAltResolutionDataSource", "config", "http", "altAddress", "entryIndex", "challenge", "entryIndexResult", "u8Codec", "Left", "dto", "error", "reason", "signedDescriptorDtoCodec", "validated", "descriptor", "HexStringUtils", "Right", "__decorateClass", "injectable", "__decorateParam", "inject", "configTypes", "networkTypes"]
+}

package/lib/esm/src/modules/solana/alt-resolution/data/HttpAltResolutionDataSource.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{Left as l,Right as i}from"purify-ts";import{HttpAltResolutionDataSource as c}from"./HttpAltResolutionDataSource";describe("HttpAltResolutionDataSource",()=>{let n,o;const e="AltAddress1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",r="cafebabe",s={metadataServiceDomain:{url:"https://nft.api.ledger.com"}};beforeEach(()=>{vi.clearAllMocks(),o={get:vi.fn()},n=new c(s,o)}),it("calls the metadata endpoint with the right path and challenge",async()=>{o.get.mockResolvedValue({signedDescriptor:"01020304",keyId:"alt_key",keyUsage:"coin_meta"}),await n.getAltResolution({altAddress:e,entryIndex:3,challenge:r}),expect(o.get).toHaveBeenCalledWith(`https://nft.api.ledger.com/v2/solana/alt-resolution/${e}/3`,{params:{challenge:r}})}),it("decodes signedDescriptor hex into Uint8Array",async()=>{o.get.mockResolvedValue({signedDescriptor:"abcd",keyId:"k",keyUsage:"u"});const t=await n.getAltResolution({altAddress:e,entryIndex:3,challenge:r});expect(t).toEqual(i({altAddress:e,entryIndex:3,descriptor:new Uint8Array([171,205]),keyId:"k",keyUsage:"u"}))}),it.each([-1,256,1.5,Number.NaN])("rejects entryIndex out of u8 range: %s",async t=>{const a=await n.getAltResolution({altAddress:e,entryIndex:t,challenge:r});expect(a.isLeft()).toBe(!0),expect(a.extract().message).toMatch(/entryIndex/)}),it("returns Left on malformed response",async()=>{o.get.mockResolvedValue({keyId:"k"});const t=await n.getAltResolution({altAddress:e,entryIndex:3,challenge:r});expect(t.isLeft()).toBe(!0),expect(t.extract().message).toMatch(new RegExp(String.raw`\[ContextModule\] HttpAltResolutionDataSource: malformed response for $${e}, ${3}$:`))}),it("returns Left when HTTP client throws",async()=>{o.get.mockRejectedValue(new Error("net"));const t=await n.getAltResolution({altAddress:e,entryIndex:3,challenge:r});expect(t).toEqual(l(new Error("[ContextModule] HttpAltResolutionDataSource: Failed to fetch ALT resolution: net")))})});
2	+ //# sourceMappingURL=HttpAltResolutionDataSource.test.js.map

package/lib/esm/src/modules/solana/alt-resolution/data/HttpAltResolutionDataSource.test.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/alt-resolution/data/HttpAltResolutionDataSource.test.ts"],
+  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { type DmkNetworkClient } from \"@ledgerhq/device-management-kit\";\nimport { Left, Right } from \"purify-ts\";\n\nimport { type ContextModuleServiceConfig } from \"@/config/model/ContextModuleConfig\";\n\nimport { type AltResolutionDataSource } from \"./AltResolutionDataSource\";\nimport { HttpAltResolutionDataSource } from \"./HttpAltResolutionDataSource\";\n\ndescribe(\"HttpAltResolutionDataSource\", () => {\n  let datasource: AltResolutionDataSource;\n  let httpMock: { get: ReturnType<typeof vi.fn> };\n  const altAddress = \"AltAddress1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\";\n  const entryIndex = 3;\n  const challenge = \"cafebabe\";\n  const config: ContextModuleServiceConfig = {\n    metadataServiceDomain: { url: \"https://nft.api.ledger.com\" },\n  } as ContextModuleServiceConfig;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n    httpMock = { get: vi.fn() };\n    datasource = new HttpAltResolutionDataSource(\n      config,\n      httpMock as unknown as DmkNetworkClient,\n    );\n  });\n\n  it(\"calls the metadata endpoint with the right path and challenge\", async () => {\n    httpMock.get.mockResolvedValue({\n      signedDescriptor: \"01020304\",\n      keyId: \"alt_key\",\n      keyUsage: \"coin_meta\",\n    });\n\n    await datasource.getAltResolution({ altAddress, entryIndex, challenge });\n\n    expect(httpMock.get).toHaveBeenCalledWith(\n      `https://nft.api.ledger.com/v2/solana/alt-resolution/${altAddress}/${entryIndex}`,\n      { params: { challenge } },\n    );\n  });\n\n  it(\"decodes signedDescriptor hex into Uint8Array\", async () => {\n    httpMock.get.mockResolvedValue({\n      signedDescriptor: \"abcd\",\n      keyId: \"k\",\n      keyUsage: \"u\",\n    });\n\n    const result = await datasource.getAltResolution({\n      altAddress,\n      entryIndex,\n      challenge,\n    });\n\n    expect(result).toEqual(\n      Right({\n        altAddress,\n        entryIndex,\n        descriptor: new Uint8Array([0xab, 0xcd]),\n        keyId: \"k\",\n        keyUsage: \"u\",\n      }),\n    );\n  });\n\n  it.each([-1, 256, 1.5, Number.NaN])(\n    \"rejects entryIndex out of u8 range: %s\",\n    async (badIndex) => {\n      const result = await datasource.getAltResolution({\n        altAddress,\n        entryIndex: badIndex,\n        challenge,\n      });\n      expect(result.isLeft()).toBe(true);\n      expect((result.extract() as Error).message).toMatch(/entryIndex/);\n    },\n  );\n\n  it(\"returns Left on malformed response\", async () => {\n    httpMock.get.mockResolvedValue({ keyId: \"k\" } as any);\n\n    const result = await datasource.getAltResolution({\n      altAddress,\n      entryIndex,\n      challenge,\n    });\n\n    expect(result.isLeft()).toBe(true);\n    expect((result.extract() as Error).message).toMatch(\n      new RegExp(\n        String.raw`\\[ContextModule\\] HttpAltResolutionDataSource: malformed response for \\(${altAddress}, ${entryIndex}\\):`,\n      ),\n    );\n  });\n\n  it(\"returns Left when HTTP client throws\", async () => {\n    httpMock.get.mockRejectedValue(new Error(\"net\"));\n\n    const result = await datasource.getAltResolution({\n      altAddress,\n      entryIndex,\n      challenge,\n    });\n\n    expect(result).toEqual(\n      Left(\n        new Error(\n          \"[ContextModule] HttpAltResolutionDataSource: Failed to fetch ALT resolution: net\",\n        ),\n      ),\n    );\n  });\n});\n"],
+  "mappings": "AAEA,OAAS,QAAAA,EAAM,SAAAC,MAAa,YAK5B,OAAS,+BAAAC,MAAmC,gCAE5C,SAAS,8BAA+B,IAAM,CAC5C,IAAIC,EACAC,EACJ,MAAMC,EAAa,8CAEbC,EAAY,WACZC,EAAqC,CACzC,sBAAuB,CAAE,IAAK,4BAA6B,CAC7D,EAEA,WAAW,IAAM,CACf,GAAG,cAAc,EACjBH,EAAW,CAAE,IAAK,GAAG,GAAG,CAAE,EAC1BD,EAAa,IAAID,EACfK,EACAH,CACF,CACF,CAAC,EAED,GAAG,gEAAiE,SAAY,CAC9EA,EAAS,IAAI,kBAAkB,CAC7B,iBAAkB,WAClB,MAAO,UACP,SAAU,WACZ,CAAC,EAED,MAAMD,EAAW,iBAAiB,CAAE,WAAAE,EAAY,aAAY,UAAAC,CAAU,CAAC,EAEvE,OAAOF,EAAS,GAAG,EAAE,qBACnB,uDAAuDC,CAAU,KACjE,CAAE,OAAQ,CAAE,UAAAC,CAAU,CAAE,CAC1B,CACF,CAAC,EAED,GAAG,+CAAgD,SAAY,CAC7DF,EAAS,IAAI,kBAAkB,CAC7B,iBAAkB,OAClB,MAAO,IACP,SAAU,GACZ,CAAC,EAED,MAAMI,EAAS,MAAML,EAAW,iBAAiB,CAC/C,WAAAE,EACA,aACA,UAAAC,CACF,CAAC,EAED,OAAOE,CAAM,EAAE,QACbP,EAAM,CACJ,WAAAI,EACA,aACA,WAAY,IAAI,WAAW,CAAC,IAAM,GAAI,CAAC,EACvC,MAAO,IACP,SAAU,GACZ,CAAC,CACH,CACF,CAAC,EAED,GAAG,KAAK,CAAC,GAAI,IAAK,IAAK,OAAO,GAAG,CAAC,EAChC,yCACA,MAAOI,GAAa,CAClB,MAAMD,EAAS,MAAML,EAAW,iBAAiB,CAC/C,WAAAE,EACA,WAAYI,EACZ,UAAAH,CACF,CAAC,EACD,OAAOE,EAAO,OAAO,CAAC,EAAE,KAAK,EAAI,EACjC,OAAQA,EAAO,QAAQ,EAAY,OAAO,EAAE,QAAQ,YAAY,CAClE,CACF,EAEA,GAAG,qCAAsC,SAAY,CACnDJ,EAAS,IAAI,kBAAkB,CAAE,MAAO,GAAI,CAAQ,EAEpD,MAAMI,EAAS,MAAML,EAAW,iBAAiB,CAC/C,WAAAE,EACA,aACA,UAAAC,CACF,CAAC,EAED,OAAOE,EAAO,OAAO,CAAC,EAAE,KAAK,EAAI,EACjC,OAAQA,EAAO,QAAQ,EAAY,OAAO,EAAE,QAC1C,IAAI,OACF,OAAO,8EAA8EH,CAAU,KAAK,CAAU,KAChH,CACF,CACF,CAAC,EAED,GAAG,uCAAwC,SAAY,CACrDD,EAAS,IAAI,kBAAkB,IAAI,MAAM,KAAK,CAAC,EAE/C,MAAMI,EAAS,MAAML,EAAW,iBAAiB,CAC/C,WAAAE,EACA,aACA,UAAAC,CACF,CAAC,EAED,OAAOE,CAAM,EAAE,QACbR,EACE,IAAI,MACF,kFACF,CACF,CACF,CACF,CAAC,CACH,CAAC",
+  "names": ["Left", "Right", "HttpAltResolutionDataSource", "datasource", "httpMock", "altAddress", "challenge", "config", "result", "badIndex"]
+}

package/lib/esm/src/modules/solana/alt-resolution/di/altResolutionModuleFactory.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{ContainerModule as e}from"inversify";import{HttpAltResolutionDataSource as r}from"../../../../modules/solana/alt-resolution/data/HttpAltResolutionDataSource";import{altResolutionTypes as t}from"../../../../modules/solana/alt-resolution/di/altResolutionTypes";import{AltResolutionContextLoader as l}from"../../../../modules/solana/alt-resolution/domain/AltResolutionContextLoader";const m=()=>new e(({bind:o})=>{o(t.AltResolutionDataSource).to(r),o(t.AltResolutionContextLoader).to(l)});export{m as altResolutionModuleFactory};
2	+ //# sourceMappingURL=altResolutionModuleFactory.js.map

package/lib/esm/src/modules/solana/alt-resolution/di/altResolutionModuleFactory.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/alt-resolution/di/altResolutionModuleFactory.ts"],
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { HttpAltResolutionDataSource } from \"@/modules/solana/alt-resolution/data/HttpAltResolutionDataSource\";\nimport { altResolutionTypes } from \"@/modules/solana/alt-resolution/di/altResolutionTypes\";\nimport { AltResolutionContextLoader } from \"@/modules/solana/alt-resolution/domain/AltResolutionContextLoader\";\n\nexport const altResolutionModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(altResolutionTypes.AltResolutionDataSource).to(\n      HttpAltResolutionDataSource,\n    );\n    bind(altResolutionTypes.AltResolutionContextLoader).to(\n      AltResolutionContextLoader,\n    );\n  });\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,+BAAAC,MAAmC,mEAC5C,OAAS,sBAAAC,MAA0B,wDACnC,OAAS,8BAAAC,MAAkC,oEAEpC,MAAMC,EAA6B,IACxC,IAAIJ,EAAgB,CAAC,CAAE,KAAAK,CAAK,IAAM,CAChCA,EAAKH,EAAmB,uBAAuB,EAAE,GAC/CD,CACF,EACAI,EAAKH,EAAmB,0BAA0B,EAAE,GAClDC,CACF,CACF,CAAC",
+  "names": ["ContainerModule", "HttpAltResolutionDataSource", "altResolutionTypes", "AltResolutionContextLoader", "altResolutionModuleFactory", "bind"]
+}

package/lib/esm/src/modules/solana/alt-resolution/di/altResolutionTypes.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ const o={AltResolutionDataSource:Symbol.for("AltResolutionDataSource"),AltResolutionContextLoader:Symbol.for("AltResolutionContextLoader")};export{o as altResolutionTypes};
2	+ //# sourceMappingURL=altResolutionTypes.js.map

package/lib/esm/src/modules/solana/alt-resolution/di/altResolutionTypes.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/alt-resolution/di/altResolutionTypes.ts"],
+  "sourcesContent": ["export const altResolutionTypes = {\n  AltResolutionDataSource: Symbol.for(\"AltResolutionDataSource\"),\n  AltResolutionContextLoader: Symbol.for(\"AltResolutionContextLoader\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAqB,CAChC,wBAAyB,OAAO,IAAI,yBAAyB,EAC7D,2BAA4B,OAAO,IAAI,4BAA4B,CACrE",
+  "names": ["altResolutionTypes"]
+}

package/lib/esm/src/modules/solana/alt-resolution/domain/AltResolutionContextLoader.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ var m=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var c=(l,o,e,t)=>{for(var r=t>1?void 0:t?y(o,e):o,a=l.length-1,s;a>=0;a--)(s=l[a])&&(r=(t?s(o,e,r):s(r))\|\|r);return t&&r&&m(o,e,r),r},n=(l,o)=>(e,t)=>o(e,t,l);import{inject as d,injectable as f}from"inversify";import{array as S,Codec as u,string as p}from"purify-ts";import{configTypes as C}from"../../../../config/di/configTypes";import{pkiTypes as A}from"../../../../modules/multichain/pki/di/pkiTypes";import{altResolutionTypes as R}from"../../../../modules/solana/alt-resolution/di/altResolutionTypes";import{ClearSignContextType as g}from"../../../../shared/model/ClearSignContext";import{loadChallengeBoundContexts as x}from"../../../../shared/utils/challengeBoundLoader";import{deviceModelIdCodec as I}from"../../../../shared/utils/deviceModelIdCodec";import{u8Codec as L}from"../../../../shared/utils/uIntCodec";const h=[g.SOLANA_ALT_RESOLUTION],v=u.interface({altAddress:p,entryIndex:L,challenge:p}),T=u.interface({deviceModelId:I,requests:S(v)});let i=class{constructor(o,e,t){this.dataSource=o;this.certificateLoader=e;this.logger=t("AltResolutionContextLoader")}logger;canHandle(o,e){return h.every(t=>e.includes(t))?T.decode(o).caseOf({Left:()=>!1,Right:({requests:t})=>t.length>0&&t.every(r=>r.altAddress.length>0&&r.challenge.length>0)}):!1}async load(o){return x({requests:o.requests,deviceModelId:o.deviceModelId,certificateLoader:this.certificateLoader,logger:this.logger,label:"ALT_RESOLUTION",fetch:e=>this.dataSource.getAltResolution(e),toContext:(e,t)=>{const r={descriptor:e.descriptor};return{type:g.SOLANA_ALT_RESOLUTION,payload:r,certificate:t}},describe:e=>({altAddress:e.altAddress,entryIndex:e.entryIndex})})}};i=c([f(),n(0,d(R.AltResolutionDataSource)),n(1,d(A.PkiCertificateLoader)),n(2,d(C.ContextModuleLoggerFactory))],i);export{i as AltResolutionContextLoader};
2	+ //# sourceMappingURL=AltResolutionContextLoader.js.map

package/lib/esm/src/modules/solana/alt-resolution/domain/AltResolutionContextLoader.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/alt-resolution/domain/AltResolutionContextLoader.ts"],
+  "sourcesContent": ["import {\n  type DeviceModelId,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\nimport { array, Codec, string } from \"purify-ts\";\n\nimport { configTypes } from \"@/config/di/configTypes\";\nimport { pkiTypes } from \"@/modules/multichain/pki/di/pkiTypes\";\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { type AltResolutionDataSource } from \"@/modules/solana/alt-resolution/data/AltResolutionDataSource\";\nimport { altResolutionTypes } from \"@/modules/solana/alt-resolution/di/altResolutionTypes\";\nimport { type SolanaAltResolutionPayload } from \"@/modules/solana/model/SolanaPayloads\";\nimport { type ContextLoader } from \"@/shared/domain/ContextLoader\";\nimport {\n  type ClearSignContext,\n  ClearSignContextType,\n} from \"@/shared/model/ClearSignContext\";\nimport { loadChallengeBoundContexts } from \"@/shared/utils/challengeBoundLoader\";\nimport { deviceModelIdCodec } from \"@/shared/utils/deviceModelIdCodec\";\nimport { u8Codec } from \"@/shared/utils/uIntCodec\";\n\nconst SUPPORTED_TYPES: ClearSignContextType[] = [\n  ClearSignContextType.SOLANA_ALT_RESOLUTION,\n];\n\nexport type SolanaAltResolutionRequest = {\n  altAddress: string;\n  entryIndex: number;\n  challenge: string;\n};\n\nexport type SolanaAltResolutionContextInput = {\n  deviceModelId: DeviceModelId;\n  requests: SolanaAltResolutionRequest[];\n};\n\nconst altResolutionRequestCodec = Codec.interface({\n  altAddress: string,\n  entryIndex: u8Codec,\n  challenge: string,\n});\n\nconst solanaAltResolutionInputCodec = Codec.interface({\n  deviceModelId: deviceModelIdCodec,\n  requests: array(altResolutionRequestCodec),\n});\n\n@injectable()\nexport class AltResolutionContextLoader\n  implements ContextLoader<SolanaAltResolutionContextInput>\n{\n  private readonly logger: LoggerPublisherService;\n\n  constructor(\n    @inject(altResolutionTypes.AltResolutionDataSource)\n    private readonly dataSource: AltResolutionDataSource,\n    @inject(pkiTypes.PkiCertificateLoader)\n    private readonly certificateLoader: PkiCertificateLoader,\n    @inject(configTypes.ContextModuleLoggerFactory)\n    loggerFactory: (tag: string) => LoggerPublisherService,\n  ) {\n    this.logger = loggerFactory(\"AltResolutionContextLoader\");\n  }\n\n  public canHandle(\n    input: unknown,\n    expectedTypes: ClearSignContextType[],\n  ): input is SolanaAltResolutionContextInput {\n    if (!SUPPORTED_TYPES.every((t) => expectedTypes.includes(t))) return false;\n    return solanaAltResolutionInputCodec.decode(input).caseOf({\n      Left: () => false,\n      Right: ({ requests }) =>\n        requests.length > 0 &&\n        requests.every(\n          (r) => r.altAddress.length > 0 && r.challenge.length > 0,\n        ),\n    });\n  }\n\n  public async load(\n    input: SolanaAltResolutionContextInput,\n  ): Promise<ClearSignContext[]> {\n    return loadChallengeBoundContexts({\n      requests: input.requests,\n      deviceModelId: input.deviceModelId,\n      certificateLoader: this.certificateLoader,\n      logger: this.logger,\n      label: \"ALT_RESOLUTION\",\n      fetch: (request) => this.dataSource.getAltResolution(request),\n      toContext: (value, certificate) => {\n        const payload: SolanaAltResolutionPayload = {\n          descriptor: value.descriptor,\n        };\n        return {\n          type: ClearSignContextType.SOLANA_ALT_RESOLUTION,\n          payload,\n          certificate,\n        };\n      },\n      describe: (request) => ({\n        altAddress: request.altAddress,\n        entryIndex: request.entryIndex,\n      }),\n    });\n  }\n}\n"],
+  "mappings": "iOAIA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YACnC,OAAS,SAAAC,EAAO,SAAAC,EAAO,UAAAC,MAAc,YAErC,OAAS,eAAAC,MAAmB,0BAC5B,OAAS,YAAAC,MAAgB,uCAGzB,OAAS,sBAAAC,MAA0B,wDAGnC,OAEE,wBAAAC,MACK,kCACP,OAAS,8BAAAC,MAAkC,sCAC3C,OAAS,sBAAAC,MAA0B,oCACnC,OAAS,WAAAC,MAAe,2BAExB,MAAMC,EAA0C,CAC9CC,EAAqB,qBACvB,EAaMC,EAA4BC,EAAM,UAAU,CAChD,WAAYC,EACZ,WAAYC,EACZ,UAAWD,CACb,CAAC,EAEKE,EAAgCH,EAAM,UAAU,CACpD,cAAeI,EACf,SAAUC,EAAMN,CAAyB,CAC3C,CAAC,EAGM,IAAMO,EAAN,KAEP,CAGE,YAEmBC,EAEAC,EAEjBC,EACA,CALiB,gBAAAF,EAEA,uBAAAC,EAIjB,KAAK,OAASC,EAAc,4BAA4B,CAC1D,CAXiB,OAaV,UACLC,EACAC,EAC0C,CAC1C,OAAKd,EAAgB,MAAO,GAAMc,EAAc,SAAS,CAAC,CAAC,EACpDR,EAA8B,OAAOO,CAAK,EAAE,OAAO,CACxD,KAAM,IAAM,GACZ,MAAO,CAAC,CAAE,SAAAE,CAAS,IACjBA,EAAS,OAAS,GAClBA,EAAS,MACN,GAAM,EAAE,WAAW,OAAS,GAAK,EAAE,UAAU,OAAS,CACzD,CACJ,CAAC,EARoE,EASvE,CAEA,MAAa,KACXF,EAC6B,CAC7B,OAAOG,EAA2B,CAChC,SAAUH,EAAM,SAChB,cAAeA,EAAM,cACrB,kBAAmB,KAAK,kBACxB,OAAQ,KAAK,OACb,MAAO,iBACP,MAAQI,GAAY,KAAK,WAAW,iBAAiBA,CAAO,EAC5D,UAAW,CAACC,EAAOC,IAAgB,CACjC,MAAMC,EAAsC,CAC1C,WAAYF,EAAM,UACpB,EACA,MAAO,CACL,KAAMjB,EAAqB,sBAC3B,QAAAmB,EACA,YAAAD,CACF,CACF,EACA,SAAWF,IAAa,CACtB,WAAYA,EAAQ,WACpB,WAAYA,EAAQ,UACtB,EACF,CAAC,CACH,CACF,EAzDaR,EAANY,EAAA,CADNC,EAAW,EAOPC,EAAA,EAAAC,EAAOC,EAAmB,uBAAuB,GAEjDF,EAAA,EAAAC,EAAOE,EAAS,oBAAoB,GAEpCH,EAAA,EAAAC,EAAOG,EAAY,0BAA0B,IAVrClB",
+  "names": ["inject", "injectable", "array", "Codec", "string", "configTypes", "pkiTypes", "altResolutionTypes", "ClearSignContextType", "loadChallengeBoundContexts", "deviceModelIdCodec", "u8Codec", "SUPPORTED_TYPES", "ClearSignContextType", "altResolutionRequestCodec", "Codec", "string", "u8Codec", "solanaAltResolutionInputCodec", "deviceModelIdCodec", "array", "AltResolutionContextLoader", "dataSource", "certificateLoader", "loggerFactory", "input", "expectedTypes", "requests", "loadChallengeBoundContexts", "request", "value", "certificate", "payload", "__decorateClass", "injectable", "__decorateParam", "inject", "altResolutionTypes", "pkiTypes", "configTypes"]
+}

package/lib/esm/src/modules/solana/alt-resolution/domain/AltResolutionContextLoader.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{DeviceModelId as o}from"@ledgerhq/device-management-kit";import{Left as y,Right as l}from"purify-ts";import{ClearSignContextType as r}from"../../../../shared/model/ClearSignContext";import{AltResolutionContextLoader as p}from"./AltResolutionContextLoader";const u=()=>({debug:vi.fn(),info:vi.fn(),warn:vi.fn(),error:vi.fn(),subscribers:[]}),A={keyUsageNumber:8,payload:new Uint8Array([1])},a="AltA1111111111111111111111111111111111111111",d="AltB2222222222222222222222222222222222222222";describe("AltResolutionContextLoader",()=>{let s,c;beforeEach(()=>{vi.restoreAllMocks(),s={getAltResolution:vi.fn()},c={loadCertificate:vi.fn().mockResolvedValue(A)}});const n=()=>new p(s,c,u);describe("canHandle",()=>{it("returns true when SOLANA_ALT_RESOLUTION is requested with valid requests",()=>{expect(n().canHandle({deviceModelId:o.NANO_X,requests:[{altAddress:a,entryIndex:0,challenge:"c"}]},[r.SOLANA_ALT_RESOLUTION])).toBe(!0)}),it("returns false when SOLANA_ALT_RESOLUTION is not requested",()=>{expect(n().canHandle({deviceModelId:o.NANO_X,requests:[{altAddress:a,entryIndex:0,challenge:"c"}]},[r.SOLANA_TOKEN])).toBe(!1)}),it("rejects out-of-range entryIndex",()=>{const e=n(),t=[r.SOLANA_ALT_RESOLUTION];expect(e.canHandle({requests:[{altAddress:a,entryIndex:-1,challenge:"c"}]},t)).toBe(!1),expect(e.canHandle({requests:[{altAddress:a,entryIndex:256,challenge:"c"}]},t)).toBe(!1),expect(e.canHandle({requests:[{altAddress:a,entryIndex:1.5,challenge:"c"}]},t)).toBe(!1)})}),describe("load",()=>{it("emits one SOLANA_ALT_RESOLUTION per request",async()=>{vi.spyOn(s,"getAltResolution").mockImplementation(async({altAddress:t,entryIndex:i})=>l({altAddress:t,entryIndex:i,descriptor:new Uint8Array([i]),keyId:"alt_key",keyUsage:"coin_meta"}));const e=await n().load({deviceModelId:o.NANO_X,requests:[{altAddress:a,entryIndex:1,challenge:"c1"},{altAddress:d,entryIndex:7,challenge:"c2"}]});expect(e).toHaveLength(2),expect(e[0]).toMatchObject({type:r.SOLANA_ALT_RESOLUTION,payload:{descriptor:new Uint8Array([1])},certificate:A}),expect(e[1]).toMatchObject({type:r.SOLANA_ALT_RESOLUTION,payload:{descriptor:new Uint8Array([7])}})}),it("dedups certificate loads across requests sharing the same (keyId, keyUsage)",async()=>{vi.spyOn(s,"getAltResolution").mockImplementation(async({altAddress:e,entryIndex:t})=>l({altAddress:e,entryIndex:t,descriptor:new Uint8Array([t]),keyId:"alt_key",keyUsage:"coin_meta"})),await n().load({deviceModelId:o.NANO_X,requests:[{altAddress:a,entryIndex:0,challenge:"c1"},{altAddress:a,entryIndex:1,challenge:"c2"},{altAddress:d,entryIndex:2,challenge:"c3"}]}),expect(c.loadCertificate).toHaveBeenCalledTimes(1)}),it("issues distinct cert loads when (keyId, keyUsage) differ",async()=>{vi.spyOn(s,"getAltResolution").mockImplementation(async({altAddress:e,entryIndex:t})=>l({altAddress:e,entryIndex:t,descriptor:new Uint8Array([t]),keyId:e===a?"alt_key_a":"alt_key_b",keyUsage:"coin_meta"})),await n().load({deviceModelId:o.NANO_X,requests:[{altAddress:a,entryIndex:0,challenge:"c1"},{altAddress:d,entryIndex:1,challenge:"c2"}]}),expect(c.loadCertificate).toHaveBeenCalledTimes(2)}),it("emits an ERROR per failing request and keeps the others",async()=>{vi.spyOn(s,"getAltResolution").mockImplementation(async({altAddress:t})=>t===a?l({altAddress:t,entryIndex:0,descriptor:new Uint8Array([170]),keyId:"k",keyUsage:"u"}):y(new Error("upstream-500")));const e=await n().load({deviceModelId:o.NANO_X,requests:[{altAddress:a,entryIndex:0,challenge:"c1"},{altAddress:d,entryIndex:1,challenge:"c2"}]});expect(e[0]?.type).toBe(r.SOLANA_ALT_RESOLUTION),expect(e[1]?.type).toBe(r.ERROR)})})});
2	+ //# sourceMappingURL=AltResolutionContextLoader.test.js.map

package/lib/esm/src/modules/solana/alt-resolution/domain/AltResolutionContextLoader.test.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/alt-resolution/domain/AltResolutionContextLoader.test.ts"],
+  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { DeviceModelId } from \"@ledgerhq/device-management-kit\";\nimport { Left, Right } from \"purify-ts\";\n\nimport { type PkiCertificateLoader } from \"@/modules/multichain/pki/domain/PkiCertificateLoader\";\nimport { type AltResolutionDataSource } from \"@/modules/solana/alt-resolution/data/AltResolutionDataSource\";\nimport { ClearSignContextType } from \"@/shared/model/ClearSignContext\";\n\nimport { AltResolutionContextLoader } from \"./AltResolutionContextLoader\";\n\nconst mockLoggerFactory = () => ({\n  debug: vi.fn(),\n  info: vi.fn(),\n  warn: vi.fn(),\n  error: vi.fn(),\n  subscribers: [],\n});\n\nconst mockCertificate = { keyUsageNumber: 8, payload: new Uint8Array([1]) };\nconst ALT_A = \"AltA1111111111111111111111111111111111111111\";\nconst ALT_B = \"AltB2222222222222222222222222222222222222222\";\n\ndescribe(\"AltResolutionContextLoader\", () => {\n  let dataSource: AltResolutionDataSource;\n  let certificateLoader: PkiCertificateLoader;\n\n  beforeEach(() => {\n    vi.restoreAllMocks();\n    dataSource = {\n      getAltResolution: vi.fn(),\n    };\n    certificateLoader = {\n      loadCertificate: vi.fn().mockResolvedValue(mockCertificate),\n    };\n  });\n\n  const makeLoader = () =>\n    new AltResolutionContextLoader(\n      dataSource,\n      certificateLoader,\n      mockLoggerFactory,\n    );\n\n  describe(\"canHandle\", () => {\n    it(\"returns true when SOLANA_ALT_RESOLUTION is requested with valid requests\", () => {\n      expect(\n        makeLoader().canHandle(\n          {\n            deviceModelId: DeviceModelId.NANO_X,\n            requests: [{ altAddress: ALT_A, entryIndex: 0, challenge: \"c\" }],\n          },\n          [ClearSignContextType.SOLANA_ALT_RESOLUTION],\n        ),\n      ).toBe(true);\n    });\n\n    it(\"returns false when SOLANA_ALT_RESOLUTION is not requested\", () => {\n      expect(\n        makeLoader().canHandle(\n          {\n            deviceModelId: DeviceModelId.NANO_X,\n            requests: [{ altAddress: ALT_A, entryIndex: 0, challenge: \"c\" }],\n          },\n          [ClearSignContextType.SOLANA_TOKEN],\n        ),\n      ).toBe(false);\n    });\n\n    it(\"rejects out-of-range entryIndex\", () => {\n      const loader = makeLoader();\n      const types = [ClearSignContextType.SOLANA_ALT_RESOLUTION];\n      expect(\n        loader.canHandle(\n          {\n            requests: [{ altAddress: ALT_A, entryIndex: -1, challenge: \"c\" }],\n          } as any,\n          types,\n        ),\n      ).toBe(false);\n      expect(\n        loader.canHandle(\n          {\n            requests: [{ altAddress: ALT_A, entryIndex: 256, challenge: \"c\" }],\n          } as any,\n          types,\n        ),\n      ).toBe(false);\n      expect(\n        loader.canHandle(\n          {\n            requests: [{ altAddress: ALT_A, entryIndex: 1.5, challenge: \"c\" }],\n          } as any,\n          types,\n        ),\n      ).toBe(false);\n    });\n  });\n\n  describe(\"load\", () => {\n    it(\"emits one SOLANA_ALT_RESOLUTION per request\", async () => {\n      vi.spyOn(dataSource, \"getAltResolution\").mockImplementation(\n        async ({ altAddress, entryIndex }) =>\n          Right({\n            altAddress,\n            entryIndex,\n            descriptor: new Uint8Array([entryIndex]),\n            keyId: \"alt_key\",\n            keyUsage: \"coin_meta\",\n          }),\n      );\n\n      const result = await makeLoader().load({\n        deviceModelId: DeviceModelId.NANO_X,\n        requests: [\n          { altAddress: ALT_A, entryIndex: 1, challenge: \"c1\" },\n          { altAddress: ALT_B, entryIndex: 7, challenge: \"c2\" },\n        ],\n      });\n\n      expect(result).toHaveLength(2);\n      expect(result[0]).toMatchObject({\n        type: ClearSignContextType.SOLANA_ALT_RESOLUTION,\n        payload: { descriptor: new Uint8Array([1]) },\n        certificate: mockCertificate,\n      });\n      expect(result[1]).toMatchObject({\n        type: ClearSignContextType.SOLANA_ALT_RESOLUTION,\n        payload: { descriptor: new Uint8Array([7]) },\n      });\n    });\n\n    it(\"dedups certificate loads across requests sharing the same (keyId, keyUsage)\", async () => {\n      vi.spyOn(dataSource, \"getAltResolution\").mockImplementation(\n        async ({ altAddress, entryIndex }) =>\n          Right({\n            altAddress,\n            entryIndex,\n            descriptor: new Uint8Array([entryIndex]),\n            keyId: \"alt_key\",\n            keyUsage: \"coin_meta\",\n          }),\n      );\n\n      await makeLoader().load({\n        deviceModelId: DeviceModelId.NANO_X,\n        requests: [\n          { altAddress: ALT_A, entryIndex: 0, challenge: \"c1\" },\n          { altAddress: ALT_A, entryIndex: 1, challenge: \"c2\" },\n          { altAddress: ALT_B, entryIndex: 2, challenge: \"c3\" },\n        ],\n      });\n\n      expect(certificateLoader.loadCertificate).toHaveBeenCalledTimes(1);\n    });\n\n    it(\"issues distinct cert loads when (keyId, keyUsage) differ\", async () => {\n      vi.spyOn(dataSource, \"getAltResolution\").mockImplementation(\n        async ({ altAddress, entryIndex }) =>\n          Right({\n            altAddress,\n            entryIndex,\n            descriptor: new Uint8Array([entryIndex]),\n            keyId: altAddress === ALT_A ? \"alt_key_a\" : \"alt_key_b\",\n            keyUsage: \"coin_meta\",\n          }),\n      );\n\n      await makeLoader().load({\n        deviceModelId: DeviceModelId.NANO_X,\n        requests: [\n          { altAddress: ALT_A, entryIndex: 0, challenge: \"c1\" },\n          { altAddress: ALT_B, entryIndex: 1, challenge: \"c2\" },\n        ],\n      });\n\n      expect(certificateLoader.loadCertificate).toHaveBeenCalledTimes(2);\n    });\n\n    it(\"emits an ERROR per failing request and keeps the others\", async () => {\n      vi.spyOn(dataSource, \"getAltResolution\").mockImplementation(\n        async ({ altAddress }) => {\n          if (altAddress === ALT_A) {\n            return Right({\n              altAddress,\n              entryIndex: 0,\n              descriptor: new Uint8Array([0xaa]),\n              keyId: \"k\",\n              keyUsage: \"u\",\n            });\n          }\n          return Left(new Error(\"upstream-500\"));\n        },\n      );\n\n      const out = await makeLoader().load({\n        deviceModelId: DeviceModelId.NANO_X,\n        requests: [\n          { altAddress: ALT_A, entryIndex: 0, challenge: \"c1\" },\n          { altAddress: ALT_B, entryIndex: 1, challenge: \"c2\" },\n        ],\n      });\n\n      expect(out[0]?.type).toBe(ClearSignContextType.SOLANA_ALT_RESOLUTION);\n      expect(out[1]?.type).toBe(ClearSignContextType.ERROR);\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["DeviceModelId", "Left", "Right", "ClearSignContextType", "AltResolutionContextLoader", "mockLoggerFactory", "mockCertificate", "ALT_A", "ALT_B", "dataSource", "certificateLoader", "makeLoader", "loader", "types", "altAddress", "entryIndex", "result", "out"]
+}

package/lib/esm/src/modules/solana/enum-variant/di/enumVariantModuleFactory.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{ContainerModule as t}from"inversify";import{enumVariantTypes as r}from"../../../../modules/solana/enum-variant/di/enumVariantTypes";import{EnumVariantContextLoader as n}from"../../../../modules/solana/enum-variant/domain/EnumVariantContextLoader";const i=()=>new t(({bind:o})=>{o(r.EnumVariantContextLoader).to(n)});export{i as enumVariantModuleFactory};
2	+ //# sourceMappingURL=enumVariantModuleFactory.js.map

package/lib/esm/src/modules/solana/enum-variant/di/enumVariantModuleFactory.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/enum-variant/di/enumVariantModuleFactory.ts"],
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { enumVariantTypes } from \"@/modules/solana/enum-variant/di/enumVariantTypes\";\nimport { EnumVariantContextLoader } from \"@/modules/solana/enum-variant/domain/EnumVariantContextLoader\";\n\n// EnumVariantContextLoader shares InstructionInfoDataSource \u2014 its binding\n// is owned by `instructionInfoModuleFactory` and reused here via DI.\nexport const enumVariantModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(enumVariantTypes.EnumVariantContextLoader).to(\n      EnumVariantContextLoader,\n    );\n  });\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,oBAAAC,MAAwB,oDACjC,OAAS,4BAAAC,MAAgC,gEAIlC,MAAMC,EAA2B,IACtC,IAAIH,EAAgB,CAAC,CAAE,KAAAI,CAAK,IAAM,CAChCA,EAAKH,EAAiB,wBAAwB,EAAE,GAC9CC,CACF,CACF,CAAC",
+  "names": ["ContainerModule", "enumVariantTypes", "EnumVariantContextLoader", "enumVariantModuleFactory", "bind"]
+}

package/lib/esm/src/modules/solana/enum-variant/di/enumVariantTypes.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ const n={EnumVariantContextLoader:Symbol.for("EnumVariantContextLoader")};export{n as enumVariantTypes};
2	+ //# sourceMappingURL=enumVariantTypes.js.map

package/lib/esm/src/modules/solana/enum-variant/di/enumVariantTypes.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/modules/solana/enum-variant/di/enumVariantTypes.ts"],
+  "sourcesContent": ["export const enumVariantTypes = {\n  EnumVariantContextLoader: Symbol.for(\"EnumVariantContextLoader\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAmB,CAC9B,yBAA0B,OAAO,IAAI,0BAA0B,CACjE",
+  "names": ["enumVariantTypes"]
+}