@ledgerhq/device-contacts-kit 0.2.0 → 0.3.1

package/lib/esm/internal/app-binder/task/SendEditExternalAddressScopeTask.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendEditExternalAddressScopeTask.test.ts"],
+  "sourcesContent": ["// Asserts the op-4 (Edit Scope) framed chunk (2-byte BE length + TLV) is\n// byte-for-byte parity with the expected wire layout.\nimport {\n  CommandResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { EditExternalAddressScopeCommand } from \"@internal/app-binder/command/EditExternalAddressScopeCommand\";\n\nimport { SendEditExternalAddressScopeTask } from \"./SendEditExternalAddressScopeTask\";\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 c9\" (2-byte BE total TLV length = 201) + TLV.\n// Tag order: STRUCT_TYPE(0x32), STRUCT_VERSION, CONTACT_NAME, SCOPE(new),\n// ACCOUNT_IDENTIFIER, PREVIOUS_SCOPE, GROUP_HANDLE, CHAIN_ID, HMAC_PROOF,\n// HMAC_REST(old), BLOCKCHAIN_FAMILY. No DERIVATION_PATH TLV.\nconst FRAMED_CHUNK = hexToBytes(\n  \"00c9\" +\n    \"010132\" +\n    \"020101\" +\n    \"81f005416c696365\" + // CONTACT_NAME \"Alice\"\n    \"81f10845746820636f6c64\" + // SCOPE (new) \"Eth cold\"\n    \"81f214\" +\n    \"55\".repeat(20) + // ACCOUNT_IDENTIFIER (unchanged)\n    \"81f508457468206d61696e\" + // PREVIOUS_SCOPE \"Eth main\"\n    \"81f640\" +\n    \"cc\".repeat(64) +\n    \"230101\" +\n    \"2920\" +\n    \"dd\".repeat(32) +\n    \"81f720\" +\n    \"aa\".repeat(32) +\n    \"510101\",\n);\n\nconst OK_PROOF = { hmacRest: hexToBytes(\"88\".repeat(32)) };\n\nconst BASE_ARGS = {\n  contactName: \"Alice\",\n  previousScope: \"Eth main\",\n  newScope: \"Eth cold\",\n  identifier: hexToBytes(\"55\".repeat(20)),\n  blockchainFamily: \"ethereum\",\n  chainId: 1n,\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(\"SendEditExternalAddressScopeTask\", () => {\n  it(\"assembles the framed chunk byte-equal to the fixture and dispatches EditExternalAddressScopeCommand\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(\n      CommandResultFactory({ data: OK_PROOF }),\n    );\n\n    const result = await new SendEditExternalAddressScopeTask(\n      api,\n      BASE_ARGS,\n    ).run();\n\n    expect(api.sendCommand.mock.calls).toHaveLength(1);\n    expect(api.sendCommand.mock.calls[0]![0]).toStrictEqual(\n      new EditExternalAddressScopeCommand({\n        data: FRAMED_CHUNK,\n        p2: 0x00,\n      }),\n    );\n    expect(result).toStrictEqual(CommandResultFactory({ data: OK_PROOF }));\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_PROOF }),\n    );\n\n    await new SendEditExternalAddressScopeTask(api, {\n      ...BASE_ARGS,\n      chainId: undefined,\n    }).run();\n\n    const command = api.sendCommand.mock\n      .calls[0]![0] as EditExternalAddressScopeCommand;\n    const framedHex = Buffer.from(command.args.data).toString(\"hex\");\n    // No `23 01 ..` CHAIN_ID TLV; HMAC_PROOF (29 20 ..) follows the path directly.\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 SendEditExternalAddressScopeTask(\n      api,\n      BASE_ARGS,\n    ).run();\n\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"user cancelled\"),\n      }),\n    );\n  });\n\n  it(\"errors when the final-chunk response does not carry hmac_rest\", async () => {\n    const api = makeApiMock();\n    api.sendCommand.mockResolvedValueOnce(CommandResultFactory({ data: {} }));\n\n    const result = await new SendEditExternalAddressScopeTask(\n      api,\n      BASE_ARGS,\n    ).run();\n\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\n          \"EditScope final-chunk response did not carry hmac_rest\",\n        ),\n      }),\n    );\n  });\n\n  it(\"throws on an unsupported blockchain family\", async () => {\n    const api = makeApiMock();\n\n    await expect(\n      new SendEditExternalAddressScopeTask(api, {\n        ...BASE_ARGS,\n        blockchainFamily: \"dogecoin\",\n      }).run(),\n    ).rejects.toThrow(/Unsupported blockchain family/);\n    expect(api.sendCommand).not.toHaveBeenCalled();\n  });\n});\n"],
+  "mappings": "AAEA,OACE,wBAAAA,EAEA,0BAAAC,MACK,kCAEP,OAAS,mCAAAC,MAAuC,+DAEhD,OAAS,oCAAAC,MAAwC,qCAEjD,SAASC,EAAWC,EAAyB,CAC3C,MAAMC,EAAM,IAAI,WAAWD,EAAI,OAAS,CAAC,EACzC,QAASE,EAAI,EAAGA,EAAIF,EAAI,OAAQE,GAAK,EACnCD,EAAIC,EAAI,CAAC,EAAI,SAASF,EAAI,MAAME,EAAGA,EAAI,CAAC,EAAG,EAAE,EAE/C,OAAOD,CACT,CAMA,MAAME,EAAeJ,EACnB,+DAME,KAAK,OAAO,EAAE,EACd,+BAEA,KAAK,OAAO,EAAE,EACd,aAEA,KAAK,OAAO,EAAE,EACd,SACA,KAAK,OAAO,EAAE,EACd,QACJ,EAEMK,EAAW,CAAE,SAAUL,EAAW,KAAK,OAAO,EAAE,CAAC,CAAE,EAEnDM,EAAY,CAChB,YAAa,QACb,cAAe,WACf,SAAU,WACV,WAAYN,EAAW,KAAK,OAAO,EAAE,CAAC,EACtC,iBAAkB,WAClB,QAAS,GACT,YAAaA,EAAW,KAAK,OAAO,EAAE,CAAC,EACvC,UAAWA,EAAW,KAAK,OAAO,EAAE,CAAC,EACrC,SAAUA,EAAW,KAAK,OAAO,EAAE,CAAC,CACtC,EAEA,SAASO,GAEP,CACA,MAAO,CAAE,YAAa,GAAG,GAAG,CAAE,CAGhC,CAEA,SAAS,mCAAoC,IAAM,CACjD,GAAG,sGAAuG,SAAY,CACpH,MAAMC,EAAMD,EAAY,EACxBC,EAAI,YAAY,sBACdZ,EAAqB,CAAE,KAAMS,CAAS,CAAC,CACzC,EAEA,MAAMI,EAAS,MAAM,IAAIV,EACvBS,EACAF,CACF,EAAE,IAAI,EAEN,OAAOE,EAAI,YAAY,KAAK,KAAK,EAAE,aAAa,CAAC,EACjD,OAAOA,EAAI,YAAY,KAAK,MAAM,CAAC,EAAG,CAAC,CAAC,EAAE,cACxC,IAAIV,EAAgC,CAClC,KAAMM,EACN,GAAI,CACN,CAAC,CACH,EACA,OAAOK,CAAM,EAAE,cAAcb,EAAqB,CAAE,KAAMS,CAAS,CAAC,CAAC,CACvE,CAAC,EAED,GAAG,sDAAuD,SAAY,CACpE,MAAMG,EAAMD,EAAY,EACxBC,EAAI,YAAY,sBACdZ,EAAqB,CAAE,KAAMS,CAAS,CAAC,CACzC,EAEA,MAAM,IAAIN,EAAiCS,EAAK,CAC9C,GAAGF,EACH,QAAS,MACX,CAAC,EAAE,IAAI,EAEP,MAAMI,EAAUF,EAAI,YAAY,KAC7B,MAAM,CAAC,EAAG,CAAC,EACRG,EAAY,OAAO,KAAKD,EAAQ,KAAK,IAAI,EAAE,SAAS,KAAK,EAE/D,OAAOC,CAAS,EAAE,IAAI,UAAU,QAAQ,EACxC,OAAOA,EAAU,SAAS,QAAQ,CAAC,EAAE,KAAK,EAAI,CAChD,CAAC,EAED,GAAG,kCAAmC,SAAY,CAChD,MAAMH,EAAMD,EAAY,EACxBC,EAAI,YAAY,sBACdZ,EAAqB,CACnB,MAAO,IAAIC,EAAuB,gBAAgB,CACpD,CAAC,CACH,EAEA,MAAMY,EAAS,MAAM,IAAIV,EACvBS,EACAF,CACF,EAAE,IAAI,EAEN,OAAOG,CAAM,EAAE,cACbb,EAAqB,CACnB,MAAO,IAAIC,EAAuB,gBAAgB,CACpD,CAAC,CACH,CACF,CAAC,EAED,GAAG,gEAAiE,SAAY,CAC9E,MAAMW,EAAMD,EAAY,EACxBC,EAAI,YAAY,sBAAsBZ,EAAqB,CAAE,KAAM,CAAC,CAAE,CAAC,CAAC,EAExE,MAAMa,EAAS,MAAM,IAAIV,EACvBS,EACAF,CACF,EAAE,IAAI,EAEN,OAAOG,CAAM,EAAE,cACbb,EAAqB,CACnB,MAAO,IAAIC,EACT,wDACF,CACF,CAAC,CACH,CACF,CAAC,EAED,GAAG,6CAA8C,SAAY,CAC3D,MAAMW,EAAMD,EAAY,EAExB,MAAM,OACJ,IAAIR,EAAiCS,EAAK,CACxC,GAAGF,EACH,iBAAkB,UACpB,CAAC,EAAE,IAAI,CACT,EAAE,QAAQ,QAAQ,+BAA+B,EACjD,OAAOE,EAAI,WAAW,EAAE,IAAI,iBAAiB,CAC/C,CAAC,CACH,CAAC",
+  "names": ["CommandResultFactory", "InvalidStatusWordError", "EditExternalAddressScopeCommand", "SendEditExternalAddressScopeTask", "hexToBytes", "hex", "out", "i", "FRAMED_CHUNK", "OK_PROOF", "BASE_ARGS", "makeApiMock", "api", "result", "command", "framedHex"]
+}

