@sphereon/ssi-sdk-ext.mnemonic-seed-manager 0.28.1-feature.oyd.cmsm.improv.20 → 0.28.1-next.53

package/dist/index.cjs

@@ -0,0 +1,746 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module2) {
+    module2.exports = {
+      IMnemonicSeedManager: {
+        components: {
+          schemas: {
+            IMnemonicInfoStoreArgs: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                hash: {
+                  type: "string"
+                },
+                mnemonic: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                masterKey: {
+                  type: "string"
+                },
+                chainCode: {
+                  type: "string"
+                },
+                kms: {
+                  type: "string"
+                },
+                path: {
+                  type: "string"
+                },
+                withZeroBytes: {
+                  type: "boolean"
+                },
+                type: {
+                  type: "string",
+                  enum: [
+                    "Ed25519",
+                    "Secp256k1"
+                  ]
+                },
+                persist: {
+                  type: "boolean"
+                }
+              }
+            },
+            DeleteResult: {
+              type: "object",
+              properties: {
+                raw: {},
+                affected: {
+                  type: [
+                    "number",
+                    "null"
+                  ]
+                }
+              },
+              required: [
+                "raw"
+              ]
+            },
+            ManagedKeyInfo: {
+              type: "object",
+              properties: {
+                kid: {
+                  type: "string",
+                  description: "Key ID"
+                },
+                kms: {
+                  type: "string",
+                  description: "Key Management System"
+                },
+                type: {
+                  $ref: "#/components/schemas/TKeyType",
+                  description: "Key type"
+                },
+                publicKeyHex: {
+                  type: "string",
+                  description: "Public key"
+                },
+                meta: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/KeyMetadata"
+                    },
+                    {
+                      type: "null"
+                    }
+                  ],
+                  description: "Optional. Key metadata. This should be used to determine which algorithms are supported."
+                }
+              },
+              required: [
+                "kid",
+                "kms",
+                "type",
+                "publicKeyHex"
+              ],
+              description: "Represents information about a managed key. Private or secret key material is NOT present."
+            },
+            TKeyType: {
+              type: "string",
+              enum: [
+                "Ed25519",
+                "Secp256k1",
+                "Secp256r1",
+                "X25519",
+                "Bls12381G1",
+                "Bls12381G2",
+                "RSA"
+              ],
+              description: "Cryptographic key type."
+            },
+            KeyMetadata: {
+              type: "object",
+              properties: {
+                algorithms: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              description: "This encapsulates data about a key.\n\nImplementations of  {@link  @veramo/key-manager#AbstractKeyManagementSystem | AbstractKeyManagementSystem }  should populate this object, for each key, with the algorithms that can be performed using it.\n\nThis can also be used to add various tags to the keys under management."
+            },
+            IMnemonicInfoKeyResult: {
+              type: "object",
+              properties: {
+                masterKey: {
+                  type: "string"
+                },
+                chainCode: {
+                  type: "string"
+                }
+              }
+            },
+            IMnemonicGeneratorArgs: {
+              type: "object",
+              properties: {
+                bits: {
+                  type: "number",
+                  enum: [
+                    128,
+                    160,
+                    192,
+                    224,
+                    256
+                  ]
+                },
+                id: {
+                  type: "string"
+                },
+                persist: {
+                  type: "boolean"
+                }
+              },
+              required: [
+                "bits"
+              ]
+            },
+            IMnemonicInfoResult: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                hash: {
+                  type: "string"
+                },
+                mnemonic: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                },
+                masterKey: {
+                  type: "string"
+                },
+                chainCode: {
+                  type: "string"
+                },
+                kms: {
+                  type: "string"
+                },
+                path: {
+                  type: "string"
+                },
+                withZeroBytes: {
+                  type: "boolean"
+                },
+                type: {
+                  type: "string",
+                  enum: [
+                    "Ed25519",
+                    "Secp256k1"
+                  ]
+                },
+                persist: {
+                  type: "boolean"
+                },
+                succeeded: {
+                  type: "boolean"
+                },
+                seed: {
+                  type: "string"
+                }
+              }
+            },
+            ISeedGeneratorArgs: {
+              type: "object",
+              properties: {
+                mnemonic: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: [
+                "mnemonic"
+              ]
+            },
+            IMnemonicVerificationArgs: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                hash: {
+                  type: "string"
+                },
+                wordList: {
+                  type: "array",
+                  items: {
+                    type: "string"
+                  }
+                }
+              },
+              required: [
+                "wordList"
+              ]
+            },
+            IPartialMnemonicVerificationArgs: {
+              type: "object",
+              properties: {
+                id: {
+                  type: "string"
+                },
+                hash: {
+                  type: "string"
+                },
+                indexedWordList: {
+                  type: "array",
+                  items: {
+                    type: "array",
+                    minItems: 2,
+                    items: [
+                      {
+                        type: "number"
+                      },
+                      {
+                        type: "string"
+                      }
+                    ],
+                    maxItems: 2
+                  }
+                }
+              },
+              required: [
+                "indexedWordList"
+              ]
+            }
+          },
+          methods: {
+            deleteMnemonicInfo: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IMnemonicInfoStoreArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/DeleteResult"
+              }
+            },
+            generateKeysFromMnemonic: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IMnemonicInfoStoreArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/ManagedKeyInfo"
+              }
+            },
+            generateMasterKey: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IMnemonicInfoStoreArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IMnemonicInfoKeyResult"
+              }
+            },
+            generateMnemonic: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IMnemonicGeneratorArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IMnemonicInfoResult"
+              }
+            },
+            generateSeed: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/ISeedGeneratorArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IMnemonicInfoResult"
+              }
+            },
+            getMnemonicInfo: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IMnemonicInfoStoreArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IMnemonicInfoResult"
+              }
+            },
+            saveMnemonicInfo: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IMnemonicInfoStoreArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IMnemonicInfoResult"
+              }
+            },
+            verifyMnemonic: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IMnemonicVerificationArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IMnemonicInfoResult"
+              }
+            },
+            verifyPartialMnemonic: {
+              description: "",
+              arguments: {
+                $ref: "#/components/schemas/IPartialMnemonicVerificationArgs"
+              },
+              returnType: {
+                $ref: "#/components/schemas/IMnemonicInfoResult"
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MnemonicSeedManager: () => MnemonicSeedManager,
+  MnemonicSeedManagerEntities: () => MnemonicSeedManagerEntities,
+  MnemonicSeedManagerMigrations: () => MnemonicSeedManagerMigrations,
+  schema: () => schema
+});
+module.exports = __toCommonJS(index_exports);
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/entities/MnemonicEntity.ts
+var import_typeorm = require("typeorm");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var MnemonicEntity = class extends import_typeorm.BaseEntity {
+  static {
+    __name(this, "MnemonicEntity");
+  }
+  id;
+  hash;
+  mnemonic;
+  masterKey;
+  chainCode;
+};
+_ts_decorate([
+  (0, import_typeorm.PrimaryColumn)({
+    name: "id",
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "id", void 0);
+_ts_decorate([
+  (0, import_typeorm.Column)({
+    name: "hash",
+    unique: true,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "hash", void 0);
+_ts_decorate([
+  (0, import_typeorm.Column)({
+    name: "mnemonic",
+    unique: true,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "mnemonic", void 0);
+_ts_decorate([
+  (0, import_typeorm.Column)({
+    name: "master_key",
+    default: null,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "masterKey", void 0);
+_ts_decorate([
+  (0, import_typeorm.Column)({
+    name: "chain_code",
+    default: null,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "chainCode", void 0);
+MnemonicEntity = _ts_decorate([
+  (0, import_typeorm.Entity)("Mnemonic")
+], MnemonicEntity);
+
+// src/agent/MnemonicSeedManager.ts
+var import_utils = require("@noble/hashes/utils");
+var import_ssi_sdk_ext = require("@sphereon/ssi-sdk-ext.key-utils");
+var import_ed25519_hd_key = require("ed25519-hd-key");
+var bip39 = __toESM(require("bip39"), 1);
+var MnemonicSeedManager = class {
+  static {
+    __name(this, "MnemonicSeedManager");
+  }
+  dbConnection;
+  secretBox;
+  schema;
+  methods;
+  constructor(dbConnection, secretBox) {
+    this.dbConnection = dbConnection;
+    this.secretBox = secretBox;
+    this.schema = schema.IMnemonicInfoGenerator;
+    this.methods = {
+      generateMnemonic: this.generateMnemonic.bind(this),
+      generateSeed: this.generateSeed.bind(this),
+      verifyMnemonic: this.verifyMnemonic.bind(this),
+      verifyPartialMnemonic: this.verifyPartialMnemonic.bind(this),
+      saveMnemonicInfo: this.saveMnemonicInfo.bind(this),
+      getMnemonicInfo: this.getMnemonicInfo.bind(this),
+      deleteMnemonicInfo: this.deleteMnemonicInfo.bind(this),
+      generateMasterKey: this.generateMasterKey.bind(this),
+      generateKeysFromMnemonic: this.generateKeysFromMnemonic.bind(this)
+    };
+    if (!secretBox) {
+      console.warn("Please provide SecretBox to the KeyStore");
+    }
+  }
+  async generateMnemonic(args) {
+    const mnemonic = bip39.generateMnemonic(args.bits);
+    if (args.persist) {
+      return await this.saveMnemonicInfo({
+        id: args.id,
+        mnemonic: mnemonic.split(" ")
+      });
+    }
+    return {
+      mnemonic: mnemonic.split(" ")
+    };
+  }
+  async verifyMnemonic(args) {
+    const mnemonicInfo = await this.getMnemonicInfo({
+      id: args.id,
+      hash: args.hash
+    });
+    if (mnemonicInfo?.mnemonic) {
+      return {
+        succeeded: mnemonicInfo.mnemonic.join(" ") === args.wordList?.join(" ")
+      };
+    }
+    throw new Error("Mnemonic not found");
+  }
+  async verifyPartialMnemonic(args) {
+    const mnemonicInfo = await this.getMnemonicInfo({
+      id: args.id,
+      hash: args.hash
+    });
+    if (mnemonicInfo?.mnemonic) {
+      return {
+        succeeded: args.indexedWordList.every((indexedWord) => mnemonicInfo.mnemonic?.indexOf(indexedWord[1]) === indexedWord[0])
+      };
+    }
+    throw new Error("Mnemonic not found");
+  }
+  async generateSeed(args) {
+    return Promise.resolve({
+      seed: (await bip39.mnemonicToSeed(args.mnemonic.join(" "))).toString("hex")
+    });
+  }
+  async saveMnemonicInfo(args) {
+    if (args.mnemonic && this.secretBox) {
+      const mnemonic = args.mnemonic.join(" ");
+      const hash = (0, import_utils.bytesToHex)((0, import_ssi_sdk_ext.shaHasher)(mnemonic, "sha256"));
+      const mnemonicInfo = new MnemonicEntity();
+      mnemonicInfo.id = args.id ? args.id : hash;
+      mnemonicInfo.hash = hash;
+      mnemonicInfo.mnemonic = await this.secretBox.encrypt(mnemonic);
+      const result = await (await this.dbConnection).getRepository(MnemonicEntity).save(mnemonicInfo);
+      return Promise.resolve({
+        id: result.id,
+        hash: result.hash,
+        mnemonic: args.mnemonic
+      });
+    } else {
+      throw new Error("Mnemonic needs to be provided.");
+    }
+  }
+  async getMnemonicInfo(args) {
+    const mnemonicInfo = await (await this.dbConnection).getRepository(MnemonicEntity).createQueryBuilder().where("id = :id", {
+      id: args.id
+    }).orWhere("hash = :hash", {
+      hash: args.hash
+    }).getOne();
+    if (mnemonicInfo?.mnemonic) {
+      const mnemonicStr = await this.secretBox?.decrypt(mnemonicInfo.mnemonic);
+      return {
+        id: mnemonicInfo.id,
+        hash: mnemonicInfo.hash,
+        mnemonic: mnemonicStr?.split(" ")
+      };
+    }
+    return {};
+  }
+  async deleteMnemonicInfo(args) {
+    return (await this.dbConnection).createQueryBuilder().delete().from(MnemonicEntity).where("id = :id", {
+      id: args.id
+    }).orWhere("hash = :hash", {
+      hash: args.hash
+    }).execute();
+  }
+  async saveMasterKey(args) {
+    if (args.masterKey) {
+      return (await this.dbConnection).createQueryBuilder().update(MnemonicEntity).set({
+        masterKey: args.masterKey
+      }).where("id = :id", {
+        id: args.id
+      }).orWhere("hash = :hash", {
+        hash: args.hash
+      }).execute();
+    }
+    throw new Error("Master Key needs to be provided.");
+  }
+  async generateMasterKey(args) {
+    const mnemonic = (await this.getMnemonicInfo({
+      id: args.id,
+      hash: args.hash
+    })).mnemonic;
+    if (mnemonic) {
+      const mnemonicInfo = await this.generateSeed({
+        mnemonic
+      });
+      if (mnemonicInfo.seed) {
+        if (args.type === "Ed25519") {
+          const { key, chainCode } = (0, import_ed25519_hd_key.getMasterKeyFromSeed)(mnemonicInfo.seed);
+          await this.saveMasterKey({
+            masterKey: key.toString("hex"),
+            chainCode: chainCode.toString("hex")
+          });
+          return {
+            masterKey: key.toString("hex"),
+            chainCode: chainCode.toString("hex")
+          };
+        } else {
+          throw new Error("Secp256k1 keys are not supported yet");
+        }
+      }
+    }
+    throw new Error("Mnemonic not found");
+  }
+  async generateKeysFromMnemonic(args, context) {
+    const mnemonic = (await this.getMnemonicInfo({
+      id: args.id,
+      hash: args.hash
+    })).mnemonic;
+    if (mnemonic && context) {
+      if (args.path && args.kms) {
+        const seed = (await this.generateSeed({
+          mnemonic
+        })).seed;
+        const { key, chainCode } = (0, import_ed25519_hd_key.derivePath)(args.path, seed);
+        const extPrivateKey = Buffer.concat([
+          key,
+          chainCode
+        ]);
+        const publicKey = (0, import_ed25519_hd_key.getPublicKey)(key, args.withZeroBytes);
+        return await context.agent.keyManagerImport({
+          privateKeyHex: extPrivateKey.toString("hex"),
+          publicKeyHex: publicKey.toString("hex"),
+          type: "Ed25519",
+          kms: args.kms
+        });
+      }
+      throw new Error("Please provide kms and derivation path");
+    }
+    throw new Error("Master Key not found");
+  }
+};
+
+// src/migrations/generic/1-CreateMnemonics.ts
+var import_debug = __toESM(require("debug"), 1);
+
+// src/migrations/postgres/1659566636105-CreateMnemonics.ts
+var CreateMnemonics1659566636105 = class {
+  static {
+    __name(this, "CreateMnemonics1659566636105");
+  }
+  name = "CreateMnemonics1659566636105";
+  async up(queryRunner) {
+    await queryRunner.query(`CREATE TABLE "Mnemonic" ("id" character varying NOT NULL, "hash" character varying NOT NULL, "mnemonic" character varying NOT NULL, "master_key" character varying, "chain_code" character varying, CONSTRAINT "UQ_hash" UNIQUE ("hash"), CONSTRAINT "UQ_mnemonic" UNIQUE ("mnemonic"), CONSTRAINT "PK_mnemonic_id" PRIMARY KEY ("id"))`);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(`DROP TABLE "Mnemonic"`);
+  }
+};
+
+// src/migrations/sqlite/1659566622817-CreateMnemonics.ts
+var CreateMnemonics1659566622817 = class {
+  static {
+    __name(this, "CreateMnemonics1659566622817");
+  }
+  name = "CreateMnemonics1659566622817";
+  async up(queryRunner) {
+    await queryRunner.query(`CREATE TABLE "Mnemonic" ("id" varchar PRIMARY KEY NOT NULL, "hash" varchar NOT NULL, "mnemonic" varchar NOT NULL, "master_key" varchar, "chain_code" varchar, CONSTRAINT "UQ_hash" UNIQUE ("hash"), CONSTRAINT "UQ_mnemonic" UNIQUE ("mnemonic"))`);
+  }
+  async down(queryRunner) {
+    await queryRunner.query(`DROP TABLE "Mnemonic"`);
+  }
+};
+
+// src/migrations/generic/1-CreateMnemonics.ts
+var debug = (0, import_debug.default)("sphereon:ssi-sdk:migrations");
+var CreateMnemonics1659567079429 = class {
+  static {
+    __name(this, "CreateMnemonics1659567079429");
+  }
+  name = "CreateMnemonics1659567079429";
+  async up(queryRunner) {
+    debug("migration: creating mnemonic tables");
+    const dbType = queryRunner.connection.driver.options.type;
+    if (dbType === "postgres") {
+      debug("using postgres migration file");
+      const mig = new CreateMnemonics1659566636105();
+      const up = await mig.up(queryRunner);
+      debug("Migration statements executed");
+      return up;
+    } else if (dbType === "sqlite" || "react-native") {
+      debug("using sqlite/react-native migration file");
+      const mig = new CreateMnemonics1659566622817();
+      const up = await mig.up(queryRunner);
+      debug("Migration statements executed");
+      return up;
+    } else {
+      return Promise.reject("Migrations are currently only supported for sqlite, react-native and postgres. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now");
+    }
+  }
+  async down(queryRunner) {
+    debug("reverting mnemonic tables");
+    const dbType = queryRunner.connection.driver.options.type;
+    if (dbType === "postgres") {
+      debug("using postgres migration file");
+      const mig = new CreateMnemonics1659566636105();
+      const down = await mig.down(queryRunner);
+      debug("Migration statements executed");
+      return down;
+    } else if (dbType === "sqlite" || "react-native") {
+      debug("using sqlite/react-native migration file");
+      const mig = new CreateMnemonics1659566622817();
+      const down = await mig.down(queryRunner);
+      debug("Migration statements executed");
+      return down;
+    } else {
+      return Promise.reject("Migrations are currently only supported for sqlite, react-native and postgres. Please run your database without migrations and with 'migrationsRun: false' and 'synchronize: true' for now");
+    }
+  }
+};
+
+// src/migrations/generic/index.ts
+var MnemonicSeedManagerMigrations = [
+  CreateMnemonics1659567079429
+];
+
+// src/index.ts
+var schema = require_plugin_schema();
+var MnemonicSeedManagerEntities = [
+  MnemonicEntity
+];
+//# sourceMappingURL=index.cjs.map