@ledgerhq/device-contacts-kit 0.2.0 → 0.3.1

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

@@ -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": "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",
+  "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/app-binder/task/SendRenameContactTask.js

@@ -0,0 +1,2 @@
+"use strict";var s=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var y=(t,e)=>{for(var a in e)s(t,a,{get:e[a],enumerable:!0})},u=(t,e,a,m)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of T(e))!p.call(t,n)&&n!==a&&s(t,n,{get:()=>e[n],enumerable:!(m=l(e,n))||m.enumerable});return t};var A=t=>u(s({},"__esModule",{value:!0}),t);var P={};y(P,{SendRenameContactTask:()=>R});module.exports=A(P);var o=require("@ledgerhq/device-management-kit"),d=require("../../app-binder/command/RenameContactCommand"),i=require("../../app-binder/model/contactsConstants"),r=require("../../app-binder/services/contactsTlvSerializer"),c=require("../../app-binder/services/sendFramedContactsPayload");class R{constructor(e,a){this.api=e;this.args=a}async run(){const e=this.buildPayload(this.args),a=await(0,c.sendFramedContactsPayload)(this.api,{payload:e,p1:i.RENAME_CONTACT_P1,makeCommand:(n,C)=>new d.RenameContactCommand({data:n,p2:C}),logger:this.args.logger,commandTag:"SendRenameContactTask"});if(!(0,o.isSuccessCommandResult)(a))return a;const{hmacProof:m}=a.data;return m?(0,o.DmkResultFactory)({data:{hmacProof:m}}):(0,o.DmkResultFactory)({error:new o.InvalidStatusWordError("RenameContact final-chunk response did not carry hmac_name")})}buildPayload(e){const a=new o.ByteArrayBuilder;return(0,r.encodeTlvUInt8)(a,r.CONTACTS_TLV_TAG.STRUCT_TYPE,r.STRUCT_TYPE_EDIT_CONTACT_NAME),(0,r.encodeTlvUInt8)(a,r.CONTACTS_TLV_TAG.STRUCT_VERSION,r.STRUCT_VERSION_VALUE),(0,r.encodeTlvAscii)(a,r.CONTACTS_TLV_TAG.CONTACT_NAME,e.newContactName),(0,r.encodeTlvAscii)(a,r.CONTACTS_TLV_TAG.PREVIOUS_CONTACT_NAME,e.previousContactName),(0,r.encodeTlvBuffer)(a,r.CONTACTS_TLV_TAG.GROUP_HANDLE,e.groupHandle),(0,r.encodeTlvBuffer)(a,r.CONTACTS_TLV_TAG.DERIVATION_PATH,(0,r.packDerivationPath)([2147483692,2147483708,2147483648,0,0])),(0,r.encodeTlvBuffer)(a,r.CONTACTS_TLV_TAG.HMAC_PROOF,e.hmacProof),a.build()}}0&&(module.exports={SendRenameContactTask});
+//# sourceMappingURL=SendRenameContactTask.js.map