package/lib/esm/internal/app-binder/task/SendRegisterIdentityTask.js

@@ -1,2 +1,2 @@
-import{ByteArrayBuilder as m,DmkResultFactory as s,InvalidStatusWordError as p,isSuccessCommandResult as C}from"@ledgerhq/device-management-kit";import{RegisterIdentityCommand as u}from"../../app-binder/command/RegisterIdentityCommand";import{BLOCKCHAIN_FAMILY_BY_NAME as I,SUB_CMD_REGISTER_IDENTITY as T}from"../../app-binder/model/contactsConstants";import{CONTACTS_TLV_TAG as t,encodeTlvAscii as c,encodeTlvBuffer as n,encodeTlvChainId as g,encodeTlvUInt8 as a,packDerivationPath as A,STRUCT_TYPE_REGISTER_IDENTITY as R,STRUCT_VERSION_VALUE as f}from"../../app-binder/services/contactsTlvSerializer";import{sendFramedContactsPayload as E}from"../../app-binder/services/sendFramedContactsPayload";class k{constructor(r,o){this.api=r;this.args=o}async run(){const r=this.buildPayload(this.args),o=await E(this.api,{payload:r,p1:T,makeCommand:(l,y)=>new u({data:l,p2:y}),logger:this.args.logger,commandTag:"SendRegisterIdentityTask"});if(!C(o))return o;const{groupHandle:e,hmacProof:i,hmacRest:d}=o.data;return!e||!i||!d?s({error:new p("RegisterIdentity final-chunk response was incomplete")}):s({data:{groupHandle:e,hmacProof:i,hmacRest:d}})}buildPayload(r){const o=I[r.blockchainFamily.toLowerCase()];if(o===void 0)throw new Error(`Unsupported blockchain family: ${r.blockchainFamily}`);const e=new m;return a(e,t.STRUCT_TYPE,R),a(e,t.STRUCT_VERSION,f),c(e,t.CONTACT_NAME,r.contactName),c(e,t.SCOPE,r.scope),n(e,t.ACCOUNT_IDENTIFIER,r.identifier),n(e,t.DERIVATION_PATH,A([2147483692,2147483708,2147483648,0,0])),r.chainId!==void 0&&g(e,t.CHAIN_ID,r.chainId),a(e,t.BLOCKCHAIN_FAMILY,o),r.existingContactGroup&&(n(e,t.GROUP_HANDLE,r.existingContactGroup.groupHandle),n(e,t.HMAC_PROOF,r.existingContactGroup.hmacProof)),e.build()}}export{k as SendRegisterIdentityTask};
+import{ByteArrayBuilder as m,DmkResultFactory as s,InvalidStatusWordError as p,isSuccessCommandResult as C}from"@ledgerhq/device-management-kit";import{RegisterIdentityCommand as u}from"../../app-binder/command/RegisterIdentityCommand";import{BLOCKCHAIN_FAMILY_BY_NAME as I,SUB_CMD_REGISTER_IDENTITY as T}from"../../app-binder/model/contactsConstants";import{CONTACTS_TLV_TAG as t,encodeTlvAscii as l,encodeTlvBuffer as n,encodeTlvChainId as g,encodeTlvUInt8 as i,STRUCT_TYPE_REGISTER_IDENTITY as R,STRUCT_VERSION_VALUE as A}from"../../app-binder/services/contactsTlvSerializer";import{sendFramedContactsPayload as f}from"../../app-binder/services/sendFramedContactsPayload";class N{constructor(e,o){this.api=e;this.args=o}async run(){const e=this.buildPayload(this.args),o=await f(this.api,{payload:e,p1:T,makeCommand:(c,y)=>new u({data:c,p2:y}),logger:this.args.logger,commandTag:"SendRegisterIdentityTask"});if(!C(o))return o;const{groupHandle:r,hmacProof:a,hmacRest:d}=o.data;return!r||!a||!d?s({error:new p("RegisterIdentity final-chunk response was incomplete")}):s({data:{groupHandle:r,hmacProof:a,hmacRest:d}})}buildPayload(e){const o=I[e.blockchainFamily.toLowerCase()];if(o===void 0)throw new Error(`Unsupported blockchain family: ${e.blockchainFamily}`);const r=new m;return i(r,t.STRUCT_TYPE,R),i(r,t.STRUCT_VERSION,A),l(r,t.CONTACT_NAME,e.contactName),l(r,t.SCOPE,e.scope),n(r,t.ACCOUNT_IDENTIFIER,e.identifier),e.chainId!==void 0&&g(r,t.CHAIN_ID,e.chainId),i(r,t.BLOCKCHAIN_FAMILY,o),e.existingContactGroup&&(n(r,t.GROUP_HANDLE,e.existingContactGroup.groupHandle),n(r,t.HMAC_PROOF,e.existingContactGroup.hmacProof)),r.build()}}export{N as SendRegisterIdentityTask};
 //# sourceMappingURL=SendRegisterIdentityTask.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/task/SendRegisterIdentityTask.ts"],
