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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendEditExternalAddressScopeTask.ts"],
+  "sourcesContent": ["// Builds the op-4 (Edit Scope) TLV and dispatches it via the shared chunked\n// framing; the device returns struct_type + hmac_rest on the final chunk. Tag\n// order: STRUCT_TYPE, STRUCT_VERSION, CONTACT_NAME, SCOPE (new), ACCOUNT_IDENTIFIER\n// (unchanged), PREVIOUS_SCOPE (old), GROUP_HANDLE, CHAIN_ID (Ethereum only),\n// HMAC_PROOF, HMAC_REST (old), BLOCKCHAIN_FAMILY.\n// No DERIVATION_PATH: external-address ops carry no path \u2014 the current Ethereum\n// app rejects the tag (0x6a80); it is Ledger-Account only (DSDK-1465).\n// Reference: Address Book Final Specifications \u2014 Edit Scope.\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 { EditExternalAddressScopeCommand } from \"@internal/app-binder/command/EditExternalAddressScopeCommand\";\nimport {\n  BLOCKCHAIN_FAMILY_BY_NAME,\n  SUB_CMD_EDIT_SCOPE,\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_EDIT_SCOPE,\n  STRUCT_VERSION_VALUE,\n} from \"@internal/app-binder/services/contactsTlvSerializer\";\nimport { sendFramedContactsPayload } from \"@internal/app-binder/services/sendFramedContactsPayload\";\n\nexport type EditScopeProof = {\n  readonly hmacRest: Uint8Array;\n};\n\nexport type SendEditExternalAddressScopeTaskArgs = {\n  readonly contactName: string;\n  readonly previousScope: string;\n  readonly newScope: string;\n  readonly identifier: Uint8Array;\n  readonly blockchainFamily: string;\n  readonly chainId?: bigint;\n  readonly groupHandle: Uint8Array;\n  readonly hmacProof: Uint8Array;\n  readonly hmacRest: Uint8Array;\n  readonly logger?: LoggerPublisherService;\n};\n\nexport class SendEditExternalAddressScopeTask {\n  constructor(\n    private readonly api: InternalApi,\n    private readonly args: SendEditExternalAddressScopeTaskArgs,\n  ) {}\n\n  async run(): Promise<CommandResult<EditScopeProof, ContactsErrorCodes>> {\n    const payload = this.buildPayload(this.args);\n\n    const result = (await sendFramedContactsPayload(this.api, {\n      payload,\n      p1: SUB_CMD_EDIT_SCOPE,\n      makeCommand: (chunk, p2) =>\n        new EditExternalAddressScopeCommand({ data: chunk, p2 }),\n      logger: this.args.logger,\n      commandTag: \"SendEditExternalAddressScopeTask\",\n    })) as CommandResult<\n      { readonly hmacRest?: Uint8Array },\n      ContactsErrorCodes\n    >;\n\n    if (!isSuccessCommandResult(result)) {\n      return result;\n    }\n\n    const { hmacRest } = result.data;\n    if (!hmacRest) {\n      return DmkResultFactory({\n        error: new InvalidStatusWordError(\n          \"EditScope final-chunk response did not carry hmac_rest\",\n        ),\n      });\n    }\n    return DmkResultFactory({ data: { hmacRest } });\n  }\n\n  private buildPayload(args: SendEditExternalAddressScopeTaskArgs): 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_EDIT_SCOPE,\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.newScope);\n    encodeTlvBuffer(\n      builder,\n      CONTACTS_TLV_TAG.ACCOUNT_IDENTIFIER,\n      args.identifier,\n    );\n    encodeTlvAscii(\n      builder,\n      CONTACTS_TLV_TAG.PREVIOUS_SCOPE,\n      args.previousScope,\n    );\n    encodeTlvBuffer(builder, CONTACTS_TLV_TAG.GROUP_HANDLE, args.groupHandle);\n    if (args.chainId !== undefined) {\n      encodeTlvChainId(builder, CONTACTS_TLV_TAG.CHAIN_ID, args.chainId);\n    }\n    encodeTlvBuffer(builder, CONTACTS_TLV_TAG.HMAC_PROOF, args.hmacProof);\n    encodeTlvBuffer(builder, CONTACTS_TLV_TAG.HMAC_REST, args.hmacRest);\n    encodeTlvUInt8(builder, CONTACTS_TLV_TAG.BLOCKCHAIN_FAMILY, family);\n\n    return builder.build();\n  }\n}\n"],
+  "mappings": "AAQA,OACE,oBAAAA,EAEA,oBAAAC,EAEA,0BAAAC,EACA,0BAAAC,MAEK,kCAEP,OAAS,mCAAAC,MAAuC,+DAChD,OACE,6BAAAC,EACA,sBAAAC,MACK,+CAEP,OACE,oBAAAC,EACA,kBAAAC,EACA,mBAAAC,EACA,oBAAAC,EACA,kBAAAC,EACA,0BAAAC,EACA,wBAAAC,MACK,sDACP,OAAS,6BAAAC,MAAiC,0DAmBnC,MAAMC,CAAiC,CAC5C,YACmBC,EACAC,EACjB,CAFiB,SAAAD,EACA,UAAAC,CAChB,CAEH,MAAM,KAAkE,CACtE,MAAMC,EAAU,KAAK,aAAa,KAAK,IAAI,EAErCC,EAAU,MAAML,EAA0B,KAAK,IAAK,CACxD,QAAAI,EACA,GAAIZ,EACJ,YAAa,CAACc,EAAOC,IACnB,IAAIjB,EAAgC,CAAE,KAAMgB,EAAO,GAAAC,CAAG,CAAC,EACzD,OAAQ,KAAK,KAAK,OAClB,WAAY,kCACd,CAAC,EAKD,GAAI,CAAClB,EAAuBgB,CAAM,EAChC,OAAOA,EAGT,KAAM,CAAE,SAAAG,CAAS,EAAIH,EAAO,KAC5B,OAAKG,EAOErB,EAAiB,CAAE,KAAM,CAAE,SAAAqB,CAAS,CAAE,CAAC,EANrCrB,EAAiB,CACtB,MAAO,IAAIC,EACT,wDACF,CACF,CAAC,CAGL,CAEQ,aAAae,EAAwD,CAC3E,MAAMM,EACJlB,EAA0BY,EAAK,iBAAiB,YAAY,CAAC,EAC/D,GAAIM,IAAW,OACb,MAAM,IAAI,MACR,kCAAkCN,EAAK,gBAAgB,EACzD,EAGF,MAAMO,EAAU,IAAIxB,EACpB,OAAAW,EACEa,EACAjB,EAAiB,YACjBK,CACF,EACAD,EACEa,EACAjB,EAAiB,eACjBM,CACF,EACAL,EAAegB,EAASjB,EAAiB,aAAcU,EAAK,WAAW,EACvET,EAAegB,EAASjB,EAAiB,MAAOU,EAAK,QAAQ,EAC7DR,EACEe,EACAjB,EAAiB,mBACjBU,EAAK,UACP,EACAT,EACEgB,EACAjB,EAAiB,eACjBU,EAAK,aACP,EACAR,EAAgBe,EAASjB,EAAiB,aAAcU,EAAK,WAAW,EACpEA,EAAK,UAAY,QACnBP,EAAiBc,EAASjB,EAAiB,SAAUU,EAAK,OAAO,EAEnER,EAAgBe,EAASjB,EAAiB,WAAYU,EAAK,SAAS,EACpER,EAAgBe,EAASjB,EAAiB,UAAWU,EAAK,QAAQ,EAClEN,EAAea,EAASjB,EAAiB,kBAAmBgB,CAAM,EAE3DC,EAAQ,MAAM,CACvB,CACF",
+  "names": ["ByteArrayBuilder", "DmkResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "EditExternalAddressScopeCommand", "BLOCKCHAIN_FAMILY_BY_NAME", "SUB_CMD_EDIT_SCOPE", "CONTACTS_TLV_TAG", "encodeTlvAscii", "encodeTlvBuffer", "encodeTlvChainId", "encodeTlvUInt8", "STRUCT_TYPE_EDIT_SCOPE", "STRUCT_VERSION_VALUE", "sendFramedContactsPayload", "SendEditExternalAddressScopeTask", "api", "args", "payload", "result", "chunk", "p2", "hmacRest", "family", "builder"]
+}

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