package/lib/cjs/internal/app-binder/task/SendRenameContactTask.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendRenameContactTask.ts"],
+  "sourcesContent": ["// Builds the TLV payload for the Rename Contact (EDIT CONTACT NAME) op and\n// dispatches it via the chunked-framing scheme shared with the other\n// address-book ops (2-byte BE total length + <=255B chunks). Rename is an\n// OS/dashboard command (CLA 0xE0 / INS 0x2E) \u2014 the caller runs this task after\n// navigating to the dashboard (GoToDashboardDeviceAction), never inside an app.\n//\n// The device rotates the contact-level hmac_name and returns the fresh proof on\n// the final chunk; per-entry hmac_rest values are untouched (they bind\n// gid|scope|id|family|chain_id, never the name), so a single APDU regardless of\n// the contact's entry count.\n//\n// Reference: Address Book Final Specifications \u2014 Edit Contact Name. Tag order:\n//   STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME (new), PREVIOUS_CONTACT_NAME\n//   (old), GROUP_HANDLE, DERIVATION_PATH, HMAC_PROOF.\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 { RenameContactCommand } from \"@internal/app-binder/command/RenameContactCommand\";\nimport { RENAME_CONTACT_P1 } 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  encodeTlvUInt8,\n  packDerivationPath,\n  STRUCT_TYPE_EDIT_CONTACT_NAME,\n  STRUCT_VERSION_VALUE,\n} from \"@internal/app-binder/services/contactsTlvSerializer\";\nimport { sendFramedContactsPayload } from \"@internal/app-binder/services/sendFramedContactsPayload\";\n\nexport type RenameContactProof = {\n  readonly hmacProof: Uint8Array;\n};\n\nexport type SendRenameContactTaskArgs = {\n  readonly previousContactName: string;\n  readonly newContactName: string;\n  readonly groupHandle: Uint8Array;\n  readonly hmacProof: Uint8Array;\n  readonly logger?: LoggerPublisherService;\n};\n\nexport class SendRenameContactTask {\n  constructor(\n    private readonly api: InternalApi,\n    private readonly args: SendRenameContactTaskArgs,\n  ) {}\n\n  async run(): Promise<CommandResult<RenameContactProof, ContactsErrorCodes>> {\n    const payload = this.buildPayload(this.args);\n\n    const result = (await sendFramedContactsPayload(this.api, {\n      payload,\n      p1: RENAME_CONTACT_P1,\n      makeCommand: (chunk, p2) => new RenameContactCommand({ data: chunk, p2 }),\n      logger: this.args.logger,\n      commandTag: \"SendRenameContactTask\",\n    })) as CommandResult<\n      { readonly hmacProof?: Uint8Array },\n      ContactsErrorCodes\n    >;\n\n    if (!isSuccessCommandResult(result)) {\n      return result;\n    }\n\n    const { hmacProof } = result.data;\n    if (!hmacProof) {\n      return DmkResultFactory({\n        error: new InvalidStatusWordError(\n          \"RenameContact final-chunk response did not carry hmac_name\",\n        ),\n      });\n    }\n    return DmkResultFactory({ data: { hmacProof } });\n  }\n\n  private buildPayload(args: SendRenameContactTaskArgs): Uint8Array {\n    const builder = new ByteArrayBuilder();\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_TYPE,\n      STRUCT_TYPE_EDIT_CONTACT_NAME,\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.newContactName);\n    encodeTlvAscii(\n      builder,\n      CONTACTS_TLV_TAG.PREVIOUS_CONTACT_NAME,\n      args.previousContactName,\n    );\n    encodeTlvBuffer(builder, CONTACTS_TLV_TAG.GROUP_HANDLE, args.groupHandle);\n    // The Ethereum app requires DERIVATION_PATH on Edit Contact Name (0x6a80\n    // without it), same as Register Identity. 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    encodeTlvBuffer(builder, CONTACTS_TLV_TAG.HMAC_PROOF, args.hmacProof);\n\n    return builder.build();\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,2BAAAE,IAAA,eAAAC,EAAAH,GAcA,IAAAI,EAQO,2CAEPC,EAAqC,6DACrCC,EAAkC,wDAElCC,EAQO,+DACPC,EAA0C,mEAcnC,MAAMN,CAAsB,CACjC,YACmBO,EACAC,EACjB,CAFiB,SAAAD,EACA,UAAAC,CAChB,CAEH,MAAM,KAAsE,CAC1E,MAAMC,EAAU,KAAK,aAAa,KAAK,IAAI,EAErCC,EAAU,QAAM,6BAA0B,KAAK,IAAK,CACxD,QAAAD,EACA,GAAI,oBACJ,YAAa,CAACE,EAAOC,IAAO,IAAI,uBAAqB,CAAE,KAAMD,EAAO,GAAAC,CAAG,CAAC,EACxE,OAAQ,KAAK,KAAK,OAClB,WAAY,uBACd,CAAC,EAKD,GAAI,IAAC,0BAAuBF,CAAM,EAChC,OAAOA,EAGT,KAAM,CAAE,UAAAG,CAAU,EAAIH,EAAO,KAC7B,OAAKG,KAOE,oBAAiB,CAAE,KAAM,CAAE,UAAAA,CAAU,CAAE,CAAC,KANtC,oBAAiB,CACtB,MAAO,IAAI,yBACT,4DACF,CACF,CAAC,CAGL,CAEQ,aAAaL,EAA6C,CAChE,MAAMM,EAAU,IAAI,mBACpB,2BACEA,EACA,mBAAiB,YACjB,+BACF,KACA,kBACEA,EACA,mBAAiB,eACjB,sBACF,KACA,kBAAeA,EAAS,mBAAiB,aAAcN,EAAK,cAAc,KAC1E,kBACEM,EACA,mBAAiB,sBACjBN,EAAK,mBACP,KACA,mBAAgBM,EAAS,mBAAiB,aAAcN,EAAK,WAAW,KAGxE,mBACEM,EACA,mBAAiB,mBACjB,sBAAmB,CAAC,WAAY,WAAY,WAAY,EAAG,CAAC,CAAC,CAC/D,KACA,mBAAgBA,EAAS,mBAAiB,WAAYN,EAAK,SAAS,EAE7DM,EAAQ,MAAM,CACvB,CACF",
+  "names": ["SendRenameContactTask_exports", "__export", "SendRenameContactTask", "__toCommonJS", "import_device_management_kit", "import_RenameContactCommand", "import_contactsConstants", "import_contactsTlvSerializer", "import_sendFramedContactsPayload", "api", "args", "payload", "result", "chunk", "p2", "hmacProof", "builder"]
+}

package/lib/cjs/internal/app-binder/task/SendRenameContactTask.test.js