-  "sourcesContent": ["// Builds the TLV payload for op 1 (Register Identity / Register External\n// Address) and dispatches it via the chunked-framing scheme shared with the\n// other address-book ops (2-byte BE total length + <=255B chunks). The device\n// returns the 129-byte register response on the final chunk.\n//\n// Reference: Address Book Final Specifications \u2014 Register Identity. Tag order:\n//   STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME, SCOPE, ACCOUNT_IDENTIFIER,\n//   DERIVATION_PATH, CHAIN_ID (Ethereum only), BLOCKCHAIN_FAMILY, then optional\n//   GROUP_HANDLE + HMAC_PROOF when extending an existing group.\n//\n// DERIVATION_PATH (tag 0x69, default m/44'/60'/0'/0/0): the Ethereum app\n// requires it on Register Identity and rejects the payload with 0x6a80 when it\n// is absent (verified on-device against the deployed dev app).\nimport {\n  ByteArrayBuilder,\n  type CommandResult,\n  DmkResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { type ExistingContactGroup } from \"@api/model/RegisterExternalAddress\";\nimport { RegisterIdentityCommand } from \"@internal/app-binder/command/RegisterIdentityCommand\";\nimport {\n  BLOCKCHAIN_FAMILY_BY_NAME,\n  SUB_CMD_REGISTER_IDENTITY,\n} from \"@internal/app-binder/model/contactsConstants\";\nimport { type ContactsErrorCodes } from \"@internal/app-binder/model/contactsErrors\";\nimport {\n  CONTACTS_TLV_TAG,\n  encodeTlvAscii,\n  encodeTlvBuffer,\n  encodeTlvChainId,\n  encodeTlvUInt8,\n  packDerivationPath,\n  STRUCT_TYPE_REGISTER_IDENTITY,\n  STRUCT_VERSION_VALUE,\n} from \"@internal/app-binder/services/contactsTlvSerializer\";\nimport { sendFramedContactsPayload } from \"@internal/app-binder/services/sendFramedContactsPayload\";\n\nexport type RegisterIdentityProofs = {\n  readonly groupHandle: Uint8Array;\n  readonly hmacProof: Uint8Array;\n  readonly hmacRest: Uint8Array;\n};\n\nexport type SendRegisterIdentityTaskArgs = {\n  readonly contactName: string;\n  readonly scope: string;\n  readonly identifier: Uint8Array;\n  readonly blockchainFamily: string;\n  readonly chainId?: bigint;\n  readonly existingContactGroup?: ExistingContactGroup;\n  readonly logger?: LoggerPublisherService;\n};\n\nexport class SendRegisterIdentityTask {\n  constructor(\n    private readonly api: InternalApi,\n    private readonly args: SendRegisterIdentityTaskArgs,\n  ) {}\n\n  async run(): Promise<\n    CommandResult<RegisterIdentityProofs, ContactsErrorCodes>\n  > {\n    const payload = this.buildPayload(this.args);\n\n    const result = (await sendFramedContactsPayload(this.api, {\n      payload,\n      p1: SUB_CMD_REGISTER_IDENTITY,\n      makeCommand: (chunk, p2) =>\n        new RegisterIdentityCommand({ data: chunk, p2 }),\n      logger: this.args.logger,\n      commandTag: \"SendRegisterIdentityTask\",\n    })) as CommandResult<\n      {\n        readonly groupHandle?: Uint8Array;\n        readonly hmacProof?: Uint8Array;\n        readonly hmacRest?: Uint8Array;\n      },\n      ContactsErrorCodes\n    >;\n\n    if (!isSuccessCommandResult(result)) {\n      return result;\n    }\n\n    const { groupHandle, hmacProof, hmacRest } = result.data;\n    if (!groupHandle || !hmacProof || !hmacRest) {\n      return DmkResultFactory({\n        error: new InvalidStatusWordError(\n          \"RegisterIdentity final-chunk response was incomplete\",\n        ),\n      });\n    }\n    return DmkResultFactory({ data: { groupHandle, hmacProof, hmacRest } });\n  }\n\n  private buildPayload(args: SendRegisterIdentityTaskArgs): Uint8Array {\n    const family =\n      BLOCKCHAIN_FAMILY_BY_NAME[args.blockchainFamily.toLowerCase()];\n    if (family === undefined) {\n      throw new Error(\n        `Unsupported blockchain family: ${args.blockchainFamily}`,\n      );\n    }\n\n    const builder = new ByteArrayBuilder();\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_TYPE,\n      STRUCT_TYPE_REGISTER_IDENTITY,\n    );\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_VERSION,\n      STRUCT_VERSION_VALUE,\n    );\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.CONTACT_NAME, args.contactName);\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.SCOPE, args.scope);\n    encodeTlvBuffer(\n      builder,\n      CONTACTS_TLV_TAG.ACCOUNT_IDENTIFIER,\n      args.identifier,\n    );\n    // The Ethereum app requires DERIVATION_PATH on Register Identity (0x6a80\n    // without it). Default m/44'/60'/0'/0/0.\n    encodeTlvBuffer(\n      builder,\n      CONTACTS_TLV_TAG.DERIVATION_PATH,\n      packDerivationPath([0x8000002c, 0x8000003c, 0x80000000, 0, 0]),\n    );\n    if (args.chainId !== undefined) {\n      encodeTlvChainId(builder, CONTACTS_TLV_TAG.CHAIN_ID, args.chainId);\n    }\n    encodeTlvUInt8(builder, CONTACTS_TLV_TAG.BLOCKCHAIN_FAMILY, family);\n\n    if (args.existingContactGroup) {\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.GROUP_HANDLE,\n        args.existingContactGroup.groupHandle,\n      );\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.HMAC_PROOF,\n        args.existingContactGroup.hmacProof,\n      );\n    }\n\n    return builder.build();\n  }\n}\n"],
-  "mappings": "AAaA,OACE,oBAAAA,EAEA,oBAAAC,EAEA,0BAAAC,EACA,0BAAAC,MAEK,kCAGP,OAAS,2BAAAC,MAA+B,uDACxC,OACE,6BAAAC,EACA,6BAAAC,MACK,+CAEP,OACE,oBAAAC,EACA,kBAAAC,EACA,mBAAAC,EACA,oBAAAC,EACA,kBAAAC,EACA,sBAAAC,EACA,iCAAAC,EACA,wBAAAC,MACK,sDACP,OAAS,6BAAAC,MAAiC,0DAkBnC,MAAMC,CAAyB,CACpC,YACmBC,EACAC,EACjB,CAFiB,SAAAD,EACA,UAAAC,CAChB,CAEH,MAAM,KAEJ,CACA,MAAMC,EAAU,KAAK,aAAa,KAAK,IAAI,EAErCC,EAAU,MAAML,EAA0B,KAAK,IAAK,CACxD,QAAAI,EACA,GAAIb,EACJ,YAAa,CAACe,EAAOC,IACnB,IAAIlB,EAAwB,CAAE,KAAMiB,EAAO,GAAAC,CAAG,CAAC,EACjD,OAAQ,KAAK,KAAK,OAClB,WAAY,0BACd,CAAC,EASD,GAAI,CAACnB,EAAuBiB,CAAM,EAChC,OAAOA,EAGT,KAAM,CAAE,YAAAG,EAAa,UAAAC,EAAW,SAAAC,CAAS,EAAIL,EAAO,KACpD,MAAI,CAACG,GAAe,CAACC,GAAa,CAACC,EAC1BxB,EAAiB,CACtB,MAAO,IAAIC,EACT,sDACF,CACF,CAAC,EAEID,EAAiB,CAAE,KAAM,CAAE,YAAAsB,EAAa,UAAAC,EAAW,SAAAC,CAAS,CAAE,CAAC,CACxE,CAEQ,aAAaP,EAAgD,CACnE,MAAMQ,EACJrB,EAA0Ba,EAAK,iBAAiB,YAAY,CAAC,EAC/D,GAAIQ,IAAW,OACb,MAAM,IAAI,MACR,kCAAkCR,EAAK,gBAAgB,EACzD,EAGF,MAAMS,EAAU,IAAI3B,EACpB,OAAAW,EACEgB,EACApB,EAAiB,YACjBM,CACF,EACAF,EACEgB,EACApB,EAAiB,eACjBO,CACF,EACAN,EAAemB,EAASpB,EAAiB,aAAcW,EAAK,WAAW,EACvEV,EAAemB,EAASpB,EAAiB,MAAOW,EAAK,KAAK,EAC1DT,EACEkB,EACApB,EAAiB,mBACjBW,EAAK,UACP,EAGAT,EACEkB,EACApB,EAAiB,gBACjBK,EAAmB,CAAC,WAAY,WAAY,WAAY,EAAG,CAAC,CAAC,CAC/D,EACIM,EAAK,UAAY,QACnBR,EAAiBiB,EAASpB,EAAiB,SAAUW,EAAK,OAAO,EAEnEP,EAAegB,EAASpB,EAAiB,kBAAmBmB,CAAM,EAE9DR,EAAK,uBACPT,EACEkB,EACApB,EAAiB,aACjBW,EAAK,qBAAqB,WAC5B,EACAT,EACEkB,EACApB,EAAiB,WACjBW,EAAK,qBAAqB,SAC5B,GAGKS,EAAQ,MAAM,CACvB,CACF",
-  "names": ["ByteArrayBuilder", "DmkResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "RegisterIdentityCommand", "BLOCKCHAIN_FAMILY_BY_NAME", "SUB_CMD_REGISTER_IDENTITY", "CONTACTS_TLV_TAG", "encodeTlvAscii", "encodeTlvBuffer", "encodeTlvChainId", "encodeTlvUInt8", "packDerivationPath", "STRUCT_TYPE_REGISTER_IDENTITY", "STRUCT_VERSION_VALUE", "sendFramedContactsPayload", "SendRegisterIdentityTask", "api", "args", "payload", "result", "chunk", "p2", "groupHandle", "hmacProof", "hmacRest", "family", "builder"]
+  "sourcesContent": ["// Builds the TLV payload for op 1 (Register Identity / Register External\n// Address) and dispatches it via the chunked-framing scheme shared with the\n// other address-book ops (2-byte BE total length + <=255B chunks). The device\n// returns the 129-byte register response on the final chunk.\n//\n// Reference: Address Book Final Specifications \u2014 Register Identity. Tag order:\n//   STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME, SCOPE, ACCOUNT_IDENTIFIER,\n//   CHAIN_ID (Ethereum only), BLOCKCHAIN_FAMILY, then optional\n//   GROUP_HANDLE + HMAC_PROOF when extending an existing group.\n//\n// No DERIVATION_PATH: external-address ops carry no path. The current Ethereum\n// app rejects the tag when present (0x6a80) and no longer requires it; the tag\n// is Ledger-Account only (verified on-device, DSDK-1465).\nimport {\n  ByteArrayBuilder,\n  type CommandResult,\n  DmkResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { type ExistingContactGroup } from \"@api/model/RegisterExternalAddress\";\nimport { RegisterIdentityCommand } from \"@internal/app-binder/command/RegisterIdentityCommand\";\nimport {\n  BLOCKCHAIN_FAMILY_BY_NAME,\n  SUB_CMD_REGISTER_IDENTITY,\n} from \"@internal/app-binder/model/contactsConstants\";\nimport { type ContactsErrorCodes } from \"@internal/app-binder/model/contactsErrors\";\nimport {\n  CONTACTS_TLV_TAG,\n  encodeTlvAscii,\n  encodeTlvBuffer,\n  encodeTlvChainId,\n  encodeTlvUInt8,\n  STRUCT_TYPE_REGISTER_IDENTITY,\n  STRUCT_VERSION_VALUE,\n} from \"@internal/app-binder/services/contactsTlvSerializer\";\nimport { sendFramedContactsPayload } from \"@internal/app-binder/services/sendFramedContactsPayload\";\n\nexport type RegisterIdentityProofs = {\n  readonly groupHandle: Uint8Array;\n  readonly hmacProof: Uint8Array;\n  readonly hmacRest: Uint8Array;\n};\n\nexport type SendRegisterIdentityTaskArgs = {\n  readonly contactName: string;\n  readonly scope: string;\n  readonly identifier: Uint8Array;\n  readonly blockchainFamily: string;\n  readonly chainId?: bigint;\n  readonly existingContactGroup?: ExistingContactGroup;\n  readonly logger?: LoggerPublisherService;\n};\n\nexport class SendRegisterIdentityTask {\n  constructor(\n    private readonly api: InternalApi,\n    private readonly args: SendRegisterIdentityTaskArgs,\n  ) {}\n\n  async run(): Promise<\n    CommandResult<RegisterIdentityProofs, ContactsErrorCodes>\n  > {\n    const payload = this.buildPayload(this.args);\n\n    const result = (await sendFramedContactsPayload(this.api, {\n      payload,\n      p1: SUB_CMD_REGISTER_IDENTITY,\n      makeCommand: (chunk, p2) =>\n        new RegisterIdentityCommand({ data: chunk, p2 }),\n      logger: this.args.logger,\n      commandTag: \"SendRegisterIdentityTask\",\n    })) as CommandResult<\n      {\n        readonly groupHandle?: Uint8Array;\n        readonly hmacProof?: Uint8Array;\n        readonly hmacRest?: Uint8Array;\n      },\n      ContactsErrorCodes\n    >;\n\n    if (!isSuccessCommandResult(result)) {\n      return result;\n    }\n\n    const { groupHandle, hmacProof, hmacRest } = result.data;\n    if (!groupHandle || !hmacProof || !hmacRest) {\n      return DmkResultFactory({\n        error: new InvalidStatusWordError(\n          \"RegisterIdentity final-chunk response was incomplete\",\n        ),\n      });\n    }\n    return DmkResultFactory({ data: { groupHandle, hmacProof, hmacRest } });\n  }\n\n  private buildPayload(args: SendRegisterIdentityTaskArgs): Uint8Array {\n    const family =\n      BLOCKCHAIN_FAMILY_BY_NAME[args.blockchainFamily.toLowerCase()];\n    if (family === undefined) {\n      throw new Error(\n        `Unsupported blockchain family: ${args.blockchainFamily}`,\n      );\n    }\n\n    const builder = new ByteArrayBuilder();\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_TYPE,\n      STRUCT_TYPE_REGISTER_IDENTITY,\n    );\n    encodeTlvUInt8(\n      builder,\n      CONTACTS_TLV_TAG.STRUCT_VERSION,\n      STRUCT_VERSION_VALUE,\n    );\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.CONTACT_NAME, args.contactName);\n    encodeTlvAscii(builder, CONTACTS_TLV_TAG.SCOPE, args.scope);\n    encodeTlvBuffer(\n      builder,\n      CONTACTS_TLV_TAG.ACCOUNT_IDENTIFIER,\n      args.identifier,\n    );\n    if (args.chainId !== undefined) {\n      encodeTlvChainId(builder, CONTACTS_TLV_TAG.CHAIN_ID, args.chainId);\n    }\n    encodeTlvUInt8(builder, CONTACTS_TLV_TAG.BLOCKCHAIN_FAMILY, family);\n\n    if (args.existingContactGroup) {\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.GROUP_HANDLE,\n        args.existingContactGroup.groupHandle,\n      );\n      encodeTlvBuffer(\n        builder,\n        CONTACTS_TLV_TAG.HMAC_PROOF,\n        args.existingContactGroup.hmacProof,\n      );\n    }\n\n    return builder.build();\n  }\n}\n"],
+  "mappings": "AAaA,OACE,oBAAAA,EAEA,oBAAAC,EAEA,0BAAAC,EACA,0BAAAC,MAEK,kCAGP,OAAS,2BAAAC,MAA+B,uDACxC,OACE,6BAAAC,EACA,6BAAAC,MACK,+CAEP,OACE,oBAAAC,EACA,kBAAAC,EACA,mBAAAC,EACA,oBAAAC,EACA,kBAAAC,EACA,iCAAAC,EACA,wBAAAC,MACK,sDACP,OAAS,6BAAAC,MAAiC,0DAkBnC,MAAMC,CAAyB,CACpC,YACmBC,EACAC,EACjB,CAFiB,SAAAD,EACA,UAAAC,CAChB,CAEH,MAAM,KAEJ,CACA,MAAMC,EAAU,KAAK,aAAa,KAAK,IAAI,EAErCC,EAAU,MAAML,EAA0B,KAAK,IAAK,CACxD,QAAAI,EACA,GAAIZ,EACJ,YAAa,CAACc,EAAOC,IACnB,IAAIjB,EAAwB,CAAE,KAAMgB,EAAO,GAAAC,CAAG,CAAC,EACjD,OAAQ,KAAK,KAAK,OAClB,WAAY,0BACd,CAAC,EASD,GAAI,CAAClB,EAAuBgB,CAAM,EAChC,OAAOA,EAGT,KAAM,CAAE,YAAAG,EAAa,UAAAC,EAAW,SAAAC,CAAS,EAAIL,EAAO,KACpD,MAAI,CAACG,GAAe,CAACC,GAAa,CAACC,EAC1BvB,EAAiB,CACtB,MAAO,IAAIC,EACT,sDACF,CACF,CAAC,EAEID,EAAiB,CAAE,KAAM,CAAE,YAAAqB,EAAa,UAAAC,EAAW,SAAAC,CAAS,CAAE,CAAC,CACxE,CAEQ,aAAaP,EAAgD,CACnE,MAAMQ,EACJpB,EAA0BY,EAAK,iBAAiB,YAAY,CAAC,EAC/D,GAAIQ,IAAW,OACb,MAAM,IAAI,MACR,kCAAkCR,EAAK,gBAAgB,EACzD,EAGF,MAAMS,EAAU,IAAI1B,EACpB,OAAAW,EACEe,EACAnB,EAAiB,YACjBK,CACF,EACAD,EACEe,EACAnB,EAAiB,eACjBM,CACF,EACAL,EAAekB,EAASnB,EAAiB,aAAcU,EAAK,WAAW,EACvET,EAAekB,EAASnB,EAAiB,MAAOU,EAAK,KAAK,EAC1DR,EACEiB,EACAnB,EAAiB,mBACjBU,EAAK,UACP,EACIA,EAAK,UAAY,QACnBP,EAAiBgB,EAASnB,EAAiB,SAAUU,EAAK,OAAO,EAEnEN,EAAee,EAASnB,EAAiB,kBAAmBkB,CAAM,EAE9DR,EAAK,uBACPR,EACEiB,EACAnB,EAAiB,aACjBU,EAAK,qBAAqB,WAC5B,EACAR,EACEiB,EACAnB,EAAiB,WACjBU,EAAK,qBAAqB,SAC5B,GAGKS,EAAQ,MAAM,CACvB,CACF",
+  "names": ["ByteArrayBuilder", "DmkResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "RegisterIdentityCommand", "BLOCKCHAIN_FAMILY_BY_NAME", "SUB_CMD_REGISTER_IDENTITY", "CONTACTS_TLV_TAG", "encodeTlvAscii", "encodeTlvBuffer", "encodeTlvChainId", "encodeTlvUInt8", "STRUCT_TYPE_REGISTER_IDENTITY", "STRUCT_VERSION_VALUE", "sendFramedContactsPayload", "SendRegisterIdentityTask", "api", "args", "payload", "result", "chunk", "p2", "groupHandle", "hmacProof", "hmacRest", "family", "builder"]
 }

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

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

package/lib/esm/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": ["CommandResultFactory", "InvalidStatusWordError", "RegisterIdentityCommand", "SendRegisterIdentityTask", "hexToBytes", "hex", "out", "i", "FRESH_FRAMED_CHUNK", "EXTENSION_FRAMED_CHUNK", "OK_PROOFS", "makeApiMock", "api", "result", "command", "framedHex"]
 }

