npm - @ledgerhq/device-contacts-kit - Versions diffs - 0.0.0-develop-20260831001535 → 0.0.0-develop-20260901001631 - Mend

@ledgerhq/device-contacts-kit 0.0.0-develop-20260831001535 → 0.0.0-develop-20260901001631

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 (200) hide show

package/lib/cjs/internal/app-binder/task/SendRegisterIdentityTask.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/task/SendRegisterIdentityTask.ts"],
-  "sourcesContent": ["// Builds the TLV payload for op 1 (Register Identity / Register External\n// Address) and dispatches it via the chunked-framing scheme shared with the\n// other address-book ops (2-byte BE total length + <=255B chunks). The device\n// returns the 129-byte register response on the final chunk.\n//\n// Reference: Address Book Final Specifications \u2014 Register Identity. Tag order:\n//   STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME, SCOPE, ACCOUNT_IDENTIFIER,\n//   DERIVATION_PATH, CHAIN_ID (Ethereum only), BLOCKCHAIN_FAMILY, then optional\n//   GROUP_HANDLE + HMAC_PROOF when extending an existing group.\n//\n// DERIVATION_PATH (tag 0x69, default m/44'/60'/0'/0/0): the Ethereum app\n// requires it on Register Identity and rejects the payload with 0x6a80 when it\n// is absent (verified on-device against the deployed dev app).\nimport {\n  ByteArrayBuilder,\n  type CommandResult,\n  DmkResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { type ExistingContactGroup } from \"@api/model/RegisterExternalAddress\";\nimport { RegisterIdentityCommand } from \"@internal/app-binder/command/RegisterIdentityCommand\";\nimport {\n  BLOCKCHAIN_FAMILY_BY_NAME,\n  SUB_CMD_REGISTER_IDENTITY,\n} from \"@internal/app-binder/model/contactsConstants\";\nimport { type ContactsErrorCodes } from \"@internal/app-binder/model/contactsErrors\";\nimport {\n  CONTACTS_TLV_TAG,\n  encodeTlvAscii,\n  encodeTlvBuffer,\n  encodeTlvChainId,\n  encodeTlvUInt8,\n  packDerivationPath,\n  STRUCT_TYPE_REGISTER_IDENTITY,\n  STRUCT_VERSION_VALUE,\n} from \"@internal/app-binder/services/contactsTlvSerializer\";\nimport { sendFramedContactsPayload } from \"@internal/app-binder/services/sendFramedContactsPayload\";\n\nexport type RegisterIdentityProofs = {\n  readonly groupHandle: Uint8Array;\n  readonly hmacProof: Uint8Array;\n  readonly hmacRest: Uint8Array;\n};\n\nexport type SendRegisterIdentityTaskArgs = {\n  readonly contactName: string;\n  readonly scope: string;\n  readonly identifier: Uint8Array;\n  readonly blockchainFamily: string;\n  readonly chainId?: bigint;\n  readonly existingContactGroup?: ExistingContactGroup;\n  readonly logger?: LoggerPublisherService;\n};\n\nexport class SendRegisterIdentityTask {\n  constructor(\n    private readonly api: InternalApi,\n    private readonly args: SendRegisterIdentityTaskArgs,\n  ) {}\n\n  async run(): Promise<\n    CommandResult<RegisterIdentityProofs, ContactsErrorCodes>\n  > {\n    const payload = this.buildPayload(this.args);\n\n    const result = (await sendFramedContactsPayload(this.api, {\n      payload,\n      p1: SUB_CMD_REGISTER_IDENTITY,\n      makeCommand: (chunk, p2) =>\n        new RegisterIdentityCommand({ data: chunk, p2 }),\n      logger: this.args.logger,\n      commandTag: \"SendRegisterIdentityTask\",\n    })) as CommandResult<\n      {\n        readonly groupHandle?: Uint8Array;\n        readonly hmacProof?: Uint8Array;\n        readonly hmacRest?: Uint8Array;\n      },\n      ContactsErrorCodes\n    >;\n\n    if (!isSuccessCommandResult(result)) {\n      return result;\n    }\n\n    const { groupHandle, hmacProof, hmacRest } = result.data;\n    if (!groupHandle || !hmacProof || !hmacRest) {\n      return DmkResultFactory({\n        error: new InvalidStatusWordError(\n          \"RegisterIdentity final-chunk response was incomplete\",\n        ),\n      });\n    }\n    return DmkResultFactory({ data: { groupHandle, hmacProof, hmacRest } });\n  }\n\n  private buildPayload(args: SendRegisterIdentityTaskArgs): Uint8Array {\n    const family =\n      BLOCKCHAIN_FAMILY_BY_NAME[args.blockchainFamily.toLowerCase()];\n    if (family === undefined) {\n      throw new Error(\n        `Unsupported blockchain family: ${args.blockchainFamily}`,\n      );\n    }\n\n    const builder = new ByteArrayBuilder();\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_TYPE,\n      STRUCT_TYPE_REGISTER_IDENTITY,\n    );\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_VERSION,\n      STRUCT_VERSION_VALUE,\n    );\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.CONTACT_NAME, args.contactName);\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.SCOPE, args.scope);\n    encodeTlvBuffer(\n      builder,\n      CONTACTS_TLV_TAG.ACCOUNT_IDENTIFIER,\n      args.identifier,\n    );\n    // The Ethereum app requires DERIVATION_PATH on Register Identity (0x6a80\n    // without it). Default m/44'/60'/0'/0/0.\n    encodeTlvBuffer(\n      builder,\n      CONTACTS_TLV_TAG.DERIVATION_PATH,\n      packDerivationPath([0x8000002c, 0x8000003c, 0x80000000, 0, 0]),\n    );\n    if (args.chainId !== undefined) {\n      encodeTlvChainId(builder, CONTACTS_TLV_TAG.CHAIN_ID, args.chainId);\n    }\n    encodeTlvUInt8(builder, CONTACTS_TLV_TAG.BLOCKCHAIN_FAMILY, family);\n\n    if (args.existingContactGroup) {\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.GROUP_HANDLE,\n        args.existingContactGroup.groupHandle,\n      );\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.HMAC_PROOF,\n        args.existingContactGroup.hmacProof,\n      );\n    }\n\n    return builder.build();\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,IAAA,eAAAC,EAAAH,GAaA,IAAAI,EAQO,2CAGPC,EAAwC,gEACxCC,EAGO,wDAEPC,EASO,+DACPC,EAA0C,mEAkBnC,MAAMN,CAAyB,CACpC,YACmBO,EACAC,EACjB,CAFiB,SAAAD,EACA,UAAAC,CAChB,CAEH,MAAM,KAEJ,CACA,MAAMC,EAAU,KAAK,aAAa,KAAK,IAAI,EAErCC,EAAU,QAAM,6BAA0B,KAAK,IAAK,CACxD,QAAAD,EACA,GAAI,4BACJ,YAAa,CAACE,EAAOC,IACnB,IAAI,0BAAwB,CAAE,KAAMD,EAAO,GAAAC,CAAG,CAAC,EACjD,OAAQ,KAAK,KAAK,OAClB,WAAY,0BACd,CAAC,EASD,GAAI,IAAC,0BAAuBF,CAAM,EAChC,OAAOA,EAGT,KAAM,CAAE,YAAAG,EAAa,UAAAC,EAAW,SAAAC,CAAS,EAAIL,EAAO,KACpD,MAAI,CAACG,GAAe,CAACC,GAAa,CAACC,KAC1B,oBAAiB,CACtB,MAAO,IAAI,yBACT,sDACF,CACF,CAAC,KAEI,oBAAiB,CAAE,KAAM,CAAE,YAAAF,EAAa,UAAAC,EAAW,SAAAC,CAAS,CAAE,CAAC,CACxE,CAEQ,aAAaP,EAAgD,CACnE,MAAMQ,EACJ,4BAA0BR,EAAK,iBAAiB,YAAY,CAAC,EAC/D,GAAIQ,IAAW,OACb,MAAM,IAAI,MACR,kCAAkCR,EAAK,gBAAgB,EACzD,EAGF,MAAMS,EAAU,IAAI,mBACpB,2BACEA,EACA,mBAAiB,YACjB,+BACF,KACA,kBACEA,EACA,mBAAiB,eACjB,sBACF,KACA,kBAAeA,EAAS,mBAAiB,aAAcT,EAAK,WAAW,KACvE,kBAAeS,EAAS,mBAAiB,MAAOT,EAAK,KAAK,KAC1D,mBACES,EACA,mBAAiB,mBACjBT,EAAK,UACP,KAGA,mBACES,EACA,mBAAiB,mBACjB,sBAAmB,CAAC,WAAY,WAAY,WAAY,EAAG,CAAC,CAAC,CAC/D,EACIT,EAAK,UAAY,WACnB,oBAAiBS,EAAS,mBAAiB,SAAUT,EAAK,OAAO,KAEnE,kBAAeS,EAAS,mBAAiB,kBAAmBD,CAAM,EAE9DR,EAAK,0BACP,mBACES,EACA,mBAAiB,aACjBT,EAAK,qBAAqB,WAC5B,KACA,mBACES,EACA,mBAAiB,WACjBT,EAAK,qBAAqB,SAC5B,GAGKS,EAAQ,MAAM,CACvB,CACF",
+  "sourcesContent": ["// Builds the TLV payload for op 1 (Register Identity / Register External\n// Address) and dispatches it via the chunked-framing scheme shared with the\n// other address-book ops (2-byte BE total length + <=255B chunks). The device\n// returns the 129-byte register response on the final chunk.\n//\n// Reference: Address Book Final Specifications \u2014 Register Identity. Tag order:\n//   STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME, SCOPE, ACCOUNT_IDENTIFIER,\n//   CHAIN_ID (Ethereum only), BLOCKCHAIN_FAMILY, then optional\n//   GROUP_HANDLE + HMAC_PROOF when extending an existing group.\n//\n// No DERIVATION_PATH: external-address ops carry no path. The current Ethereum\n// app rejects the tag when present (0x6a80) and no longer requires it; the tag\n// is Ledger-Account only (verified on-device, DSDK-1465).\nimport {\n  ByteArrayBuilder,\n  type CommandResult,\n  DmkResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { type ExistingContactGroup } from \"@api/model/RegisterExternalAddress\";\nimport { RegisterIdentityCommand } from \"@internal/app-binder/command/RegisterIdentityCommand\";\nimport {\n  BLOCKCHAIN_FAMILY_BY_NAME,\n  SUB_CMD_REGISTER_IDENTITY,\n} from \"@internal/app-binder/model/contactsConstants\";\nimport { type ContactsErrorCodes } from \"@internal/app-binder/model/contactsErrors\";\nimport {\n  CONTACTS_TLV_TAG,\n  encodeTlvAscii,\n  encodeTlvBuffer,\n  encodeTlvChainId,\n  encodeTlvUInt8,\n  STRUCT_TYPE_REGISTER_IDENTITY,\n  STRUCT_VERSION_VALUE,\n} from \"@internal/app-binder/services/contactsTlvSerializer\";\nimport { sendFramedContactsPayload } from \"@internal/app-binder/services/sendFramedContactsPayload\";\n\nexport type RegisterIdentityProofs = {\n  readonly groupHandle: Uint8Array;\n  readonly hmacProof: Uint8Array;\n  readonly hmacRest: Uint8Array;\n};\n\nexport type SendRegisterIdentityTaskArgs = {\n  readonly contactName: string;\n  readonly scope: string;\n  readonly identifier: Uint8Array;\n  readonly blockchainFamily: string;\n  readonly chainId?: bigint;\n  readonly existingContactGroup?: ExistingContactGroup;\n  readonly logger?: LoggerPublisherService;\n};\n\nexport class SendRegisterIdentityTask {\n  constructor(\n    private readonly api: InternalApi,\n    private readonly args: SendRegisterIdentityTaskArgs,\n  ) {}\n\n  async run(): Promise<\n    CommandResult<RegisterIdentityProofs, ContactsErrorCodes>\n  > {\n    const payload = this.buildPayload(this.args);\n\n    const result = (await sendFramedContactsPayload(this.api, {\n      payload,\n      p1: SUB_CMD_REGISTER_IDENTITY,\n      makeCommand: (chunk, p2) =>\n        new RegisterIdentityCommand({ data: chunk, p2 }),\n      logger: this.args.logger,\n      commandTag: \"SendRegisterIdentityTask\",\n    })) as CommandResult<\n      {\n        readonly groupHandle?: Uint8Array;\n        readonly hmacProof?: Uint8Array;\n        readonly hmacRest?: Uint8Array;\n      },\n      ContactsErrorCodes\n    >;\n\n    if (!isSuccessCommandResult(result)) {\n      return result;\n    }\n\n    const { groupHandle, hmacProof, hmacRest } = result.data;\n    if (!groupHandle || !hmacProof || !hmacRest) {\n      return DmkResultFactory({\n        error: new InvalidStatusWordError(\n          \"RegisterIdentity final-chunk response was incomplete\",\n        ),\n      });\n    }\n    return DmkResultFactory({ data: { groupHandle, hmacProof, hmacRest } });\n  }\n\n  private buildPayload(args: SendRegisterIdentityTaskArgs): Uint8Array {\n    const family =\n      BLOCKCHAIN_FAMILY_BY_NAME[args.blockchainFamily.toLowerCase()];\n    if (family === undefined) {\n      throw new Error(\n        `Unsupported blockchain family: ${args.blockchainFamily}`,\n      );\n    }\n\n    const builder = new ByteArrayBuilder();\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_TYPE,\n      STRUCT_TYPE_REGISTER_IDENTITY,\n    );\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_VERSION,\n      STRUCT_VERSION_VALUE,\n    );\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.CONTACT_NAME, args.contactName);\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.SCOPE, args.scope);\n    encodeTlvBuffer(\n      builder,\n      CONTACTS_TLV_TAG.ACCOUNT_IDENTIFIER,\n      args.identifier,\n    );\n    if (args.chainId !== undefined) {\n      encodeTlvChainId(builder, CONTACTS_TLV_TAG.CHAIN_ID, args.chainId);\n    }\n    encodeTlvUInt8(builder, CONTACTS_TLV_TAG.BLOCKCHAIN_FAMILY, family);\n\n    if (args.existingContactGroup) {\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.GROUP_HANDLE,\n        args.existingContactGroup.groupHandle,\n      );\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.HMAC_PROOF,\n        args.existingContactGroup.hmacProof,\n      );\n    }\n\n    return builder.build();\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,IAAA,eAAAC,EAAAH,GAaA,IAAAI,EAQO,2CAGPC,EAAwC,gEACxCC,EAGO,wDAEPC,EAQO,+DACPC,EAA0C,mEAkBnC,MAAMN,CAAyB,CACpC,YACmBO,EACAC,EACjB,CAFiB,SAAAD,EACA,UAAAC,CAChB,CAEH,MAAM,KAEJ,CACA,MAAMC,EAAU,KAAK,aAAa,KAAK,IAAI,EAErCC,EAAU,QAAM,6BAA0B,KAAK,IAAK,CACxD,QAAAD,EACA,GAAI,4BACJ,YAAa,CAACE,EAAOC,IACnB,IAAI,0BAAwB,CAAE,KAAMD,EAAO,GAAAC,CAAG,CAAC,EACjD,OAAQ,KAAK,KAAK,OAClB,WAAY,0BACd,CAAC,EASD,GAAI,IAAC,0BAAuBF,CAAM,EAChC,OAAOA,EAGT,KAAM,CAAE,YAAAG,EAAa,UAAAC,EAAW,SAAAC,CAAS,EAAIL,EAAO,KACpD,MAAI,CAACG,GAAe,CAACC,GAAa,CAACC,KAC1B,oBAAiB,CACtB,MAAO,IAAI,yBACT,sDACF,CACF,CAAC,KAEI,oBAAiB,CAAE,KAAM,CAAE,YAAAF,EAAa,UAAAC,EAAW,SAAAC,CAAS,CAAE,CAAC,CACxE,CAEQ,aAAaP,EAAgD,CACnE,MAAMQ,EACJ,4BAA0BR,EAAK,iBAAiB,YAAY,CAAC,EAC/D,GAAIQ,IAAW,OACb,MAAM,IAAI,MACR,kCAAkCR,EAAK,gBAAgB,EACzD,EAGF,MAAMS,EAAU,IAAI,mBACpB,2BACEA,EACA,mBAAiB,YACjB,+BACF,KACA,kBACEA,EACA,mBAAiB,eACjB,sBACF,KACA,kBAAeA,EAAS,mBAAiB,aAAcT,EAAK,WAAW,KACvE,kBAAeS,EAAS,mBAAiB,MAAOT,EAAK,KAAK,KAC1D,mBACES,EACA,mBAAiB,mBACjBT,EAAK,UACP,EACIA,EAAK,UAAY,WACnB,oBAAiBS,EAAS,mBAAiB,SAAUT,EAAK,OAAO,KAEnE,kBAAeS,EAAS,mBAAiB,kBAAmBD,CAAM,EAE9DR,EAAK,0BACP,mBACES,EACA,mBAAiB,aACjBT,EAAK,qBAAqB,WAC5B,KACA,mBACES,EACA,mBAAiB,WACjBT,EAAK,qBAAqB,SAC5B,GAGKS,EAAQ,MAAM,CACvB,CACF",
   "names": ["SendRegisterIdentityTask_exports", "__export", "SendRegisterIdentityTask", "__toCommonJS", "import_device_management_kit", "import_RegisterIdentityCommand", "import_contactsConstants", "import_contactsTlvSerializer", "import_sendFramedContactsPayload", "api", "args", "payload", "result", "chunk", "p2", "groupHandle", "hmacProof", "hmacRest", "family", "builder"]
 }

package/lib/cjs/internal/app-binder/task/SendRegisterIdentityTask.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var n=require("@ledgerhq/device-management-kit"),r=require("../../app-binder/command/RegisterIdentityCommand"),a=require("./SendRegisterIdentityTask");function e(c){const d=new Uint8Array(c.length/2);for(let t=0;t<c.length;t+=2)d[t/2]=parseInt(c.slice(t,t+2),16);return d}const s=e("004d01012d02010181f005416c69636581f108457468206d61696e81f21400000000000000000000000000000000deadbeef6915058000002c8000003c800000000000000000000000230101510101"),m=e("00b301012d02010181f005416c69636581f108417262206d61696e81f21444444444444444444444444444444444444444446915058000002c8000003c8000000000000000000000002302a4b151010181f640cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc2920dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"),i={groupHandle:e("cc".repeat(64)),hmacProof:e("dd".repeat(32)),hmacRest:e("aa".repeat(32))};function o(){return{sendCommand:vi.fn()}}describe("SendRegisterIdentityTask",()=>{it("assembles a fresh-register framed chunk and dispatches RegisterIdentityCommand",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({data:i}));const d=await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"ethereum",chainId:1n}).run();expect(c.sendCommand.mock.calls).toHaveLength(1),expect(c.sendCommand.mock.calls[0][0]).toStrictEqual(new r.RegisterIdentityCommand({data:s,p2:0})),expect(d).toStrictEqual((0,n.CommandResultFactory)({data:i}))}),it("appends GROUP_HANDLE + HMAC_PROOF on extension and frames the extension payload",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({data:i})),await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Arb main",identifier:e("44".repeat(20)),blockchainFamily:"ethereum",chainId:42161n,existingContactGroup:{groupHandle:e("cc".repeat(64)),hmacProof:e("dd".repeat(32))}}).run(),expect(c.sendCommand.mock.calls).toHaveLength(1),expect(c.sendCommand.mock.calls[0][0]).toStrictEqual(new r.RegisterIdentityCommand({data:m,p2:0}))}),it("omits the CHAIN_ID TLV when chainId is not provided",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({data:i})),await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"ethereum"}).run();const d=c.sendCommand.mock.calls[0][0],t=Buffer.from(d.args.data).toString("hex");expect(t).not.toContain("230101"),expect(t.endsWith("510101")).toBe(!0)}),it("propagates command-level errors",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({error:new n.InvalidStatusWordError("user cancelled")}));const d=await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"ethereum",chainId:1n}).run();expect(d).toStrictEqual((0,n.CommandResultFactory)({error:new n.InvalidStatusWordError("user cancelled")}))}),it("throws on an unsupported blockchain family",async()=>{const c=o();await expect(new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"dogecoin",chainId:1n}).run()).rejects.toThrow(/Unsupported blockchain family/),expect(c.sendCommand).not.toHaveBeenCalled()})});
+"use strict";var n=require("@ledgerhq/device-management-kit"),r=require("../../app-binder/command/RegisterIdentityCommand"),a=require("./SendRegisterIdentityTask");function e(c){const d=new Uint8Array(c.length/2);for(let t=0;t<c.length;t+=2)d[t/2]=parseInt(c.slice(t,t+2),16);return d}const s=e("003601012d02010181f005416c69636581f108457468206d61696e81f21400000000000000000000000000000000deadbeef230101510101"),m=e("009c01012d02010181f005416c69636581f108417262206d61696e81f21444444444444444444444444444444444444444442302a4b151010181f640cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc2920dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"),i={groupHandle:e("cc".repeat(64)),hmacProof:e("dd".repeat(32)),hmacRest:e("aa".repeat(32))};function o(){return{sendCommand:vi.fn()}}describe("SendRegisterIdentityTask",()=>{it("assembles a fresh-register framed chunk and dispatches RegisterIdentityCommand",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({data:i}));const d=await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"ethereum",chainId:1n}).run();expect(c.sendCommand.mock.calls).toHaveLength(1),expect(c.sendCommand.mock.calls[0][0]).toStrictEqual(new r.RegisterIdentityCommand({data:s,p2:0})),expect(d).toStrictEqual((0,n.CommandResultFactory)({data:i}))}),it("appends GROUP_HANDLE + HMAC_PROOF on extension and frames the extension payload",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({data:i})),await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Arb main",identifier:e("44".repeat(20)),blockchainFamily:"ethereum",chainId:42161n,existingContactGroup:{groupHandle:e("cc".repeat(64)),hmacProof:e("dd".repeat(32))}}).run(),expect(c.sendCommand.mock.calls).toHaveLength(1),expect(c.sendCommand.mock.calls[0][0]).toStrictEqual(new r.RegisterIdentityCommand({data:m,p2:0}))}),it("omits the CHAIN_ID TLV when chainId is not provided",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({data:i})),await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"ethereum"}).run();const d=c.sendCommand.mock.calls[0][0],t=Buffer.from(d.args.data).toString("hex");expect(t).not.toContain("230101"),expect(t.endsWith("510101")).toBe(!0)}),it("propagates command-level errors",async()=>{const c=o();c.sendCommand.mockResolvedValueOnce((0,n.CommandResultFactory)({error:new n.InvalidStatusWordError("user cancelled")}));const d=await new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"ethereum",chainId:1n}).run();expect(d).toStrictEqual((0,n.CommandResultFactory)({error:new n.InvalidStatusWordError("user cancelled")}))}),it("throws on an unsupported blockchain family",async()=>{const c=o();await expect(new a.SendRegisterIdentityTask(c,{contactName:"Alice",scope:"Eth main",identifier:e("00000000000000000000000000000000deadbeef"),blockchainFamily:"dogecoin",chainId:1n}).run()).rejects.toThrow(/Unsupported blockchain family/),expect(c.sendCommand).not.toHaveBeenCalled()})});
 //# sourceMappingURL=SendRegisterIdentityTask.test.js.map