@@ -0,0 +1,2 @@
+"use strict";var a=require("@ledgerhq/device-management-kit"),i=require("../../app-binder/command/RenameContactCommand"),o=require("./SendRenameContactTask");function s(e){const n=new Uint8Array(e.length/2);for(let t=0;t<e.length;t+=2)n[t/2]=parseInt(e.slice(t,t+2),16);return n}const r=s("cc".repeat(64)),c=s("dd".repeat(32)),d=s("ee".repeat(32)),l="6915058000002c8000003c800000000000000000000000",p=s("009001012e02010181f003426f6281f305416c69636581f640"+"cc".repeat(64)+l+"2920"+"dd".repeat(32));function m(){return{sendCommand:vi.fn()}}describe("SendRenameContactTask",()=>{it("assembles the rename framed chunk and dispatches RenameContactCommand",async()=>{const e=m();e.sendCommand.mockResolvedValueOnce((0,a.CommandResultFactory)({data:{hmacProof:d}}));const n=await new o.SendRenameContactTask(e,{previousContactName:"Alice",newContactName:"Bob",groupHandle:r,hmacProof:c}).run();expect(e.sendCommand.mock.calls).toHaveLength(1),expect(e.sendCommand.mock.calls[0][0]).toStrictEqual(new i.RenameContactCommand({data:p,p2:0})),expect(n).toStrictEqual((0,a.CommandResultFactory)({data:{hmacProof:d}}))}),it("emits the DERIVATION_PATH tag immediately before HMAC_PROOF",async()=>{const e=m();e.sendCommand.mockResolvedValueOnce((0,a.CommandResultFactory)({data:{hmacProof:d}})),await new o.SendRenameContactTask(e,{previousContactName:"Alice",newContactName:"Bob",groupHandle:r,hmacProof:c}).run();const n=e.sendCommand.mock.calls[0][0],t=Buffer.from(n.args.data).toString("hex");expect(t.endsWith(l+"2920"+"dd".repeat(32))).toBe(!0)}),it("propagates command-level errors",async()=>{const e=m();e.sendCommand.mockResolvedValueOnce((0,a.CommandResultFactory)({error:new a.InvalidStatusWordError("user cancelled")}));const n=await new o.SendRenameContactTask(e,{previousContactName:"Alice",newContactName:"Bob",groupHandle:r,hmacProof:c}).run();expect(n).toStrictEqual((0,a.CommandResultFactory)({error:new a.InvalidStatusWordError("user cancelled")}))}),it("returns InvalidStatusWordError when the final response carries no hmac_name",async()=>{const e=m();e.sendCommand.mockResolvedValueOnce((0,a.CommandResultFactory)({data:{}}));const n=await new o.SendRenameContactTask(e,{previousContactName:"Alice",newContactName:"Bob",groupHandle:r,hmacProof:c}).run();expect(n.status).not.toBe(void 0),"error"in n&&expect(n.error).toBeInstanceOf(a.InvalidStatusWordError)})});
+//# sourceMappingURL=SendRenameContactTask.test.js.map

package/lib/cjs/internal/app-binder/task/SendRenameContactTask.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendRenameContactTask.test.ts"],
+  "sourcesContent": ["// Validates that the TLV serializer + tag ordering + chunk framing produce the\n// expected wire bytes for the Rename Contact (EDIT CONTACT NAME) op. The framed\n// chunk = 2-byte BE total length + TLV. Tag order: STRUCT_TYPE, STRUCT_VERSION,\n// CONTACT_NAME (new), PREVIOUS_CONTACT_NAME (old), GROUP_HANDLE, DERIVATION_PATH,\n// HMAC_PROOF \u2014 with tags >= 0x80 (0xf0/0xf3/0xf6) encoded as the 2-byte DER form\n// [0x81, tag].\nimport {\n  CommandResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { RenameContactCommand } from \"@internal/app-binder/command/RenameContactCommand\";\n\nimport { SendRenameContactTask } from \"./SendRenameContactTask\";\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\nconst GROUP_HANDLE = hexToBytes(\"cc\".repeat(64));\nconst HMAC_PROOF_IN = hexToBytes(\"dd\".repeat(32));\nconst HMAC_PROOF_OUT = hexToBytes(\"ee\".repeat(32));\n\n// Framed chunk = \"00 90\" (2-byte BE total TLV length = 144) + TLV:\n//   01 01 2e            STRUCT_TYPE = EDIT_CONTACT_NAME (0x2e)\n//   02 01 01            STRUCT_VERSION = 1\n//   81 f0 03 \"Bob\"      CONTACT_NAME (new), tag 0xf0 -> [81 f0]\n//   81 f3 05 \"Alice\"    PREVIOUS_CONTACT_NAME (old), tag 0xf3 -> [81 f3]\n//   81 f6 40 <64x cc>   GROUP_HANDLE, tag 0xf6 -> [81 f6]\n//   69 15 05 <5x path>  DERIVATION_PATH (0x69), m/44'/60'/0'/0/0\n//   29 20 <32x dd>      HMAC_PROOF\nconst DERIVATION_PATH_TLV = \"6915058000002c8000003c800000000000000000000000\";\nconst FRAMED_CHUNK = hexToBytes(\n  \"0090\" +\n    \"01012e\" +\n    \"020101\" +\n    \"81f003426f62\" +\n    \"81f305416c696365\" +\n    \"81f640\" +\n    \"cc\".repeat(64) +\n    DERIVATION_PATH_TLV +\n    \"2920\" +\n    \"dd\".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(\"SendRenameContactTask\", () => {\n  it(\"assembles the rename framed chunk and dispatches RenameContactCommand\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: { hmacProof: HMAC_PROOF_OUT } }),\n    );\n\n    const result = await new SendRenameContactTask(api, {\n      previousContactName: \"Alice\",\n      newContactName: \"Bob\",\n      groupHandle: GROUP_HANDLE,\n      hmacProof: HMAC_PROOF_IN,\n    }).run();\n\n    expect(api.sendCommand.mock.calls).toHaveLength(1);\n    expect(api.sendCommand.mock.calls[0]![0]).toStrictEqual(\n      new RenameContactCommand({ data: FRAMED_CHUNK, p2: 0x00 }),\n    );\n    expect(result).toStrictEqual(\n      CommandResultFactory({ data: { hmacProof: HMAC_PROOF_OUT } }),\n    );\n  });\n\n  it(\"emits the DERIVATION_PATH tag immediately before HMAC_PROOF\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: { hmacProof: HMAC_PROOF_OUT } }),\n    );\n\n    await new SendRenameContactTask(api, {\n      previousContactName: \"Alice\",\n      newContactName: \"Bob\",\n      groupHandle: GROUP_HANDLE,\n      hmacProof: HMAC_PROOF_IN,\n    }).run();\n\n    // The Ethereum app requires DERIVATION_PATH (0x69); it sits immediately\n    // before HMAC_PROOF (0x29), matching Register Identity.\n    const command = api.sendCommand.mock.calls[0]![0] as RenameContactCommand;\n    const framedHex = Buffer.from(command.args.data).toString(\"hex\");\n    expect(\n      framedHex.endsWith(DERIVATION_PATH_TLV + \"2920\" + \"dd\".repeat(32)),\n    ).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 SendRenameContactTask(api, {\n      previousContactName: \"Alice\",\n      newContactName: \"Bob\",\n      groupHandle: GROUP_HANDLE,\n      hmacProof: HMAC_PROOF_IN,\n    }).run();\n\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"user cancelled\"),\n      }),\n    );\n  });\n\n  it(\"returns InvalidStatusWordError when the final response carries no hmac_name\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(CommandResultFactory({ data: {} }));\n\n    const result = await new SendRenameContactTask(api, {\n      previousContactName: \"Alice\",\n      newContactName: \"Bob\",\n      groupHandle: GROUP_HANDLE,\n      hmacProof: HMAC_PROOF_IN,\n    }).run();\n\n    expect(result.status).not.toBe(undefined);\n    if (\"error\" in result) {\n      expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n    }\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["import_device_management_kit", "import_RenameContactCommand", "import_SendRenameContactTask", "hexToBytes", "hex", "out", "i", "GROUP_HANDLE", "HMAC_PROOF_IN", "HMAC_PROOF_OUT", "DERIVATION_PATH_TLV", "FRAMED_CHUNK", "makeApiMock", "api", "result", "command", "framedHex"]
+}

