@iota/signers 0.0.0-dev-20251015065834

package/dist/cjs/ledger/index.js

@@ -0,0 +1,191 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var ledger_exports = {};
+__export(ledger_exports, {
+  LedgerSigner: () => LedgerSigner
+});
+module.exports = __toCommonJS(ledger_exports);
+var import_cryptography = require("@iota/iota-sdk/cryptography");
+var import_ed25519 = require("@iota/iota-sdk/keypairs/ed25519");
+var import_transactions = require("@iota/iota-sdk/transactions");
+var import_utils = require("@iota/iota-sdk/utils");
+var import_bcs = require("./bcs.js");
+var import_bcs2 = require("@iota/iota-sdk/bcs");
+var _derivationPath, _publicKey, _ledgerClient, _iotaClient, _LedgerSigner_instances, getClearSigningOptions_fn;
+const _LedgerSigner = class _LedgerSigner extends import_cryptography.Signer {
+  /**
+   * Creates an instance of LedgerSigner. It's expected to call the static `fromDerivationPath` method to create an instance.
+   * @example
+   * ```
+   * const signer = await LedgerSigner.fromDerivationPath(derivationPath, options);
+   * ```
+   */
+  constructor({ publicKey, derivationPath, ledgerClient, iotaClient }) {
+    super();
+    __privateAdd(this, _LedgerSigner_instances);
+    __privateAdd(this, _derivationPath);
+    __privateAdd(this, _publicKey);
+    __privateAdd(this, _ledgerClient);
+    __privateAdd(this, _iotaClient);
+    __privateSet(this, _publicKey, publicKey);
+    __privateSet(this, _derivationPath, derivationPath);
+    __privateSet(this, _ledgerClient, ledgerClient);
+    __privateSet(this, _iotaClient, iotaClient);
+  }
+  /**
+   * Retrieves the key scheme used by this signer.
+   */
+  getKeyScheme() {
+    return "ED25519";
+  }
+  /**
+   * Retrieves the public key associated with this signer.
+   * @returns The Ed25519PublicKey instance.
+   */
+  getPublicKey() {
+    return __privateGet(this, _publicKey);
+  }
+  /**
+   * Signs the provided transaction bytes.
+   * @returns The signed transaction bytes and signature.
+   */
+  async signTransaction(bytes) {
+    const transactionOptions = await __privateMethod(this, _LedgerSigner_instances, getClearSigningOptions_fn).call(this, bytes).catch(() => ({
+      // Fail gracefully so network errors or serialization issues don't break transaction signing:
+      bcsObjects: []
+    }));
+    const intentMessage = (0, import_cryptography.messageWithIntent)("TransactionData", bytes);
+    const { signature } = await __privateGet(this, _ledgerClient).signTransaction(
+      __privateGet(this, _derivationPath),
+      intentMessage,
+      transactionOptions
+    );
+    return {
+      bytes: (0, import_utils.toB64)(bytes),
+      signature: (0, import_cryptography.toSerializedSignature)({
+        signature,
+        signatureScheme: this.getKeyScheme(),
+        publicKey: __privateGet(this, _publicKey)
+      })
+    };
+  }
+  /**
+   * Signs the provided personal message.
+   * @returns The signed message bytes and signature.
+   */
+  async signPersonalMessage(bytes) {
+    const intentMessage = (0, import_cryptography.messageWithIntent)(
+      "PersonalMessage",
+      import_bcs2.bcs.byteVector().serialize(bytes).toBytes()
+    );
+    const { signature } = await __privateGet(this, _ledgerClient).signTransaction(
+      __privateGet(this, _derivationPath),
+      intentMessage
+    );
+    return {
+      bytes: (0, import_utils.toB64)(bytes),
+      signature: (0, import_cryptography.toSerializedSignature)({
+        signature,
+        signatureScheme: this.getKeyScheme(),
+        publicKey: __privateGet(this, _publicKey)
+      })
+    };
+  }
+  /**
+   * Prepares the signer by fetching and setting the public key from a Ledger device.
+   * It is recommended to initialize an `LedgerSigner` instance using this function.
+   * @returns A promise that resolves once a `LedgerSigner` instance is prepared (public key is set).
+   */
+  static async fromDerivationPath(derivationPath, ledgerClient, iotaClient) {
+    const { publicKey } = await ledgerClient.getPublicKey(derivationPath);
+    if (!publicKey) {
+      throw new Error("Failed to get public key from Ledger.");
+    }
+    return new _LedgerSigner({
+      derivationPath,
+      publicKey: new import_ed25519.Ed25519PublicKey(publicKey),
+      ledgerClient,
+      iotaClient
+    });
+  }
+  /**
+   * Generic signing is not supported by Ledger.
+   * @throws Always throws an error indicating generic signing is unsupported.
+   */
+  sign() {
+    throw new Error("Ledger Signer does not support generic signing.");
+  }
+  /**
+   * Generic signing is not supported by Ledger.
+   * @throws Always throws an error indicating generic signing is unsupported.
+   */
+  signWithIntent() {
+    throw new Error("Ledger Signer does not support generic signing.");
+  }
+};
+_derivationPath = new WeakMap();
+_publicKey = new WeakMap();
+_ledgerClient = new WeakMap();
+_iotaClient = new WeakMap();
+_LedgerSigner_instances = new WeakSet();
+getClearSigningOptions_fn = async function(transactionBytes) {
+  const transaction = import_transactions.Transaction.from(transactionBytes);
+  const data = transaction.getData();
+  const gasObjectIds = data.gasData.payment?.map((object) => object.objectId) ?? [];
+  const inputObjectIds = data.inputs.map((input) => {
+    return input.$kind === "Object" && input.Object.$kind === "ImmOrOwnedObject" ? input.Object.ImmOrOwnedObject.objectId : null;
+  }).filter((objectId) => !!objectId);
+  const objects = await __privateGet(this, _iotaClient).multiGetObjects({
+    ids: [...gasObjectIds, ...inputObjectIds],
+    options: {
+      showBcs: true,
+      showPreviousTransaction: true,
+      showStorageRebate: true,
+      showOwner: true
+    }
+  });
+  const bcsObjects = objects.map((object) => {
+    if (object.error || !object.data || object.data.bcs?.dataType !== "moveObject") {
+      return null;
+    }
+    return import_bcs.IotaMoveObject.serialize({
+      data: {
+        MoveObject: {
+          type: object.data.bcs.type,
+          version: object.data.bcs.version,
+          contents: object.data.bcs.bcsBytes
+        }
+      },
+      owner: object.data.owner,
+      previousTransaction: object.data.previousTransaction,
+      storageRebate: object.data.storageRebate
+    }).toBytes();
+  }).filter((bcsBytes) => !!bcsBytes);
+  return { bcsObjects };
+};
+let LedgerSigner = _LedgerSigner;
+//# sourceMappingURL=index.js.map