@@ -0,0 +1,2 @@
+import{CommandResultFactory as a,InvalidStatusWordError as d}from"@ledgerhq/device-management-kit";import{EditExternalAddressScopeCommand as m}from"../../app-binder/command/EditExternalAddressScopeCommand";import{SendEditExternalAddressScopeTask as r}from"./SendEditExternalAddressScopeTask";function o(e){const n=new Uint8Array(e.length/2);for(let t=0;t<e.length;t+=2)n[t/2]=parseInt(e.slice(t,t+2),16);return n}const l=o("00c901013202010181f005416c69636581f10845746820636f6c6481f214"+"55".repeat(20)+"81f508457468206d61696e81f640"+"cc".repeat(64)+"2301012920"+"dd".repeat(32)+"81f720"+"aa".repeat(32)+"510101"),i={hmacRest:o("88".repeat(32))},c={contactName:"Alice",previousScope:"Eth main",newScope:"Eth cold",identifier:o("55".repeat(20)),blockchainFamily:"ethereum",chainId:1n,groupHandle:o("cc".repeat(64)),hmacProof:o("dd".repeat(32)),hmacRest:o("aa".repeat(32))};function s(){return{sendCommand:vi.fn()}}describe("SendEditExternalAddressScopeTask",()=>{it("assembles the framed chunk byte-equal to the fixture and dispatches EditExternalAddressScopeCommand",async()=>{const e=s();e.sendCommand.mockResolvedValueOnce(a({data:i}));const n=await new r(e,c).run();expect(e.sendCommand.mock.calls).toHaveLength(1),expect(e.sendCommand.mock.calls[0][0]).toStrictEqual(new m({data:l,p2:0})),expect(n).toStrictEqual(a({data:i}))}),it("omits the CHAIN_ID TLV when chainId is not provided",async()=>{const e=s();e.sendCommand.mockResolvedValueOnce(a({data:i})),await new r(e,{...c,chainId:void 0}).run();const n=e.sendCommand.mock.calls[0][0],t=Buffer.from(n.args.data).toString("hex");expect(t).not.toContain("230101"),expect(t.endsWith("510101")).toBe(!0)}),it("propagates command-level errors",async()=>{const e=s();e.sendCommand.mockResolvedValueOnce(a({error:new d("user cancelled")}));const n=await new r(e,c).run();expect(n).toStrictEqual(a({error:new d("user cancelled")}))}),it("errors when the final-chunk response does not carry hmac_rest",async()=>{const e=s();e.sendCommand.mockResolvedValueOnce(a({data:{}}));const n=await new r(e,c).run();expect(n).toStrictEqual(a({error:new d("EditScope final-chunk response did not carry hmac_rest")}))}),it("throws on an unsupported blockchain family",async()=>{const e=s();await expect(new r(e,{...c,blockchainFamily:"dogecoin"}).run()).rejects.toThrow(/Unsupported blockchain family/),expect(e.sendCommand).not.toHaveBeenCalled()})});
+//# sourceMappingURL=SendEditExternalAddressScopeTask.test.js.map

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": "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",
+  "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/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/di/useCaseModule.js