package/lib/cjs/internal/di.test.js

@@ -1,2 +1,2 @@
-"use strict";var i=require("./app-binder/ContactsAppBinder"),a=require("./app-binder/di/appBinderTypes"),o=require("./di"),t=require("./externalTypes"),p=require("./use-cases/di/useCaseTypes"),m=require("./use-cases/RegisterExternalAddressUseCase");describe("makeContainer",()=>{const s={},n="session-id",r="Ethereum",e=(0,o.makeContainer)({dmk:s,sessionId:n,appName:r});it("binds dmk, sessionId and appName as external values",()=>{expect(e.get(t.externalTypes.Dmk)).toBe(s),expect(e.get(t.externalTypes.SessionId)).toBe(n),expect(e.get(t.externalTypes.AppName)).toBe(r)}),it("binds the ContactsAppBinder",()=>{expect(e.get(a.appBinderTypes.AppBinder)).toBeInstanceOf(i.ContactsAppBinder)}),it("binds the RegisterExternalAddressUseCase",()=>{expect(e.get(p.useCaseTypes.RegisterExternalAddressUseCase)).toBeInstanceOf(m.RegisterExternalAddressUseCase)})});
+"use strict";var i=require("./app-binder/ContactsAppBinder"),r=require("./app-binder/di/appBinderTypes"),p=require("./di"),t=require("./externalTypes"),s=require("./use-cases/di/useCaseTypes"),m=require("./use-cases/RegisterExternalAddressUseCase"),c=require("./use-cases/RenameContactUseCase");describe("makeContainer",()=>{const n={},a="session-id",o="Ethereum",e=(0,p.makeContainer)({dmk:n,sessionId:a,appName:o});it("binds dmk, sessionId and appName as external values",()=>{expect(e.get(t.externalTypes.Dmk)).toBe(n),expect(e.get(t.externalTypes.SessionId)).toBe(a),expect(e.get(t.externalTypes.AppName)).toBe(o)}),it("binds the ContactsAppBinder",()=>{expect(e.get(r.appBinderTypes.AppBinder)).toBeInstanceOf(i.ContactsAppBinder)}),it("binds the RegisterExternalAddressUseCase",()=>{expect(e.get(s.useCaseTypes.RegisterExternalAddressUseCase)).toBeInstanceOf(m.RegisterExternalAddressUseCase)}),it("binds the RenameContactUseCase",()=>{expect(e.get(s.useCaseTypes.RenameContactUseCase)).toBeInstanceOf(c.RenameContactUseCase)})});
 //# sourceMappingURL=di.test.js.map