package/dist/cjs/ledger/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ledger/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2025 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type IotaLedgerClient from '@iota/ledgerjs-hw-app-iota';\nimport type { IotaClient } from '@iota/iota-sdk/client';\nimport type { SignatureWithBytes } from '@iota/iota-sdk/cryptography';\nimport { messageWithIntent, Signer, toSerializedSignature } from '@iota/iota-sdk/cryptography';\nimport { Ed25519PublicKey } from '@iota/iota-sdk/keypairs/ed25519';\nimport { Transaction } from '@iota/iota-sdk/transactions';\nimport { toB64 } from '@iota/iota-sdk/utils';\n\nimport { IotaMoveObject } from './bcs.js';\nimport { bcs } from '@iota/iota-sdk/bcs';\n\n/**\n * Configuration options for initializing the LedgerSigner.\n */\nexport interface LedgerSignerOptions {\n    publicKey: Ed25519PublicKey;\n    derivationPath: string;\n    ledgerClient: IotaLedgerClient;\n    iotaClient: IotaClient;\n}\n\n/**\n * Ledger integrates with the Iota blockchain to provide signing capabilities using Ledger devices.\n */\nexport class LedgerSigner extends Signer {\n    #derivationPath: string;\n    #publicKey: Ed25519PublicKey;\n    #ledgerClient: IotaLedgerClient;\n    #iotaClient: IotaClient;\n\n    /**\n     * Creates an instance of LedgerSigner. It's expected to call the static `fromDerivationPath` method to create an instance.\n     * @example\n     * ```\n     * const signer = await LedgerSigner.fromDerivationPath(derivationPath, options);\n     * ```\n     */\n    constructor({ publicKey, derivationPath, ledgerClient, iotaClient }: LedgerSignerOptions) {\n        super();\n        this.#publicKey = publicKey;\n        this.#derivationPath = derivationPath;\n        this.#ledgerClient = ledgerClient;\n        this.#iotaClient = iotaClient;\n    }\n\n    /**\n     * Retrieves the key scheme used by this signer.\n     */\n    override getKeyScheme() {\n        return 'ED25519' as const;\n    }\n\n    /**\n     * Retrieves the public key associated with this signer.\n     * @returns The Ed25519PublicKey instance.\n     */\n    override getPublicKey() {\n        return this.#publicKey;\n    }\n\n    /**\n     * Signs the provided transaction bytes.\n     * @returns The signed transaction bytes and signature.\n     */\n    override async signTransaction(bytes: Uint8Array): Promise<SignatureWithBytes> {\n        const transactionOptions = await this.#getClearSigningOptions(bytes).catch(() => ({\n            // Fail gracefully so network errors or serialization issues don't break transaction signing:\n            bcsObjects: [],\n        }));\n\n        const intentMessage = messageWithIntent('TransactionData', bytes);\n        const { signature } = await this.#ledgerClient.signTransaction(\n            this.#derivationPath,\n            intentMessage,\n            transactionOptions,\n        );\n\n        return {\n            bytes: toB64(bytes),\n            signature: toSerializedSignature({\n                signature,\n                signatureScheme: this.getKeyScheme(),\n                publicKey: this.#publicKey,\n            }),\n        };\n    }\n\n    /**\n     * Signs the provided personal message.\n     * @returns The signed message bytes and signature.\n     */\n    override async signPersonalMessage(bytes: Uint8Array): Promise<SignatureWithBytes> {\n        const intentMessage = messageWithIntent(\n            'PersonalMessage',\n            bcs.byteVector().serialize(bytes).toBytes(),\n        );\n        const { signature } = await this.#ledgerClient.signTransaction(\n            this.#derivationPath,\n            intentMessage,\n        );\n\n        return {\n            bytes: toB64(bytes),\n            signature: toSerializedSignature({\n                signature,\n                signatureScheme: this.getKeyScheme(),\n                publicKey: this.#publicKey,\n            }),\n        };\n    }\n\n    /**\n     * Prepares the signer by fetching and setting the public key from a Ledger device.\n     * It is recommended to initialize an `LedgerSigner` instance using this function.\n     * @returns A promise that resolves once a `LedgerSigner` instance is prepared (public key is set).\n     */\n    static async fromDerivationPath(\n        derivationPath: string,\n        ledgerClient: IotaLedgerClient,\n        iotaClient: IotaClient,\n    ) {\n        const { publicKey } = await ledgerClient.getPublicKey(derivationPath);\n        if (!publicKey) {\n            throw new Error('Failed to get public key from Ledger.');\n        }\n\n        return new LedgerSigner({\n            derivationPath,\n            publicKey: new Ed25519PublicKey(publicKey),\n            ledgerClient,\n            iotaClient,\n        });\n    }\n\n    async #getClearSigningOptions(transactionBytes: Uint8Array) {\n        const transaction = Transaction.from(transactionBytes);\n        const data = transaction.getData();\n\n        const gasObjectIds = data.gasData.payment?.map((object) => object.objectId) ?? [];\n        const inputObjectIds = data.inputs\n            .map((input) => {\n                return input.$kind === 'Object' && input.Object.$kind === 'ImmOrOwnedObject'\n                    ? input.Object.ImmOrOwnedObject.objectId\n                    : null;\n            })\n            .filter((objectId): objectId is string => !!objectId);\n\n        const objects = await this.#iotaClient.multiGetObjects({\n            ids: [...gasObjectIds, ...inputObjectIds],\n            options: {\n                showBcs: true,\n                showPreviousTransaction: true,\n                showStorageRebate: true,\n                showOwner: true,\n            },\n        });\n\n        // NOTE: We should probably get rid of this manual serialization logic in favor of using the\n        // already serialized object bytes from the GraphQL API once there is more mainstream support\n        // for it + we can enforce the transport type on the Iota client.\n        const bcsObjects = objects\n            .map((object) => {\n                if (object.error || !object.data || object.data.bcs?.dataType !== 'moveObject') {\n                    return null;\n                }\n\n                return IotaMoveObject.serialize({\n                    data: {\n                        MoveObject: {\n                            type: object.data.bcs.type,\n                            version: object.data.bcs.version,\n                            contents: object.data.bcs.bcsBytes,\n                        },\n                    },\n                    owner: object.data.owner!,\n                    previousTransaction: object.data.previousTransaction!,\n                    storageRebate: object.data.storageRebate!,\n                }).toBytes();\n            })\n            .filter((bcsBytes): bcsBytes is Uint8Array => !!bcsBytes);\n\n        return { bcsObjects };\n    }\n\n    /**\n     * Generic signing is not supported by Ledger.\n     * @throws Always throws an error indicating generic signing is unsupported.\n     */\n    override sign(): never {\n        throw new Error('Ledger Signer does not support generic signing.');\n    }\n\n    /**\n     * Generic signing is not supported by Ledger.\n     * @throws Always throws an error indicating generic signing is unsupported.\n     */\n    override signWithIntent(): never {\n        throw new Error('Ledger Signer does not support generic signing.');\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["import_bcs"]
+}

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "private": true,
+  "type": "commonjs",
+  "sideEffects": false
+}