@@ -1,2 +1,2 @@
-import{ContainerModule as o}from"inversify";import{RegisterExternalAddressUseCase as t}from"../../use-cases/RegisterExternalAddressUseCase";import{RenameContactUseCase as r}from"../../use-cases/RenameContactUseCase";import{useCaseTypes as s}from"./useCaseTypes";const i=()=>new o(({bind:e})=>{e(s.RegisterExternalAddressUseCase).to(t),e(s.RenameContactUseCase).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\";\nimport { RenameContactUseCase } from \"@internal/use-cases/RenameContactUseCase\";\n\nimport { useCaseTypes } from \"./useCaseTypes\";\n\nexport const useCaseModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(useCaseTypes.RegisterExternalAddressUseCase).to(\n      RegisterExternalAddressUseCase,\n    );\n    bind(useCaseTypes.RenameContactUseCase).to(RenameContactUseCase);\n  });\n"],
-  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,kCAAAC,MAAsC,qDAC/C,OAAS,wBAAAC,MAA4B,2CAErC,OAAS,gBAAAC,MAAoB,iBAEtB,MAAMC,EAAuB,IAClC,IAAIJ,EAAgB,CAAC,CAAE,KAAAK,CAAK,IAAM,CAChCA,EAAKF,EAAa,8BAA8B,EAAE,GAChDF,CACF,EACAI,EAAKF,EAAa,oBAAoB,EAAE,GAAGD,CAAoB,CACjE,CAAC",
-  "names": ["ContainerModule", "RegisterExternalAddressUseCase", "RenameContactUseCase", "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"),RenameContactUseCase:Symbol.for("RenameContactUseCase")};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  RenameContactUseCase: Symbol.for(\"RenameContactUseCase\"),\n} as const;\n"],
-  "mappings": "AAAO,MAAMA,EAAe,CAC1B,+BAAgC,OAAO,IAAI,gCAAgC,EAC3E,qBAAsB,OAAO,IAAI,sBAAsB,CACzD",
+  "sourcesContent": ["export const useCaseTypes = {\n  RegisterExternalAddressUseCase: Symbol.for(\"RegisterExternalAddressUseCase\"),\n  RenameContactUseCase: Symbol.for(\"RenameContactUseCase\"),\n  EditExternalAddressIdentifierUseCase: Symbol.for(\n    \"EditExternalAddressIdentifierUseCase\",\n  ),\n  EditExternalAddressScopeUseCase: Symbol.for(\n    \"EditExternalAddressScopeUseCase\",\n  ),\n} as const;\n"],
+  "mappings": "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.0.0-develop-20260831001535"
+  "version": "0.0.0-develop-20260901001631"
 }

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