package/lib/cjs/internal/di.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/di.test.ts"],
-  "sourcesContent": ["import { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\n\nimport { ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { makeContainer } from \"@internal/di\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { useCaseTypes } from \"@internal/use-cases/di/useCaseTypes\";\nimport { RegisterExternalAddressUseCase } from \"@internal/use-cases/RegisterExternalAddressUseCase\";\n\ndescribe(\"makeContainer\", () => {\n  const dmk = {} as DeviceManagementKit;\n  const sessionId = \"session-id\";\n  const appName = \"Ethereum\";\n\n  const container = makeContainer({ dmk, sessionId, appName });\n\n  it(\"binds dmk, sessionId and appName as external values\", () => {\n    expect(container.get(externalTypes.Dmk)).toBe(dmk);\n    expect(container.get(externalTypes.SessionId)).toBe(sessionId);\n    expect(container.get(externalTypes.AppName)).toBe(appName);\n  });\n\n  it(\"binds the ContactsAppBinder\", () => {\n    expect(container.get(appBinderTypes.AppBinder)).toBeInstanceOf(\n      ContactsAppBinder,\n    );\n  });\n\n  it(\"binds the RegisterExternalAddressUseCase\", () => {\n    expect(\n      container.get(useCaseTypes.RegisterExternalAddressUseCase),\n    ).toBeInstanceOf(RegisterExternalAddressUseCase);\n  });\n});\n"],
-  "mappings": "aAEA,IAAAA,EAAkC,kDAClCC,EAA+B,kDAC/BC,EAA8B,wBAC9BC,EAA8B,mCAC9BC,EAA6B,+CAC7BC,EAA+C,8DAE/C,SAAS,gBAAiB,IAAM,CAC9B,MAAMC,EAAM,CAAC,EACPC,EAAY,aACZC,EAAU,WAEVC,KAAY,iBAAc,CAAE,IAAAH,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,EAE3D,GAAG,sDAAuD,IAAM,CAC9D,OAAOC,EAAU,IAAI,gBAAc,GAAG,CAAC,EAAE,KAAKH,CAAG,EACjD,OAAOG,EAAU,IAAI,gBAAc,SAAS,CAAC,EAAE,KAAKF,CAAS,EAC7D,OAAOE,EAAU,IAAI,gBAAc,OAAO,CAAC,EAAE,KAAKD,CAAO,CAC3D,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,OAAOC,EAAU,IAAI,iBAAe,SAAS,CAAC,EAAE,eAC9C,mBACF,CACF,CAAC,EAED,GAAG,2CAA4C,IAAM,CACnD,OACEA,EAAU,IAAI,eAAa,8BAA8B,CAC3D,EAAE,eAAe,gCAA8B,CACjD,CAAC,CACH,CAAC",
-  "names": ["import_ContactsAppBinder", "import_appBinderTypes", "import_di", "import_externalTypes", "import_useCaseTypes", "import_RegisterExternalAddressUseCase", "dmk", "sessionId", "appName", "container"]
+  "sourcesContent": ["import { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\n\nimport { ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { makeContainer } from \"@internal/di\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { useCaseTypes } from \"@internal/use-cases/di/useCaseTypes\";\nimport { RegisterExternalAddressUseCase } from \"@internal/use-cases/RegisterExternalAddressUseCase\";\nimport { RenameContactUseCase } from \"@internal/use-cases/RenameContactUseCase\";\n\ndescribe(\"makeContainer\", () => {\n  const dmk = {} as DeviceManagementKit;\n  const sessionId = \"session-id\";\n  const appName = \"Ethereum\";\n\n  const container = makeContainer({ dmk, sessionId, appName });\n\n  it(\"binds dmk, sessionId and appName as external values\", () => {\n    expect(container.get(externalTypes.Dmk)).toBe(dmk);\n    expect(container.get(externalTypes.SessionId)).toBe(sessionId);\n    expect(container.get(externalTypes.AppName)).toBe(appName);\n  });\n\n  it(\"binds the ContactsAppBinder\", () => {\n    expect(container.get(appBinderTypes.AppBinder)).toBeInstanceOf(\n      ContactsAppBinder,\n    );\n  });\n\n  it(\"binds the RegisterExternalAddressUseCase\", () => {\n    expect(\n      container.get(useCaseTypes.RegisterExternalAddressUseCase),\n    ).toBeInstanceOf(RegisterExternalAddressUseCase);\n  });\n\n  it(\"binds the RenameContactUseCase\", () => {\n    expect(container.get(useCaseTypes.RenameContactUseCase)).toBeInstanceOf(\n      RenameContactUseCase,\n    );\n  });\n});\n"],
+  "mappings": "aAEA,IAAAA,EAAkC,kDAClCC,EAA+B,kDAC/BC,EAA8B,wBAC9BC,EAA8B,mCAC9BC,EAA6B,+CAC7BC,EAA+C,8DAC/CC,EAAqC,oDAErC,SAAS,gBAAiB,IAAM,CAC9B,MAAMC,EAAM,CAAC,EACPC,EAAY,aACZC,EAAU,WAEVC,KAAY,iBAAc,CAAE,IAAAH,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,EAE3D,GAAG,sDAAuD,IAAM,CAC9D,OAAOC,EAAU,IAAI,gBAAc,GAAG,CAAC,EAAE,KAAKH,CAAG,EACjD,OAAOG,EAAU,IAAI,gBAAc,SAAS,CAAC,EAAE,KAAKF,CAAS,EAC7D,OAAOE,EAAU,IAAI,gBAAc,OAAO,CAAC,EAAE,KAAKD,CAAO,CAC3D,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,OAAOC,EAAU,IAAI,iBAAe,SAAS,CAAC,EAAE,eAC9C,mBACF,CACF,CAAC,EAED,GAAG,2CAA4C,IAAM,CACnD,OACEA,EAAU,IAAI,eAAa,8BAA8B,CAC3D,EAAE,eAAe,gCAA8B,CACjD,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzC,OAAOA,EAAU,IAAI,eAAa,oBAAoB,CAAC,EAAE,eACvD,sBACF,CACF,CAAC,CACH,CAAC",
+  "names": ["import_ContactsAppBinder", "import_appBinderTypes", "import_di", "import_externalTypes", "import_useCaseTypes", "import_RegisterExternalAddressUseCase", "import_RenameContactUseCase", "dmk", "sessionId", "appName", "container"]
 }

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