package/dist/cjs/webcrypto/index.d.ts

@@ -0,0 +1,26 @@
+import type { SignatureScheme } from '@iota/iota-sdk/cryptography';
+import { Signer } from '@iota/iota-sdk/cryptography';
+import { Secp256r1PublicKey } from '@iota/iota-sdk/keypairs/secp256r1';
+export interface ExportedWebCryptoKeypair {
+    privateKey: CryptoKey;
+    publicKey: Uint8Array;
+}
+export declare class WebCryptoSigner extends Signer {
+    #private;
+    privateKey: CryptoKey;
+    static generate({ extractable }?: {
+        extractable?: boolean;
+    }): Promise<WebCryptoSigner>;
+    /**
+     * Imports a keypair using the value returned by `export()`.
+     */
+    static import(data: ExportedWebCryptoKeypair): WebCryptoSigner;
+    getKeyScheme(): SignatureScheme;
+    constructor(privateKey: CryptoKey, publicKey: Uint8Array);
+    /**
+     * Exports the keypair so that it can be stored in IndexedDB.
+     */
+    export(): ExportedWebCryptoKeypair;
+    getPublicKey(): Secp256r1PublicKey;
+    sign(bytes: Uint8Array): Promise<Uint8Array>;
+}

package/dist/cjs/webcrypto/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var webcrypto_exports = {};
+__export(webcrypto_exports, {
+  WebCryptoSigner: () => WebCryptoSigner
+});
+module.exports = __toCommonJS(webcrypto_exports);
+var import_cryptography = require("@iota/iota-sdk/cryptography");
+var import_secp256r1 = require("@iota/iota-sdk/keypairs/secp256r1");
+var import_p256 = require("@noble/curves/p256");
+var _publicKey;
+function getCompressedPublicKey(publicKey) {
+  const rawBytes = new Uint8Array(publicKey);
+  const x = rawBytes.slice(1, 33);
+  const y = rawBytes.slice(33, 65);
+  const prefix = (y[31] & 1) === 0 ? 2 : 3;
+  const compressed = new Uint8Array(import_secp256r1.Secp256r1PublicKey.SIZE);
+  compressed[0] = prefix;
+  compressed.set(x, 1);
+  return compressed;
+}
+const _WebCryptoSigner = class _WebCryptoSigner extends import_cryptography.Signer {
+  constructor(privateKey, publicKey) {
+    super();
+    __privateAdd(this, _publicKey);
+    this.privateKey = privateKey;
+    __privateSet(this, _publicKey, new import_secp256r1.Secp256r1PublicKey(publicKey));
+  }
+  static async generate({ extractable = false } = {}) {
+    const keypair = await globalThis.crypto.subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: "P-256"
+      },
+      extractable,
+      ["sign", "verify"]
+    );
+    const publicKey = await globalThis.crypto.subtle.exportKey("raw", keypair.publicKey);
+    return new _WebCryptoSigner(
+      keypair.privateKey,
+      getCompressedPublicKey(new Uint8Array(publicKey))
+    );
+  }
+  /**
+   * Imports a keypair using the value returned by `export()`.
+   */
+  static import(data) {
+    return new _WebCryptoSigner(data.privateKey, data.publicKey);
+  }
+  getKeyScheme() {
+    return "Secp256r1";
+  }
+  /**
+   * Exports the keypair so that it can be stored in IndexedDB.
+   */
+  export() {
+    const exportedKeypair = {
+      privateKey: this.privateKey,
+      publicKey: __privateGet(this, _publicKey).toRawBytes()
+    };
+    Object.defineProperty(exportedKeypair, "toJSON", {
+      enumerable: false,
+      value: () => {
+        throw new Error(
+          "The exported keypair must not be serialized. It must be stored in IndexedDB directly."
+        );
+      }
+    });
+    return exportedKeypair;
+  }
+  getPublicKey() {
+    return __privateGet(this, _publicKey);
+  }
+  async sign(bytes) {
+    const rawSignature = await globalThis.crypto.subtle.sign(
+      {
+        name: "ECDSA",
+        hash: "SHA-256"
+      },
+      this.privateKey,
+      bytes
+    );
+    const signature = import_p256.secp256r1.Signature.fromCompact(new Uint8Array(rawSignature));
+    return signature.normalizeS().toCompactRawBytes();
+  }
+};
+_publicKey = new WeakMap();
+let WebCryptoSigner = _WebCryptoSigner;
+//# sourceMappingURL=index.js.map