package/lib/cjs/internal/app-binder/task/SendRegisterIdentityTask.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/task/SendRegisterIdentityTask.test.ts"],
-  "sourcesContent": ["// Validates that the TLV serializer + tag ordering + chunk framing produce the\n// expected wire bytes for op 1 (Register Identity): tags >= 0x80 use the 2-byte\n// DER form [0x81, tag], and Register Identity carries DERIVATION_PATH (tag 0x69,\n// m/44'/60'/0'/0/0) which the Ethereum app requires. The framed chunk = 2-byte\n// BE total length + TLV.\nimport {\n  CommandResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { RegisterIdentityCommand } from \"@internal/app-binder/command/RegisterIdentityCommand\";\n\nimport { SendRegisterIdentityTask } from \"./SendRegisterIdentityTask\";\n\nfunction hexToBytes(hex: string): Uint8Array {\n  const out = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    out[i / 2] = parseInt(hex.slice(i, i + 2), 16);\n  }\n  return out;\n}\n\n// Framed chunk = \"00 <Lc>\" (2-byte BE total TLV length) + TLV. Tag order:\n// STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME, SCOPE, ACCOUNT_IDENTIFIER,\n// DERIVATION_PATH, CHAIN_ID, BLOCKCHAIN_FAMILY, then optional GROUP_HANDLE +\n// HMAC_PROOF. Tags >= 0x80 are encoded as [0x81, tag]; DERIVATION_PATH (0x69)\n// packs m/44'/60'/0'/0/0 as \"05 8000002c 8000003c 80000000 00000000 00000000\".\nconst FRESH_FRAMED_CHUNK = hexToBytes(\n  \"004d01012d020101\" +\n    \"81f005416c696365\" +\n    \"81f108457468206d61696e\" +\n    \"81f21400000000000000000000000000000000deadbeef\" +\n    \"6915058000002c8000003c800000000000000000000000\" +\n    \"230101510101\",\n);\n\nconst EXTENSION_FRAMED_CHUNK = hexToBytes(\n  \"00b301012d020101\" +\n    \"81f005416c696365\" +\n    \"81f108417262206d61696e\" +\n    \"81f2144444444444444444444444444444444444444444\" +\n    \"6915058000002c8000003c800000000000000000000000\" +\n    \"2302a4b1510101\" +\n    \"81f640cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\" +\n    \"2920dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\",\n);\n\nconst OK_PROOFS = {\n  groupHandle: hexToBytes(\"cc\".repeat(64)),\n  hmacProof: hexToBytes(\"dd\".repeat(32)),\n  hmacRest: hexToBytes(\"aa\".repeat(32)),\n};\n\nfunction makeApiMock(): InternalApi & {\n  sendCommand: ReturnType<typeof vi.fn>;\n} {\n  return { sendCommand: vi.fn() } as unknown as InternalApi & {\n    sendCommand: ReturnType<typeof vi.fn>;\n  };\n}\n\ndescribe(\"SendRegisterIdentityTask\", () => {\n  it(\"assembles a fresh-register framed chunk and dispatches RegisterIdentityCommand\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: OK_PROOFS }),\n    );\n\n    const result = await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Eth main\",\n      identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n      blockchainFamily: \"ethereum\",\n      chainId: 1n,\n    }).run();\n\n    expect(api.sendCommand.mock.calls).toHaveLength(1);\n    expect(api.sendCommand.mock.calls[0]![0]).toStrictEqual(\n      new RegisterIdentityCommand({ data: FRESH_FRAMED_CHUNK, p2: 0x00 }),\n    );\n    expect(result).toStrictEqual(CommandResultFactory({ data: OK_PROOFS }));\n  });\n\n  it(\"appends GROUP_HANDLE + HMAC_PROOF on extension and frames the extension payload\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: OK_PROOFS }),\n    );\n\n    await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Arb main\",\n      identifier: hexToBytes(\"44\".repeat(20)),\n      blockchainFamily: \"ethereum\",\n      chainId: 42161n,\n      existingContactGroup: {\n        groupHandle: hexToBytes(\"cc\".repeat(64)),\n        hmacProof: hexToBytes(\"dd\".repeat(32)),\n      },\n    }).run();\n\n    expect(api.sendCommand.mock.calls).toHaveLength(1);\n    expect(api.sendCommand.mock.calls[0]![0]).toStrictEqual(\n      new RegisterIdentityCommand({ data: EXTENSION_FRAMED_CHUNK, p2: 0x00 }),\n    );\n  });\n\n  it(\"omits the CHAIN_ID TLV when chainId is not provided\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: OK_PROOFS }),\n    );\n\n    await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Eth main\",\n      identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n      blockchainFamily: \"ethereum\",\n    }).run();\n\n    const command = api.sendCommand.mock\n      .calls[0]![0] as RegisterIdentityCommand;\n    // No `23 01 ..` CHAIN_ID TLV; BLOCKCHAIN_FAMILY 51 01 01 follows the path.\n    const framedHex = Buffer.from(command.args.data).toString(\"hex\");\n    expect(framedHex).not.toContain(\"230101\");\n    expect(framedHex.endsWith(\"510101\")).toBe(true);\n  });\n\n  it(\"propagates command-level errors\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"user cancelled\"),\n      }),\n    );\n\n    const result = await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Eth main\",\n      identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n      blockchainFamily: \"ethereum\",\n      chainId: 1n,\n    }).run();\n\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"user cancelled\"),\n      }),\n    );\n  });\n\n  it(\"throws on an unsupported blockchain family\", async () => {\n    const api = makeApiMock();\n\n    await expect(\n      new SendRegisterIdentityTask(api, {\n        contactName: \"Alice\",\n        scope: \"Eth main\",\n        identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n        blockchainFamily: \"dogecoin\",\n        chainId: 1n,\n      }).run(),\n    ).rejects.toThrow(/Unsupported blockchain family/);\n    expect(api.sendCommand).not.toHaveBeenCalled();\n  });\n});\n"],
-  "mappings": "aAKA,IAAAA,EAIO,2CAEPC,EAAwC,gEAExCC,EAAyC,sCAEzC,SAASC,EAAWC,EAAyB,CAC3C,MAAMC,EAAM,IAAI,WAAWD,EAAI,OAAS,CAAC,EACzC,QAASE,EAAI,EAAGA,EAAIF,EAAI,OAAQE,GAAK,EACnCD,EAAIC,EAAI,CAAC,EAAI,SAASF,EAAI,MAAME,EAAGA,EAAI,CAAC,EAAG,EAAE,EAE/C,OAAOD,CACT,CAOA,MAAME,EAAqBJ,EACzB,gKAMF,EAEMK,EAAyBL,EAC7B,4WAQF,EAEMM,EAAY,CAChB,YAAaN,EAAW,KAAK,OAAO,EAAE,CAAC,EACvC,UAAWA,EAAW,KAAK,OAAO,EAAE,CAAC,EACrC,SAAUA,EAAW,KAAK,OAAO,EAAE,CAAC,CACtC,EAEA,SAASO,GAEP,CACA,MAAO,CAAE,YAAa,GAAG,GAAG,CAAE,CAGhC,CAEA,SAAS,2BAA4B,IAAM,CACzC,GAAG,iFAAkF,SAAY,CAC/F,MAAMC,EAAMD,EAAY,EACxBC,EAAI,YAAY,yBACd,wBAAqB,CAAE,KAAMF,CAAU,CAAC,CAC1C,EAEA,MAAMG,EAAS,MAAM,IAAI,2BAAyBD,EAAK,CACrD,YAAa,QACb,MAAO,WACP,WAAYR,EAAW,0CAA0C,EACjE,iBAAkB,WAClB,QAAS,EACX,CAAC,EAAE,IAAI,EAEP,OAAOQ,EAAI,YAAY,KAAK,KAAK,EAAE,aAAa,CAAC,EACjD,OAAOA,EAAI,YAAY,KAAK,MAAM,CAAC,EAAG,CAAC,CAAC,EAAE,cACxC,IAAI,0BAAwB,CAAE,KAAMJ,EAAoB,GAAI,CAAK,CAAC,CACpE,EACA,OAAOK,CAAM,EAAE,iBAAc,wBAAqB,CAAE,KAAMH,CAAU,CAAC,CAAC,CACxE,CAAC,EAED,GAAG,kFAAmF,SAAY,CAChG,MAAME,EAAMD,EAAY,EACxBC,EAAI,YAAY,yBACd,wBAAqB,CAAE,KAAMF,CAAU,CAAC,CAC1C,EAEA,MAAM,IAAI,2BAAyBE,EAAK,CACtC,YAAa,QACb,MAAO,WACP,WAAYR,EAAW,KAAK,OAAO,EAAE,CAAC,EACtC,iBAAkB,WAClB,QAAS,OACT,qBAAsB,CACpB,YAAaA,EAAW,KAAK,OAAO,EAAE,CAAC,EACvC,UAAWA,EAAW,KAAK,OAAO,EAAE,CAAC,CACvC,CACF,CAAC,EAAE,IAAI,EAEP,OAAOQ,EAAI,YAAY,KAAK,KAAK,EAAE,aAAa,CAAC,EACjD,OAAOA,EAAI,YAAY,KAAK,MAAM,CAAC,EAAG,CAAC,CAAC,EAAE,cACxC,IAAI,0BAAwB,CAAE,KAAMH,EAAwB,GAAI,CAAK,CAAC,CACxE,CACF,CAAC,EAED,GAAG,sDAAuD,SAAY,CACpE,MAAMG,EAAMD,EAAY,EACxBC,EAAI,YAAY,yBACd,wBAAqB,CAAE,KAAMF,CAAU,CAAC,CAC1C,EAEA,MAAM,IAAI,2BAAyBE,EAAK,CACtC,YAAa,QACb,MAAO,WACP,WAAYR,EAAW,0CAA0C,EACjE,iBAAkB,UACpB,CAAC,EAAE,IAAI,EAEP,MAAMU,EAAUF,EAAI,YAAY,KAC7B,MAAM,CAAC,EAAG,CAAC,EAERG,EAAY,OAAO,KAAKD,EAAQ,KAAK,IAAI,EAAE,SAAS,KAAK,EAC/D,OAAOC,CAAS,EAAE,IAAI,UAAU,QAAQ,EACxC,OAAOA,EAAU,SAAS,QAAQ,CAAC,EAAE,KAAK,EAAI,CAChD,CAAC,EAED,GAAG,kCAAmC,SAAY,CAChD,MAAMH,EAAMD,EAAY,EACxBC,EAAI,YAAY,yBACd,wBAAqB,CACnB,MAAO,IAAI,yBAAuB,gBAAgB,CACpD,CAAC,CACH,EAEA,MAAMC,EAAS,MAAM,IAAI,2BAAyBD,EAAK,CACrD,YAAa,QACb,MAAO,WACP,WAAYR,EAAW,0CAA0C,EACjE,iBAAkB,WAClB,QAAS,EACX,CAAC,EAAE,IAAI,EAEP,OAAOS,CAAM,EAAE,iBACb,wBAAqB,CACnB,MAAO,IAAI,yBAAuB,gBAAgB,CACpD,CAAC,CACH,CACF,CAAC,EAED,GAAG,6CAA8C,SAAY,CAC3D,MAAMD,EAAMD,EAAY,EAExB,MAAM,OACJ,IAAI,2BAAyBC,EAAK,CAChC,YAAa,QACb,MAAO,WACP,WAAYR,EAAW,0CAA0C,EACjE,iBAAkB,WAClB,QAAS,EACX,CAAC,EAAE,IAAI,CACT,EAAE,QAAQ,QAAQ,+BAA+B,EACjD,OAAOQ,EAAI,WAAW,EAAE,IAAI,iBAAiB,CAC/C,CAAC,CACH,CAAC",
+  "sourcesContent": ["// Validates that the TLV serializer + tag ordering + chunk framing produce the\n// expected wire bytes for op 1 (Register Identity): tags >= 0x80 use the 2-byte\n// DER form [0x81, tag], and Register Identity carries NO DERIVATION_PATH (the\n// Ethereum app rejects the tag on external-address ops). The framed chunk =\n// 2-byte BE total length + TLV.\nimport {\n  CommandResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { RegisterIdentityCommand } from \"@internal/app-binder/command/RegisterIdentityCommand\";\n\nimport { SendRegisterIdentityTask } from \"./SendRegisterIdentityTask\";\n\nfunction hexToBytes(hex: string): Uint8Array {\n  const out = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    out[i / 2] = parseInt(hex.slice(i, i + 2), 16);\n  }\n  return out;\n}\n\n// Framed chunk = \"00 <Lc>\" (2-byte BE total TLV length) + TLV. Tag order:\n// STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME, SCOPE, ACCOUNT_IDENTIFIER,\n// CHAIN_ID, BLOCKCHAIN_FAMILY, then optional GROUP_HANDLE + HMAC_PROOF. Tags\n// >= 0x80 are encoded as [0x81, tag]. No DERIVATION_PATH TLV.\nconst FRESH_FRAMED_CHUNK = hexToBytes(\n  \"003601012d020101\" +\n    \"81f005416c696365\" +\n    \"81f108457468206d61696e\" +\n    \"81f21400000000000000000000000000000000deadbeef\" +\n    \"230101510101\",\n);\n\nconst EXTENSION_FRAMED_CHUNK = hexToBytes(\n  \"009c01012d020101\" +\n    \"81f005416c696365\" +\n    \"81f108417262206d61696e\" +\n    \"81f2144444444444444444444444444444444444444444\" +\n    \"2302a4b1510101\" +\n    \"81f640cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\" +\n    \"2920dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\",\n);\n\nconst OK_PROOFS = {\n  groupHandle: hexToBytes(\"cc\".repeat(64)),\n  hmacProof: hexToBytes(\"dd\".repeat(32)),\n  hmacRest: hexToBytes(\"aa\".repeat(32)),\n};\n\nfunction makeApiMock(): InternalApi & {\n  sendCommand: ReturnType<typeof vi.fn>;\n} {\n  return { sendCommand: vi.fn() } as unknown as InternalApi & {\n    sendCommand: ReturnType<typeof vi.fn>;\n  };\n}\n\ndescribe(\"SendRegisterIdentityTask\", () => {\n  it(\"assembles a fresh-register framed chunk and dispatches RegisterIdentityCommand\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: OK_PROOFS }),\n    );\n\n    const result = await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Eth main\",\n      identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n      blockchainFamily: \"ethereum\",\n      chainId: 1n,\n    }).run();\n\n    expect(api.sendCommand.mock.calls).toHaveLength(1);\n    expect(api.sendCommand.mock.calls[0]![0]).toStrictEqual(\n      new RegisterIdentityCommand({ data: FRESH_FRAMED_CHUNK, p2: 0x00 }),\n    );\n    expect(result).toStrictEqual(CommandResultFactory({ data: OK_PROOFS }));\n  });\n\n  it(\"appends GROUP_HANDLE + HMAC_PROOF on extension and frames the extension payload\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: OK_PROOFS }),\n    );\n\n    await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Arb main\",\n      identifier: hexToBytes(\"44\".repeat(20)),\n      blockchainFamily: \"ethereum\",\n      chainId: 42161n,\n      existingContactGroup: {\n        groupHandle: hexToBytes(\"cc\".repeat(64)),\n        hmacProof: hexToBytes(\"dd\".repeat(32)),\n      },\n    }).run();\n\n    expect(api.sendCommand.mock.calls).toHaveLength(1);\n    expect(api.sendCommand.mock.calls[0]![0]).toStrictEqual(\n      new RegisterIdentityCommand({ data: EXTENSION_FRAMED_CHUNK, p2: 0x00 }),\n    );\n  });\n\n  it(\"omits the CHAIN_ID TLV when chainId is not provided\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: OK_PROOFS }),\n    );\n\n    await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Eth main\",\n      identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n      blockchainFamily: \"ethereum\",\n    }).run();\n\n    const command = api.sendCommand.mock\n      .calls[0]![0] as RegisterIdentityCommand;\n    // No `23 01 ..` CHAIN_ID TLV; BLOCKCHAIN_FAMILY 51 01 01 follows the path.\n    const framedHex = Buffer.from(command.args.data).toString(\"hex\");\n    expect(framedHex).not.toContain(\"230101\");\n    expect(framedHex.endsWith(\"510101\")).toBe(true);\n  });\n\n  it(\"propagates command-level errors\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"user cancelled\"),\n      }),\n    );\n\n    const result = await new SendRegisterIdentityTask(api, {\n      contactName: \"Alice\",\n      scope: \"Eth main\",\n      identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n      blockchainFamily: \"ethereum\",\n      chainId: 1n,\n    }).run();\n\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"user cancelled\"),\n      }),\n    );\n  });\n\n  it(\"throws on an unsupported blockchain family\", async () => {\n    const api = makeApiMock();\n\n    await expect(\n      new SendRegisterIdentityTask(api, {\n        contactName: \"Alice\",\n        scope: \"Eth main\",\n        identifier: hexToBytes(\"00000000000000000000000000000000deadbeef\"),\n        blockchainFamily: \"dogecoin\",\n        chainId: 1n,\n      }).run(),\n    ).rejects.toThrow(/Unsupported blockchain family/);\n    expect(api.sendCommand).not.toHaveBeenCalled();\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_device_management_kit", "import_RegisterIdentityCommand", "import_SendRegisterIdentityTask", "hexToBytes", "hex", "out", "i", "FRESH_FRAMED_CHUNK", "EXTENSION_FRAMED_CHUNK", "OK_PROOFS", "makeApiMock", "api", "result", "command", "framedHex"]
 }