@@ -0,0 +1,2 @@
+"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});
+//# sourceMappingURL=EditExternalAddressIdentifierUseCase.js.map

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

@@ -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

@@ -0,0 +1,2 @@
+"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)})});
+//# sourceMappingURL=EditExternalAddressIdentifierUseCase.test.js.map

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

@@ -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

@@ -0,0 +1,2 @@
+"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});
+//# sourceMappingURL=EditExternalAddressScopeUseCase.js.map

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

@@ -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

@@ -0,0 +1,2 @@
+"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)})});
+//# sourceMappingURL=EditExternalAddressScopeUseCase.test.js.map

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

@@ -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/RenameContactUseCase.js

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

package/lib/cjs/internal/use-cases/RenameContactUseCase.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/use-cases/RenameContactUseCase.ts"],
+  "sourcesContent": ["import { inject, injectable } from \"inversify\";\n\nimport { type RenameContactDAReturnType } from \"@api/app-binder/RenameContactDeviceActionTypes\";\nimport { type RenameContactInput } from \"@api/model/RenameContact\";\nimport { ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\n\n/**\n * Delegates to `ContactsAppBinder`, which uses its injected `dmk` and\n * `sessionId` to construct and execute the `RenameContactDeviceAction`. The\n * injected `appName` is not used: rename is a dashboard operation served by the\n * device OS, not the embedded app.\n *\n * Caller-input validation is intentionally NOT done here: the public API returns\n * a device action, so validation lives inside the device action and surfaces as\n * a typed terminal error state on the observable rather than a synchronous throw.\n */\n@injectable()\nexport class RenameContactUseCase {\n  constructor(\n    @inject(appBinderTypes.AppBinder)\n    private readonly appBinder: ContactsAppBinder,\n  ) {}\n\n  execute(input: RenameContactInput): RenameContactDAReturnType {\n    return this.appBinder.renameContact(input);\n  }\n}\n"],
+  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,qBAKnCC,EAA+B,kDAaxB,IAAMC,EAAN,KAA2B,CAChC,YAEmBC,EACjB,CADiB,eAAAA,CAChB,CAEH,QAAQC,EAAsD,CAC5D,OAAO,KAAK,UAAU,cAAcA,CAAK,CAC3C,CACF,EATaF,EAANG,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,iBAAe,SAAS,IAFvBJ",
+  "names": ["RenameContactUseCase_exports", "__export", "RenameContactUseCase", "__toCommonJS", "import_inversify", "import_appBinderTypes", "RenameContactUseCase", "appBinder", "input", "__decorateClass", "__decorateParam"]
+}

package/lib/cjs/internal/use-cases/RenameContactUseCase.test.js

@@ -0,0 +1,2 @@
+"use strict";var c=require("./RenameContactUseCase");function o(){const e=vi.fn().mockReturnValue("DA_RETURN"),t={renameContact:e};return{useCase:new c.RenameContactUseCase(t),renameContact:e}}const a={previousContactName:"Alice",newContactName:"Bob",groupHandle:new Uint8Array(64).fill(204),hmacProof:new Uint8Array(32).fill(221)};describe("RenameContactUseCase",()=>{it("delegates to the app binder",()=>{const{useCase:e,renameContact: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,renameContact:t}=o(),n={...a,newContactName:""};expect(()=>e.execute(n)).not.toThrow(),expect(t).toHaveBeenCalledWith(n)})});
+//# sourceMappingURL=RenameContactUseCase.test.js.map

