@bitgo-beta/sdk-lib-safes 1.0.0-beta.0

package/dist/src/index.js

@@ -0,0 +1,26 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @prettier
+ *
+ * @experimental Pure Safe derivation leaf. Never imports sdk-core/BaseCoin/Wallet/Safe/key-card.
+ */
+__exportStar(require("./ed25519KeyDeriver"), exports);
+__exportStar(require("./ed25519Pub"), exports);
+__exportStar(require("./safeDerivation"), exports);
+__exportStar(require("./safeSlot"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOzs7O0dBSUc7QUFDSCxzREFBb0M7QUFDcEMsK0NBQTZCO0FBQzdCLG1EQUFpQztBQUNqQyw2Q0FBMkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwcmV0dGllclxuICpcbiAqIEBleHBlcmltZW50YWwgUHVyZSBTYWZlIGRlcml2YXRpb24gbGVhZi4gTmV2ZXIgaW1wb3J0cyBzZGstY29yZS9CYXNlQ29pbi9XYWxsZXQvU2FmZS9rZXktY2FyZC5cbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9lZDI1NTE5S2V5RGVyaXZlcic7XG5leHBvcnQgKiBmcm9tICcuL2VkMjU1MTlQdWInO1xuZXhwb3J0ICogZnJvbSAnLi9zYWZlRGVyaXZhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3NhZmVTbG90JztcbiJdfQ==

package/dist/src/safeDerivation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @prettier
+ *
+ * @experimental Shared safe child derivation for mint and sign.
+ *
+ * User child: hardened `m/<index>'` from the sequential `safe.derivationIndex[slot]`.
+ * Backup / BitGo children are soft-derived server-side at `m/<index>` (not here).
+ *
+ * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —
+ * that is the custody hashed path and cannot reproduce a safe child.
+ */
+import * as t from 'io-ts';
+export declare const DERIVED_FROM_PARENT_WITH_HARDENED_PATH: RegExp;
+export declare function parseSafeDerivationIndex(index: string | number): number;
+export declare function getSafeHardenedDerivationPath(index: string | number): string;
+export interface DerivedFromParentWithHardenedPathBrand {
+    readonly DerivedFromParentWithHardenedPath: unique symbol;
+}
+export type DerivedFromParentWithHardenedPath = t.Branded<string, DerivedFromParentWithHardenedPathBrand>;
+export declare const DerivedFromParentWithHardenedPath: t.BrandC<t.StringC, DerivedFromParentWithHardenedPathBrand>;
+export declare function parseDerivedFromParentWithHardenedPath(path: string): number;
+export interface SafeHardenedChildKey {
+    prv: string;
+    pub: string;
+    derivationPath: string;
+}
+export declare function deriveSafeChildHardenedFromXprv(rootXprv: string, index: string | number): SafeHardenedChildKey;
+/** Re-derive and assert both results match before the child is registered. */
+export declare function deriveAndSelfCheckSafeChildHardened(rootXprv: string, index: string | number): SafeHardenedChildKey;
+/**
+ * SLIP-0010 hardened derivation of a safe user child from an ed25519 root secret seed.
+ *
+ * `rootPrv` is a Stellar StrKey `S…` secret seed (what slot-④ `ed25519Multisig` user roots store).
+ * The derivation reuses the existing SLIP-0010 implementation {@link Ed25519KeyDeriver.derivePath}
+ * (hardened-only CKDPriv over the `ed25519 seed` HMAC master), then expands the resulting 32-byte
+ * child seed into a keypair with `nacl`. The child `pub` is a bare StrKey `G…`; the `prv` is the
+ * raw 32-byte child seed as hex (the seed input a signer needs).
+ *
+ * Unlike the secp256k1 path, ed25519 hardened derivation needs no chain code — the composite
+ * `pub‖chainCode` form is only for SOFT co-signer derivation and is not used here.
+ */
+export declare function deriveSafeChildEd25519Hardened(rootPrv: string, index: string | number): SafeHardenedChildKey;
+//# sourceMappingURL=safeDerivation.d.ts.map

package/dist/src/safeDerivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeDerivation.d.ts","sourceRoot":"","sources":["../../src/safeDerivation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAQ3B,eAAO,MAAM,sCAAsC,QAAgB,CAAC;AAEpE,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAavE;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAE5E;AAED,MAAM,WAAW,sCAAsC;IACrD,QAAQ,CAAC,iCAAiC,EAAE,OAAO,MAAM,CAAC;CAC3D;AAED,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,sCAAsC,CAAC,CAAC;AAE1G,eAAO,MAAM,iCAAiC,6DAI7C,CAAC;AAcF,wBAAgB,sCAAsC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO3E;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,CAAC;CACxB;AAaD,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,oBAAoB,CAI9G;AAED,8EAA8E;AAC9E,wBAAgB,mCAAmC,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,oBAAoB,CAOlH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,oBAAoB,CAY5G"}

package/dist/src/safeDerivation.js

@@ -0,0 +1,151 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DerivedFromParentWithHardenedPath = exports.DERIVED_FROM_PARENT_WITH_HARDENED_PATH = void 0;
+exports.parseSafeDerivationIndex = parseSafeDerivationIndex;
+exports.getSafeHardenedDerivationPath = getSafeHardenedDerivationPath;
+exports.parseDerivedFromParentWithHardenedPath = parseDerivedFromParentWithHardenedPath;
+exports.deriveSafeChildHardenedFromXprv = deriveSafeChildHardenedFromXprv;
+exports.deriveAndSelfCheckSafeChildHardened = deriveAndSelfCheckSafeChildHardened;
+exports.deriveSafeChildEd25519Hardened = deriveSafeChildEd25519Hardened;
+/**
+ * @prettier
+ *
+ * @experimental Shared safe child derivation for mint and sign.
+ *
+ * User child: hardened `m/<index>'` from the sequential `safe.derivationIndex[slot]`.
+ * Backup / BitGo children are soft-derived server-side at `m/<index>` (not here).
+ *
+ * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —
+ * that is the custody hashed path and cannot reproduce a safe child.
+ */
+const t = __importStar(require("io-ts"));
+const nacl = __importStar(require("tweetnacl"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const ed25519KeyDeriver_1 = require("./ed25519KeyDeriver");
+const codecs_1 = require("./codecs");
+const ed25519Pub_1 = require("./ed25519Pub");
+const MAX_BIP32_INDEX = 0x7fffffff;
+exports.DERIVED_FROM_PARENT_WITH_HARDENED_PATH = /^m\/(\d+)'$/;
+function parseSafeDerivationIndex(index) {
+    let idx;
+    if (typeof index === 'number') {
+        idx = index;
+    }
+    else if (/^\d+$/.test(index)) {
+        idx = Number(index);
+    }
+    else {
+        throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);
+    }
+    if (!Number.isInteger(idx) || idx < 0 || idx > MAX_BIP32_INDEX) {
+        throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);
+    }
+    return idx;
+}
+function getSafeHardenedDerivationPath(index) {
+    return `m/${parseSafeDerivationIndex(index)}'`;
+}
+exports.DerivedFromParentWithHardenedPath = t.brand(t.string, (s) => parseDerivedFromParentWithHardenedPathIndex(s) !== undefined, 'DerivedFromParentWithHardenedPath');
+function parseDerivedFromParentWithHardenedPathIndex(path) {
+    const match = exports.DERIVED_FROM_PARENT_WITH_HARDENED_PATH.exec(path);
+    if (!match) {
+        return undefined;
+    }
+    try {
+        return parseSafeDerivationIndex(match[1]);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseDerivedFromParentWithHardenedPath(path) {
+    const validated = (0, codecs_1.decodeWithCodec)(exports.DerivedFromParentWithHardenedPath, path, 'derivedFromParentWithHardenedPath');
+    const index = parseDerivedFromParentWithHardenedPathIndex(validated);
+    if (index === undefined) {
+        throw new Error(`Invalid derivedFromParentWithHardenedPath '${path}': expected m/<n>'`);
+    }
+    return index;
+}
+function childFromNode(child, derivationPath) {
+    if (!child.privateKey) {
+        throw new Error(`Failed to derive hardened safe child at ${derivationPath}`);
+    }
+    return {
+        prv: child.toBase58(),
+        pub: child.neutered().toBase58(),
+        derivationPath,
+    };
+}
+function deriveSafeChildHardenedFromXprv(rootXprv, index) {
+    const idx = parseSafeDerivationIndex(index);
+    const derivationPath = getSafeHardenedDerivationPath(idx);
+    return childFromNode(utxo_lib_1.bip32.fromBase58(rootXprv).deriveHardened(idx), derivationPath);
+}
+/** Re-derive and assert both results match before the child is registered. */
+function deriveAndSelfCheckSafeChildHardened(rootXprv, index) {
+    const first = deriveSafeChildHardenedFromXprv(rootXprv, index);
+    const second = deriveSafeChildHardenedFromXprv(rootXprv, index);
+    if (first.pub !== second.pub || first.prv !== second.prv) {
+        throw new Error(`Safe child self-check failed at ${first.derivationPath}: derivation was not deterministic`);
+    }
+    return first;
+}
+/**
+ * SLIP-0010 hardened derivation of a safe user child from an ed25519 root secret seed.
+ *
+ * `rootPrv` is a Stellar StrKey `S…` secret seed (what slot-④ `ed25519Multisig` user roots store).
+ * The derivation reuses the existing SLIP-0010 implementation {@link Ed25519KeyDeriver.derivePath}
+ * (hardened-only CKDPriv over the `ed25519 seed` HMAC master), then expands the resulting 32-byte
+ * child seed into a keypair with `nacl`. The child `pub` is a bare StrKey `G…`; the `prv` is the
+ * raw 32-byte child seed as hex (the seed input a signer needs).
+ *
+ * Unlike the secp256k1 path, ed25519 hardened derivation needs no chain code — the composite
+ * `pub‖chainCode` form is only for SOFT co-signer derivation and is not used here.
+ */
+function deriveSafeChildEd25519Hardened(rootPrv, index) {
+    const idx = parseSafeDerivationIndex(index);
+    const derivationPath = getSafeHardenedDerivationPath(idx);
+    const rawSeedHex = (0, ed25519Pub_1.decodeEd25519StrKeySecretSeed)(rootPrv).toString('hex');
+    const childSeed = ed25519KeyDeriver_1.Ed25519KeyDeriver.derivePath(derivationPath, rawSeedHex).key;
+    const keyPair = nacl.sign.keyPair.fromSeed(Uint8Array.from(childSeed));
+    const pub = (0, ed25519Pub_1.encodeEd25519StrKeyPublicKey)(Buffer.from(keyPair.publicKey));
+    return {
+        prv: Buffer.from(childSeed).toString('hex'),
+        pub,
+        derivationPath,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safeDerivation.js","sourceRoot":"","sources":["../../src/safeDerivation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * @experimental Shared safe child derivation for mint and sign.\n *\n * User child: hardened `m/<index>'` from the sequential `safe.derivationIndex[slot]`.\n * Backup / BitGo children are soft-derived server-side at `m/<index>` (not here).\n *\n * Do not use `derivedFromParentWithSeed` / `deriveKeyWithSeed` (`m/999999/a/b`) —\n * that is the custody hashed path and cannot reproduce a safe child.\n */\nimport * as t from 'io-ts';\nimport * as nacl from 'tweetnacl';\nimport { bip32, BIP32Interface } from '@bitgo-beta/utxo-lib';\nimport { Ed25519KeyDeriver } from './ed25519KeyDeriver';\nimport { decodeWithCodec } from './codecs';\nimport { decodeEd25519StrKeySecretSeed, encodeEd25519StrKeyPublicKey } from './ed25519Pub';\n\nconst MAX_BIP32_INDEX = 0x7fffffff;\nexport const DERIVED_FROM_PARENT_WITH_HARDENED_PATH = /^m\\/(\\d+)'$/;\n\nexport function parseSafeDerivationIndex(index: string | number): number {\n  let idx: number;\n  if (typeof index === 'number') {\n    idx = index;\n  } else if (/^\\d+$/.test(index)) {\n    idx = Number(index);\n  } else {\n    throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);\n  }\n  if (!Number.isInteger(idx) || idx < 0 || idx > MAX_BIP32_INDEX) {\n    throw new Error(`Invalid safe derivation index '${index}': expected a non-negative integer`);\n  }\n  return idx;\n}\n\nexport function getSafeHardenedDerivationPath(index: string | number): string {\n  return `m/${parseSafeDerivationIndex(index)}'`;\n}\n\nexport interface DerivedFromParentWithHardenedPathBrand {\n  readonly DerivedFromParentWithHardenedPath: unique symbol;\n}\n\nexport type DerivedFromParentWithHardenedPath = t.Branded<string, DerivedFromParentWithHardenedPathBrand>;\n\nexport const DerivedFromParentWithHardenedPath = t.brand(\n  t.string,\n  (s): s is DerivedFromParentWithHardenedPath => parseDerivedFromParentWithHardenedPathIndex(s) !== undefined,\n  'DerivedFromParentWithHardenedPath'\n);\n\nfunction parseDerivedFromParentWithHardenedPathIndex(path: string): number | undefined {\n  const match = DERIVED_FROM_PARENT_WITH_HARDENED_PATH.exec(path);\n  if (!match) {\n    return undefined;\n  }\n  try {\n    return parseSafeDerivationIndex(match[1]);\n  } catch {\n    return undefined;\n  }\n}\n\nexport function parseDerivedFromParentWithHardenedPath(path: string): number {\n  const validated = decodeWithCodec(DerivedFromParentWithHardenedPath, path, 'derivedFromParentWithHardenedPath');\n  const index = parseDerivedFromParentWithHardenedPathIndex(validated);\n  if (index === undefined) {\n    throw new Error(`Invalid derivedFromParentWithHardenedPath '${path}': expected m/<n>'`);\n  }\n  return index;\n}\n\nexport interface SafeHardenedChildKey {\n  prv: string;\n  pub: string;\n  derivationPath: string;\n}\n\nfunction childFromNode(child: BIP32Interface, derivationPath: string): SafeHardenedChildKey {\n  if (!child.privateKey) {\n    throw new Error(`Failed to derive hardened safe child at ${derivationPath}`);\n  }\n  return {\n    prv: child.toBase58(),\n    pub: child.neutered().toBase58(),\n    derivationPath,\n  };\n}\n\nexport function deriveSafeChildHardenedFromXprv(rootXprv: string, index: string | number): SafeHardenedChildKey {\n  const idx = parseSafeDerivationIndex(index);\n  const derivationPath = getSafeHardenedDerivationPath(idx);\n  return childFromNode(bip32.fromBase58(rootXprv).deriveHardened(idx), derivationPath);\n}\n\n/** Re-derive and assert both results match before the child is registered. */\nexport function deriveAndSelfCheckSafeChildHardened(rootXprv: string, index: string | number): SafeHardenedChildKey {\n  const first = deriveSafeChildHardenedFromXprv(rootXprv, index);\n  const second = deriveSafeChildHardenedFromXprv(rootXprv, index);\n  if (first.pub !== second.pub || first.prv !== second.prv) {\n    throw new Error(`Safe child self-check failed at ${first.derivationPath}: derivation was not deterministic`);\n  }\n  return first;\n}\n\n/**\n * SLIP-0010 hardened derivation of a safe user child from an ed25519 root secret seed.\n *\n * `rootPrv` is a Stellar StrKey `S…` secret seed (what slot-④ `ed25519Multisig` user roots store).\n * The derivation reuses the existing SLIP-0010 implementation {@link Ed25519KeyDeriver.derivePath}\n * (hardened-only CKDPriv over the `ed25519 seed` HMAC master), then expands the resulting 32-byte\n * child seed into a keypair with `nacl`. The child `pub` is a bare StrKey `G…`; the `prv` is the\n * raw 32-byte child seed as hex (the seed input a signer needs).\n *\n * Unlike the secp256k1 path, ed25519 hardened derivation needs no chain code — the composite\n * `pub‖chainCode` form is only for SOFT co-signer derivation and is not used here.\n */\nexport function deriveSafeChildEd25519Hardened(rootPrv: string, index: string | number): SafeHardenedChildKey {\n  const idx = parseSafeDerivationIndex(index);\n  const derivationPath = getSafeHardenedDerivationPath(idx);\n  const rawSeedHex = decodeEd25519StrKeySecretSeed(rootPrv).toString('hex');\n  const childSeed = Ed25519KeyDeriver.derivePath(derivationPath, rawSeedHex).key;\n  const keyPair = nacl.sign.keyPair.fromSeed(Uint8Array.from(childSeed));\n  const pub = encodeEd25519StrKeyPublicKey(Buffer.from(keyPair.publicKey));\n  return {\n    prv: Buffer.from(childSeed).toString('hex'),\n    pub,\n    derivationPath,\n  };\n}\n"]}

package/dist/src/safeSlot.d.ts

@@ -0,0 +1,7 @@
+import type { RootKeyType } from '@bitgo/public-types';
+type OnchainSafeRootKeySlot = Extract<RootKeyType, 'secp256k1Multisig' | 'ed25519Multisig'>;
+type TssSafeRootKeySlot = Extract<RootKeyType, 'ecdsaMpc'>;
+export declare function onchainSlotForCoin(chain: string): OnchainSafeRootKeySlot;
+export declare function tssSlotForCoin(chain: string): TssSafeRootKeySlot;
+export {};
+//# sourceMappingURL=safeSlot.d.ts.map

package/dist/src/safeSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeSlot.d.ts","sourceRoot":"","sources":["../../src/safeSlot.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,KAAK,sBAAsB,GAAG,OAAO,CAAC,WAAW,EAAE,mBAAmB,GAAG,iBAAiB,CAAC,CAAC;AAC5F,KAAK,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;AAE3D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,CASxE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAShE"}

package/dist/src/safeSlot.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onchainSlotForCoin = onchainSlotForCoin;
+exports.tssSlotForCoin = tssSlotForCoin;
+/**
+ * @prettier
+ *
+ * @experimental Shared safe slot-for-coin mapping.
+ *
+ * Maps a coin chain + minting model to the safe root slot that derives it. The slot
+ * is a signing scheme, not a coin: slot ① secp256k1Multisig serves UTXO + XRP + TRX + …,
+ * slot ④ ed25519Multisig serves ALGO/XLM/HBAR, and ecdsaMpc serves TSS coins.
+ *
+ * The multisigType-vs-coin validation stays in sdk-core (it needs IBaseCoin); these
+ * functions take only the chain so this leaf never imports sdk-core.
+ */
+const statics_1 = require("@bitgo-beta/statics");
+function onchainSlotForCoin(chain) {
+    const curve = statics_1.coins.get(chain).primaryKeyCurve;
+    if (curve === statics_1.KeyCurve.Secp256k1) {
+        return 'secp256k1Multisig';
+    }
+    if (curve === statics_1.KeyCurve.Ed25519) {
+        return 'ed25519Multisig';
+    }
+    throw new Error(`Coin '${chain}' is not supported for safe wallet minting`);
+}
+function tssSlotForCoin(chain) {
+    const curve = statics_1.coins.get(chain).primaryKeyCurve;
+    if (curve === statics_1.KeyCurve.Secp256k1) {
+        return 'ecdsaMpc';
+    }
+    if (curve === statics_1.KeyCurve.Ed25519) {
+        throw new Error('ed25519 MPC safe wallet minting is not yet supported');
+    }
+    throw new Error(`Coin '${chain}' is not supported for safe wallet minting`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZVNsb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2FmZVNsb3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFrQkEsZ0RBU0M7QUFFRCx3Q0FTQztBQXRDRDs7Ozs7Ozs7Ozs7R0FXRztBQUNILGlEQUFzRDtBQU10RCxTQUFnQixrQkFBa0IsQ0FBQyxLQUFhO0lBQzlDLE1BQU0sS0FBSyxHQUFHLGVBQUssQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsZUFBZSxDQUFDO0lBQy9DLElBQUksS0FBSyxLQUFLLGtCQUFRLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDakMsT0FBTyxtQkFBbUIsQ0FBQztJQUM3QixDQUFDO0lBQ0QsSUFBSSxLQUFLLEtBQUssa0JBQVEsQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUMvQixPQUFPLGlCQUFpQixDQUFDO0lBQzNCLENBQUM7SUFDRCxNQUFNLElBQUksS0FBSyxDQUFDLFNBQVMsS0FBSyw0Q0FBNEMsQ0FBQyxDQUFDO0FBQzlFLENBQUM7QUFFRCxTQUFnQixjQUFjLENBQUMsS0FBYTtJQUMxQyxNQUFNLEtBQUssR0FBRyxlQUFLLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLGVBQWUsQ0FBQztJQUMvQyxJQUFJLEtBQUssS0FBSyxrQkFBUSxDQUFDLFNBQVMsRUFBRSxDQUFDO1FBQ2pDLE9BQU8sVUFBVSxDQUFDO0lBQ3BCLENBQUM7SUFDRCxJQUFJLEtBQUssS0FBSyxrQkFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQy9CLE1BQU0sSUFBSSxLQUFLLENBQUMsc0RBQXNELENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyxTQUFTLEtBQUssNENBQTRDLENBQUMsQ0FBQztBQUM5RSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcHJldHRpZXJcbiAqXG4gKiBAZXhwZXJpbWVudGFsIFNoYXJlZCBzYWZlIHNsb3QtZm9yLWNvaW4gbWFwcGluZy5cbiAqXG4gKiBNYXBzIGEgY29pbiBjaGFpbiArIG1pbnRpbmcgbW9kZWwgdG8gdGhlIHNhZmUgcm9vdCBzbG90IHRoYXQgZGVyaXZlcyBpdC4gVGhlIHNsb3RcbiAqIGlzIGEgc2lnbmluZyBzY2hlbWUsIG5vdCBhIGNvaW46IHNsb3Qg4pGgIHNlY3AyNTZrMU11bHRpc2lnIHNlcnZlcyBVVFhPICsgWFJQICsgVFJYICsg4oCmLFxuICogc2xvdCDikaMgZWQyNTUxOU11bHRpc2lnIHNlcnZlcyBBTEdPL1hMTS9IQkFSLCBhbmQgZWNkc2FNcGMgc2VydmVzIFRTUyBjb2lucy5cbiAqXG4gKiBUaGUgbXVsdGlzaWdUeXBlLXZzLWNvaW4gdmFsaWRhdGlvbiBzdGF5cyBpbiBzZGstY29yZSAoaXQgbmVlZHMgSUJhc2VDb2luKTsgdGhlc2VcbiAqIGZ1bmN0aW9ucyB0YWtlIG9ubHkgdGhlIGNoYWluIHNvIHRoaXMgbGVhZiBuZXZlciBpbXBvcnRzIHNkay1jb3JlLlxuICovXG5pbXBvcnQgeyBjb2lucywgS2V5Q3VydmUgfSBmcm9tICdAYml0Z28tYmV0YS9zdGF0aWNzJztcbmltcG9ydCB0eXBlIHsgUm9vdEtleVR5cGUgfSBmcm9tICdAYml0Z28vcHVibGljLXR5cGVzJztcblxudHlwZSBPbmNoYWluU2FmZVJvb3RLZXlTbG90ID0gRXh0cmFjdDxSb290S2V5VHlwZSwgJ3NlY3AyNTZrMU11bHRpc2lnJyB8ICdlZDI1NTE5TXVsdGlzaWcnPjtcbnR5cGUgVHNzU2FmZVJvb3RLZXlTbG90ID0gRXh0cmFjdDxSb290S2V5VHlwZSwgJ2VjZHNhTXBjJz47XG5cbmV4cG9ydCBmdW5jdGlvbiBvbmNoYWluU2xvdEZvckNvaW4oY2hhaW46IHN0cmluZyk6IE9uY2hhaW5TYWZlUm9vdEtleVNsb3Qge1xuICBjb25zdCBjdXJ2ZSA9IGNvaW5zLmdldChjaGFpbikucHJpbWFyeUtleUN1cnZlO1xuICBpZiAoY3VydmUgPT09IEtleUN1cnZlLlNlY3AyNTZrMSkge1xuICAgIHJldHVybiAnc2VjcDI1NmsxTXVsdGlzaWcnO1xuICB9XG4gIGlmIChjdXJ2ZSA9PT0gS2V5Q3VydmUuRWQyNTUxOSkge1xuICAgIHJldHVybiAnZWQyNTUxOU11bHRpc2lnJztcbiAgfVxuICB0aHJvdyBuZXcgRXJyb3IoYENvaW4gJyR7Y2hhaW59JyBpcyBub3Qgc3VwcG9ydGVkIGZvciBzYWZlIHdhbGxldCBtaW50aW5nYCk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiB0c3NTbG90Rm9yQ29pbihjaGFpbjogc3RyaW5nKTogVHNzU2FmZVJvb3RLZXlTbG90IHtcbiAgY29uc3QgY3VydmUgPSBjb2lucy5nZXQoY2hhaW4pLnByaW1hcnlLZXlDdXJ2ZTtcbiAgaWYgKGN1cnZlID09PSBLZXlDdXJ2ZS5TZWNwMjU2azEpIHtcbiAgICByZXR1cm4gJ2VjZHNhTXBjJztcbiAgfVxuICBpZiAoY3VydmUgPT09IEtleUN1cnZlLkVkMjU1MTkpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ2VkMjU1MTkgTVBDIHNhZmUgd2FsbGV0IG1pbnRpbmcgaXMgbm90IHlldCBzdXBwb3J0ZWQnKTtcbiAgfVxuICB0aHJvdyBuZXcgRXJyb3IoYENvaW4gJyR7Y2hhaW59JyBpcyBub3Qgc3VwcG9ydGVkIGZvciBzYWZlIHdhbGxldCBtaW50aW5nYCk7XG59XG4iXX0=