package/lib/cjs/internal/use-cases/EditExternalAddressIdentifierUseCase.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var o=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var B=Object.prototype.hasOwnProperty;var l=(t,r)=>{for(var p in r)o(t,p,{get:r[p],enumerable:!0})},s=(t,r,p,i)=>{if(r&&typeof r=="object"\|\|typeof r=="function")for(let e of y(r))!B.call(t,e)&&e!==p&&o(t,e,{get:()=>r[e],enumerable:!(i=c(r,e))\|\|i.enumerable});return t};var x=t=>s(o({},"__esModule",{value:!0}),t),f=(t,r,p,i)=>{for(var e=i>1?void 0:i?c(r,p):r,m=t.length-1,a;m>=0;m--)(a=t[m])&&(e=(i?a(r,p,e):a(e))\|\|e);return i&&e&&o(r,p,e),e},u=(t,r)=>(p,i)=>r(p,i,t);var I={};l(I,{EditExternalAddressIdentifierUseCase:()=>n});module.exports=x(I);var d=require("inversify"),A=require("../app-binder/di/appBinderTypes");let n=class{constructor(r){this.appBinder=r}execute(r){return this.appBinder.editExternalAddressIdentifier(r)}};n=f([(0,d.injectable)(),u(0,(0,d.inject)(A.appBinderTypes.AppBinder))],n);0&&(module.exports={EditExternalAddressIdentifierUseCase});
2	+ //# sourceMappingURL=EditExternalAddressIdentifierUseCase.js.map

package/lib/cjs/internal/use-cases/EditExternalAddressIdentifierUseCase.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/use-cases/EditExternalAddressIdentifierUseCase.ts"],
+  "sourcesContent": ["import { inject, injectable } from \"inversify\";\n\nimport { type EditExternalAddressIdentifierDAReturnType } from \"@api/app-binder/EditExternalAddressIdentifierDeviceActionTypes\";\nimport { type EditExternalAddressIdentifierInput } from \"@api/model/EditExternalAddressIdentifier\";\nimport { ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\n\n/**\n * Delegates to `ContactsAppBinder`, which constructs and executes the\n * `EditExternalAddressIdentifierDeviceAction`. Input validation lives in the\n * device action (surfaced as a typed error state), not here.\n */\n@injectable()\nexport class EditExternalAddressIdentifierUseCase {\n  constructor(\n    @inject(appBinderTypes.AppBinder)\n    private readonly appBinder: ContactsAppBinder,\n  ) {}\n\n  execute(\n    input: EditExternalAddressIdentifierInput,\n  ): EditExternalAddressIdentifierDAReturnType {\n    return this.appBinder.editExternalAddressIdentifier(input);\n  }\n}\n"],
+  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0CAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,qBAKnCC,EAA+B,kDAQxB,IAAMC,EAAN,KAA2C,CAChD,YAEmBC,EACjB,CADiB,eAAAA,CAChB,CAEH,QACEC,EAC2C,CAC3C,OAAO,KAAK,UAAU,8BAA8BA,CAAK,CAC3D,CACF,EAXaF,EAANG,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,iBAAe,SAAS,IAFvBJ",
+  "names": ["EditExternalAddressIdentifierUseCase_exports", "__export", "EditExternalAddressIdentifierUseCase", "__toCommonJS", "import_inversify", "import_appBinderTypes", "EditExternalAddressIdentifierUseCase", "appBinder", "input", "__decorateClass", "__decorateParam"]
+}

package/lib/cjs/internal/use-cases/EditExternalAddressIdentifierUseCase.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var a=require("./EditExternalAddressIdentifierUseCase");function r(){const e=vi.fn().mockReturnValue("DA_RETURN"),t={editExternalAddressIdentifier:e};return{useCase:new a.EditExternalAddressIdentifierUseCase(t),editExternalAddressIdentifier:e}}const i={contactName:"Alice",scope:"Eth main",previousIdentifier:new Uint8Array(20).fill(17),newIdentifier:new Uint8Array(20).fill(34),blockchainFamily:"ethereum",chainId:1n,groupHandle:new Uint8Array(64).fill(204),hmacProof:new Uint8Array(32).fill(221),hmacRest:new Uint8Array(32).fill(170)};describe("EditExternalAddressIdentifierUseCase",()=>{it("delegates to the app binder",()=>{const{useCase:e,editExternalAddressIdentifier:t}=r(),n=e.execute(i);expect(t).toHaveBeenCalledWith(i),expect(n).toBe("DA_RETURN")}),it("does not validate \u2014 invalid input is forwarded, not thrown",()=>{const{useCase:e,editExternalAddressIdentifier:t}=r(),n={...i,contactName:""};expect(()=>e.execute(n)).not.toThrow(),expect(t).toHaveBeenCalledWith(n)})});
2	+ //# sourceMappingURL=EditExternalAddressIdentifierUseCase.test.js.map

package/lib/cjs/internal/use-cases/EditExternalAddressIdentifierUseCase.test.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/use-cases/EditExternalAddressIdentifierUseCase.test.ts"],
+  "sourcesContent": ["import { type EditExternalAddressIdentifierInput } from \"@api/model/EditExternalAddressIdentifier\";\nimport { type ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\n\nimport { EditExternalAddressIdentifierUseCase } from \"./EditExternalAddressIdentifierUseCase\";\n\nfunction makeUseCase() {\n  const editExternalAddressIdentifier = vi.fn().mockReturnValue(\"DA_RETURN\");\n  const appBinder = {\n    editExternalAddressIdentifier,\n  } as unknown as ContactsAppBinder;\n  return {\n    useCase: new EditExternalAddressIdentifierUseCase(appBinder),\n    editExternalAddressIdentifier,\n  };\n}\n\nconst VALID_INPUT: EditExternalAddressIdentifierInput = {\n  contactName: \"Alice\",\n  scope: \"Eth main\",\n  previousIdentifier: new Uint8Array(20).fill(0x11),\n  newIdentifier: new Uint8Array(20).fill(0x22),\n  blockchainFamily: \"ethereum\",\n  chainId: 1n,\n  groupHandle: new Uint8Array(64).fill(0xcc),\n  hmacProof: new Uint8Array(32).fill(0xdd),\n  hmacRest: new Uint8Array(32).fill(0xaa),\n};\n\ndescribe(\"EditExternalAddressIdentifierUseCase\", () => {\n  it(\"delegates to the app binder\", () => {\n    const { useCase, editExternalAddressIdentifier } = makeUseCase();\n\n    const result = useCase.execute(VALID_INPUT);\n\n    expect(editExternalAddressIdentifier).toHaveBeenCalledWith(VALID_INPUT);\n    expect(result).toBe(\"DA_RETURN\");\n  });\n\n  it(\"does not validate \u2014 invalid input is forwarded, not thrown\", () => {\n    // Validation now lives in the device action and surfaces as a typed DA\n    // error state; the use case must never throw for bad input.\n    const { useCase, editExternalAddressIdentifier } = makeUseCase();\n\n    const invalidInput = { ...VALID_INPUT, contactName: \"\" };\n    expect(() => useCase.execute(invalidInput)).not.toThrow();\n    expect(editExternalAddressIdentifier).toHaveBeenCalledWith(invalidInput);\n  });\n});\n"],
+  "mappings": "aAGA,IAAAA,EAAqD,kDAErD,SAASC,GAAc,CACrB,MAAMC,EAAgC,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACnEC,EAAY,CAChB,8BAAAD,CACF,EACA,MAAO,CACL,QAAS,IAAI,uCAAqCC,CAAS,EAC3D,8BAAAD,CACF,CACF,CAEA,MAAME,EAAkD,CACtD,YAAa,QACb,MAAO,WACP,mBAAoB,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EAChD,cAAe,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EAC3C,iBAAkB,WAClB,QAAS,GACT,YAAa,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,EACzC,UAAW,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,EACvC,SAAU,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,CACxC,EAEA,SAAS,uCAAwC,IAAM,CACrD,GAAG,8BAA+B,IAAM,CACtC,KAAM,CAAE,QAAAC,EAAS,8BAAAH,CAA8B,EAAID,EAAY,EAEzDK,EAASD,EAAQ,QAAQD,CAAW,EAE1C,OAAOF,CAA6B,EAAE,qBAAqBE,CAAW,EACtE,OAAOE,CAAM,EAAE,KAAK,WAAW,CACjC,CAAC,EAED,GAAG,kEAA8D,IAAM,CAGrE,KAAM,CAAE,QAAAD,EAAS,8BAAAH,CAA8B,EAAID,EAAY,EAEzDM,EAAe,CAAE,GAAGH,EAAa,YAAa,EAAG,EACvD,OAAO,IAAMC,EAAQ,QAAQE,CAAY,CAAC,EAAE,IAAI,QAAQ,EACxD,OAAOL,CAA6B,EAAE,qBAAqBK,CAAY,CACzE,CAAC,CACH,CAAC",
+  "names": ["import_EditExternalAddressIdentifierUseCase", "makeUseCase", "editExternalAddressIdentifier", "appBinder", "VALID_INPUT", "useCase", "result", "invalidInput"]
+}

package/lib/cjs/internal/use-cases/EditExternalAddressScopeUseCase.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var i=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var B=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var l=(p,r)=>{for(var e in r)i(p,e,{get:r[e],enumerable:!0})},s=(p,r,e,n)=>{if(r&&typeof r=="object"\|\|typeof r=="function")for(let t of B(r))!f.call(p,t)&&t!==e&&i(p,t,{get:()=>r[t],enumerable:!(n=a(r,t))\|\|n.enumerable});return p};var x=p=>s(i({},"__esModule",{value:!0}),p),u=(p,r,e,n)=>{for(var t=n>1?void 0:n?a(r,e):r,c=p.length-1,m;c>=0;c--)(m=p[c])&&(t=(n?m(r,e,t):m(t))\|\|t);return n&&t&&i(r,e,t),t},A=(p,r)=>(e,n)=>r(e,n,p);var E={};l(E,{EditExternalAddressScopeUseCase:()=>o});module.exports=x(E);var d=require("inversify"),y=require("../app-binder/di/appBinderTypes");let o=class{constructor(r){this.appBinder=r}execute(r){return this.appBinder.editExternalAddressScope(r)}};o=u([(0,d.injectable)(),A(0,(0,d.inject)(y.appBinderTypes.AppBinder))],o);0&&(module.exports={EditExternalAddressScopeUseCase});
2	+ //# sourceMappingURL=EditExternalAddressScopeUseCase.js.map