package/lib/cjs/internal/use-cases/RenameContactUseCase.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/use-cases/RenameContactUseCase.test.ts"],
+  "sourcesContent": ["import { type RenameContactInput } from \"@api/model/RenameContact\";\nimport { type ContactsAppBinder } from \"@internal/app-binder/ContactsAppBinder\";\n\nimport { RenameContactUseCase } from \"./RenameContactUseCase\";\n\nfunction makeUseCase() {\n  const renameContact = vi.fn().mockReturnValue(\"DA_RETURN\");\n  const appBinder = { renameContact } as unknown as ContactsAppBinder;\n  return {\n    useCase: new RenameContactUseCase(appBinder),\n    renameContact,\n  };\n}\n\nconst VALID_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(\"RenameContactUseCase\", () => {\n  it(\"delegates to the app binder\", () => {\n    const { useCase, renameContact } = makeUseCase();\n\n    const result = useCase.execute(VALID_INPUT);\n\n    expect(renameContact).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 lives in the device action and surfaces as a typed DA error\n    // state; the use case must never throw for bad input.\n    const { useCase, renameContact } = makeUseCase();\n\n    const invalidInput = { ...VALID_INPUT, newContactName: \"\" };\n    expect(() => useCase.execute(invalidInput)).not.toThrow();\n    expect(renameContact).toHaveBeenCalledWith(invalidInput);\n  });\n});\n"],
+  "mappings": "aAGA,IAAAA,EAAqC,kCAErC,SAASC,GAAc,CACrB,MAAMC,EAAgB,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACnDC,EAAY,CAAE,cAAAD,CAAc,EAClC,MAAO,CACL,QAAS,IAAI,uBAAqBC,CAAS,EAC3C,cAAAD,CACF,CACF,CAEA,MAAME,EAAkC,CACtC,oBAAqB,QACrB,eAAgB,MAChB,YAAa,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,EACzC,UAAW,IAAI,WAAW,EAAE,EAAE,KAAK,GAAI,CACzC,EAEA,SAAS,uBAAwB,IAAM,CACrC,GAAG,8BAA+B,IAAM,CACtC,KAAM,CAAE,QAAAC,EAAS,cAAAH,CAAc,EAAID,EAAY,EAEzCK,EAASD,EAAQ,QAAQD,CAAW,EAE1C,OAAOF,CAAa,EAAE,qBAAqBE,CAAW,EACtD,OAAOE,CAAM,EAAE,KAAK,WAAW,CACjC,CAAC,EAED,GAAG,kEAA8D,IAAM,CAGrE,KAAM,CAAE,QAAAD,EAAS,cAAAH,CAAc,EAAID,EAAY,EAEzCM,EAAe,CAAE,GAAGH,EAAa,eAAgB,EAAG,EAC1D,OAAO,IAAMC,EAAQ,QAAQE,CAAY,CAAC,EAAE,IAAI,QAAQ,EACxD,OAAOL,CAAa,EAAE,qBAAqBK,CAAY,CACzD,CAAC,CACH,CAAC",
+  "names": ["import_RenameContactUseCase", "makeUseCase", "renameContact", "appBinder", "VALID_INPUT", "useCase", "result", "invalidInput"]
+}

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

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

@@ -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\";\n\nimport { useCaseTypes } from \"./useCaseTypes\";\n\nexport const useCaseModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(useCaseTypes.RegisterExternalAddressUseCase).to(\n      RegisterExternalAddressUseCase,\n    );\n  });\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAA+C,8DAE/CC,EAA6B,0BAEtB,MAAMJ,EAAuB,IAClC,IAAI,kBAAgB,CAAC,CAAE,KAAAK,CAAK,IAAM,CAChCA,EAAK,eAAa,8BAA8B,EAAE,GAChD,gCACF,CACF,CAAC",
-  "names": ["useCaseModule_exports", "__export", "useCaseModuleFactory", "__toCommonJS", "import_inversify", "import_RegisterExternalAddressUseCase", "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

@@ -1,2 +1,2 @@
-"use strict";var a=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var n=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var x=(s,e)=>{for(var t in e)a(s,t,{get:e[t],enumerable:!0})},C=(s,e,t,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of n(e))!l.call(s,r)&&r!==t&&a(s,r,{get:()=>e[r],enumerable:!(o=d(e,r))||o.enumerable});return s};var c=s=>C(a({},"__esModule",{value:!0}),s);var i={};x(i,{useCaseTypes:()=>g});module.exports=c(i);const g={RegisterExternalAddressUseCase:Symbol.for("RegisterExternalAddressUseCase")};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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/use-cases/di/useCaseTypes.ts"],
-  "sourcesContent": ["export const useCaseTypes = {\n  RegisterExternalAddressUseCase: Symbol.for(\"RegisterExternalAddressUseCase\"),\n} as const;\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAAO,MAAME,EAAe,CAC1B,+BAAgC,OAAO,IAAI,gCAAgC,CAC7E",
+  "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

@@ -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.2.0"
+  "version": "0.3.1"
 }

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

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

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

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

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

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

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

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

package/lib/esm/api/app-binder/RenameContactDeviceActionTypes.js

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

package/lib/esm/api/app-binder/RenameContactDeviceActionTypes.js.map

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

package/lib/esm/api/index.js