package/lib/esm/internal/app-binder/task/SendRenameContactTask.js

@@ -0,0 +1,2 @@
+import{ByteArrayBuilder as c,DmkResultFactory as n,InvalidStatusWordError as C,isSuccessCommandResult as l}from"@ledgerhq/device-management-kit";import{RenameContactCommand as T}from"../../app-binder/command/RenameContactCommand";import{RENAME_CONTACT_P1 as p}from"../../app-binder/model/contactsConstants";import{CONTACTS_TLV_TAG as e,encodeTlvAscii as m,encodeTlvBuffer as o,encodeTlvUInt8 as s,packDerivationPath as y,STRUCT_TYPE_EDIT_CONTACT_NAME as u,STRUCT_VERSION_VALUE as A}from"../../app-binder/services/contactsTlvSerializer";import{sendFramedContactsPayload as R}from"../../app-binder/services/sendFramedContactsPayload";class S{constructor(a,r){this.api=a;this.args=r}async run(){const a=this.buildPayload(this.args),r=await R(this.api,{payload:a,p1:p,makeCommand:(d,i)=>new T({data:d,p2:i}),logger:this.args.logger,commandTag:"SendRenameContactTask"});if(!l(r))return r;const{hmacProof:t}=r.data;return t?n({data:{hmacProof:t}}):n({error:new C("RenameContact final-chunk response did not carry hmac_name")})}buildPayload(a){const r=new c;return s(r,e.STRUCT_TYPE,u),s(r,e.STRUCT_VERSION,A),m(r,e.CONTACT_NAME,a.newContactName),m(r,e.PREVIOUS_CONTACT_NAME,a.previousContactName),o(r,e.GROUP_HANDLE,a.groupHandle),o(r,e.DERIVATION_PATH,y([2147483692,2147483708,2147483648,0,0])),o(r,e.HMAC_PROOF,a.hmacProof),r.build()}}export{S as SendRenameContactTask};
+//# sourceMappingURL=SendRenameContactTask.js.map