package/lib/cjs/internal/use-cases/EditExternalAddressScopeUseCase.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/use-cases/EditExternalAddressScopeUseCase.ts"],
+  "sourcesContent": ["import { inject, injectable } from \"inversify\";\n\nimport { type EditExternalAddressScopeDAReturnType } from \"@api/app-binder/EditExternalAddressScopeDeviceActionTypes\";\nimport { type EditExternalAddressScopeInput } from \"@api/model/EditExternalAddressScope\";\nimport { ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\n\n/**\n * Delegates to `ContactsAppBinder`, which constructs and executes the\n * `EditExternalAddressScopeDeviceAction`. Input validation lives in the device\n * action (surfaced as a typed error state), not here.\n */\n@injectable()\nexport class EditExternalAddressScopeUseCase {\n  constructor(\n    @inject(appBinderTypes.AppBinder)\n    private readonly appBinder: ContactsAppBinder,\n  ) {}\n\n  execute(\n    input: EditExternalAddressScopeInput,\n  ): EditExternalAddressScopeDAReturnType {\n    return this.appBinder.editExternalAddressScope(input);\n  }\n}\n"],
+  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,qCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,qBAKnCC,EAA+B,kDAQxB,IAAMC,EAAN,KAAsC,CAC3C,YAEmBC,EACjB,CADiB,eAAAA,CAChB,CAEH,QACEC,EACsC,CACtC,OAAO,KAAK,UAAU,yBAAyBA,CAAK,CACtD,CACF,EAXaF,EAANG,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,iBAAe,SAAS,IAFvBJ",
+  "names": ["EditExternalAddressScopeUseCase_exports", "__export", "EditExternalAddressScopeUseCase", "__toCommonJS", "import_inversify", "import_appBinderTypes", "EditExternalAddressScopeUseCase", "appBinder", "input", "__decorateClass", "__decorateParam"]
+}

package/lib/cjs/internal/use-cases/EditExternalAddressScopeUseCase.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var r=require("./EditExternalAddressScopeUseCase");function o(){const e=vi.fn().mockReturnValue("DA_RETURN"),t={editExternalAddressScope:e};return{useCase:new r.EditExternalAddressScopeUseCase(t),editExternalAddressScope:e}}const a={contactName:"Alice",previousScope:"Eth main",newScope:"Eth cold",identifier:new Uint8Array(20).fill(17),blockchainFamily:"ethereum",chainId:1n,groupHandle:new Uint8Array(64).fill(204),hmacProof:new Uint8Array(32).fill(221),hmacRest:new Uint8Array(32).fill(170)};describe("EditExternalAddressScopeUseCase",()=>{it("delegates to the app binder",()=>{const{useCase:e,editExternalAddressScope:t}=o(),n=e.execute(a);expect(t).toHaveBeenCalledWith(a),expect(n).toBe("DA_RETURN")}),it("does not validate \u2014 invalid input is forwarded, not thrown",()=>{const{useCase:e,editExternalAddressScope:t}=o(),n={...a,contactName:""};expect(()=>e.execute(n)).not.toThrow(),expect(t).toHaveBeenCalledWith(n)})});
2	+ //# sourceMappingURL=EditExternalAddressScopeUseCase.test.js.map

package/lib/cjs/internal/use-cases/EditExternalAddressScopeUseCase.test.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/use-cases/EditExternalAddressScopeUseCase.test.ts"],
+  "sourcesContent": ["import { type EditExternalAddressScopeInput } from \"@api/model/EditExternalAddressScope\";\nimport { type ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\n\nimport { EditExternalAddressScopeUseCase } from \"./EditExternalAddressScopeUseCase\";\n\nfunction makeUseCase() {\n  const editExternalAddressScope = vi.fn().mockReturnValue(\"DA_RETURN\");\n  const appBinder = {\n    editExternalAddressScope,\n  } as unknown as ContactsAppBinder;\n  return {\n    useCase: new EditExternalAddressScopeUseCase(appBinder),\n    editExternalAddressScope,\n  };\n}\n\nconst VALID_INPUT: EditExternalAddressScopeInput = {\n  contactName: \"Alice\",\n  previousScope: \"Eth main\",\n  newScope: \"Eth cold\",\n  identifier: new Uint8Array(20).fill(0x11),\n  blockchainFamily: \"ethereum\",\n  chainId: 1n,\n  groupHandle: new Uint8Array(64).fill(0xcc),\n  hmacProof: new Uint8Array(32).fill(0xdd),\n  hmacRest: new Uint8Array(32).fill(0xaa),\n};\n\ndescribe(\"EditExternalAddressScopeUseCase\", () => {\n  it(\"delegates to the app binder\", () => {\n    const { useCase, editExternalAddressScope } = makeUseCase();\n\n    const result = useCase.execute(VALID_INPUT);\n\n    expect(editExternalAddressScope).toHaveBeenCalledWith(VALID_INPUT);\n    expect(result).toBe(\"DA_RETURN\");\n  });\n\n  it(\"does not validate \u2014 invalid input is forwarded, not thrown\", () => {\n    // Validation now lives in the device action and surfaces as a typed DA\n    // error state; the use case must never throw for bad input.\n    const { useCase, editExternalAddressScope } = makeUseCase();\n\n    const invalidInput = { ...VALID_INPUT, contactName: \"\" };\n    expect(() => useCase.execute(invalidInput)).not.toThrow();\n    expect(editExternalAddressScope).toHaveBeenCalledWith(invalidInput);\n  });\n});\n"],
+  "mappings": "aAGA,IAAAA,EAAgD,6CAEhD,SAASC,GAAc,CACrB,MAAMC,EAA2B,GAAG,GAAG,EAAE,gBAAgB,WAAW,EAC9DC,EAAY,CAChB,yBAAAD,CACF,EACA,MAAO,CACL,QAAS,IAAI,kCAAgCC,CAAS,EACtD,yBAAAD,CACF,CACF,CAEA,MAAME,EAA6C,CACjD,YAAa,QACb,cAAe,WACf,SAAU,WACV,WAAY,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EACxC,iBAAkB,WAClB,QAAS,GACT,YAAa,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,EACzC,UAAW,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,EACvC,SAAU,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,CACxC,EAEA,SAAS,kCAAmC,IAAM,CAChD,GAAG,8BAA+B,IAAM,CACtC,KAAM,CAAE,QAAAC,EAAS,yBAAAH,CAAyB,EAAID,EAAY,EAEpDK,EAASD,EAAQ,QAAQD,CAAW,EAE1C,OAAOF,CAAwB,EAAE,qBAAqBE,CAAW,EACjE,OAAOE,CAAM,EAAE,KAAK,WAAW,CACjC,CAAC,EAED,GAAG,kEAA8D,IAAM,CAGrE,KAAM,CAAE,QAAAD,EAAS,yBAAAH,CAAyB,EAAID,EAAY,EAEpDM,EAAe,CAAE,GAAGH,EAAa,YAAa,EAAG,EACvD,OAAO,IAAMC,EAAQ,QAAQE,CAAY,CAAC,EAAE,IAAI,QAAQ,EACxD,OAAOL,CAAwB,EAAE,qBAAqBK,CAAY,CACpE,CAAC,CACH,CAAC",
+  "names": ["import_EditExternalAddressScopeUseCase", "makeUseCase", "editExternalAddressScope", "appBinder", "VALID_INPUT", "useCase", "result", "invalidInput"]
+}

package/lib/cjs/internal/use-cases/di/useCaseModule.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var r=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var f=(e,s)=>{for(var t in s)r(e,t,{get:s[t],enumerable:!0})},l=(e,s,t,m)=>{if(s&&typeof s=="object"||typeof s=="function")for(let o of d(s))!c.call(e,o)&&o!==t&&r(e,o,{get:()=>s[o],enumerable:!(m=p(s,o))||m.enumerable});return e};var u=e=>l(r({},"__esModule",{value:!0}),e);var U={};f(U,{useCaseModuleFactory:()=>R});module.exports=u(U);var n=require("inversify"),C=require("../../use-cases/RegisterExternalAddressUseCase"),i=require("../../use-cases/RenameContactUseCase"),a=require("./useCaseTypes");const R=()=>new n.ContainerModule(({bind:e})=>{e(a.useCaseTypes.RegisterExternalAddressUseCase).to(C.RegisterExternalAddressUseCase),e(a.useCaseTypes.RenameContactUseCase).to(i.RenameContactUseCase)});0&&(module.exports={useCaseModuleFactory});
+"use strict";var a=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var U=(e,s)=>{for(var o in s)a(e,o,{get:s[o],enumerable:!0})},x=(e,s,o,d)=>{if(s&&typeof s=="object"||typeof s=="function")for(let t of f(s))!l.call(e,t)&&t!==o&&a(e,t,{get:()=>s[t],enumerable:!(d=E(s,t))||d.enumerable});return e};var c=e=>x(a({},"__esModule",{value:!0}),e);var u={};U(u,{useCaseModuleFactory:()=>A});module.exports=c(u);var i=require("inversify"),m=require("../../use-cases/EditExternalAddressIdentifierUseCase"),n=require("../../use-cases/EditExternalAddressScopeUseCase"),C=require("../../use-cases/RegisterExternalAddressUseCase"),p=require("../../use-cases/RenameContactUseCase"),r=require("./useCaseTypes");const A=()=>new i.ContainerModule(({bind:e})=>{e(r.useCaseTypes.RegisterExternalAddressUseCase).to(C.RegisterExternalAddressUseCase),e(r.useCaseTypes.RenameContactUseCase).to(p.RenameContactUseCase),e(r.useCaseTypes.EditExternalAddressIdentifierUseCase).to(m.EditExternalAddressIdentifierUseCase),e(r.useCaseTypes.EditExternalAddressScopeUseCase).to(n.EditExternalAddressScopeUseCase)});0&&(module.exports={useCaseModuleFactory});
 //# sourceMappingURL=useCaseModule.js.map

package/lib/cjs/internal/use-cases/di/useCaseModule.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/use-cases/di/useCaseModule.ts"],
-  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { RegisterExternalAddressUseCase } from \"@internal/use-cases/RegisterExternalAddressUseCase\";\nimport { RenameContactUseCase } from \"@internal/use-cases/RenameContactUseCase\";\n\nimport { useCaseTypes } from \"./useCaseTypes\";\n\nexport const useCaseModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(useCaseTypes.RegisterExternalAddressUseCase).to(\n      RegisterExternalAddressUseCase,\n    );\n    bind(useCaseTypes.RenameContactUseCase).to(RenameContactUseCase);\n  });\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAA+C,8DAC/CC,EAAqC,oDAErCC,EAA6B,0BAEtB,MAAML,EAAuB,IAClC,IAAI,kBAAgB,CAAC,CAAE,KAAAM,CAAK,IAAM,CAChCA,EAAK,eAAa,8BAA8B,EAAE,GAChD,gCACF,EACAA,EAAK,eAAa,oBAAoB,EAAE,GAAG,sBAAoB,CACjE,CAAC",
-  "names": ["useCaseModule_exports", "__export", "useCaseModuleFactory", "__toCommonJS", "import_inversify", "import_RegisterExternalAddressUseCase", "import_RenameContactUseCase", "import_useCaseTypes", "bind"]
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { EditExternalAddressIdentifierUseCase } from \"@internal/use-cases/EditExternalAddressIdentifierUseCase\";\nimport { EditExternalAddressScopeUseCase } from \"@internal/use-cases/EditExternalAddressScopeUseCase\";\nimport { RegisterExternalAddressUseCase } from \"@internal/use-cases/RegisterExternalAddressUseCase\";\nimport { RenameContactUseCase } from \"@internal/use-cases/RenameContactUseCase\";\n\nimport { useCaseTypes } from \"./useCaseTypes\";\n\nexport const useCaseModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(useCaseTypes.RegisterExternalAddressUseCase).to(\n      RegisterExternalAddressUseCase,\n    );\n    bind(useCaseTypes.RenameContactUseCase).to(RenameContactUseCase);\n    bind(useCaseTypes.EditExternalAddressIdentifierUseCase).to(\n      EditExternalAddressIdentifierUseCase,\n    );\n    bind(useCaseTypes.EditExternalAddressScopeUseCase).to(\n      EditExternalAddressScopeUseCase,\n    );\n  });\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAAqD,oEACrDC,EAAgD,+DAChDC,EAA+C,8DAC/CC,EAAqC,oDAErCC,EAA6B,0BAEtB,MAAMP,EAAuB,IAClC,IAAI,kBAAgB,CAAC,CAAE,KAAAQ,CAAK,IAAM,CAChCA,EAAK,eAAa,8BAA8B,EAAE,GAChD,gCACF,EACAA,EAAK,eAAa,oBAAoB,EAAE,GAAG,sBAAoB,EAC/DA,EAAK,eAAa,oCAAoC,EAAE,GACtD,sCACF,EACAA,EAAK,eAAa,+BAA+B,EAAE,GACjD,iCACF,CACF,CAAC",
+  "names": ["useCaseModule_exports", "__export", "useCaseModuleFactory", "__toCommonJS", "import_inversify", "import_EditExternalAddressIdentifierUseCase", "import_EditExternalAddressScopeUseCase", "import_RegisterExternalAddressUseCase", "import_RenameContactUseCase", "import_useCaseTypes", "bind"]
 }

package/lib/cjs/internal/use-cases/di/useCaseTypes.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var o=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var C=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var d=(s,e)=>{for(var t in e)o(s,t,{get:e[t],enumerable:!0})},l=(s,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of C(e))!c.call(s,a)&&a!==t&&o(s,a,{get:()=>e[a],enumerable:!(r=n(e,a))||r.enumerable});return s};var m=s=>l(o({},"__esModule",{value:!0}),s);var U={};d(U,{useCaseTypes:()=>R});module.exports=m(U);const R={RegisterExternalAddressUseCase:Symbol.for("RegisterExternalAddressUseCase"),RenameContactUseCase:Symbol.for("RenameContactUseCase")};0&&(module.exports={useCaseTypes});
+"use strict";var a=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var n=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var i=(s,e)=>{for(var t in e)a(s,t,{get:e[t],enumerable:!0})},l=(s,e,t,d)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of n(e))!C.call(s,r)&&r!==t&&a(s,r,{get:()=>e[r],enumerable:!(d=o(e,r))||d.enumerable});return s};var E=s=>l(a({},"__esModule",{value:!0}),s);var x={};i(x,{useCaseTypes:()=>U});module.exports=E(x);const U={RegisterExternalAddressUseCase:Symbol.for("RegisterExternalAddressUseCase"),RenameContactUseCase:Symbol.for("RenameContactUseCase"),EditExternalAddressIdentifierUseCase:Symbol.for("EditExternalAddressIdentifierUseCase"),EditExternalAddressScopeUseCase:Symbol.for("EditExternalAddressScopeUseCase")};0&&(module.exports={useCaseTypes});
 //# sourceMappingURL=useCaseTypes.js.map

package/lib/cjs/internal/use-cases/di/useCaseTypes.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/use-cases/di/useCaseTypes.ts"],
-  "sourcesContent": ["export const useCaseTypes = {\n  RegisterExternalAddressUseCase: Symbol.for(\"RegisterExternalAddressUseCase\"),\n  RenameContactUseCase: Symbol.for(\"RenameContactUseCase\"),\n} as const;\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAAO,MAAME,EAAe,CAC1B,+BAAgC,OAAO,IAAI,gCAAgC,EAC3E,qBAAsB,OAAO,IAAI,sBAAsB,CACzD",
+  "sourcesContent": ["export const useCaseTypes = {\n  RegisterExternalAddressUseCase: Symbol.for(\"RegisterExternalAddressUseCase\"),\n  RenameContactUseCase: Symbol.for(\"RenameContactUseCase\"),\n  EditExternalAddressIdentifierUseCase: Symbol.for(\n    \"EditExternalAddressIdentifierUseCase\",\n  ),\n  EditExternalAddressScopeUseCase: Symbol.for(\n    \"EditExternalAddressScopeUseCase\",\n  ),\n} as const;\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAAO,MAAME,EAAe,CAC1B,+BAAgC,OAAO,IAAI,gCAAgC,EAC3E,qBAAsB,OAAO,IAAI,sBAAsB,EACvD,qCAAsC,OAAO,IAC3C,sCACF,EACA,gCAAiC,OAAO,IACtC,iCACF,CACF",
   "names": ["useCaseTypes_exports", "__export", "useCaseTypes", "__toCommonJS"]
 }

package/lib/cjs/package.json CHANGED Viewed

@@ -58,5 +58,5 @@
     "watch:builds": "pnpm ldmk-tool watch --entryPoints src/index.ts,src/**/*.ts --tsconfig tsconfig.prod.json",
     "watch:types": "concurrently \"tsc --watch -p tsconfig.prod.json\" \"tsc-alias --watch -p tsconfig.prod.json\""
   },
-  "version": "0.0.0-develop-20260831001535"
+  "version": "0.0.0-develop-20260901001631"
 }

package/lib/esm/api/app-binder/EditExternalAddressIdentifierDeviceActionTypes.js ADDED Viewed

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

package/lib/esm/api/app-binder/EditExternalAddressIdentifierDeviceActionTypes.js.map ADDED Viewed

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

package/lib/esm/api/app-binder/EditExternalAddressScopeDeviceActionTypes.js ADDED Viewed

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

package/lib/esm/api/app-binder/EditExternalAddressScopeDeviceActionTypes.js.map ADDED Viewed

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

package/lib/esm/api/index.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ContactsManagerBuilder as r}from"./ContactsManagerBuilder";import{CONTACTS_VERSION_REQUIREMENTS as p,ETHEREUM_APP_NAME as a,isContactsSupported as o,isVersionAtLeast as s,resolveContactsVersionRequirements as d}from"./model/ContactsVersionRequirements";export{p as CONTACTS_VERSION_REQUIREMENTS,r as ContactsManagerBuilder,a as ETHEREUM_APP_NAME,o as isContactsSupported,s as isVersionAtLeast,d as resolveContactsVersionRequirements};
+import{ContactsManagerBuilder as r}from"./ContactsManagerBuilder";import{CONTACTS_VERSION_REQUIREMENTS as d,ETHEREUM_APP_NAME as p,isContactsSupported as s,isVersionAtLeast as a,resolveContactsVersionRequirements as o}from"./model/ContactsVersionRequirements";export{d as CONTACTS_VERSION_REQUIREMENTS,r as ContactsManagerBuilder,p as ETHEREUM_APP_NAME,s as isContactsSupported,a as isVersionAtLeast,o as resolveContactsVersionRequirements};
 //# sourceMappingURL=index.js.map