package/dist/cjs/webcrypto/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/webcrypto/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2025 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { SignatureScheme } from '@iota/iota-sdk/cryptography';\nimport { Signer } from '@iota/iota-sdk/cryptography';\nimport { Secp256r1PublicKey } from '@iota/iota-sdk/keypairs/secp256r1';\nimport { secp256r1 } from '@noble/curves/p256';\n\n// Convert from uncompressed (65 bytes) to compressed (33 bytes) format\nfunction getCompressedPublicKey(publicKey: Uint8Array) {\n    const rawBytes = new Uint8Array(publicKey);\n    const x = rawBytes.slice(1, 33);\n    const y = rawBytes.slice(33, 65);\n\n    const prefix = (y[31] & 1) === 0 ? 0x02 : 0x03;\n\n    const compressed = new Uint8Array(Secp256r1PublicKey.SIZE);\n    compressed[0] = prefix;\n    compressed.set(x, 1);\n\n    return compressed;\n}\n\nexport interface ExportedWebCryptoKeypair {\n    privateKey: CryptoKey;\n    publicKey: Uint8Array;\n}\n\nexport class WebCryptoSigner extends Signer {\n    privateKey: CryptoKey;\n\n    #publicKey: Secp256r1PublicKey;\n\n    static async generate({ extractable = false }: { extractable?: boolean } = {}) {\n        const keypair = await globalThis.crypto.subtle.generateKey(\n            {\n                name: 'ECDSA',\n                namedCurve: 'P-256',\n            },\n            extractable,\n            ['sign', 'verify'],\n        );\n\n        const publicKey = await globalThis.crypto.subtle.exportKey('raw', keypair.publicKey);\n\n        return new WebCryptoSigner(\n            keypair.privateKey,\n            getCompressedPublicKey(new Uint8Array(publicKey)),\n        );\n    }\n\n    /**\n     * Imports a keypair using the value returned by `export()`.\n     */\n    static import(data: ExportedWebCryptoKeypair) {\n        return new WebCryptoSigner(data.privateKey, data.publicKey);\n    }\n\n    getKeyScheme(): SignatureScheme {\n        return 'Secp256r1';\n    }\n\n    constructor(privateKey: CryptoKey, publicKey: Uint8Array) {\n        super();\n        this.privateKey = privateKey;\n        this.#publicKey = new Secp256r1PublicKey(publicKey);\n    }\n\n    /**\n     * Exports the keypair so that it can be stored in IndexedDB.\n     */\n    export(): ExportedWebCryptoKeypair {\n        const exportedKeypair = {\n            privateKey: this.privateKey,\n            publicKey: this.#publicKey.toRawBytes(),\n        };\n\n        Object.defineProperty(exportedKeypair, 'toJSON', {\n            enumerable: false,\n            value: () => {\n                throw new Error(\n                    'The exported keypair must not be serialized. It must be stored in IndexedDB directly.',\n                );\n            },\n        });\n\n        return exportedKeypair;\n    }\n\n    getPublicKey() {\n        return this.#publicKey;\n    }\n\n    async sign(bytes: Uint8Array): Promise<Uint8Array> {\n        const rawSignature = await globalThis.crypto.subtle.sign(\n            {\n                name: 'ECDSA',\n                hash: 'SHA-256',\n            },\n            this.privateKey,\n            bytes,\n        );\n\n        const signature = secp256r1.Signature.fromCompact(new Uint8Array(rawSignature));\n\n        return signature.normalizeS().toCompactRawBytes();\n    }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,0BAAuB;AACvB,uBAAmC;AACnC,kBAA0B;AAP1B;AAUA,SAAS,uBAAuB,WAAuB;AACnD,QAAM,WAAW,IAAI,WAAW,SAAS;AACzC,QAAM,IAAI,SAAS,MAAM,GAAG,EAAE;AAC9B,QAAM,IAAI,SAAS,MAAM,IAAI,EAAE;AAE/B,QAAM,UAAU,EAAE,EAAE,IAAI,OAAO,IAAI,IAAO;AAE1C,QAAM,aAAa,IAAI,WAAW,oCAAmB,IAAI;AACzD,aAAW,CAAC,IAAI;AAChB,aAAW,IAAI,GAAG,CAAC;AAEnB,SAAO;AACX;AAOO,MAAM,mBAAN,MAAM,yBAAwB,2BAAO;AAAA,EAkCxC,YAAY,YAAuB,WAAuB;AACtD,UAAM;AAhCV;AAiCI,SAAK,aAAa;AAClB,uBAAK,YAAa,IAAI,oCAAmB,SAAS;AAAA,EACtD;AAAA,EAjCA,aAAa,SAAS,EAAE,cAAc,MAAM,IAA+B,CAAC,GAAG;AAC3E,UAAM,UAAU,MAAM,WAAW,OAAO,OAAO;AAAA,MAC3C;AAAA,QACI,MAAM;AAAA,QACN,YAAY;AAAA,MAChB;AAAA,MACA;AAAA,MACA,CAAC,QAAQ,QAAQ;AAAA,IACrB;AAEA,UAAM,YAAY,MAAM,WAAW,OAAO,OAAO,UAAU,OAAO,QAAQ,SAAS;AAEnF,WAAO,IAAI;AAAA,MACP,QAAQ;AAAA,MACR,uBAAuB,IAAI,WAAW,SAAS,CAAC;AAAA,IACpD;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,OAAO,MAAgC;AAC1C,WAAO,IAAI,iBAAgB,KAAK,YAAY,KAAK,SAAS;AAAA,EAC9D;AAAA,EAEA,eAAgC;AAC5B,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAWA,SAAmC;AAC/B,UAAM,kBAAkB;AAAA,MACpB,YAAY,KAAK;AAAA,MACjB,WAAW,mBAAK,YAAW,WAAW;AAAA,IAC1C;AAEA,WAAO,eAAe,iBAAiB,UAAU;AAAA,MAC7C,YAAY;AAAA,MACZ,OAAO,MAAM;AACT,cAAM,IAAI;AAAA,UACN;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ,CAAC;AAED,WAAO;AAAA,EACX;AAAA,EAEA,eAAe;AACX,WAAO,mBAAK;AAAA,EAChB;AAAA,EAEA,MAAM,KAAK,OAAwC;AAC/C,UAAM,eAAe,MAAM,WAAW,OAAO,OAAO;AAAA,MAChD;AAAA,QACI,MAAM;AAAA,QACN,MAAM;AAAA,MACV;AAAA,MACA,KAAK;AAAA,MACL;AAAA,IACJ;AAEA,UAAM,YAAY,sBAAU,UAAU,YAAY,IAAI,WAAW,YAAY,CAAC;AAE9E,WAAO,UAAU,WAAW,EAAE,kBAAkB;AAAA,EACpD;AACJ;AA5EI;AAHG,IAAM,kBAAN;",
+  "names": []
+}