package/lib/esm/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": "AAcA,OACE,oBAAAA,EAEA,oBAAAC,EAEA,0BAAAC,EACA,0BAAAC,MAEK,kCAEP,OAAS,wBAAAC,MAA4B,oDACrC,OAAS,qBAAAC,MAAyB,+CAElC,OACE,oBAAAC,EACA,kBAAAC,EACA,mBAAAC,EACA,kBAAAC,EACA,sBAAAC,EACA,iCAAAC,EACA,wBAAAC,MACK,sDACP,OAAS,6BAAAC,MAAiC,0DAcnC,MAAMC,CAAsB,CACjC,YACmBC,EACAC,EACjB,CAFiB,SAAAD,EACA,UAAAC,CAChB,CAEH,MAAM,KAAsE,CAC1E,MAAMC,EAAU,KAAK,aAAa,KAAK,IAAI,EAErCC,EAAU,MAAML,EAA0B,KAAK,IAAK,CACxD,QAAAI,EACA,GAAIZ,EACJ,YAAa,CAACc,EAAOC,IAAO,IAAIhB,EAAqB,CAAE,KAAMe,EAAO,GAAAC,CAAG,CAAC,EACxE,OAAQ,KAAK,KAAK,OAClB,WAAY,uBACd,CAAC,EAKD,GAAI,CAACjB,EAAuBe,CAAM,EAChC,OAAOA,EAGT,KAAM,CAAE,UAAAG,CAAU,EAAIH,EAAO,KAC7B,OAAKG,EAOEpB,EAAiB,CAAE,KAAM,CAAE,UAAAoB,CAAU,CAAE,CAAC,EANtCpB,EAAiB,CACtB,MAAO,IAAIC,EACT,4DACF,CACF,CAAC,CAGL,CAEQ,aAAac,EAA6C,CAChE,MAAMM,EAAU,IAAItB,EACpB,OAAAS,EACEa,EACAhB,EAAiB,YACjBK,CACF,EACAF,EACEa,EACAhB,EAAiB,eACjBM,CACF,EACAL,EAAee,EAAShB,EAAiB,aAAcU,EAAK,cAAc,EAC1ET,EACEe,EACAhB,EAAiB,sBACjBU,EAAK,mBACP,EACAR,EAAgBc,EAAShB,EAAiB,aAAcU,EAAK,WAAW,EAGxER,EACEc,EACAhB,EAAiB,gBACjBI,EAAmB,CAAC,WAAY,WAAY,WAAY,EAAG,CAAC,CAAC,CAC/D,EACAF,EAAgBc,EAAShB,EAAiB,WAAYU,EAAK,SAAS,EAE7DM,EAAQ,MAAM,CACvB,CACF",
+  "names": ["ByteArrayBuilder", "DmkResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "RenameContactCommand", "RENAME_CONTACT_P1", "CONTACTS_TLV_TAG", "encodeTlvAscii", "encodeTlvBuffer", "encodeTlvUInt8", "packDerivationPath", "STRUCT_TYPE_EDIT_CONTACT_NAME", "STRUCT_VERSION_VALUE", "sendFramedContactsPayload", "SendRenameContactTask", "api", "args", "payload", "result", "chunk", "p2", "hmacProof", "builder"]
+}

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

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

package/lib/esm/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": ["CommandResultFactory", "InvalidStatusWordError", "RenameContactCommand", "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/esm/internal/di.test.js

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

package/lib/esm/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,OAAS,qBAAAA,MAAyB,yCAClC,OAAS,kBAAAC,MAAsB,yCAC/B,OAAS,iBAAAC,MAAqB,eAC9B,OAAS,iBAAAC,MAAqB,0BAC9B,OAAS,gBAAAC,MAAoB,sCAC7B,OAAS,kCAAAC,MAAsC,qDAE/C,SAAS,gBAAiB,IAAM,CAC9B,MAAMC,EAAM,CAAC,EACPC,EAAY,aACZC,EAAU,WAEVC,EAAYP,EAAc,CAAE,IAAAI,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,EAE3D,GAAG,sDAAuD,IAAM,CAC9D,OAAOC,EAAU,IAAIN,EAAc,GAAG,CAAC,EAAE,KAAKG,CAAG,EACjD,OAAOG,EAAU,IAAIN,EAAc,SAAS,CAAC,EAAE,KAAKI,CAAS,EAC7D,OAAOE,EAAU,IAAIN,EAAc,OAAO,CAAC,EAAE,KAAKK,CAAO,CAC3D,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,OAAOC,EAAU,IAAIR,EAAe,SAAS,CAAC,EAAE,eAC9CD,CACF,CACF,CAAC,EAED,GAAG,2CAA4C,IAAM,CACnD,OACES,EAAU,IAAIL,EAAa,8BAA8B,CAC3D,EAAE,eAAeC,CAA8B,CACjD,CAAC,CACH,CAAC",
-  "names": ["ContactsAppBinder", "appBinderTypes", "makeContainer", "externalTypes", "useCaseTypes", "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,OAAS,qBAAAA,MAAyB,yCAClC,OAAS,kBAAAC,MAAsB,yCAC/B,OAAS,iBAAAC,MAAqB,eAC9B,OAAS,iBAAAC,MAAqB,0BAC9B,OAAS,gBAAAC,MAAoB,sCAC7B,OAAS,kCAAAC,MAAsC,qDAC/C,OAAS,wBAAAC,MAA4B,2CAErC,SAAS,gBAAiB,IAAM,CAC9B,MAAMC,EAAM,CAAC,EACPC,EAAY,aACZC,EAAU,WAEVC,EAAYR,EAAc,CAAE,IAAAK,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,EAE3D,GAAG,sDAAuD,IAAM,CAC9D,OAAOC,EAAU,IAAIP,EAAc,GAAG,CAAC,EAAE,KAAKI,CAAG,EACjD,OAAOG,EAAU,IAAIP,EAAc,SAAS,CAAC,EAAE,KAAKK,CAAS,EAC7D,OAAOE,EAAU,IAAIP,EAAc,OAAO,CAAC,EAAE,KAAKM,CAAO,CAC3D,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,OAAOC,EAAU,IAAIT,EAAe,SAAS,CAAC,EAAE,eAC9CD,CACF,CACF,CAAC,EAED,GAAG,2CAA4C,IAAM,CACnD,OACEU,EAAU,IAAIN,EAAa,8BAA8B,CAC3D,EAAE,eAAeC,CAA8B,CACjD,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzC,OAAOK,EAAU,IAAIN,EAAa,oBAAoB,CAAC,EAAE,eACvDE,CACF,CACF,CAAC,CACH,CAAC",
+  "names": ["ContactsAppBinder", "appBinderTypes", "makeContainer", "externalTypes", "useCaseTypes", "RegisterExternalAddressUseCase", "RenameContactUseCase", "dmk", "sessionId", "appName", "container"]
 }

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