package/lib/esm/api/index.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/index.ts"],
-  "sourcesContent": ["export {\n  type RegisterExternalAddressDAError,\n  type RegisterExternalAddressDAInput,\n  type RegisterExternalAddressDAIntermediateValue,\n  type RegisterExternalAddressDAOutput,\n  type RegisterExternalAddressDARequiredInteraction,\n  type RegisterExternalAddressDAReturnType,\n  type RegisterExternalAddressDAState,\n} from \"@api/app-binder/RegisterExternalAddressDeviceActionTypes\";\nexport {\n  type RenameContactDAError,\n  type RenameContactDAInput,\n  type RenameContactDAIntermediateValue,\n  type RenameContactDAOutput,\n  type RenameContactDARequiredInteraction,\n  type RenameContactDAReturnType,\n  type RenameContactDAState,\n} from \"@api/app-binder/RenameContactDeviceActionTypes\";\nexport { type ContactsManager } from \"@api/ContactsManager\";\nexport { ContactsManagerBuilder } from \"@api/ContactsManagerBuilder\";\nexport {\n  CONTACTS_VERSION_REQUIREMENTS,\n  type ContactsModelRequirement,\n  type ContactsModelSupport,\n  type ContactsModelUnsupported,\n  type ContactsSupportQuery,\n  type ContactsVersionRequirements,\n  ETHEREUM_APP_NAME,\n  isContactsSupported,\n  isVersionAtLeast,\n  resolveContactsVersionRequirements,\n} from \"@api/model/ContactsVersionRequirements\";\nexport {\n  type ExistingContactGroup,\n  type RegisterExternalAddressInput,\n  type RegisterExternalAddressMode,\n  type RegisterExternalAddressOutput,\n} from \"@api/model/RegisterExternalAddress\";\nexport {\n  type RenameContactInput,\n  type RenameContactOutput,\n} from \"@api/model/RenameContact\";\n"],
-  "mappings": "AAmBA,OAAS,0BAAAA,MAA8B,8BACvC,OACE,iCAAAC,EAMA,qBAAAC,EACA,uBAAAC,EACA,oBAAAC,EACA,sCAAAC,MACK",
+  "sourcesContent": ["export {\n  type EditExternalAddressIdentifierDAError,\n  type EditExternalAddressIdentifierDAInput,\n  type EditExternalAddressIdentifierDAIntermediateValue,\n  type EditExternalAddressIdentifierDAOutput,\n  type EditExternalAddressIdentifierDARequiredInteraction,\n  type EditExternalAddressIdentifierDAReturnType,\n  type EditExternalAddressIdentifierDAState,\n} from \"@api/app-binder/EditExternalAddressIdentifierDeviceActionTypes\";\nexport {\n  type EditExternalAddressScopeDAError,\n  type EditExternalAddressScopeDAInput,\n  type EditExternalAddressScopeDAIntermediateValue,\n  type EditExternalAddressScopeDAOutput,\n  type EditExternalAddressScopeDARequiredInteraction,\n  type EditExternalAddressScopeDAReturnType,\n  type EditExternalAddressScopeDAState,\n} from \"@api/app-binder/EditExternalAddressScopeDeviceActionTypes\";\nexport {\n  type RegisterExternalAddressDAError,\n  type RegisterExternalAddressDAInput,\n  type RegisterExternalAddressDAIntermediateValue,\n  type RegisterExternalAddressDAOutput,\n  type RegisterExternalAddressDARequiredInteraction,\n  type RegisterExternalAddressDAReturnType,\n  type RegisterExternalAddressDAState,\n} from \"@api/app-binder/RegisterExternalAddressDeviceActionTypes\";\nexport {\n  type RenameContactDAError,\n  type RenameContactDAInput,\n  type RenameContactDAIntermediateValue,\n  type RenameContactDAOutput,\n  type RenameContactDARequiredInteraction,\n  type RenameContactDAReturnType,\n  type RenameContactDAState,\n} from \"@api/app-binder/RenameContactDeviceActionTypes\";\nexport { type ContactsManager } from \"@api/ContactsManager\";\nexport { ContactsManagerBuilder } from \"@api/ContactsManagerBuilder\";\nexport {\n  CONTACTS_VERSION_REQUIREMENTS,\n  type ContactsModelRequirement,\n  type ContactsModelSupport,\n  type ContactsModelUnsupported,\n  type ContactsSupportQuery,\n  type ContactsVersionRequirements,\n  ETHEREUM_APP_NAME,\n  isContactsSupported,\n  isVersionAtLeast,\n  resolveContactsVersionRequirements,\n} from \"@api/model/ContactsVersionRequirements\";\nexport {\n  type EditExternalAddressIdentifierInput,\n  type EditExternalAddressIdentifierOutput,\n} from \"@api/model/EditExternalAddressIdentifier\";\nexport {\n  type EditExternalAddressScopeInput,\n  type EditExternalAddressScopeOutput,\n} from \"@api/model/EditExternalAddressScope\";\nexport {\n  type ExistingContactGroup,\n  type RegisterExternalAddressInput,\n  type RegisterExternalAddressMode,\n  type RegisterExternalAddressOutput,\n} from \"@api/model/RegisterExternalAddress\";\nexport {\n  type RenameContactInput,\n  type RenameContactOutput,\n} from \"@api/model/RenameContact\";\n"],
+  "mappings": "AAqCA,OAAS,0BAAAA,MAA8B,8BACvC,OACE,iCAAAC,EAMA,qBAAAC,EACA,uBAAAC,EACA,oBAAAC,EACA,sCAAAC,MACK",
   "names": ["ContactsManagerBuilder", "CONTACTS_VERSION_REQUIREMENTS", "ETHEREUM_APP_NAME", "isContactsSupported", "isVersionAtLeast", "resolveContactsVersionRequirements"]
 }

package/lib/esm/api/model/EditExternalAddressIdentifier.js ADDED Viewed

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

package/lib/esm/api/model/EditExternalAddressIdentifier.js.map ADDED Viewed

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

package/lib/esm/api/model/EditExternalAddressScope.js ADDED Viewed

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

package/lib/esm/api/model/EditExternalAddressScope.js.map ADDED Viewed

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

package/lib/esm/internal/DefaultContactsManager.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{makeContainer as a}from"./di";import{useCaseTypes as t}from"./use-cases/di/useCaseTypes";class m{_container;constructor({dmk:e,sessionId:r,appName:n}){this._container=a({dmk:e,sessionId:r,appName:n})}registerExternalAddress(e){return this._container.get(t.RegisterExternalAddressUseCase).execute(e)}renameContact(e){return this._container.get(t.RenameContactUseCase).execute(e)}get container(){return this._container}}export{m as DefaultContactsManager};
+import{makeContainer as s}from"./di";import{useCaseTypes as t}from"./use-cases/di/useCaseTypes";class d{_container;constructor({dmk:e,sessionId:r,appName:n}){this._container=s({dmk:e,sessionId:r,appName:n})}registerExternalAddress(e){return this._container.get(t.RegisterExternalAddressUseCase).execute(e)}renameContact(e){return this._container.get(t.RenameContactUseCase).execute(e)}editExternalAddressIdentifier(e){return this._container.get(t.EditExternalAddressIdentifierUseCase).execute(e)}editExternalAddressScope(e){return this._container.get(t.EditExternalAddressScopeUseCase).execute(e)}get container(){return this._container}}export{d as DefaultContactsManager};
 //# sourceMappingURL=DefaultContactsManager.js.map

package/lib/esm/internal/DefaultContactsManager.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/DefaultContactsManager.ts"],
-  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\n\nimport { type RegisterExternalAddressDAReturnType } from \"@api/app-binder/RegisterExternalAddressDeviceActionTypes\";\nimport { type RenameContactDAReturnType } from \"@api/app-binder/RenameContactDeviceActionTypes\";\nimport { type ContactsManager } from \"@api/ContactsManager\";\nimport { type RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { type RenameContactInput } from \"@api/model/RenameContact\";\nimport { makeContainer } from \"@internal/di\";\nimport { useCaseTypes } from \"@internal/use-cases/di/useCaseTypes\";\nimport { type RegisterExternalAddressUseCase } from \"@internal/use-cases/RegisterExternalAddressUseCase\";\nimport { type RenameContactUseCase } from \"@internal/use-cases/RenameContactUseCase\";\n\ntype DefaultContactsManagerConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  appName: string;\n};\n\nexport class DefaultContactsManager implements ContactsManager {\n  private readonly _container: Container;\n\n  constructor({\n    dmk,\n    sessionId,\n    appName,\n  }: DefaultContactsManagerConstructorArgs) {\n    this._container = makeContainer({ dmk, sessionId, appName });\n  }\n\n  registerExternalAddress(\n    input: RegisterExternalAddressInput,\n  ): RegisterExternalAddressDAReturnType {\n    return this._container\n      .get<RegisterExternalAddressUseCase>(\n        useCaseTypes.RegisterExternalAddressUseCase,\n      )\n      .execute(input);\n  }\n\n  renameContact(input: RenameContactInput): RenameContactDAReturnType {\n    return this._container\n      .get<RenameContactUseCase>(useCaseTypes.RenameContactUseCase)\n      .execute(input);\n  }\n\n  /**\n   * Exposes the DI container so future operation methods can resolve their\n   * `UseCase`. Not part of the public API.\n   */\n  protected get container(): Container {\n    return this._container;\n  }\n}\n"],
-  "mappings": "AAWA,OAAS,iBAAAA,MAAqB,eAC9B,OAAS,gBAAAC,MAAoB,sCAUtB,MAAMC,CAAkD,CAC5C,WAEjB,YAAY,CACV,IAAAC,EACA,UAAAC,EACA,QAAAC,CACF,EAA0C,CACxC,KAAK,WAAaL,EAAc,CAAE,IAAAG,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,CAC7D,CAEA,wBACEC,EACqC,CACrC,OAAO,KAAK,WACT,IACCL,EAAa,8BACf,EACC,QAAQK,CAAK,CAClB,CAEA,cAAcA,EAAsD,CAClE,OAAO,KAAK,WACT,IAA0BL,EAAa,oBAAoB,EAC3D,QAAQK,CAAK,CAClB,CAMA,IAAc,WAAuB,CACnC,OAAO,KAAK,UACd,CACF",
+  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\n\nimport { type EditExternalAddressIdentifierDAReturnType } from \"@api/app-binder/EditExternalAddressIdentifierDeviceActionTypes\";\nimport { type EditExternalAddressScopeDAReturnType } from \"@api/app-binder/EditExternalAddressScopeDeviceActionTypes\";\nimport { type RegisterExternalAddressDAReturnType } from \"@api/app-binder/RegisterExternalAddressDeviceActionTypes\";\nimport { type RenameContactDAReturnType } from \"@api/app-binder/RenameContactDeviceActionTypes\";\nimport { type ContactsManager } from \"@api/ContactsManager\";\nimport { type EditExternalAddressIdentifierInput } from \"@api/model/EditExternalAddressIdentifier\";\nimport { type EditExternalAddressScopeInput } from \"@api/model/EditExternalAddressScope\";\nimport { type RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { type RenameContactInput } from \"@api/model/RenameContact\";\nimport { makeContainer } from \"@internal/di\";\nimport { useCaseTypes } from \"@internal/use-cases/di/useCaseTypes\";\nimport { type EditExternalAddressIdentifierUseCase } from \"@internal/use-cases/EditExternalAddressIdentifierUseCase\";\nimport { type EditExternalAddressScopeUseCase } from \"@internal/use-cases/EditExternalAddressScopeUseCase\";\nimport { type RegisterExternalAddressUseCase } from \"@internal/use-cases/RegisterExternalAddressUseCase\";\nimport { type RenameContactUseCase } from \"@internal/use-cases/RenameContactUseCase\";\n\ntype DefaultContactsManagerConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  appName: string;\n};\n\nexport class DefaultContactsManager implements ContactsManager {\n  private readonly _container: Container;\n\n  constructor({\n    dmk,\n    sessionId,\n    appName,\n  }: DefaultContactsManagerConstructorArgs) {\n    this._container = makeContainer({ dmk, sessionId, appName });\n  }\n\n  registerExternalAddress(\n    input: RegisterExternalAddressInput,\n  ): RegisterExternalAddressDAReturnType {\n    return this._container\n      .get<RegisterExternalAddressUseCase>(\n        useCaseTypes.RegisterExternalAddressUseCase,\n      )\n      .execute(input);\n  }\n\n  renameContact(input: RenameContactInput): RenameContactDAReturnType {\n    return this._container\n      .get<RenameContactUseCase>(useCaseTypes.RenameContactUseCase)\n      .execute(input);\n  }\n\n  editExternalAddressIdentifier(\n    input: EditExternalAddressIdentifierInput,\n  ): EditExternalAddressIdentifierDAReturnType {\n    return this._container\n      .get<EditExternalAddressIdentifierUseCase>(\n        useCaseTypes.EditExternalAddressIdentifierUseCase,\n      )\n      .execute(input);\n  }\n\n  editExternalAddressScope(\n    input: EditExternalAddressScopeInput,\n  ): EditExternalAddressScopeDAReturnType {\n    return this._container\n      .get<EditExternalAddressScopeUseCase>(\n        useCaseTypes.EditExternalAddressScopeUseCase,\n      )\n      .execute(input);\n  }\n\n  /**\n   * Exposes the DI container so future operation methods can resolve their\n   * `UseCase`. Not part of the public API.\n   */\n  protected get container(): Container {\n    return this._container;\n  }\n}\n"],
+  "mappings": "AAeA,OAAS,iBAAAA,MAAqB,eAC9B,OAAS,gBAAAC,MAAoB,sCAYtB,MAAMC,CAAkD,CAC5C,WAEjB,YAAY,CACV,IAAAC,EACA,UAAAC,EACA,QAAAC,CACF,EAA0C,CACxC,KAAK,WAAaL,EAAc,CAAE,IAAAG,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,CAC7D,CAEA,wBACEC,EACqC,CACrC,OAAO,KAAK,WACT,IACCL,EAAa,8BACf,EACC,QAAQK,CAAK,CAClB,CAEA,cAAcA,EAAsD,CAClE,OAAO,KAAK,WACT,IAA0BL,EAAa,oBAAoB,EAC3D,QAAQK,CAAK,CAClB,CAEA,8BACEA,EAC2C,CAC3C,OAAO,KAAK,WACT,IACCL,EAAa,oCACf,EACC,QAAQK,CAAK,CAClB,CAEA,yBACEA,EACsC,CACtC,OAAO,KAAK,WACT,IACCL,EAAa,+BACf,EACC,QAAQK,CAAK,CAClB,CAMA,IAAc,WAAuB,CACnC,OAAO,KAAK,UACd,CACF",
   "names": ["makeContainer", "useCaseTypes", "DefaultContactsManager", "dmk", "sessionId", "appName", "input"]
 }