package/dist/esm/ledger/bcs.d.ts

@@ -0,0 +1,25 @@
+import type { ObjectOwner } from '@iota/iota-sdk/client';
+export declare const IotaMoveObject: import("@iota/iota-sdk/bcs").BcsType<{
+    data: {
+        MoveObject: {
+            type: any;
+            version: string;
+            contents: any;
+        };
+        $kind: "MoveObject";
+    };
+    owner: any;
+    previousTransaction: string;
+    storageRebate: string;
+}, {
+    data: {
+        MoveObject: {
+            type: string;
+            version: string | number | bigint;
+            contents: string;
+        };
+    };
+    owner: ObjectOwner;
+    previousTransaction: string;
+    storageRebate: string | number | bigint;
+}>;

package/dist/esm/ledger/bcs.js

@@ -0,0 +1,66 @@
+import { bcs, TypeTagSerializer } from "@iota/iota-sdk/bcs";
+import {
+  fromB64,
+  normalizeStructTag,
+  normalizeIotaAddress,
+  parseStructTag
+} from "@iota/iota-sdk/utils";
+const IOTA_FRAMEWORK_ADDRESS = normalizeIotaAddress("0x2");
+const IOTA_SYSTEM_ADDRESS = normalizeIotaAddress("0x3");
+const MoveObjectType = bcs.enum("MoveObjectType", {
+  Other: bcs.StructTag,
+  GasCoin: null,
+  StakedIota: null,
+  Coin: bcs.TypeTag
+});
+const IotaMoveObject = bcs.struct("IotaMoveObject", {
+  data: bcs.enum("Data", {
+    MoveObject: bcs.struct("MoveObject", {
+      type: MoveObjectType.transform({
+        input: (objectType) => {
+          const structTag = parseStructTag(objectType);
+          if (structTag.address === IOTA_FRAMEWORK_ADDRESS && structTag.module === "coin" && structTag.name === "Coin" && typeof structTag.typeParams[0] === "object") {
+            const innerStructTag = structTag.typeParams[0];
+            if (innerStructTag.address === IOTA_FRAMEWORK_ADDRESS && innerStructTag.module === "iota" && innerStructTag.name === "IOTA") {
+              return { GasCoin: true, $kind: "GasCoin" };
+            }
+            return { Coin: normalizeStructTag(innerStructTag), $kind: "Coin" };
+          } else if (structTag.address === IOTA_SYSTEM_ADDRESS && structTag.module === "staking_pool" && structTag.name === "StakedIota") {
+            return { StakedIota: true, $kind: "StakedIota" };
+          }
+          return {
+            Other: {
+              ...structTag,
+              typeParams: structTag.typeParams.map((typeParam) => {
+                return TypeTagSerializer.parseFromStr(
+                  normalizeStructTag(typeParam)
+                );
+              })
+            },
+            $kind: "Other"
+          };
+        }
+      }),
+      version: bcs.u64(),
+      contents: bcs.byteVector().transform({ input: fromB64 })
+    })
+  }),
+  owner: bcs.Owner.transform({
+    input: (objectOwner) => {
+      if (objectOwner === "Immutable") {
+        return { Immutable: null };
+      } else if ("Shared" in objectOwner) {
+        return {
+          Shared: { initialSharedVersion: objectOwner.Shared.initial_shared_version }
+        };
+      }
+      return objectOwner;
+    }
+  }),
+  previousTransaction: bcs.ObjectDigest,
+  storageRebate: bcs.u64()
+});
+export {
+  IotaMoveObject
+};
+//# sourceMappingURL=bcs.js.map