@@ -0,0 +1,2 @@
+var c=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var m=(p,r,i,e)=>{for(var t=e>1?void 0:e?f(r,i):r,o=p.length-1,d;o>=0;o--)(d=p[o])&&(t=(e?d(r,i,t):d(t))||t);return e&&t&&c(r,i,t),t},a=(p,r)=>(i,e)=>r(i,e,p);import{inject as u,injectable as A}from"inversify";import{appBinderTypes as y}from"../app-binder/di/appBinderTypes";let n=class{constructor(r){this.appBinder=r}execute(r){return this.appBinder.editExternalAddressIdentifier(r)}};n=m([A(),a(0,u(y.AppBinder))],n);export{n as EditExternalAddressIdentifierUseCase};
+//# sourceMappingURL=EditExternalAddressIdentifierUseCase.js.map

package/lib/esm/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": "iOAAA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAKnC,OAAS,kBAAAC,MAAsB,yCAQxB,IAAMC,EAAN,KAA2C,CAChD,YAEmBC,EACjB,CADiB,eAAAA,CAChB,CAEH,QACEC,EAC2C,CAC3C,OAAO,KAAK,UAAU,8BAA8BA,CAAK,CAC3D,CACF,EAXaF,EAANG,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAe,SAAS,IAFvBP",
+  "names": ["inject", "injectable", "appBinderTypes", "EditExternalAddressIdentifierUseCase", "appBinder", "input", "__decorateClass", "injectable", "__decorateParam", "inject", "appBinderTypes"]
+}

package/lib/esm/internal/use-cases/EditExternalAddressIdentifierUseCase.test.js