package/lib/esm/internal/DefaultContactsManager.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{DefaultContactsManager as i}from"./DefaultContactsManager";const o={contactName:"Alice",scope:"Eth main",identifier:new Uint8Array(20).fill(17),blockchainFamily:"ethereum",chainId:1n},c={previousContactName:"Alice",newContactName:"Bob",groupHandle:new Uint8Array(64).fill(204),hmacProof:new Uint8Array(32).fill(221)};describe("DefaultContactsManager",()=>{it("registerExternalAddress flows manager -> use-case -> binder -> dmk.executeDeviceAction",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),n={executeDeviceAction:e},a=new i({dmk:n,sessionId:"session-id",appName:"Ethereum"}).registerExternalAddress(o);expect(e).toHaveBeenCalledTimes(1);const t=e.mock.calls[0][0];expect(t.sessionId).toBe("session-id"),expect(t.deviceAction).toBeDefined(),expect(a).toBe("DA_RETURN")}),it("does not throw on invalid input \u2014 it dispatches the device action, which surfaces the error",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),n={executeDeviceAction:e},s=new i({dmk:n,sessionId:"session-id",appName:"Ethereum"});expect(()=>s.registerExternalAddress({...o,contactName:""})).not.toThrow(),expect(e).toHaveBeenCalledTimes(1)}),it("renameContact flows manager -> use-case -> binder -> dmk.executeDeviceAction",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),n={executeDeviceAction:e},a=new i({dmk:n,sessionId:"session-id",appName:"Ethereum"}).renameContact(c);expect(e).toHaveBeenCalledTimes(1);const t=e.mock.calls[0][0];expect(t.sessionId).toBe("session-id"),expect(t.deviceAction).toBeDefined(),expect(a).toBe("DA_RETURN")})});
+import{DefaultContactsManager as a}from"./DefaultContactsManager";const c={contactName:"Alice",scope:"Eth main",identifier:new Uint8Array(20).fill(17),blockchainFamily:"ethereum",chainId:1n},o={previousContactName:"Alice",newContactName:"Bob",groupHandle:new Uint8Array(64).fill(204),hmacProof:new Uint8Array(32).fill(221)},r={contactName:"Alice",scope:"Eth main",previousIdentifier:new Uint8Array(20).fill(17),newIdentifier:new Uint8Array(20).fill(34),blockchainFamily:"ethereum",chainId:1n,groupHandle:new Uint8Array(64).fill(204),hmacProof:new Uint8Array(32).fill(221),hmacRest:new Uint8Array(32).fill(170)},d={contactName:"Alice",previousScope:"Eth main",newScope:"Eth cold",identifier:new Uint8Array(20).fill(17),blockchainFamily:"ethereum",chainId:1n,groupHandle:new Uint8Array(64).fill(204),hmacProof:new Uint8Array(32).fill(221),hmacRest:new Uint8Array(32).fill(170)};describe("DefaultContactsManager",()=>{it("registerExternalAddress flows manager -> use-case -> binder -> dmk.executeDeviceAction",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),t={executeDeviceAction:e},i=new a({dmk:t,sessionId:"session-id",appName:"Ethereum"}).registerExternalAddress(c);expect(e).toHaveBeenCalledTimes(1);const n=e.mock.calls[0][0];expect(n.sessionId).toBe("session-id"),expect(n.deviceAction).toBeDefined(),expect(i).toBe("DA_RETURN")}),it("does not throw on invalid input \u2014 it dispatches the device action, which surfaces the error",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),t={executeDeviceAction:e},s=new a({dmk:t,sessionId:"session-id",appName:"Ethereum"});expect(()=>s.registerExternalAddress({...c,contactName:""})).not.toThrow(),expect(e).toHaveBeenCalledTimes(1)}),it("renameContact flows manager -> use-case -> binder -> dmk.executeDeviceAction",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),t={executeDeviceAction:e},i=new a({dmk:t,sessionId:"session-id",appName:"Ethereum"}).renameContact(o);expect(e).toHaveBeenCalledTimes(1);const n=e.mock.calls[0][0];expect(n.sessionId).toBe("session-id"),expect(n.deviceAction).toBeDefined(),expect(i).toBe("DA_RETURN")}),it("editExternalAddressIdentifier flows manager -> use-case -> binder -> dmk.executeDeviceAction",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),t={executeDeviceAction:e},i=new a({dmk:t,sessionId:"session-id",appName:"Ethereum"}).editExternalAddressIdentifier(r);expect(e).toHaveBeenCalledTimes(1);const n=e.mock.calls[0][0];expect(n.sessionId).toBe("session-id"),expect(n.deviceAction).toBeDefined(),expect(i).toBe("DA_RETURN")}),it("editExternalAddressScope flows manager -> use-case -> binder -> dmk.executeDeviceAction",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),t={executeDeviceAction:e},i=new a({dmk:t,sessionId:"session-id",appName:"Ethereum"}).editExternalAddressScope(d);expect(e).toHaveBeenCalledTimes(1);const n=e.mock.calls[0][0];expect(n.sessionId).toBe("session-id"),expect(n.deviceAction).toBeDefined(),expect(i).toBe("DA_RETURN")})});
 //# sourceMappingURL=DefaultContactsManager.test.js.map

package/lib/esm/internal/DefaultContactsManager.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/DefaultContactsManager.test.ts"],
-  "sourcesContent": ["import { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\n\nimport { type RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { type RenameContactInput } from \"@api/model/RenameContact\";\n\nimport { DefaultContactsManager } from \"./DefaultContactsManager\";\n\nconst VALID_INPUT: RegisterExternalAddressInput = {\n  contactName: \"Alice\",\n  scope: \"Eth main\",\n  identifier: new Uint8Array(20).fill(0x11),\n  blockchainFamily: \"ethereum\",\n  chainId: 1n,\n};\n\nconst VALID_RENAME_INPUT: RenameContactInput = {\n  previousContactName: \"Alice\",\n  newContactName: \"Bob\",\n  groupHandle: new Uint8Array(64).fill(0xcc),\n  hmacProof: new Uint8Array(32).fill(0xdd),\n};\n\ndescribe(\"DefaultContactsManager\", () => {\n  it(\"registerExternalAddress flows manager -> use-case -> binder -> dmk.executeDeviceAction\", () => {\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    const result = manager.registerExternalAddress(VALID_INPUT);\n\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n    const call = executeDeviceAction.mock.calls[0]![0] as {\n      sessionId: string;\n      deviceAction: unknown;\n    };\n    expect(call.sessionId).toBe(\"session-id\");\n    expect(call.deviceAction).toBeDefined();\n    expect(result).toBe(\"DA_RETURN\");\n  });\n\n  it(\"does not throw on invalid input \u2014 it dispatches the device action, which surfaces the error\", () => {\n    // The public API returns a device action; invalid caller input must reach\n    // the observable as a typed error state rather than throwing synchronously.\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    expect(() =>\n      manager.registerExternalAddress({\n        ...VALID_INPUT,\n        contactName: \"\",\n      }),\n    ).not.toThrow();\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"renameContact flows manager -> use-case -> binder -> dmk.executeDeviceAction\", () => {\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    const result = manager.renameContact(VALID_RENAME_INPUT);\n\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n    const call = executeDeviceAction.mock.calls[0]![0] as {\n      sessionId: string;\n      deviceAction: unknown;\n    };\n    expect(call.sessionId).toBe(\"session-id\");\n    expect(call.deviceAction).toBeDefined();\n    expect(result).toBe(\"DA_RETURN\");\n  });\n});\n"],
-  "mappings": "AAKA,OAAS,0BAAAA,MAA8B,2BAEvC,MAAMC,EAA4C,CAChD,YAAa,QACb,MAAO,WACP,WAAY,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EACxC,iBAAkB,WAClB,QAAS,EACX,EAEMC,EAAyC,CAC7C,oBAAqB,QACrB,eAAgB,MAChB,YAAa,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,EACzC,UAAW,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,CACzC,EAEA,SAAS,yBAA0B,IAAM,CACvC,GAAG,yFAA0F,IAAM,CACjG,MAAMC,EAAsB,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACzDC,EAAM,CAAE,oBAAAD,CAAoB,EAQ5BE,EANU,IAAIL,EAAuB,CACzC,IAAAI,EACA,UAAW,aACX,QAAS,UACX,CAAC,EAEsB,wBAAwBH,CAAW,EAE1D,OAAOE,CAAmB,EAAE,sBAAsB,CAAC,EACnD,MAAMG,EAAOH,EAAoB,KAAK,MAAM,CAAC,EAAG,CAAC,EAIjD,OAAOG,EAAK,SAAS,EAAE,KAAK,YAAY,EACxC,OAAOA,EAAK,YAAY,EAAE,YAAY,EACtC,OAAOD,CAAM,EAAE,KAAK,WAAW,CACjC,CAAC,EAED,GAAG,mGAA+F,IAAM,CAGtG,MAAMF,EAAsB,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACzDC,EAAM,CAAE,oBAAAD,CAAoB,EAE5BI,EAAU,IAAIP,EAAuB,CACzC,IAAAI,EACA,UAAW,aACX,QAAS,UACX,CAAC,EAED,OAAO,IACLG,EAAQ,wBAAwB,CAC9B,GAAGN,EACH,YAAa,EACf,CAAC,CACH,EAAE,IAAI,QAAQ,EACd,OAAOE,CAAmB,EAAE,sBAAsB,CAAC,CACrD,CAAC,EAED,GAAG,+EAAgF,IAAM,CACvF,MAAMA,EAAsB,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACzDC,EAAM,CAAE,oBAAAD,CAAoB,EAQ5BE,EANU,IAAIL,EAAuB,CACzC,IAAAI,EACA,UAAW,aACX,QAAS,UACX,CAAC,EAEsB,cAAcF,CAAkB,EAEvD,OAAOC,CAAmB,EAAE,sBAAsB,CAAC,EACnD,MAAMG,EAAOH,EAAoB,KAAK,MAAM,CAAC,EAAG,CAAC,EAIjD,OAAOG,EAAK,SAAS,EAAE,KAAK,YAAY,EACxC,OAAOA,EAAK,YAAY,EAAE,YAAY,EACtC,OAAOD,CAAM,EAAE,KAAK,WAAW,CACjC,CAAC,CACH,CAAC",
-  "names": ["DefaultContactsManager", "VALID_INPUT", "VALID_RENAME_INPUT", "executeDeviceAction", "dmk", "result", "call", "manager"]
+  "sourcesContent": ["import { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\n\nimport { type EditExternalAddressIdentifierInput } from \"@api/model/EditExternalAddressIdentifier\";\nimport { type EditExternalAddressScopeInput } from \"@api/model/EditExternalAddressScope\";\nimport { type RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { type RenameContactInput } from \"@api/model/RenameContact\";\n\nimport { DefaultContactsManager } from \"./DefaultContactsManager\";\n\nconst VALID_INPUT: RegisterExternalAddressInput = {\n  contactName: \"Alice\",\n  scope: \"Eth main\",\n  identifier: new Uint8Array(20).fill(0x11),\n  blockchainFamily: \"ethereum\",\n  chainId: 1n,\n};\n\nconst VALID_RENAME_INPUT: RenameContactInput = {\n  previousContactName: \"Alice\",\n  newContactName: \"Bob\",\n  groupHandle: new Uint8Array(64).fill(0xcc),\n  hmacProof: new Uint8Array(32).fill(0xdd),\n};\n\nconst VALID_EDIT_INPUT: EditExternalAddressIdentifierInput = {\n  contactName: \"Alice\",\n  scope: \"Eth main\",\n  previousIdentifier: new Uint8Array(20).fill(0x11),\n  newIdentifier: new Uint8Array(20).fill(0x22),\n  blockchainFamily: \"ethereum\",\n  chainId: 1n,\n  groupHandle: new Uint8Array(64).fill(0xcc),\n  hmacProof: new Uint8Array(32).fill(0xdd),\n  hmacRest: new Uint8Array(32).fill(0xaa),\n};\n\nconst VALID_EDIT_SCOPE_INPUT: EditExternalAddressScopeInput = {\n  contactName: \"Alice\",\n  previousScope: \"Eth main\",\n  newScope: \"Eth cold\",\n  identifier: new Uint8Array(20).fill(0x11),\n  blockchainFamily: \"ethereum\",\n  chainId: 1n,\n  groupHandle: new Uint8Array(64).fill(0xcc),\n  hmacProof: new Uint8Array(32).fill(0xdd),\n  hmacRest: new Uint8Array(32).fill(0xaa),\n};\n\ndescribe(\"DefaultContactsManager\", () => {\n  it(\"registerExternalAddress flows manager -> use-case -> binder -> dmk.executeDeviceAction\", () => {\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    const result = manager.registerExternalAddress(VALID_INPUT);\n\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n    const call = executeDeviceAction.mock.calls[0]![0] as {\n      sessionId: string;\n      deviceAction: unknown;\n    };\n    expect(call.sessionId).toBe(\"session-id\");\n    expect(call.deviceAction).toBeDefined();\n    expect(result).toBe(\"DA_RETURN\");\n  });\n\n  it(\"does not throw on invalid input \u2014 it dispatches the device action, which surfaces the error\", () => {\n    // The public API returns a device action; invalid caller input must reach\n    // the observable as a typed error state rather than throwing synchronously.\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    expect(() =>\n      manager.registerExternalAddress({\n        ...VALID_INPUT,\n        contactName: \"\",\n      }),\n    ).not.toThrow();\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n  });\n\n  it(\"renameContact flows manager -> use-case -> binder -> dmk.executeDeviceAction\", () => {\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    const result = manager.renameContact(VALID_RENAME_INPUT);\n\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n    const call = executeDeviceAction.mock.calls[0]![0] as {\n      sessionId: string;\n      deviceAction: unknown;\n    };\n    expect(call.sessionId).toBe(\"session-id\");\n    expect(call.deviceAction).toBeDefined();\n    expect(result).toBe(\"DA_RETURN\");\n  });\n\n  it(\"editExternalAddressIdentifier flows manager -> use-case -> binder -> dmk.executeDeviceAction\", () => {\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    const result = manager.editExternalAddressIdentifier(VALID_EDIT_INPUT);\n\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n    const call = executeDeviceAction.mock.calls[0]![0] as {\n      sessionId: string;\n      deviceAction: unknown;\n    };\n    expect(call.sessionId).toBe(\"session-id\");\n    expect(call.deviceAction).toBeDefined();\n    expect(result).toBe(\"DA_RETURN\");\n  });\n\n  it(\"editExternalAddressScope flows manager -> use-case -> binder -> dmk.executeDeviceAction\", () => {\n    const executeDeviceAction = vi.fn().mockReturnValue(\"DA_RETURN\");\n    const dmk = { executeDeviceAction } as unknown as DeviceManagementKit;\n\n    const manager = new DefaultContactsManager({\n      dmk,\n      sessionId: \"session-id\",\n      appName: \"Ethereum\",\n    });\n\n    const result = manager.editExternalAddressScope(VALID_EDIT_SCOPE_INPUT);\n\n    expect(executeDeviceAction).toHaveBeenCalledTimes(1);\n    const call = executeDeviceAction.mock.calls[0]![0] as {\n      sessionId: string;\n      deviceAction: unknown;\n    };\n    expect(call.sessionId).toBe(\"session-id\");\n    expect(call.deviceAction).toBeDefined();\n    expect(result).toBe(\"DA_RETURN\");\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["DefaultContactsManager", "VALID_INPUT", "VALID_RENAME_INPUT", "VALID_EDIT_INPUT", "VALID_EDIT_SCOPE_INPUT", "executeDeviceAction", "dmk", "result", "call", "manager"]
 }

package/lib/esm/internal/app-binder/ContactsAppBinder.js CHANGED Viewed

@@ -1,2 +1,2 @@
-var u=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var d=(i,e,n,t)=>{for(var r=t>1?void 0:t?y(e,n):e,m=i.length-1,a;m>=0;m--)(a=i[m])&&(r=(t?a(e,n,r):a(r))||r);return t&&r&&u(e,n,r),r},s=(i,e)=>(n,t)=>e(n,t,i);import{inject as p,injectable as A}from"inversify";import{RegisterExternalAddressDeviceAction as R}from"../app-binder/device-action/RegisterExternalAddress/RegisterExternalAddressDeviceAction";import{RenameContactDeviceAction as D}from"../app-binder/device-action/RenameContact/RenameContactDeviceAction";import{externalTypes as c}from"../externalTypes";let o=class{constructor(e,n,t){this.dmk=e;this.sessionId=n;this.appName=t}registerExternalAddress(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new R({input:{...e,appName:this.appName}})})}renameContact(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new D({input:e})})}};o=d([A(),s(0,p(c.Dmk)),s(1,p(c.SessionId)),s(2,p(c.AppName))],o);export{o as ContactsAppBinder};
+var A=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var c=(n,e,i,t)=>{for(var r=t>1?void 0:t?u(e,i):e,o=n.length-1,p;o>=0;o--)(p=n[o])&&(r=(t?p(e,i,r):p(r))||r);return t&&r&&A(e,i,r),r},s=(n,e)=>(i,t)=>e(i,t,n);import{inject as a,injectable as E}from"inversify";import{EditExternalAddressIdentifierDeviceAction as I}from"../app-binder/device-action/EditExternalAddressIdentifier/EditExternalAddressIdentifierDeviceAction";import{EditExternalAddressScopeDeviceAction as l}from"../app-binder/device-action/EditExternalAddressScope/EditExternalAddressScopeDeviceAction";import{RegisterExternalAddressDeviceAction as x}from"../app-binder/device-action/RegisterExternalAddress/RegisterExternalAddressDeviceAction";import{RenameContactDeviceAction as y}from"../app-binder/device-action/RenameContact/RenameContactDeviceAction";import{externalTypes as m}from"../externalTypes";let d=class{constructor(e,i,t){this.dmk=e;this.sessionId=i;this.appName=t}registerExternalAddress(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new x({input:{...e,appName:this.appName}})})}renameContact(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new y({input:e})})}editExternalAddressIdentifier(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new I({input:{...e,appName:this.appName}})})}editExternalAddressScope(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new l({input:{...e,appName:this.appName}})})}};d=c([E(),s(0,a(m.Dmk)),s(1,a(m.SessionId)),s(2,a(m.AppName))],d);export{d as ContactsAppBinder};
 //# sourceMappingURL=ContactsAppBinder.js.map

