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

package/dist/index.js

@@ -1,39 +1,718 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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;
+};
+
+// plugin.schema.json
+var require_plugin_schema = __commonJS({
+  "plugin.schema.json"(exports, module) {
+    module.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
+import "reflect-metadata";
+
+// src/entities/MnemonicEntity.ts
+import { Column, Entity, BaseEntity, PrimaryColumn } from "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 BaseEntity {
+  static {
+    __name(this, "MnemonicEntity");
+  }
+  id;
+  hash;
+  mnemonic;
+  masterKey;
+  chainCode;
+};
+_ts_decorate([
+  PrimaryColumn({
+    name: "id",
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "id", void 0);
+_ts_decorate([
+  Column({
+    name: "hash",
+    unique: true,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "hash", void 0);
+_ts_decorate([
+  Column({
+    name: "mnemonic",
+    unique: true,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "mnemonic", void 0);
+_ts_decorate([
+  Column({
+    name: "master_key",
+    default: null,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "masterKey", void 0);
+_ts_decorate([
+  Column({
+    name: "chain_code",
+    default: null,
+    type: "varchar"
+  }),
+  _ts_metadata("design:type", String)
+], MnemonicEntity.prototype, "chainCode", void 0);
+MnemonicEntity = _ts_decorate([
+  Entity("Mnemonic")
+], MnemonicEntity);
+
+// src/agent/MnemonicSeedManager.ts
+import { bytesToHex } from "@noble/hashes/utils";
+import { shaHasher } from "@sphereon/ssi-sdk-ext.key-utils";
+import { derivePath, getMasterKeyFromSeed, getPublicKey } from "ed25519-hd-key";
+import * as bip39 from "bip39";
+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 = bytesToHex(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 } = 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 } = derivePath(args.path, seed);
+        const extPrivateKey = Buffer.concat([
+          key,
+          chainCode
+        ]);
+        const publicKey = 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
+import Debug from "debug";
+
+// 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 = Debug("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
+];
+export {
+  MnemonicSeedManager,
+  MnemonicSeedManagerEntities,
+  MnemonicSeedManagerMigrations,
+  schema
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MnemonicSeedManagerMigrations = exports.MnemonicSeedManagerEntities = exports.MnemonicSeedManager = exports.schema = void 0;
-const MnemonicEntity_1 = require("./entities/MnemonicEntity");
-/**
- * @internal
- */
-const schema = require('../plugin.schema.json');
-exports.schema = schema;
-/**
- * @public
- */
-var MnemonicSeedManager_1 = require("./agent/MnemonicSeedManager");
-Object.defineProperty(exports, "MnemonicSeedManager", { enumerable: true, get: function () { return MnemonicSeedManager_1.MnemonicSeedManager; } });
-__exportStar(require("./types/IMnemonicSeedManager"), exports);
-/**
- * @internal
- */
-exports.MnemonicSeedManagerEntities = [MnemonicEntity_1.MnemonicEntity];
-/**
- * @internal
- */
-var migrations_1 = require("./migrations");
-Object.defineProperty(exports, "MnemonicSeedManagerMigrations", { enumerable: true, get: function () { return migrations_1.MnemonicSeedManagerMigrations; } });
 //# sourceMappingURL=index.js.map