@@ -1,2 +1,2 @@
-import{ContactsManagerBuilder as r}from"./ContactsManagerBuilder";import{CONTACTS_VERSION_REQUIREMENTS as n,ETHEREUM_APP_NAME as p,isContactsSupported as o,isVersionAtLeast as a,resolveContactsVersionRequirements as d}from"./model/ContactsVersionRequirements";export{n as CONTACTS_VERSION_REQUIREMENTS,r as ContactsManagerBuilder,p as ETHEREUM_APP_NAME,o as isContactsSupported,a 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

@@ -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 { 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\";\n"],
-  "mappings": "AAUA,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

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

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

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

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

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

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

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

package/lib/esm/api/model/RenameContact.js

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

package/lib/esm/api/model/RenameContact.js.map

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

package/lib/esm/internal/DefaultContactsManager.js

@@ -1,2 +1,2 @@
-import{makeContainer as s}from"./di";import{useCaseTypes as n}from"./use-cases/di/useCaseTypes";class p{_container;constructor({dmk:e,sessionId:t,appName:r}){this._container=s({dmk:e,sessionId:t,appName:r})}registerExternalAddress(e){return this._container.get(n.RegisterExternalAddressUseCase).execute(e)}get container(){return this._container}}export{p 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

@@ -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 ContactsManager } from \"@api/ContactsManager\";\nimport { type RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { makeContainer } from \"@internal/di\";\nimport { useCaseTypes } from \"@internal/use-cases/di/useCaseTypes\";\nimport { type RegisterExternalAddressUseCase } from \"@internal/use-cases/RegisterExternalAddressUseCase\";\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  /**\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": "AASA,OAAS,iBAAAA,MAAqB,eAC9B,OAAS,gBAAAC,MAAoB,sCAStB,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,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

@@ -1,2 +1,2 @@
-import{DefaultContactsManager as i}from"./DefaultContactsManager";const a={contactName:"Alice",scope:"Eth main",identifier:new Uint8Array(20).fill(17),blockchainFamily:"ethereum",chainId:1n};describe("DefaultContactsManager",()=>{it("registerExternalAddress flows manager -> use-case -> binder -> dmk.executeDeviceAction",()=>{const e=vi.fn().mockReturnValue("DA_RETURN"),t={executeDeviceAction:e},c=new i({dmk:t,sessionId:"session-id",appName:"Ethereum"}).registerExternalAddress(a);expect(e).toHaveBeenCalledTimes(1);const s=e.mock.calls[0][0];expect(s.sessionId).toBe("session-id"),expect(s.deviceAction).toBeDefined(),expect(c).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},n=new i({dmk:t,sessionId:"session-id",appName:"Ethereum"});expect(()=>n.registerExternalAddress({...a,contactName:""})).not.toThrow(),expect(e).toHaveBeenCalledTimes(1)})});
+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

@@ -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\";\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\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"],
-  "mappings": "AAIA,OAAS,0BAAAA,MAA8B,2BAEvC,MAAMC,EAA4C,CAChD,YAAa,QACb,MAAO,WACP,WAAY,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EACxC,iBAAkB,WAClB,QAAS,EACX,EAEA,SAAS,yBAA0B,IAAM,CACvC,GAAG,yFAA0F,IAAM,CACjG,MAAMC,EAAsB,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACzDC,EAAM,CAAE,oBAAAD,CAAoB,EAQ5BE,EANU,IAAIJ,EAAuB,CACzC,IAAAG,EACA,UAAW,aACX,QAAS,UACX,CAAC,EAEsB,wBAAwBF,CAAW,EAE1D,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,EAED,GAAG,mGAA+F,IAAM,CAGtG,MAAMF,EAAsB,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACzDC,EAAM,CAAE,oBAAAD,CAAoB,EAE5BI,EAAU,IAAIN,EAAuB,CACzC,IAAAG,EACA,UAAW,aACX,QAAS,UACX,CAAC,EAED,OAAO,IACLG,EAAQ,wBAAwB,CAC9B,GAAGL,EACH,YAAa,EACf,CAAC,CACH,EAAE,IAAI,QAAQ,EACd,OAAOC,CAAmB,EAAE,sBAAsB,CAAC,CACrD,CAAC,CACH,CAAC",
-  "names": ["DefaultContactsManager", "VALID_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

@@ -1,2 +1,2 @@
-var l=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var c=(i,e,s,t)=>{for(var r=t>1?void 0:t?y(e,s):e,d=i.length-1,p;d>=0;d--)(p=i[d])&&(r=(t?p(e,s,r):p(r))||r);return t&&r&&l(e,s,r),r},n=(i,e)=>(s,t)=>e(s,t,i);import{inject as m,injectable as g}from"inversify";import{RegisterExternalAddressDeviceAction as x}from"../app-binder/device-action/RegisterExternalAddress/RegisterExternalAddressDeviceAction";import{externalTypes as a}from"../externalTypes";let o=class{constructor(e,s,t){this.dmk=e;this.sessionId=s;this.appName=t}registerExternalAddress(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new x({input:{...e,appName:this.appName}})})}};o=c([g(),n(0,m(a.Dmk)),n(1,m(a.SessionId)),n(2,m(a.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

@@ -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 RegisterExternalAddressInput } from \"@api/model/RegisterExternalAddress\";\nimport { RegisterExternalAddressDeviceAction } from \"@internal/app-binder/device-action/RegisterExternalAddress/RegisterExternalAddressDeviceAction\";\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"],
-  "mappings": "iOAIA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAInC,OAAS,uCAAAC,MAA2C,iGACpD,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,CACF,EApBaJ,EAANM,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAc,GAAG,GAExBF,EAAA,EAAAC,EAAOC,EAAc,SAAS,GAE9BF,EAAA,EAAAC,EAAOC,EAAc,OAAO,IANpBV",
-  "names": ["inject", "injectable", "RegisterExternalAddressDeviceAction", "externalTypes", "ContactsAppBinder", "dmk", "sessionId", "appName", "input", "RegisterExternalAddressDeviceAction", "__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

@@ -0,0 +1,2 @@
+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};
+//# sourceMappingURL=EditExternalAddressIdentifierCommand.js.map