package/dist/esm/ledger/bcs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ledger/bcs.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// Modifications Copyright (c) 2025 IOTA Stiftung\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs, TypeTagSerializer } from '@iota/iota-sdk/bcs';\nimport type { ObjectOwner } from '@iota/iota-sdk/client';\nimport {\n    fromB64,\n    normalizeStructTag,\n    normalizeIotaAddress,\n    parseStructTag,\n} from '@iota/iota-sdk/utils';\n\nconst IOTA_FRAMEWORK_ADDRESS = normalizeIotaAddress('0x2');\nconst IOTA_SYSTEM_ADDRESS = normalizeIotaAddress('0x3');\n\nconst MoveObjectType = bcs.enum('MoveObjectType', {\n    Other: bcs.StructTag,\n    GasCoin: null,\n    StakedIota: null,\n    Coin: bcs.TypeTag,\n});\n\nexport const IotaMoveObject = bcs.struct('IotaMoveObject', {\n    data: bcs.enum('Data', {\n        MoveObject: bcs.struct('MoveObject', {\n            type: MoveObjectType.transform({\n                input: (objectType: string): typeof MoveObjectType.$inferType => {\n                    const structTag = parseStructTag(objectType);\n\n                    if (\n                        structTag.address === IOTA_FRAMEWORK_ADDRESS &&\n                        structTag.module === 'coin' &&\n                        structTag.name === 'Coin' &&\n                        typeof structTag.typeParams[0] === 'object'\n                    ) {\n                        const innerStructTag = structTag.typeParams[0];\n                        if (\n                            innerStructTag.address === IOTA_FRAMEWORK_ADDRESS &&\n                            innerStructTag.module === 'iota' &&\n                            innerStructTag.name === 'IOTA'\n                        ) {\n                            return { GasCoin: true, $kind: 'GasCoin' };\n                        }\n                        return { Coin: normalizeStructTag(innerStructTag), $kind: 'Coin' };\n                    } else if (\n                        structTag.address === IOTA_SYSTEM_ADDRESS &&\n                        structTag.module === 'staking_pool' &&\n                        structTag.name === 'StakedIota'\n                    ) {\n                        return { StakedIota: true, $kind: 'StakedIota' };\n                    }\n                    return {\n                        Other: {\n                            ...structTag,\n                            typeParams: structTag.typeParams.map((typeParam) => {\n                                return TypeTagSerializer.parseFromStr(\n                                    normalizeStructTag(typeParam),\n                                );\n                            }),\n                        },\n                        $kind: 'Other',\n                    };\n                },\n            }),\n            version: bcs.u64(),\n            contents: bcs.byteVector().transform({ input: fromB64 }),\n        }),\n    }),\n    owner: bcs.Owner.transform({\n        input: (objectOwner: ObjectOwner) => {\n            if (objectOwner === 'Immutable') {\n                return { Immutable: null };\n            } else if ('Shared' in objectOwner) {\n                return {\n                    Shared: { initialSharedVersion: objectOwner.Shared.initial_shared_version },\n                };\n            }\n            return objectOwner;\n        },\n    }),\n    previousTransaction: bcs.ObjectDigest,\n    storageRebate: bcs.u64(),\n});\n"],
+  "mappings": "AAIA,SAAS,KAAK,yBAAyB;AAEvC;AAAA,EACI;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACG;AAEP,MAAM,yBAAyB,qBAAqB,KAAK;AACzD,MAAM,sBAAsB,qBAAqB,KAAK;AAEtD,MAAM,iBAAiB,IAAI,KAAK,kBAAkB;AAAA,EAC9C,OAAO,IAAI;AAAA,EACX,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,MAAM,IAAI;AACd,CAAC;AAEM,MAAM,iBAAiB,IAAI,OAAO,kBAAkB;AAAA,EACvD,MAAM,IAAI,KAAK,QAAQ;AAAA,IACnB,YAAY,IAAI,OAAO,cAAc;AAAA,MACjC,MAAM,eAAe,UAAU;AAAA,QAC3B,OAAO,CAAC,eAAyD;AAC7D,gBAAM,YAAY,eAAe,UAAU;AAE3C,cACI,UAAU,YAAY,0BACtB,UAAU,WAAW,UACrB,UAAU,SAAS,UACnB,OAAO,UAAU,WAAW,CAAC,MAAM,UACrC;AACE,kBAAM,iBAAiB,UAAU,WAAW,CAAC;AAC7C,gBACI,eAAe,YAAY,0BAC3B,eAAe,WAAW,UAC1B,eAAe,SAAS,QAC1B;AACE,qBAAO,EAAE,SAAS,MAAM,OAAO,UAAU;AAAA,YAC7C;AACA,mBAAO,EAAE,MAAM,mBAAmB,cAAc,GAAG,OAAO,OAAO;AAAA,UACrE,WACI,UAAU,YAAY,uBACtB,UAAU,WAAW,kBACrB,UAAU,SAAS,cACrB;AACE,mBAAO,EAAE,YAAY,MAAM,OAAO,aAAa;AAAA,UACnD;AACA,iBAAO;AAAA,YACH,OAAO;AAAA,cACH,GAAG;AAAA,cACH,YAAY,UAAU,WAAW,IAAI,CAAC,cAAc;AAChD,uBAAO,kBAAkB;AAAA,kBACrB,mBAAmB,SAAS;AAAA,gBAChC;AAAA,cACJ,CAAC;AAAA,YACL;AAAA,YACA,OAAO;AAAA,UACX;AAAA,QACJ;AAAA,MACJ,CAAC;AAAA,MACD,SAAS,IAAI,IAAI;AAAA,MACjB,UAAU,IAAI,WAAW,EAAE,UAAU,EAAE,OAAO,QAAQ,CAAC;AAAA,IAC3D,CAAC;AAAA,EACL,CAAC;AAAA,EACD,OAAO,IAAI,MAAM,UAAU;AAAA,IACvB,OAAO,CAAC,gBAA6B;AACjC,UAAI,gBAAgB,aAAa;AAC7B,eAAO,EAAE,WAAW,KAAK;AAAA,MAC7B,WAAW,YAAY,aAAa;AAChC,eAAO;AAAA,UACH,QAAQ,EAAE,sBAAsB,YAAY,OAAO,uBAAuB;AAAA,QAC9E;AAAA,MACJ;AACA,aAAO;AAAA,IACX;AAAA,EACJ,CAAC;AAAA,EACD,qBAAqB,IAAI;AAAA,EACzB,eAAe,IAAI,IAAI;AAC3B,CAAC;",
+  "names": []
+}