package/lib/esm/internal/app-binder/ContactsAppBinder.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/app-binder/ContactsAppBinder.ts"],
-  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { type RegisterExternalAddressDAReturnType } from \"@api/app-binder/RegisterExternalAddressDeviceActionTypes\";\nimport { type RenameContactDAReturnType } from \"@api/app-binder/RenameContactDeviceActionTypes\";\nimport { type RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { type RenameContactInput } from \"@api/model/RenameContact\";\nimport { RegisterExternalAddressDeviceAction } from \"@internal/app-binder/device-action/RegisterExternalAddress/RegisterExternalAddressDeviceAction\";\nimport { RenameContactDeviceAction } from \"@internal/app-binder/device-action/RenameContact/RenameContactDeviceAction\";\nimport { externalTypes } from \"@internal/externalTypes\";\n\n/**\n * Constructs and executes Contacts `DeviceAction`s using the injected `dmk`,\n * `sessionId`, and `appName`. Each Address Book operation gets one method here.\n */\n@injectable()\nexport class ContactsAppBinder {\n  constructor(\n    @inject(externalTypes.Dmk)\n    protected readonly dmk: DeviceManagementKit,\n    @inject(externalTypes.SessionId)\n    protected readonly sessionId: DeviceSessionId,\n    @inject(externalTypes.AppName)\n    protected readonly appName: string,\n  ) {}\n\n  registerExternalAddress(\n    input: RegisterExternalAddressInput,\n  ): RegisterExternalAddressDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new RegisterExternalAddressDeviceAction({\n        input: { ...input, appName: this.appName },\n      }),\n    });\n  }\n\n  renameContact(input: RenameContactInput): RenameContactDAReturnType {\n    // Rename is a dashboard operation: `appName` is intentionally not passed \u2014\n    // the OS serves the command and there is no app to open.\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new RenameContactDeviceAction({ input }),\n    });\n  }\n}\n"],
-  "mappings": "iOAIA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAMnC,OAAS,uCAAAC,MAA2C,iGACpD,OAAS,6BAAAC,MAAiC,6EAC1C,OAAS,iBAAAC,MAAqB,0BAOvB,IAAMC,EAAN,KAAwB,CAC7B,YAEqBC,EAEAC,EAEAC,EACnB,CALmB,SAAAF,EAEA,eAAAC,EAEA,aAAAC,CAClB,CAEH,wBACEC,EACqC,CACrC,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAIC,EAAoC,CACpD,MAAO,CAAE,GAAGD,EAAO,QAAS,KAAK,OAAQ,CAC3C,CAAC,CACH,CAAC,CACH,CAEA,cAAcA,EAAsD,CAGlE,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAIE,EAA0B,CAAE,MAAAF,CAAM,CAAC,CACvD,CAAC,CACH,CACF,EA7BaJ,EAANO,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAc,GAAG,GAExBF,EAAA,EAAAC,EAAOC,EAAc,SAAS,GAE9BF,EAAA,EAAAC,EAAOC,EAAc,OAAO,IANpBX",
-  "names": ["inject", "injectable", "RegisterExternalAddressDeviceAction", "RenameContactDeviceAction", "externalTypes", "ContactsAppBinder", "dmk", "sessionId", "appName", "input", "RegisterExternalAddressDeviceAction", "RenameContactDeviceAction", "__decorateClass", "injectable", "__decorateParam", "inject", "externalTypes"]
+  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { type EditExternalAddressIdentifierDAReturnType } from \"@api/app-binder/EditExternalAddressIdentifierDeviceActionTypes\";\nimport { type EditExternalAddressScopeDAReturnType } from \"@api/app-binder/EditExternalAddressScopeDeviceActionTypes\";\nimport { type RegisterExternalAddressDAReturnType } from \"@api/app-binder/RegisterExternalAddressDeviceActionTypes\";\nimport { type RenameContactDAReturnType } from \"@api/app-binder/RenameContactDeviceActionTypes\";\nimport { type EditExternalAddressIdentifierInput } from \"@api/model/EditExternalAddressIdentifier\";\nimport { type EditExternalAddressScopeInput } from \"@api/model/EditExternalAddressScope\";\nimport { type RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { type RenameContactInput } from \"@api/model/RenameContact\";\nimport { EditExternalAddressIdentifierDeviceAction } from \"@internal/app-binder/device-action/EditExternalAddressIdentifier/EditExternalAddressIdentifierDeviceAction\";\nimport { EditExternalAddressScopeDeviceAction } from \"@internal/app-binder/device-action/EditExternalAddressScope/EditExternalAddressScopeDeviceAction\";\nimport { RegisterExternalAddressDeviceAction } from \"@internal/app-binder/device-action/RegisterExternalAddress/RegisterExternalAddressDeviceAction\";\nimport { RenameContactDeviceAction } from \"@internal/app-binder/device-action/RenameContact/RenameContactDeviceAction\";\nimport { externalTypes } from \"@internal/externalTypes\";\n\n/**\n * Constructs and executes Contacts `DeviceAction`s using the injected `dmk`,\n * `sessionId`, and `appName`. Each Address Book operation gets one method here.\n */\n@injectable()\nexport class ContactsAppBinder {\n  constructor(\n    @inject(externalTypes.Dmk)\n    protected readonly dmk: DeviceManagementKit,\n    @inject(externalTypes.SessionId)\n    protected readonly sessionId: DeviceSessionId,\n    @inject(externalTypes.AppName)\n    protected readonly appName: string,\n  ) {}\n\n  registerExternalAddress(\n    input: RegisterExternalAddressInput,\n  ): RegisterExternalAddressDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new RegisterExternalAddressDeviceAction({\n        input: { ...input, appName: this.appName },\n      }),\n    });\n  }\n\n  renameContact(input: RenameContactInput): RenameContactDAReturnType {\n    // Rename is a dashboard operation: `appName` is intentionally not passed \u2014\n    // the OS serves the command and there is no app to open.\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new RenameContactDeviceAction({ input }),\n    });\n  }\n\n  editExternalAddressIdentifier(\n    input: EditExternalAddressIdentifierInput,\n  ): EditExternalAddressIdentifierDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new EditExternalAddressIdentifierDeviceAction({\n        input: { ...input, appName: this.appName },\n      }),\n    });\n  }\n\n  editExternalAddressScope(\n    input: EditExternalAddressScopeInput,\n  ): EditExternalAddressScopeDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new EditExternalAddressScopeDeviceAction({\n        input: { ...input, appName: this.appName },\n      }),\n    });\n  }\n}\n"],
+  "mappings": "iOAIA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAUnC,OAAS,6CAAAC,MAAiD,6GAC1D,OAAS,wCAAAC,MAA4C,mGACrD,OAAS,uCAAAC,MAA2C,iGACpD,OAAS,6BAAAC,MAAiC,6EAC1C,OAAS,iBAAAC,MAAqB,0BAOvB,IAAMC,EAAN,KAAwB,CAC7B,YAEqBC,EAEAC,EAEAC,EACnB,CALmB,SAAAF,EAEA,eAAAC,EAEA,aAAAC,CAClB,CAEH,wBACEC,EACqC,CACrC,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAIC,EAAoC,CACpD,MAAO,CAAE,GAAGD,EAAO,QAAS,KAAK,OAAQ,CAC3C,CAAC,CACH,CAAC,CACH,CAEA,cAAcA,EAAsD,CAGlE,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAIE,EAA0B,CAAE,MAAAF,CAAM,CAAC,CACvD,CAAC,CACH,CAEA,8BACEA,EAC2C,CAC3C,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAIG,EAA0C,CAC1D,MAAO,CAAE,GAAGH,EAAO,QAAS,KAAK,OAAQ,CAC3C,CAAC,CACH,CAAC,CACH,CAEA,yBACEA,EACsC,CACtC,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAII,EAAqC,CACrD,MAAO,CAAE,GAAGJ,EAAO,QAAS,KAAK,OAAQ,CAC3C,CAAC,CACH,CAAC,CACH,CACF,EAnDaJ,EAANS,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAc,GAAG,GAExBF,EAAA,EAAAC,EAAOC,EAAc,SAAS,GAE9BF,EAAA,EAAAC,EAAOC,EAAc,OAAO,IANpBb",
+  "names": ["inject", "injectable", "EditExternalAddressIdentifierDeviceAction", "EditExternalAddressScopeDeviceAction", "RegisterExternalAddressDeviceAction", "RenameContactDeviceAction", "externalTypes", "ContactsAppBinder", "dmk", "sessionId", "appName", "input", "RegisterExternalAddressDeviceAction", "RenameContactDeviceAction", "EditExternalAddressIdentifierDeviceAction", "EditExternalAddressScopeDeviceAction", "__decorateClass", "injectable", "__decorateParam", "inject", "externalTypes"]
 }

package/lib/esm/internal/app-binder/command/EditExternalAddressIdentifierCommand.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{ApduBuilder as i,ApduParser as m,CommandResultFactory as t,InvalidStatusWordError as a}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as p}from"@ledgerhq/signer-utils";import{Maybe as E}from"purify-ts";import{CONTACTS_APDU_CLA as l,CONTACTS_APDU_INS as u,HMAC_REST_BYTES as C,SUB_CMD_EDIT_IDENTIFIER as A}from"../../app-binder/model/contactsConstants";import{CONTACTS_APP_ERRORS as f,contactsCommandErrorFactory as c}from"../../app-binder/model/contactsErrors";import{STRUCT_TYPE_EDIT_IDENTIFIER as y}from"../../app-binder/services/contactsTlvSerializer";const s=y;function I(n,r){const e=n.extractFieldByLength(r);if(!(!e\|\|e.length!==r))return Uint8Array.from(e)}class U{name="editExternalAddressIdentifier";args;errorHelper=new p(f,c);constructor(r){this.args=r}getApdu(){return new i({cla:l,ins:u,p1:A,p2:this.args.p2}).addBufferToData(this.args.data).build()}parseResponse(r){return E.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{if(r.data.length===0)return t({data:{}});const e=new m(r),d=e.extract8BitUInt();if(d!==s)return t({error:new a(`Expected struct_type 0x${s.toString(16)}, got ${d===void 0?"undefined":`0x${d.toString(16)}`}`)});const o=I(e,C);return o?t({data:{hmacRest:o}}):t({error:new a("hmac_rest missing or truncated")})})}}export{U as EditExternalAddressIdentifierCommand};
2	+ //# sourceMappingURL=EditExternalAddressIdentifierCommand.js.map

package/lib/esm/internal/app-binder/command/EditExternalAddressIdentifierCommand.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/command/EditExternalAddressIdentifierCommand.ts"],
+  "sourcesContent": ["// Edit Identifier \u2014 sub-command P1=0x03 of the address-book APDU (CLA 0xB0 /\n// INS 0x10). Frames one chunk; on the final chunk parses the 33-byte response\n// struct_type(0x31) + hmac_rest(32) (the rotated address-level proof).\n// Intermediate chunks ack SW=0x9000 with no data. SW 0x6982 = seed/handle\n// mismatch, surfaced via the shared error helper before any device UI.\n// Protocol: Address Book Final Specifications \u2014 Edit Identifier.\nimport {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  CONTACTS_APDU_CLA,\n  CONTACTS_APDU_INS,\n  HMAC_REST_BYTES,\n  SUB_CMD_EDIT_IDENTIFIER,\n} from \"@internal/app-binder/model/contactsConstants\";\nimport {\n  CONTACTS_APP_ERRORS,\n  contactsCommandErrorFactory,\n  type ContactsErrorCodes,\n} from \"@internal/app-binder/model/contactsErrors\";\nimport { STRUCT_TYPE_EDIT_IDENTIFIER } from \"@internal/app-binder/services/contactsTlvSerializer\";\n\nexport type EditExternalAddressIdentifierCommandArgs = {\n  /** One framed chunk built by sendFramedContactsPayload. */\n  readonly data: Uint8Array;\n  /** 0x00 for the first/only chunk, 0x80 for continuation chunks. */\n  readonly p2: number;\n};\n\nexport type EditExternalAddressIdentifierCommandResponse = {\n  /**\n   * Present only on the final chunk \u2014 the device returns struct_type(0x31) +\n   * hmac_rest(32) there. Intermediate chunks return SW=0x9000 with no data.\n   * This is the replacement address-level proof (rotated `hmac_rest`).\n   */\n  readonly hmacRest?: Uint8Array;\n};\n\nconst RESPONSE_STRUCT_TYPE = STRUCT_TYPE_EDIT_IDENTIFIER;\n\n/**\n * Extract `length` bytes as a freshly-owned plain `Uint8Array` (the parser may\n * hand back a `Buffer` view backed by the response), or `undefined` if the\n * response is too short.\n */\nfunction extractField(\n  parser: ApduParser,\n  length: number,\n): Uint8Array | undefined {\n  const field = parser.extractFieldByLength(length);\n  if (!field || field.length !== length) return undefined;\n  return Uint8Array.from(field);\n}\n\nexport class EditExternalAddressIdentifierCommand\n  implements\n    Command<\n      EditExternalAddressIdentifierCommandResponse,\n      EditExternalAddressIdentifierCommandArgs,\n      ContactsErrorCodes\n    >\n{\n  readonly name = \"editExternalAddressIdentifier\";\n  readonly args: EditExternalAddressIdentifierCommandArgs;\n  private readonly errorHelper = new CommandErrorHelper<\n    EditExternalAddressIdentifierCommandResponse,\n    ContactsErrorCodes\n  >(CONTACTS_APP_ERRORS, contactsCommandErrorFactory);\n\n  constructor(args: EditExternalAddressIdentifierCommandArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    return new ApduBuilder({\n      cla: CONTACTS_APDU_CLA,\n      ins: CONTACTS_APDU_INS,\n      p1: SUB_CMD_EDIT_IDENTIFIER,\n      p2: this.args.p2,\n    })\n      .addBufferToData(this.args.data)\n      .build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<\n    EditExternalAddressIdentifierCommandResponse,\n    ContactsErrorCodes\n  > {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      if (response.data.length === 0) {\n        // Intermediate chunk \u2014 device acks with SW=0x9000 and no payload.\n        return CommandResultFactory({ data: {} });\n      }\n\n      const parser = new ApduParser(response);\n\n      const structType = parser.extract8BitUInt();\n      if (structType !== RESPONSE_STRUCT_TYPE) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\n            `Expected struct_type 0x${RESPONSE_STRUCT_TYPE.toString(16)}, got ${\n              structType === undefined\n                ? \"undefined\"\n                : `0x${structType.toString(16)}`\n            }`,\n          ),\n        });\n      }\n\n      const hmacRest = extractField(parser, HMAC_REST_BYTES);\n      if (!hmacRest) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"hmac_rest missing or truncated\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { hmacRest },\n      });\n    });\n  }\n}\n"],
+  "mappings": "AAMA,OAEE,eAAAA,EACA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,qBAAAC,EACA,qBAAAC,EACA,mBAAAC,EACA,2BAAAC,MACK,+CACP,OACE,uBAAAC,EACA,+BAAAC,MAEK,4CACP,OAAS,+BAAAC,MAAmC,sDAkB5C,MAAMC,EAAuBD,EAO7B,SAASE,EACPC,EACAC,EACwB,CACxB,MAAMC,EAAQF,EAAO,qBAAqBC,CAAM,EAChD,GAAI,GAACC,GAASA,EAAM,SAAWD,GAC/B,OAAO,WAAW,KAAKC,CAAK,CAC9B,CAEO,MAAMC,CAOb,CACW,KAAO,gCACP,KACQ,YAAc,IAAId,EAGjCM,EAAqBC,CAA2B,EAElD,YAAYQ,EAAgD,CAC1D,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,OAAO,IAAInB,EAAY,CACrB,IAAKM,EACL,IAAKC,EACL,GAAIE,EACJ,GAAI,KAAK,KAAK,EAChB,CAAC,EACE,gBAAgB,KAAK,KAAK,IAAI,EAC9B,MAAM,CACX,CAEA,cACEW,EAIA,CACA,OAAOf,EAAM,aACX,KAAK,YAAY,SAASe,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,GAAIA,EAAS,KAAK,SAAW,EAE3B,OAAOlB,EAAqB,CAAE,KAAM,CAAC,CAAE,CAAC,EAG1C,MAAMa,EAAS,IAAId,EAAWmB,CAAQ,EAEhCC,EAAaN,EAAO,gBAAgB,EAC1C,GAAIM,IAAeR,EACjB,OAAOX,EAAqB,CAC1B,MAAO,IAAIC,EACT,0BAA0BU,EAAqB,SAAS,EAAE,CAAC,SACzDQ,IAAe,OACX,YACA,KAAKA,EAAW,SAAS,EAAE,CAAC,EAClC,EACF,CACF,CAAC,EAGH,MAAMC,EAAWR,EAAaC,EAAQP,CAAe,EACrD,OAAKc,EAMEpB,EAAqB,CAC1B,KAAM,CAAE,SAAAoB,CAAS,CACnB,CAAC,EAPQpB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,gCAAgC,CACpE,CAAC,CAML,CAAC,CACH,CACF",
+  "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "CONTACTS_APDU_CLA", "CONTACTS_APDU_INS", "HMAC_REST_BYTES", "SUB_CMD_EDIT_IDENTIFIER", "CONTACTS_APP_ERRORS", "contactsCommandErrorFactory", "STRUCT_TYPE_EDIT_IDENTIFIER", "RESPONSE_STRUCT_TYPE", "extractField", "parser", "length", "field", "EditExternalAddressIdentifierCommand", "args", "response", "structType", "hmacRest"]
+}