@@ -1,5 +1,9 @@
+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";
 /**
@@ -30,5 +34,24 @@ export interface ContactsManager {
      * 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,yBAAyB,EAAE,MAAM,gDAAgD,CAAC;AAChG,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;CACrE"}
+{"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/index.d.ts

@@ -1,8 +1,12 @@
+export { type EditExternalAddressIdentifierDAError, type EditExternalAddressIdentifierDAInput, type EditExternalAddressIdentifierDAIntermediateValue, type EditExternalAddressIdentifierDAOutput, type EditExternalAddressIdentifierDARequiredInteraction, type EditExternalAddressIdentifierDAReturnType, type EditExternalAddressIdentifierDAState, } from "./app-binder/EditExternalAddressIdentifierDeviceActionTypes";
+export { type EditExternalAddressScopeDAError, type EditExternalAddressScopeDAInput, type EditExternalAddressScopeDAIntermediateValue, type EditExternalAddressScopeDAOutput, type EditExternalAddressScopeDARequiredInteraction, type EditExternalAddressScopeDAReturnType, type EditExternalAddressScopeDAState, } from "./app-binder/EditExternalAddressScopeDeviceActionTypes";
 export { type RegisterExternalAddressDAError, type RegisterExternalAddressDAInput, type RegisterExternalAddressDAIntermediateValue, type RegisterExternalAddressDAOutput, type RegisterExternalAddressDARequiredInteraction, type RegisterExternalAddressDAReturnType, type RegisterExternalAddressDAState, } from "./app-binder/RegisterExternalAddressDeviceActionTypes";
 export { type RenameContactDAError, type RenameContactDAInput, type RenameContactDAIntermediateValue, type RenameContactDAOutput, type RenameContactDARequiredInteraction, type RenameContactDAReturnType, type RenameContactDAState, } from "./app-binder/RenameContactDeviceActionTypes";
 export { type ContactsManager } from "./ContactsManager";
 export { ContactsManagerBuilder } from "./ContactsManagerBuilder";
 export { CONTACTS_VERSION_REQUIREMENTS, type ContactsModelRequirement, type ContactsModelSupport, type ContactsModelUnsupported, type ContactsSupportQuery, type ContactsVersionRequirements, ETHEREUM_APP_NAME, isContactsSupported, isVersionAtLeast, resolveContactsVersionRequirements, } from "./model/ContactsVersionRequirements";
+export { type EditExternalAddressIdentifierInput, type EditExternalAddressIdentifierOutput, } from "./model/EditExternalAddressIdentifier";
+export { type EditExternalAddressScopeInput, type EditExternalAddressScopeOutput, } from "./model/EditExternalAddressScope";
 export { type ExistingContactGroup, type RegisterExternalAddressInput, type RegisterExternalAddressMode, type RegisterExternalAddressOutput, } from "./model/RegisterExternalAddress";
 export { type RenameContactInput, type RenameContactOutput, } from "./model/RenameContact";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACnC,KAAK,0CAA0C,EAC/C,KAAK,+BAA+B,EACpC,KAAK,4CAA4C,EACjD,KAAK,mCAAmC,EACxC,KAAK,8BAA8B,GACpC,MAAM,0DAA0D,CAAC;AAClE,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACrC,KAAK,qBAAqB,EAC1B,KAAK,kCAAkC,EACvC,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,GAC1B,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EACL,6BAA6B,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,kCAAkC,GACnC,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,6BAA6B,GACnC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,gDAAgD,EACrD,KAAK,qCAAqC,EAC1C,KAAK,kDAAkD,EACvD,KAAK,yCAAyC,EAC9C,KAAK,oCAAoC,GAC1C,MAAM,gEAAgE,CAAC;AACxE,OAAO,EACL,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,EACpC,KAAK,2CAA2C,EAChD,KAAK,gCAAgC,EACrC,KAAK,6CAA6C,EAClD,KAAK,oCAAoC,EACzC,KAAK,+BAA+B,GACrC,MAAM,2DAA2D,CAAC;AACnE,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACnC,KAAK,0CAA0C,EAC/C,KAAK,+BAA+B,EACpC,KAAK,4CAA4C,EACjD,KAAK,mCAAmC,EACxC,KAAK,8BAA8B,GACpC,MAAM,0DAA0D,CAAC;AAClE,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACrC,KAAK,qBAAqB,EAC1B,KAAK,kCAAkC,EACvC,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,GAC1B,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EACL,6BAA6B,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,kCAAkC,GACnC,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,KAAK,kCAAkC,EACvC,KAAK,mCAAmC,GACzC,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,8BAA8B,GACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,6BAA6B,GACnC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,GACzB,MAAM,0BAA0B,CAAC"}

package/lib/types/api/model/EditExternalAddressIdentifier.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Public input/output types for `ContactsManager.editExternalAddressIdentifier`.
+ *
+ * EDIT IDENTIFIER replaces an entry's identifier bytes within an existing
+ * contact group. Only the address-level `hmacRest` rotates; the group-level
+ * `hmacProof` passes through unchanged. Proof material is raw bytes (the host
+ * owns persistence); `derivationPath` is kit-internal and not exposed.
+ */
+export type EditExternalAddressIdentifierInput = {
+    /** The contact's name, proven to the device via `hmacProof`. */
+    readonly contactName: string;
+    /** The entry's current label/scope; shown on the approval screen. */
+    readonly scope: string;
+    /** The current (pre-edit) address bytes, proven via `hmacRest`. */
+    readonly previousIdentifier: Uint8Array;
+    /** The replacement address bytes (20 bytes for Ethereum). */
+    readonly newIdentifier: Uint8Array;
+    /** Blockchain family name, e.g. "ethereum" (v1 supports Ethereum only). */
+    readonly blockchainFamily: string;
+    readonly chainId?: bigint;
+    /** 64-byte group handle returned by the group's Register Identity. */
+    readonly groupHandle: Uint8Array;
+    /**
+     * The contact-group name proof (device `hmac_name`) — passed back so the
+     * device can verify the entry belongs to the group. Unchanged by the edit.
+     */
+    readonly hmacProof: Uint8Array;
+    /**
+     * The entry's current 32-byte address proof (`hmac_rest`) — passed back so the
+     * device can verify continuity before approving. Replaced by the returned
+     * `hmacRest` on success.
+     */
+    readonly hmacRest: Uint8Array;
+    /**
+     * When `true`, the open-app step is skipped (the caller guarantees the app is
+     * already open). The app-version guard still runs.
+     */
+    readonly skipOpenApp?: boolean;
+};
+export type EditExternalAddressIdentifierOutput = {
+    /** Echoed input, needed by the host to locate the entry it is replacing. */
+    readonly contactName: string;
+    readonly scope: string;
+    /** Echoed previous address bytes, to match the entry being replaced. */
+    readonly previousIdentifier: Uint8Array;
+    /** The new address bytes now bound to the entry. */
+    readonly identifier: Uint8Array;
+    readonly blockchainFamily: string;
+    readonly chainId?: bigint;
+    /** Echoed group handle, unchanged by the edit. */
+    readonly groupHandle: Uint8Array;
+    /** Echoed group-level name proof, unchanged by the edit. */
+    readonly hmacProof: Uint8Array;
+    /** The replacement address-level proof (rotated `hmac_rest`) to persist. */
+    readonly hmacRest: Uint8Array;
+};
+//# sourceMappingURL=EditExternalAddressIdentifier.d.ts.map