package/dist/esm/ledger/index.d.ts

@@ -0,0 +1,63 @@
+import type IotaLedgerClient from '@iota/ledgerjs-hw-app-iota';
+import type { IotaClient } from '@iota/iota-sdk/client';
+import type { SignatureWithBytes } from '@iota/iota-sdk/cryptography';
+import { Signer } from '@iota/iota-sdk/cryptography';
+import { Ed25519PublicKey } from '@iota/iota-sdk/keypairs/ed25519';
+/**
+ * Configuration options for initializing the LedgerSigner.
+ */
+export interface LedgerSignerOptions {
+    publicKey: Ed25519PublicKey;
+    derivationPath: string;
+    ledgerClient: IotaLedgerClient;
+    iotaClient: IotaClient;
+}
+/**
+ * Ledger integrates with the Iota blockchain to provide signing capabilities using Ledger devices.
+ */
+export declare class LedgerSigner extends Signer {
+    #private;
+    /**
+     * Creates an instance of LedgerSigner. It's expected to call the static `fromDerivationPath` method to create an instance.
+     * @example
+     * ```
+     * const signer = await LedgerSigner.fromDerivationPath(derivationPath, options);
+     * ```
+     */
+    constructor({ publicKey, derivationPath, ledgerClient, iotaClient }: LedgerSignerOptions);
+    /**
+     * Retrieves the key scheme used by this signer.
+     */
+    getKeyScheme(): "ED25519";
+    /**
+     * Retrieves the public key associated with this signer.
+     * @returns The Ed25519PublicKey instance.
+     */
+    getPublicKey(): Ed25519PublicKey;
+    /**
+     * Signs the provided transaction bytes.
+     * @returns The signed transaction bytes and signature.
+     */
+    signTransaction(bytes: Uint8Array): Promise<SignatureWithBytes>;
+    /**
+     * Signs the provided personal message.
+     * @returns The signed message bytes and signature.
+     */
+    signPersonalMessage(bytes: Uint8Array): Promise<SignatureWithBytes>;
+    /**
+     * Prepares the signer by fetching and setting the public key from a Ledger device.
+     * It is recommended to initialize an `LedgerSigner` instance using this function.
+     * @returns A promise that resolves once a `LedgerSigner` instance is prepared (public key is set).
+     */
+    static fromDerivationPath(derivationPath: string, ledgerClient: IotaLedgerClient, iotaClient: IotaClient): Promise<LedgerSigner>;
+    /**
+     * Generic signing is not supported by Ledger.
+     * @throws Always throws an error indicating generic signing is unsupported.
+     */
+    sign(): never;
+    /**
+     * Generic signing is not supported by Ledger.
+     * @throws Always throws an error indicating generic signing is unsupported.
+     */
+    signWithIntent(): never;
+}