package/lib/esm/internal/app-binder/command/EditExternalAddressIdentifierCommand.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{CommandResultStatus as a}from"@ledgerhq/device-management-kit";import{CONTACT_SEED_MISMATCH_ERROR_CODE as m,ContactsCommandError as s}from"../../app-binder/model/contactsErrors";import{EditExternalAddressIdentifierCommand as o}from"./EditExternalAddressIdentifierCommand";function d(e){const t=new Uint8Array(e.length/2);for(let r=0;r<e.length;r+=2)t[r/2]=parseInt(e.slice(r,r+2),16);return t}const u=d("88".repeat(32)),c="31"+"88".repeat(32);function n(e){return{data:Buffer.from(d(e)),statusCode:Buffer.from([144,0])}}describe("EditExternalAddressIdentifierCommand",()=>{describe("getApdu",()=>{it("wraps the framed chunk under B0 10 03 with P2=0x00 for the first/only chunk",()=>{const e=Uint8Array.from([0,3,170,187,204]),t=new o({data:e,p2:0}).getApdu();expect(t.getRawApdu()).toStrictEqual(Uint8Array.from([176,16,3,0,5,0,3,170,187,204]))}),it("uses P2=0x80 for continuation chunks",()=>{const e=Uint8Array.from([170,187]),t=new o({data:e,p2:128}).getApdu();expect(t.getRawApdu()).toStrictEqual(Uint8Array.from([176,16,3,128,2,170,187]))})}),describe("parseResponse",()=>{it("returns an empty payload for an intermediate chunk (SW=0x9000, no data)",()=>{const e=new o({data:new Uint8Array,p2:0}).parseResponse({data:Buffer.from([]),statusCode:Buffer.from([144,0])});expect(e).toStrictEqual({status:a.Success,data:{}})}),it("extracts the rotated hmac_rest from the final-chunk response",()=>{const t=new o({data:new Uint8Array,p2:0}).parseResponse(n(c));expect(t).toStrictEqual({status:a.Success,data:{hmacRest:u}})}),it("returns InvalidStatusWordError when struct_type is wrong",()=>{const e="ee"+c.slice(2),r=new o({data:new Uint8Array,p2:0}).parseResponse(n(e));expect(r.status).toBe(a.Error)}),it("returns InvalidStatusWordError when hmac_rest is truncated",()=>{const e="31"+"88".repeat(16),r=new o({data:new Uint8Array,p2:0}).parseResponse(n(e));expect(r.status).toBe(a.Error)}),it("maps a known SW (0x6985) to a ContactsCommandError",()=>{const t=new o({data:new Uint8Array,p2:0}).parseResponse({data:Buffer.from([]),statusCode:Buffer.from([105,133])});expect(t.status).toBe(a.Error),t.status===a.Error&&(expect(t.error).toBeInstanceOf(s),expect(t.error.errorCode).toBe("6985"))}),it("maps SW=0x6982 to a seed-mismatch ContactsCommandError",()=>{const t=new o({data:new Uint8Array,p2:0}).parseResponse({data:Buffer.from([]),statusCode:Buffer.from([105,130])});expect(t.status).toBe(a.Error),t.status===a.Error&&(expect(t.error).toBeInstanceOf(s),expect(t.error.errorCode).toBe(m))})})});
2	+ //# sourceMappingURL=EditExternalAddressIdentifierCommand.test.js.map

package/lib/esm/internal/app-binder/command/EditExternalAddressIdentifierCommand.test.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/command/EditExternalAddressIdentifierCommand.test.ts"],
+  "sourcesContent": ["// Thin chunk-framer: wraps a pre-framed chunk under B0 10 03 <P2> and parses\n// the 33-byte edit response (struct_type 0x31 + hmac_rest) on the final chunk.\n// TLV byte-parity is asserted in SendEditExternalAddressIdentifierTask.test.ts.\nimport {\n  type ApduResponse,\n  CommandResultStatus,\n} from \"@ledgerhq/device-management-kit\";\n\nimport {\n  CONTACT_SEED_MISMATCH_ERROR_CODE,\n  ContactsCommandError,\n} from \"@internal/app-binder/model/contactsErrors\";\n\nimport { EditExternalAddressIdentifierCommand } from \"./EditExternalAddressIdentifierCommand\";\n\nfunction hexToBytes(hex: string): Uint8Array {\n  const out = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    out[i / 2] = parseInt(hex.slice(i, i + 2), 16);\n  }\n  return out;\n}\n\n// Device response: struct_type(0x31) + rotated hmac_rest(32).\nconst HMAC_REST = hexToBytes(\"88\".repeat(32));\nconst RESPONSE_HEX = \"31\" + \"88\".repeat(32);\n\nfunction makeResponse(hex: string): ApduResponse {\n  return {\n    data: Buffer.from(hexToBytes(hex)),\n    statusCode: Buffer.from([0x90, 0x00]),\n  };\n}\n\ndescribe(\"EditExternalAddressIdentifierCommand\", () => {\n  describe(\"getApdu\", () => {\n    it(\"wraps the framed chunk under B0 10 03 with P2=0x00 for the first/only chunk\", () => {\n      const data = Uint8Array.from([0x00, 0x03, 0xaa, 0xbb, 0xcc]);\n\n      const apdu = new EditExternalAddressIdentifierCommand({\n        data,\n        p2: 0x00,\n      }).getApdu();\n\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([\n          0xb0, 0x10, 0x03, 0x00, 0x05, 0x00, 0x03, 0xaa, 0xbb, 0xcc,\n        ]),\n      );\n    });\n\n    it(\"uses P2=0x80 for continuation chunks\", () => {\n      const data = Uint8Array.from([0xaa, 0xbb]);\n\n      const apdu = new EditExternalAddressIdentifierCommand({\n        data,\n        p2: 0x80,\n      }).getApdu();\n\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xb0, 0x10, 0x03, 0x80, 0x02, 0xaa, 0xbb]),\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"returns an empty payload for an intermediate chunk (SW=0x9000, no data)\", () => {\n      const result = new EditExternalAddressIdentifierCommand({\n        data: new Uint8Array(),\n        p2: 0x00,\n      }).parseResponse({\n        data: Buffer.from([]),\n        statusCode: Buffer.from([0x90, 0x00]),\n      });\n\n      expect(result).toStrictEqual({\n        status: CommandResultStatus.Success,\n        data: {},\n      });\n    });\n\n    it(\"extracts the rotated hmac_rest from the final-chunk response\", () => {\n      const command = new EditExternalAddressIdentifierCommand({\n        data: new Uint8Array(),\n        p2: 0x00,\n      });\n\n      const result = command.parseResponse(makeResponse(RESPONSE_HEX));\n\n      expect(result).toStrictEqual({\n        status: CommandResultStatus.Success,\n        data: { hmacRest: HMAC_REST },\n      });\n    });\n\n    it(\"returns InvalidStatusWordError when struct_type is wrong\", () => {\n      const wrongType = \"ee\" + RESPONSE_HEX.slice(2); // replace 0x31 with 0xee\n      const command = new EditExternalAddressIdentifierCommand({\n        data: new Uint8Array(),\n        p2: 0x00,\n      });\n\n      const result = command.parseResponse(makeResponse(wrongType));\n\n      expect(result.status).toBe(CommandResultStatus.Error);\n    });\n\n    it(\"returns InvalidStatusWordError when hmac_rest is truncated\", () => {\n      const truncated = \"31\" + \"88\".repeat(16); // only 16 of 32 bytes\n      const command = new EditExternalAddressIdentifierCommand({\n        data: new Uint8Array(),\n        p2: 0x00,\n      });\n\n      const result = command.parseResponse(makeResponse(truncated));\n\n      expect(result.status).toBe(CommandResultStatus.Error);\n    });\n\n    it(\"maps a known SW (0x6985) to a ContactsCommandError\", () => {\n      const command = new EditExternalAddressIdentifierCommand({\n        data: new Uint8Array(),\n        p2: 0x00,\n      });\n\n      const result = command.parseResponse({\n        data: Buffer.from([]),\n        statusCode: Buffer.from([0x69, 0x85]),\n      });\n\n      expect(result.status).toBe(CommandResultStatus.Error);\n      if (result.status === CommandResultStatus.Error) {\n        expect(result.error).toBeInstanceOf(ContactsCommandError);\n        expect((result.error as ContactsCommandError).errorCode).toBe(\"6985\");\n      }\n    });\n\n    it(\"maps SW=0x6982 to a seed-mismatch ContactsCommandError\", () => {\n      // The device returns 0x6982 when the seed-bound HMAC / group-handle\n      // verification fails \u2014 i.e. the entry was registered with another seed.\n      const command = new EditExternalAddressIdentifierCommand({\n        data: new Uint8Array(),\n        p2: 0x00,\n      });\n\n      const result = command.parseResponse({\n        data: Buffer.from([]),\n        statusCode: Buffer.from([0x69, 0x82]),\n      });\n\n      expect(result.status).toBe(CommandResultStatus.Error);\n      if (result.status === CommandResultStatus.Error) {\n        expect(result.error).toBeInstanceOf(ContactsCommandError);\n        expect((result.error as ContactsCommandError).errorCode).toBe(\n          CONTACT_SEED_MISMATCH_ERROR_CODE,\n        );\n      }\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["CommandResultStatus", "CONTACT_SEED_MISMATCH_ERROR_CODE", "ContactsCommandError", "EditExternalAddressIdentifierCommand", "hexToBytes", "hex", "out", "i", "HMAC_REST", "RESPONSE_HEX", "makeResponse", "data", "apdu", "result", "wrongType", "truncated"]
+}

package/lib/esm/internal/app-binder/command/EditExternalAddressScopeCommand.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import{ApduBuilder as m,ApduParser as p,CommandResultFactory as t,InvalidStatusWordError as a}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as i}from"@ledgerhq/signer-utils";import{Maybe as E}from"purify-ts";import{CONTACTS_APDU_CLA as c,CONTACTS_APDU_INS as C,HMAC_REST_BYTES as l,SUB_CMD_EDIT_SCOPE as u}from"../../app-binder/model/contactsConstants";import{CONTACTS_APP_ERRORS as A,contactsCommandErrorFactory as S}from"../../app-binder/model/contactsErrors";import{STRUCT_TYPE_EDIT_SCOPE as y}from"../../app-binder/services/contactsTlvSerializer";const s=y;function f(d,r){const e=d.extractFieldByLength(r);if(!(!e\|\|e.length!==r))return Uint8Array.from(e)}class U{name="editExternalAddressScope";args;errorHelper=new i(A,S);constructor(r){this.args=r}getApdu(){return new m({cla:c,ins:C,p1:u,p2:this.args.p2}).addBufferToData(this.args.data).build()}parseResponse(r){return E.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{if(r.data.length===0)return t({data:{}});const e=new p(r),o=e.extract8BitUInt();if(o!==s)return t({error:new a(`Expected struct_type 0x${s.toString(16)}, got ${o===void 0?"undefined":`0x${o.toString(16)}`}`)});const n=f(e,l);return n?t({data:{hmacRest:n}}):t({error:new a("hmac_rest missing or truncated")})})}}export{U as EditExternalAddressScopeCommand};
2	+ //# sourceMappingURL=EditExternalAddressScopeCommand.js.map

package/lib/esm/internal/app-binder/command/EditExternalAddressScopeCommand.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/command/EditExternalAddressScopeCommand.ts"],
+  "sourcesContent": ["// Edit Scope \u2014 sub-command P1=0x04 of the address-book APDU (CLA 0xB0 /\n// INS 0x10). Frames one chunk; on the final chunk parses the 33-byte response\n// struct_type(0x32) + hmac_rest(32) (the rotated address-level proof).\n// Intermediate chunks ack SW=0x9000 with no data. SW 0x6982 = seed/handle\n// mismatch, surfaced via the shared error helper before any device UI.\n// Protocol: Address Book Final Specifications \u2014 Edit Scope.\nimport {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  CONTACTS_APDU_CLA,\n  CONTACTS_APDU_INS,\n  HMAC_REST_BYTES,\n  SUB_CMD_EDIT_SCOPE,\n} from \"@internal/app-binder/model/contactsConstants\";\nimport {\n  CONTACTS_APP_ERRORS,\n  contactsCommandErrorFactory,\n  type ContactsErrorCodes,\n} from \"@internal/app-binder/model/contactsErrors\";\nimport { STRUCT_TYPE_EDIT_SCOPE } from \"@internal/app-binder/services/contactsTlvSerializer\";\n\nexport type EditExternalAddressScopeCommandArgs = {\n  /** One framed chunk built by sendFramedContactsPayload. */\n  readonly data: Uint8Array;\n  /** 0x00 for the first/only chunk, 0x80 for continuation chunks. */\n  readonly p2: number;\n};\n\nexport type EditExternalAddressScopeCommandResponse = {\n  /**\n   * Present only on the final chunk \u2014 the device returns struct_type(0x32) +\n   * hmac_rest(32) there. Intermediate chunks return SW=0x9000 with no data.\n   * This is the replacement address-level proof (rotated `hmac_rest`).\n   */\n  readonly hmacRest?: Uint8Array;\n};\n\nconst RESPONSE_STRUCT_TYPE = STRUCT_TYPE_EDIT_SCOPE;\n\n/**\n * Extract `length` bytes as a freshly-owned plain `Uint8Array` (the parser may\n * hand back a `Buffer` view backed by the response), or `undefined` if the\n * response is too short.\n */\nfunction extractField(\n  parser: ApduParser,\n  length: number,\n): Uint8Array | undefined {\n  const field = parser.extractFieldByLength(length);\n  if (!field || field.length !== length) return undefined;\n  return Uint8Array.from(field);\n}\n\nexport class EditExternalAddressScopeCommand\n  implements\n    Command<\n      EditExternalAddressScopeCommandResponse,\n      EditExternalAddressScopeCommandArgs,\n      ContactsErrorCodes\n    >\n{\n  readonly name = \"editExternalAddressScope\";\n  readonly args: EditExternalAddressScopeCommandArgs;\n  private readonly errorHelper = new CommandErrorHelper<\n    EditExternalAddressScopeCommandResponse,\n    ContactsErrorCodes\n  >(CONTACTS_APP_ERRORS, contactsCommandErrorFactory);\n\n  constructor(args: EditExternalAddressScopeCommandArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    return new ApduBuilder({\n      cla: CONTACTS_APDU_CLA,\n      ins: CONTACTS_APDU_INS,\n      p1: SUB_CMD_EDIT_SCOPE,\n      p2: this.args.p2,\n    })\n      .addBufferToData(this.args.data)\n      .build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<\n    EditExternalAddressScopeCommandResponse,\n    ContactsErrorCodes\n  > {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      if (response.data.length === 0) {\n        // Intermediate chunk \u2014 device acks with SW=0x9000 and no payload.\n        return CommandResultFactory({ data: {} });\n      }\n\n      const parser = new ApduParser(response);\n\n      const structType = parser.extract8BitUInt();\n      if (structType !== RESPONSE_STRUCT_TYPE) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\n            `Expected struct_type 0x${RESPONSE_STRUCT_TYPE.toString(16)}, got ${\n              structType === undefined\n                ? \"undefined\"\n                : `0x${structType.toString(16)}`\n            }`,\n          ),\n        });\n      }\n\n      const hmacRest = extractField(parser, HMAC_REST_BYTES);\n      if (!hmacRest) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"hmac_rest missing or truncated\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { hmacRest },\n      });\n    });\n  }\n}\n"],
+  "mappings": "AAMA,OAEE,eAAAA,EACA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,qBAAAC,EACA,qBAAAC,EACA,mBAAAC,EACA,sBAAAC,MACK,+CACP,OACE,uBAAAC,EACA,+BAAAC,MAEK,4CACP,OAAS,0BAAAC,MAA8B,sDAkBvC,MAAMC,EAAuBD,EAO7B,SAASE,EACPC,EACAC,EACwB,CACxB,MAAMC,EAAQF,EAAO,qBAAqBC,CAAM,EAChD,GAAI,GAACC,GAASA,EAAM,SAAWD,GAC/B,OAAO,WAAW,KAAKC,CAAK,CAC9B,CAEO,MAAMC,CAOb,CACW,KAAO,2BACP,KACQ,YAAc,IAAId,EAGjCM,EAAqBC,CAA2B,EAElD,YAAYQ,EAA2C,CACrD,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,OAAO,IAAInB,EAAY,CACrB,IAAKM,EACL,IAAKC,EACL,GAAIE,EACJ,GAAI,KAAK,KAAK,EAChB,CAAC,EACE,gBAAgB,KAAK,KAAK,IAAI,EAC9B,MAAM,CACX,CAEA,cACEW,EAIA,CACA,OAAOf,EAAM,aACX,KAAK,YAAY,SAASe,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,GAAIA,EAAS,KAAK,SAAW,EAE3B,OAAOlB,EAAqB,CAAE,KAAM,CAAC,CAAE,CAAC,EAG1C,MAAMa,EAAS,IAAId,EAAWmB,CAAQ,EAEhCC,EAAaN,EAAO,gBAAgB,EAC1C,GAAIM,IAAeR,EACjB,OAAOX,EAAqB,CAC1B,MAAO,IAAIC,EACT,0BAA0BU,EAAqB,SAAS,EAAE,CAAC,SACzDQ,IAAe,OACX,YACA,KAAKA,EAAW,SAAS,EAAE,CAAC,EAClC,EACF,CACF,CAAC,EAGH,MAAMC,EAAWR,EAAaC,EAAQP,CAAe,EACrD,OAAKc,EAMEpB,EAAqB,CAC1B,KAAM,CAAE,SAAAoB,CAAS,CACnB,CAAC,EAPQpB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,gCAAgC,CACpE,CAAC,CAML,CAAC,CACH,CACF",
+  "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "CONTACTS_APDU_CLA", "CONTACTS_APDU_INS", "HMAC_REST_BYTES", "SUB_CMD_EDIT_SCOPE", "CONTACTS_APP_ERRORS", "contactsCommandErrorFactory", "STRUCT_TYPE_EDIT_SCOPE", "RESPONSE_STRUCT_TYPE", "extractField", "parser", "length", "field", "EditExternalAddressScopeCommand", "args", "response", "structType", "hmacRest"]
+}