@@ -0,0 +1,2 @@
+import{EditExternalAddressIdentifierUseCase as a}from"./EditExternalAddressIdentifierUseCase";function r(){const e=vi.fn().mockReturnValue("DA_RETURN"),t={editExternalAddressIdentifier:e};return{useCase:new a(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/esm/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,OAAS,wCAAAA,MAA4C,yCAErD,SAASC,GAAc,CACrB,MAAMC,EAAgC,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACnEC,EAAY,CAChB,8BAAAD,CACF,EACA,MAAO,CACL,QAAS,IAAIF,EAAqCG,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": ["EditExternalAddressIdentifierUseCase", "makeUseCase", "editExternalAddressIdentifier", "appBinder", "VALID_INPUT", "useCase", "result", "invalidInput"]
+}

package/lib/esm/internal/use-cases/EditExternalAddressScopeUseCase.js

@@ -0,0 +1,2 @@
+var a=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var c=(e,r,n,t)=>{for(var p=t>1?void 0:t?u(r,n):r,i=e.length-1,d;i>=0;i--)(d=e[i])&&(p=(t?d(r,n,p):d(p))||p);return t&&p&&a(r,n,p),p},m=(e,r)=>(n,t)=>r(n,t,e);import{inject as A,injectable as y}from"inversify";import{appBinderTypes as B}from"../app-binder/di/appBinderTypes";let o=class{constructor(r){this.appBinder=r}execute(r){return this.appBinder.editExternalAddressScope(r)}};o=c([y(),m(0,A(B.AppBinder))],o);export{o as EditExternalAddressScopeUseCase};
+//# sourceMappingURL=EditExternalAddressScopeUseCase.js.map

package/lib/esm/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": "iOAAA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAKnC,OAAS,kBAAAC,MAAsB,yCAQxB,IAAMC,EAAN,KAAsC,CAC3C,YAEmBC,EACjB,CADiB,eAAAA,CAChB,CAEH,QACEC,EACsC,CACtC,OAAO,KAAK,UAAU,yBAAyBA,CAAK,CACtD,CACF,EAXaF,EAANG,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAe,SAAS,IAFvBP",
+  "names": ["inject", "injectable", "appBinderTypes", "EditExternalAddressScopeUseCase", "appBinder", "input", "__decorateClass", "injectable", "__decorateParam", "inject", "appBinderTypes"]
+}

package/lib/esm/internal/use-cases/EditExternalAddressScopeUseCase.test.js

@@ -0,0 +1,2 @@
+import{EditExternalAddressScopeUseCase as r}from"./EditExternalAddressScopeUseCase";function o(){const e=vi.fn().mockReturnValue("DA_RETURN"),t={editExternalAddressScope:e};return{useCase:new r(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/esm/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,OAAS,mCAAAA,MAAuC,oCAEhD,SAASC,GAAc,CACrB,MAAMC,EAA2B,GAAG,GAAG,EAAE,gBAAgB,WAAW,EAC9DC,EAAY,CAChB,yBAAAD,CACF,EACA,MAAO,CACL,QAAS,IAAIF,EAAgCG,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": ["EditExternalAddressScopeUseCase", "makeUseCase", "editExternalAddressScope", "appBinder", "VALID_INPUT", "useCase", "result", "invalidInput"]
+}

package/lib/esm/internal/use-cases/RenameContactUseCase.js

@@ -0,0 +1,2 @@
+var d=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var a=(e,t,n,r)=>{for(var p=r>1?void 0:r?u(t,n):t,i=e.length-1,m;i>=0;i--)(m=e[i])&&(p=(r?m(t,n,p):m(p))||p);return r&&p&&d(t,n,p),p},c=(e,t)=>(n,r)=>t(n,r,e);import{inject as y,injectable as B}from"inversify";import{appBinderTypes as f}from"../app-binder/di/appBinderTypes";let o=class{constructor(t){this.appBinder=t}execute(t){return this.appBinder.renameContact(t)}};o=a([B(),c(0,y(f.AppBinder))],o);export{o as RenameContactUseCase};
+//# sourceMappingURL=RenameContactUseCase.js.map

package/lib/esm/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": "iOAAA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAKnC,OAAS,kBAAAC,MAAsB,yCAaxB,IAAMC,EAAN,KAA2B,CAChC,YAEmBC,EACjB,CADiB,eAAAA,CAChB,CAEH,QAAQC,EAAsD,CAC5D,OAAO,KAAK,UAAU,cAAcA,CAAK,CAC3C,CACF,EATaF,EAANG,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAe,SAAS,IAFvBP",
+  "names": ["inject", "injectable", "appBinderTypes", "RenameContactUseCase", "appBinder", "input", "__decorateClass", "injectable", "__decorateParam", "inject", "appBinderTypes"]
+}

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

@@ -0,0 +1,2 @@
+import{RenameContactUseCase as c}from"./RenameContactUseCase";function o(){const e=vi.fn().mockReturnValue("DA_RETURN"),t={renameContact:e};return{useCase:new c(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/esm/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,OAAS,wBAAAA,MAA4B,yBAErC,SAASC,GAAc,CACrB,MAAMC,EAAgB,GAAG,GAAG,EAAE,gBAAgB,WAAW,EACnDC,EAAY,CAAE,cAAAD,CAAc,EAClC,MAAO,CACL,QAAS,IAAIF,EAAqBG,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": ["RenameContactUseCase", "makeUseCase", "renameContact", "appBinder", "VALID_INPUT", "useCase", "result", "invalidInput"]
+}

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

@@ -1,2 +1,2 @@
-import{ContainerModule as s}from"inversify";import{RegisterExternalAddressUseCase as r}from"../../use-cases/RegisterExternalAddressUseCase";import{useCaseTypes as o}from"./useCaseTypes";const i=()=>new s(({bind:e})=>{e(o.RegisterExternalAddressUseCase).to(r)});export{i as useCaseModuleFactory};
+import{ContainerModule as t}from"inversify";import{EditExternalAddressIdentifierUseCase as r}from"../../use-cases/EditExternalAddressIdentifierUseCase";import{EditExternalAddressScopeUseCase as o}from"../../use-cases/EditExternalAddressScopeUseCase";import{RegisterExternalAddressUseCase as a}from"../../use-cases/RegisterExternalAddressUseCase";import{RenameContactUseCase as d}from"../../use-cases/RenameContactUseCase";import{useCaseTypes as s}from"./useCaseTypes";const f=()=>new t(({bind:e})=>{e(s.RegisterExternalAddressUseCase).to(a),e(s.RenameContactUseCase).to(d),e(s.EditExternalAddressIdentifierUseCase).to(r),e(s.EditExternalAddressScopeUseCase).to(o)});export{f as useCaseModuleFactory};
 //# sourceMappingURL=useCaseModule.js.map

package/lib/esm/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": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,kCAAAC,MAAsC,qDAE/C,OAAS,gBAAAC,MAAoB,iBAEtB,MAAMC,EAAuB,IAClC,IAAIH,EAAgB,CAAC,CAAE,KAAAI,CAAK,IAAM,CAChCA,EAAKF,EAAa,8BAA8B,EAAE,GAChDD,CACF,CACF,CAAC",
-  "names": ["ContainerModule", "RegisterExternalAddressUseCase", "useCaseTypes", "useCaseModuleFactory", "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": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,wCAAAC,MAA4C,2DACrD,OAAS,mCAAAC,MAAuC,sDAChD,OAAS,kCAAAC,MAAsC,qDAC/C,OAAS,wBAAAC,MAA4B,2CAErC,OAAS,gBAAAC,MAAoB,iBAEtB,MAAMC,EAAuB,IAClC,IAAIN,EAAgB,CAAC,CAAE,KAAAO,CAAK,IAAM,CAChCA,EAAKF,EAAa,8BAA8B,EAAE,GAChDF,CACF,EACAI,EAAKF,EAAa,oBAAoB,EAAE,GAAGD,CAAoB,EAC/DG,EAAKF,EAAa,oCAAoC,EAAE,GACtDJ,CACF,EACAM,EAAKF,EAAa,+BAA+B,EAAE,GACjDH,CACF,CACF,CAAC",
+  "names": ["ContainerModule", "EditExternalAddressIdentifierUseCase", "EditExternalAddressScopeUseCase", "RegisterExternalAddressUseCase", "RenameContactUseCase", "useCaseTypes", "useCaseModuleFactory", "bind"]
 }

package/lib/esm/internal/use-cases/di/useCaseTypes.js

@@ -1,2 +1,2 @@
-const e={RegisterExternalAddressUseCase:Symbol.for("RegisterExternalAddressUseCase")};export{e as useCaseTypes};
+const e={RegisterExternalAddressUseCase:Symbol.for("RegisterExternalAddressUseCase"),RenameContactUseCase:Symbol.for("RenameContactUseCase"),EditExternalAddressIdentifierUseCase:Symbol.for("EditExternalAddressIdentifierUseCase"),EditExternalAddressScopeUseCase:Symbol.for("EditExternalAddressScopeUseCase")};export{e as useCaseTypes};
 //# sourceMappingURL=useCaseTypes.js.map

package/lib/esm/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": "AAAO,MAAMA,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": "AAAO,MAAMA,EAAe,CAC1B,+BAAgC,OAAO,IAAI,gCAAgC,EAC3E,qBAAsB,OAAO,IAAI,sBAAsB,EACvD,qCAAsC,OAAO,IAC3C,sCACF,EACA,gCAAiC,OAAO,IACtC,iCACF,CACF",
   "names": ["useCaseTypes"]
 }

package/lib/esm/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/types/api/ContactsManager.d.ts

@@ -1,5 +1,11 @@
+import { type EditExternalAddressIdentifierDAReturnType } from "./app-binder/EditExternalAddressIdentifierDeviceActionTypes";
+import { type EditExternalAddressScopeDAReturnType } from "./app-binder/EditExternalAddressScopeDeviceActionTypes";
 import { type RegisterExternalAddressDAReturnType } from "./app-binder/RegisterExternalAddressDeviceActionTypes";
+import { type RenameContactDAReturnType } from "./app-binder/RenameContactDeviceActionTypes";
+import { type EditExternalAddressIdentifierInput } from "./model/EditExternalAddressIdentifier";
+import { type EditExternalAddressScopeInput } from "./model/EditExternalAddressScope";
 import { type RegisterExternalAddressInput } from "./model/RegisterExternalAddress";
+import { type RenameContactInput } from "./model/RenameContact";
 /**
  * Public, stateless Contacts (Address Book) manager.
  *
@@ -18,5 +24,34 @@ export interface ContactsManager {
      * IDENTITY. Returns the device-issued group handle and proofs to persist.
      */
     registerExternalAddress(input: RegisterExternalAddressInput): RegisterExternalAddressDAReturnType;
+    /**
+     * Rename an existing contact group (EDIT CONTACT NAME). This is a
+     * blockchain-agnostic dashboard operation served by the device OS: it always
+     * navigates to the dashboard first (never opens an app), checks the Contacts
+     * minimum OS version, then rotates the group's name proof. Pass the current
+     * `previousContactName`, the `newContactName`, the group's `groupHandle`, and
+     * the existing `hmacProof`; returns the replacement group-level `hmacProof` to
+     * persist.
+     */
+    renameContact(input: RenameContactInput): RenameContactDAReturnType;
+    /**
+     * Edit an external address's identifier (EDIT IDENTIFIER) — replace an entry's
+     * address bytes within a contact group. Opens the app by default (`skipOpenApp:
+     * true` skips it; the version guard still runs) and checks the Contacts version
+     * requirements. Pass the previous/new identifiers, `groupHandle`, `hmacProof`,
+     * and current `hmacRest`; returns the replacement `hmacRest` (the `hmacProof`
+     * is unchanged).
+     */
+    editExternalAddressIdentifier(input: EditExternalAddressIdentifierInput): EditExternalAddressIdentifierDAReturnType;
+    /**
+     * Edit an external address's scope (EDIT SCOPE) — replace an entry's scope
+     * (its context label) within a contact group while keeping the same contact
+     * name and identifier. Opens the app by default (`skipOpenApp: true` skips it;
+     * the version guard still runs) and checks the Contacts version requirements.
+     * Pass the previous/new scopes, `identifier`, `groupHandle`, `hmacProof`, and
+     * current `hmacRest`; returns the replacement `hmacRest` (the `hmacProof` is
+     * unchanged).
+     */
+    editExternalAddressScope(input: EditExternalAddressScopeInput): EditExternalAddressScopeDAReturnType;
 }
 //# sourceMappingURL=ContactsManager.d.ts.map

package/lib/types/api/ContactsManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContactsManager.d.ts","sourceRoot":"","sources":["../../../src/api/ContactsManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,0DAA0D,CAAC;AACpH,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAEvF;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,uBAAuB,CACrB,KAAK,EAAE,4BAA4B,GAClC,mCAAmC,CAAC;CACxC"}
+{"version":3,"file":"ContactsManager.d.ts","sourceRoot":"","sources":["../../../src/api/ContactsManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,yCAAyC,EAAE,MAAM,gEAAgE,CAAC;AAChI,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,2DAA2D,CAAC;AACtH,OAAO,EAAE,KAAK,mCAAmC,EAAE,MAAM,0DAA0D,CAAC;AACpH,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,gDAAgD,CAAC;AAChG,OAAO,EAAE,KAAK,kCAAkC,EAAE,MAAM,0CAA0C,CAAC;AACnG,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AACzF,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AACvF,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,uBAAuB,CACrB,KAAK,EAAE,4BAA4B,GAClC,mCAAmC,CAAC;IAEvC;;;;;;;;OAQG;IACH,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,yBAAyB,CAAC;IAEpE;;;;;;;OAOG;IACH,6BAA6B,CAC3B,KAAK,EAAE,kCAAkC,GACxC,yCAAyC,CAAC;IAE7C;;;;;;;;OAQG;IACH,wBAAwB,CACtB,KAAK,EAAE,6BAA6B,GACnC,oCAAoC,CAAC;CACzC"}

package/lib/types/api/app-binder/EditExternalAddressIdentifierDeviceActionTypes.d.ts

@@ -0,0 +1,27 @@
+import { type CommandErrorResult, type DeviceActionState, type ExecuteDeviceActionReturnType, type OpenAppDAError, type OpenAppDARequiredInteraction, type UserInteractionRequired } from "@ledgerhq/device-management-kit";
+import { type EditExternalAddressIdentifierInput, type EditExternalAddressIdentifierOutput } from "../model/EditExternalAddressIdentifier";
+import { type ContactsErrorCodes, type ContactsVersionRequirementError } from "../../internal/app-binder/model/contactsErrors";
+import { type ContactsValidationError } from "../../internal/app-binder/model/contactsValidation";
+/** Machine input: the public input plus the injected embedded-app name. */
+export type EditExternalAddressIdentifierDAInput = EditExternalAddressIdentifierInput & {
+    readonly appName: string;
+};
+export type EditExternalAddressIdentifierDAOutput = EditExternalAddressIdentifierOutput;
+export type EditExternalAddressIdentifierDAError = OpenAppDAError | ContactsValidationError | ContactsVersionRequirementError | CommandErrorResult<ContactsErrorCodes>["error"];
+export type EditExternalAddressIdentifierDARequiredInteraction = OpenAppDARequiredInteraction | UserInteractionRequired.RegisterWallet;
+export type EditExternalAddressIdentifierDAIntermediateValue = {
+    readonly requiredUserInteraction: EditExternalAddressIdentifierDARequiredInteraction;
+};
+export type EditExternalAddressIdentifierDAState = DeviceActionState<EditExternalAddressIdentifierDAOutput, EditExternalAddressIdentifierDAError, EditExternalAddressIdentifierDAIntermediateValue>;
+export type EditExternalAddressIdentifierDAInternalState = {
+    readonly error: EditExternalAddressIdentifierDAError | null;
+    /** The running app read freshly by WaitForAppAndVersion, for the version guard. */
+    readonly appAndVersion: {
+        readonly name: string;
+        readonly version: string;
+    } | null;
+    /** The rotated address-level proof returned by the device on success. */
+    readonly hmacRest: Uint8Array | null;
+};
+export type EditExternalAddressIdentifierDAReturnType = ExecuteDeviceActionReturnType<EditExternalAddressIdentifierDAOutput, EditExternalAddressIdentifierDAError, EditExternalAddressIdentifierDAIntermediateValue>;
+//# sourceMappingURL=EditExternalAddressIdentifierDeviceActionTypes.d.ts.map

package/lib/types/api/app-binder/EditExternalAddressIdentifierDeviceActionTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditExternalAddressIdentifierDeviceActionTypes.d.ts","sourceRoot":"","sources":["../../../../src/api/app-binder/EditExternalAddressIdentifierDeviceActionTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC7B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EACL,KAAK,kCAAkC,EACvC,KAAK,mCAAmC,EACzC,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,+BAA+B,EACrC,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAE7F,2EAA2E;AAC3E,MAAM,MAAM,oCAAoC,GAC9C,kCAAkC,GAAG;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEJ,MAAM,MAAM,qCAAqC,GAC/C,mCAAmC,CAAC;AAEtC,MAAM,MAAM,oCAAoC,GAC5C,cAAc,GACd,uBAAuB,GACvB,+BAA+B,GAC/B,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,OAAO,CAAC,CAAC;AAEpD,MAAM,MAAM,kDAAkD,GAC1D,4BAA4B,GAC5B,uBAAuB,CAAC,cAAc,CAAC;AAE3C,MAAM,MAAM,gDAAgD,GAAG;IAC7D,QAAQ,CAAC,uBAAuB,EAAE,kDAAkD,CAAC;CACtF,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG,iBAAiB,CAClE,qCAAqC,EACrC,oCAAoC,EACpC,gDAAgD,CACjD,CAAC;AAEF,MAAM,MAAM,4CAA4C,GAAG;IACzD,QAAQ,CAAC,KAAK,EAAE,oCAAoC,GAAG,IAAI,CAAC;IAC5D,mFAAmF;IACnF,QAAQ,CAAC,aAAa,EAAE;QACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KAC1B,GAAG,IAAI,CAAC;IACT,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,yCAAyC,GACnD,6BAA6B,CAC3B,qCAAqC,EACrC,oCAAoC,EACpC,gDAAgD,CACjD,CAAC"}

package/lib/types/api/app-binder/EditExternalAddressScopeDeviceActionTypes.d.ts

@@ -0,0 +1,27 @@
+import { type CommandErrorResult, type DeviceActionState, type ExecuteDeviceActionReturnType, type OpenAppDAError, type OpenAppDARequiredInteraction, type UserInteractionRequired } from "@ledgerhq/device-management-kit";
+import { type EditExternalAddressScopeInput, type EditExternalAddressScopeOutput } from "../model/EditExternalAddressScope";
+import { type ContactsErrorCodes, type ContactsVersionRequirementError } from "../../internal/app-binder/model/contactsErrors";
+import { type ContactsValidationError } from "../../internal/app-binder/model/contactsValidation";
+/** Machine input: the public input plus the injected embedded-app name. */
+export type EditExternalAddressScopeDAInput = EditExternalAddressScopeInput & {
+    readonly appName: string;
+};
+export type EditExternalAddressScopeDAOutput = EditExternalAddressScopeOutput;
+export type EditExternalAddressScopeDAError = OpenAppDAError | ContactsValidationError | ContactsVersionRequirementError | CommandErrorResult<ContactsErrorCodes>["error"];
+export type EditExternalAddressScopeDARequiredInteraction = OpenAppDARequiredInteraction | UserInteractionRequired.RegisterWallet;
+export type EditExternalAddressScopeDAIntermediateValue = {
+    readonly requiredUserInteraction: EditExternalAddressScopeDARequiredInteraction;
+};
+export type EditExternalAddressScopeDAState = DeviceActionState<EditExternalAddressScopeDAOutput, EditExternalAddressScopeDAError, EditExternalAddressScopeDAIntermediateValue>;
+export type EditExternalAddressScopeDAInternalState = {
+    readonly error: EditExternalAddressScopeDAError | null;
+    /** The running app read freshly by WaitForAppAndVersion, for the version guard. */
+    readonly appAndVersion: {
+        readonly name: string;
+        readonly version: string;
+    } | null;
+    /** The rotated address-level proof returned by the device on success. */
+    readonly hmacRest: Uint8Array | null;
+};
+export type EditExternalAddressScopeDAReturnType = ExecuteDeviceActionReturnType<EditExternalAddressScopeDAOutput, EditExternalAddressScopeDAError, EditExternalAddressScopeDAIntermediateValue>;
+//# sourceMappingURL=EditExternalAddressScopeDeviceActionTypes.d.ts.map

package/lib/types/api/app-binder/EditExternalAddressScopeDeviceActionTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditExternalAddressScopeDeviceActionTypes.d.ts","sourceRoot":"","sources":["../../../../src/api/app-binder/EditExternalAddressScopeDeviceActionTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC7B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,8BAA8B,EACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,+BAA+B,EACrC,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAE7F,2EAA2E;AAC3E,MAAM,MAAM,+BAA+B,GAAG,6BAA6B,GAAG;IAC5E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,8BAA8B,CAAC;AAE9E,MAAM,MAAM,+BAA+B,GACvC,cAAc,GACd,uBAAuB,GACvB,+BAA+B,GAC/B,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,OAAO,CAAC,CAAC;AAEpD,MAAM,MAAM,6CAA6C,GACrD,4BAA4B,GAC5B,uBAAuB,CAAC,cAAc,CAAC;AAE3C,MAAM,MAAM,2CAA2C,GAAG;IACxD,QAAQ,CAAC,uBAAuB,EAAE,6CAA6C,CAAC;CACjF,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,iBAAiB,CAC7D,gCAAgC,EAChC,+BAA+B,EAC/B,2CAA2C,CAC5C,CAAC;AAEF,MAAM,MAAM,uCAAuC,GAAG;IACpD,QAAQ,CAAC,KAAK,EAAE,+BAA+B,GAAG,IAAI,CAAC;IACvD,mFAAmF;IACnF,QAAQ,CAAC,aAAa,EAAE;QACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KAC1B,GAAG,IAAI,CAAC;IACT,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAC9C,6BAA6B,CAC3B,gCAAgC,EAChC,+BAA+B,EAC/B,2CAA2C,CAC5C,CAAC"}

package/lib/types/api/app-binder/RenameContactDeviceActionTypes.d.ts

@@ -0,0 +1,25 @@
+import { type CommandErrorResult, type DeviceActionState, type ExecuteDeviceActionReturnType, type GoToDashboardDAError, type GoToDashboardDARequiredInteraction, type UserInteractionRequired } from "@ledgerhq/device-management-kit";
+import { type RenameContactInput, type RenameContactOutput } from "../model/RenameContact";
+import { type ContactsErrorCodes, type ContactsVersionRequirementError } from "../../internal/app-binder/model/contactsErrors";
+import { type ContactsValidationError } from "../../internal/app-binder/model/contactsValidation";
+/**
+ * Rename is a dashboard operation, so the machine input is exactly the public
+ * input — no embedded-app name is injected (the OS serves the command; there is
+ * no app to open).
+ */
+export type RenameContactDAInput = RenameContactInput;
+export type RenameContactDAOutput = RenameContactOutput;
+export type RenameContactDAError = GoToDashboardDAError | ContactsValidationError | ContactsVersionRequirementError | CommandErrorResult<ContactsErrorCodes>["error"];
+export type RenameContactDARequiredInteraction = GoToDashboardDARequiredInteraction | UserInteractionRequired.RegisterWallet;
+export type RenameContactDAIntermediateValue = {
+    readonly requiredUserInteraction: RenameContactDARequiredInteraction;
+};
+export type RenameContactDAState = DeviceActionState<RenameContactDAOutput, RenameContactDAError, RenameContactDAIntermediateValue>;
+export type RenameContactDAInternalState = {
+    readonly error: RenameContactDAError | null;
+    readonly proof: {
+        readonly hmacProof: Uint8Array;
+    } | null;
+};
+export type RenameContactDAReturnType = ExecuteDeviceActionReturnType<RenameContactDAOutput, RenameContactDAError, RenameContactDAIntermediateValue>;
+//# sourceMappingURL=RenameContactDeviceActionTypes.d.ts.map