package/lib/types/api/model/EditExternalAddressIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditExternalAddressIdentifier.d.ts","sourceRoot":"","sources":["../../../../src/api/model/EditExternalAddressIdentifier.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,kCAAkC,GAAG;IAC/C,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,QAAQ,CAAC,kBAAkB,EAAE,UAAU,CAAC;IACxC,6DAA6D;IAC7D,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAC;IACnC,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG;IAChD,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,QAAQ,CAAC,kBAAkB,EAAE,UAAU,CAAC;IACxC,oDAAoD;IACpD,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/B,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;CAC/B,CAAC"}

package/lib/types/api/model/EditExternalAddressScope.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Public input/output types for `ContactsManager.editExternalAddressScope`.
+ *
+ * EDIT SCOPE replaces an entry's scope (its context label) within an existing
+ * contact group while keeping the same contact name and identifier. Only the
+ * address-level `hmacRest` rotates; the group-level `hmacProof` passes through
+ * unchanged. Proof material is raw bytes (the host owns persistence);
+ * `derivationPath` is kit-internal and not exposed.
+ */
+export type EditExternalAddressScopeInput = {
+    /** The contact's name, proven to the device via `hmacProof`. Unchanged. */
+    readonly contactName: string;
+    /** The entry's current scope; shown on the approval screen and proven via `hmacRest`. */
+    readonly previousScope: string;
+    /** The replacement scope (max 32 printable ASCII chars). */
+    readonly newScope: string;
+    /** The entry's identifier bytes (20 bytes for Ethereum). Unchanged by the edit. */
+    readonly identifier: Uint8Array;
+    /** Blockchain family name, e.g. "ethereum" (v1 supports Ethereum only). */
+    readonly blockchainFamily: string;
+    readonly chainId?: bigint;
+    /** 64-byte group handle returned by the group's Register Identity. */
+    readonly groupHandle: Uint8Array;
+    /**
+     * The contact-group name proof (device `hmac_name`) — passed back so the
+     * device can verify the entry belongs to the group. Unchanged by the edit.
+     */
+    readonly hmacProof: Uint8Array;
+    /**
+     * The entry's current 32-byte address proof (`hmac_rest`) — passed back so the
+     * device can verify the previous scope/identifier before approving. Replaced
+     * by the returned `hmacRest` on success.
+     */
+    readonly hmacRest: Uint8Array;
+    /**
+     * When `true`, the open-app step is skipped (the caller guarantees the app is
+     * already open). The app-version guard still runs.
+     */
+    readonly skipOpenApp?: boolean;
+};
+export type EditExternalAddressScopeOutput = {
+    /** Echoed input, needed by the host to locate the entry it is replacing. */
+    readonly contactName: string;
+    /** Echoed previous scope, to match the entry being replaced. */
+    readonly previousScope: string;
+    /** The new scope now bound to the entry. */
+    readonly scope: string;
+    /** Echoed identifier bytes, unchanged by the edit. */
+    readonly identifier: Uint8Array;
+    readonly blockchainFamily: string;
+    readonly chainId?: bigint;
+    /** Echoed group handle, unchanged by the edit. */
+    readonly groupHandle: Uint8Array;
+    /** Echoed group-level name proof, unchanged by the edit. */
+    readonly hmacProof: Uint8Array;
+    /** The replacement address-level proof (rotated `hmac_rest`) to persist. */
+    readonly hmacRest: Uint8Array;
+};
+//# sourceMappingURL=EditExternalAddressScope.d.ts.map