@bitgo-beta/sdk-core 8.2.1-beta.1905 → 8.2.1-beta.1907

package/dist/src/bitgo/defi/defiVault.d.ts

@@ -1,7 +1,5 @@
-/**
- * @prettier
- */
-import { DefiOperation, DefiOperationListResult, DepositResult, DepositToVaultOptions, GetOperationOptions, IDefiVault, ListOperationsOptions, ResumeDepositOptions } from './iDefiVault';
+import { GetVaultResponse } from '@bitgo/public-types';
+import { DefiOperation, DefiOperationListResult, DepositResult, DepositToVaultOptions, GetOperationOptions, GetVaultConfigOptions, IDefiVault, ListOperationsOptions, ResumeDepositOptions } from './iDefiVault';
 import { IWallet } from '../wallet';
 /**
  * Error thrown when a concurrent active deposit already exists for the (wallet, vault) pair.
@@ -25,13 +23,17 @@ export declare class DefiVault implements IDefiVault {
     private readonly wallet;
     private readonly bitgo;
     constructor(wallet: IWallet);
+    /**
+     * Fetch vault config from defi-service. Used internally to determine
+     * which deposit path to take (Concrete vs Morpho).
+     */
+    getVaultConfig(params: GetVaultConfigOptions): Promise<GetVaultResponse>;
     /**
      * Deposit an amount of underlying asset into a vault.
      *
-     * Internally issues two sendMany calls (approve + deposit) and returns the
-     * operationId that links them. If the deposit sendMany fails after
-     * the approve succeeds, the error propagates — the server-side reconciler
-     * handles orphaned approvals.
+     * Dispatches to the concrete or morpho path based on vault provider.
+     * The concrete path returns a pendingApproval (custodial wallet).
+     * The morpho path issues two sendMany calls (approve + deposit).
      *
      * @param params.vaultId - DeFi-service vault identifier
      * @param params.amount - amount in base units of the underlying asset
@@ -39,6 +41,17 @@ export declare class DefiVault implements IDefiVault {
      * @param params.walletPassphrase - required for hot wallets, omit for custody
      */
     depositToVault(params: DepositToVaultOptions): Promise<DepositResult>;
+    /**
+     * Concrete BTC vault deposit path. The client BTC wallet is custodial, so
+     * sendMany returns a pendingApproval rather than a signed transfer.
+     * No recipients are sent — WP resolves the escrow destination server-side.
+     */
+    private depositToConcreteVault;
+    /**
+     * Morpho vault deposit path. Issues two sendMany calls (approve + deposit)
+     * and returns the operationId that links them.
+     */
+    private depositToMorphoVault;
     /**
      * Resume a partially-completed deposit. Call this when the SDK process died
      * between the approve and deposit txRequest creation.
@@ -82,6 +95,12 @@ export declare class DefiVault implements IDefiVault {
      * populates the intent.
      */
     private extractOperationId;
+    /**
+     * Extracts {@link ConcreteDepositResult} from a custodial sendMany response.
+     * Concrete BTC deposits return a `pendingApproval` instead of a txRequest —
+     * throws if `pendingApproval.id` is absent, indicating an unexpected shape.
+     */
+    private extractConcreteDepositResult;
     private operationsUrl;
 }
 //# sourceMappingURL=defiVault.d.ts.map

package/dist/src/bitgo/defi/defiVault.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defiVault.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/defi/defiVault.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,UAAU,EACV,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,SAAgB,WAAW,EAAE,MAAM,CAAC;gBAExB,WAAW,EAAE,MAAM;CAKhC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,SAAU,YAAW,UAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;gBAEtB,MAAM,EAAE,OAAO;IAK3B;;;;;;;;;;;;OAYG;IACG,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,aAAa,CAAC;IA2D3E;;;;;;OAMG;IACG,aAAa,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC;IAoCzE;;;;OAIG;IACG,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;IAQvE;;;;;;;;OAQG;IACG,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkBrF;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;IA0B1B,OAAO,CAAC,aAAa;CAGtB"}
+{"version":3,"file":"defiVault.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/defi/defiVault.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAiB,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAGL,aAAa,EACb,uBAAuB,EACvB,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,UAAU,EACV,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,SAAgB,WAAW,EAAE,MAAM,CAAC;gBAExB,WAAW,EAAE,MAAM;CAKhC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,SAAU,YAAW,UAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;gBAEtB,MAAM,EAAE,OAAO;IAK3B;;;OAGG;IACG,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAU9E;;;;;;;;;;;OAWG;IACG,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,aAAa,CAAC;IAmB3E;;;;OAIG;YACW,sBAAsB;IAcpC;;;OAGG;YACW,oBAAoB;IAoDlC;;;;;;OAMG;IACG,aAAa,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC;IAoCzE;;;;OAIG;IACG,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC;IAQvE;;;;;;;;OAQG;IACG,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkBrF;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;IA0B1B;;;;OAIG;IACH,OAAO,CAAC,4BAA4B;IAWpC,OAAO,CAAC,aAAa;CAGtB"}

package/dist/src/bitgo/defi/defiVault.js

@@ -1,6 +1,45 @@
 "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.DefiVault = exports.ActiveOperationExistsError = void 0;
+/**
+ * @prettier
+ */
+const t = __importStar(require("io-ts"));
+const public_types_1 = require("@bitgo/public-types");
+const utils_1 = require("../utils");
 /**
  * Error thrown when a concurrent active deposit already exists for the (wallet, vault) pair.
  */
@@ -28,13 +67,25 @@ class DefiVault {
         this.wallet = wallet;
         this.bitgo = wallet.bitgo;
     }
+    /**
+     * Fetch vault config from defi-service. Used internally to determine
+     * which deposit path to take (Concrete vs Morpho).
+     */
+    async getVaultConfig(params) {
+        if (!params.vaultId) {
+            throw new Error('vaultId is required');
+        }
+        const raw = await this.bitgo
+            .get(this.bitgo.microservicesUrl(`/api/defi-service/v1/vaults/${params.vaultId}`))
+            .result();
+        return (0, utils_1.decodeWithCodec)(public_types_1.GetVaultResponse, raw, 'getVaultConfig');
+    }
     /**
      * Deposit an amount of underlying asset into a vault.
      *
-     * Internally issues two sendMany calls (approve + deposit) and returns the
-     * operationId that links them. If the deposit sendMany fails after
-     * the approve succeeds, the error propagates — the server-side reconciler
-     * handles orphaned approvals.
+     * Dispatches to the concrete or morpho path based on vault provider.
+     * The concrete path returns a pendingApproval (custodial wallet).
+     * The morpho path issues two sendMany calls (approve + deposit).
      *
      * @param params.vaultId - DeFi-service vault identifier
      * @param params.amount - amount in base units of the underlying asset
@@ -48,6 +99,39 @@ class DefiVault {
         if (!params.amount) {
             throw new Error('amount is required');
         }
+        const config = await this.getVaultConfig({ vaultId: params.vaultId });
+        if (config.protocol === public_types_1.VaultProtocol.CONCRETE_BTCCX) {
+            return this.depositToConcreteVault(params);
+        }
+        else if (config.protocol === public_types_1.VaultProtocol.MORPHO) {
+            return this.depositToMorphoVault(params);
+        }
+        else {
+            throw new Error(`Unsupported vault protocol: ${config.protocol}`);
+        }
+    }
+    /**
+     * Concrete BTC vault deposit path. The client BTC wallet is custodial, so
+     * sendMany returns a pendingApproval rather than a signed transfer.
+     * No recipients are sent — WP resolves the escrow destination server-side.
+     */
+    async depositToConcreteVault(params) {
+        const sendManyResult = await this.wallet.sendMany({
+            type: 'defi-deposit',
+            defiParams: {
+                vaultId: params.vaultId,
+                amount: params.amount,
+                actionType: 'defi-deposit',
+            },
+            ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),
+        });
+        return this.extractConcreteDepositResult(sendManyResult);
+    }
+    /**
+     * Morpho vault deposit path. Issues two sendMany calls (approve + deposit)
+     * and returns the operationId that links them.
+     */
+    async depositToMorphoVault(params) {
         // TODO(CGD-1709): Re-enable active operation pre-flight check once the
         // defi-service operations endpoint is deployed and returning active state.
         // const activeOps: DefiOperationListResult = await this.bitgo
@@ -217,9 +301,24 @@ class DefiVault {
         const intent = txRequest.intent;
         return intent?.operationId;
     }
+    /**
+     * Extracts {@link ConcreteDepositResult} from a custodial sendMany response.
+     * Concrete BTC deposits return a `pendingApproval` instead of a txRequest —
+     * throws if `pendingApproval.id` is absent, indicating an unexpected shape.
+     */
+    extractConcreteDepositResult(sendManyResult) {
+        const SendManyConcreteResponse = t.type({
+            pendingApproval: t.intersection([t.type({ id: t.string }), t.partial({ state: t.string })]),
+        });
+        const decoded = (0, utils_1.decodeWithCodec)(SendManyConcreteResponse, sendManyResult, 'defi-deposit sendMany response');
+        return {
+            pendingApprovalId: decoded.pendingApproval.id,
+            state: decoded.pendingApproval.state ?? 'awaitingSignature',
+        };
+    }
     operationsUrl() {
         return `/api/defi-service/v1/wallets/${this.wallet.id()}/operations`;
     }
 }
 exports.DefiVault = DefiVault;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defiVault.js","sourceRoot":"","sources":["../../../../src/bitgo/defi/defiVault.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport {\n  DefiOperation,\n  DefiOperationListResult,\n  DepositResult,\n  DepositToVaultOptions,\n  GetOperationOptions,\n  IDefiVault,\n  ListOperationsOptions,\n  ResumeDepositOptions,\n} from './iDefiVault';\nimport { IWallet } from '../wallet';\nimport { BitGoBase } from '../bitgoBase';\n\n/**\n * Error thrown when a concurrent active deposit already exists for the (wallet, vault) pair.\n */\nexport class ActiveOperationExistsError extends Error {\n  public readonly operationId: string;\n\n  constructor(operationId: string) {\n    super(`An active deposit operation already exists: ${operationId}`);\n    this.name = 'ActiveOperationExistsError';\n    this.operationId = operationId;\n  }\n}\n\n/**\n * Orchestrates ERC-4626 vault deposit and withdraw flows for a wallet.\n *\n * Exposed as `wallet.defi` on the Wallet class. See TDD §6.3.1 for the full\n * design: the SDK sequences two sendMany calls (approve + deposit) and\n * returns an operationId that the UI uses for status tracking and recovery.\n *\n * Uses wallet.sendMany() under the hood so that both custody wallets\n * (txRequest creation only) and hot wallets (create + sign + broadcast)\n * are handled by the existing infrastructure.\n */\nexport class DefiVault implements IDefiVault {\n  private readonly wallet: IWallet;\n  private readonly bitgo: BitGoBase;\n\n  constructor(wallet: IWallet) {\n    this.wallet = wallet;\n    this.bitgo = wallet.bitgo;\n  }\n\n  /**\n   * Deposit an amount of underlying asset into a vault.\n   *\n   * Internally issues two sendMany calls (approve + deposit) and returns the\n   * operationId that links them. If the deposit sendMany fails after\n   * the approve succeeds, the error propagates — the server-side reconciler\n   * handles orphaned approvals.\n   *\n   * @param params.vaultId - DeFi-service vault identifier\n   * @param params.amount - amount in base units of the underlying asset\n   * @param params.clientIdempotencyKey - optional client idempotency key\n   * @param params.walletPassphrase - required for hot wallets, omit for custody\n   */\n  async depositToVault(params: DepositToVaultOptions): Promise<DepositResult> {\n    if (!params.vaultId) {\n      throw new Error('vaultId is required');\n    }\n    if (!params.amount) {\n      throw new Error('amount is required');\n    }\n\n    // TODO(CGD-1709): Re-enable active operation pre-flight check once the\n    // defi-service operations endpoint is deployed and returning active state.\n    // const activeOps: DefiOperationListResult = await this.bitgo\n    //   .get(this.bitgo.microservicesUrl(this.operationsUrl()))\n    //   .query({ vaultId: params.vaultId, state: 'active' })\n    //   .result();\n    //\n    // if (activeOps.items && activeOps.items.length > 0) {\n    //   throw new ActiveOperationExistsError(activeOps.items[0].operationId);\n    // }\n\n    // Step 1: Approve txRequest via sendMany\n    const approveResult = await this.wallet.sendMany({\n      type: 'defiApprove',\n      defiParams: {\n        vaultId: params.vaultId,\n        amount: params.amount,\n        ...(params.clientIdempotencyKey ? { clientIdempotencyKey: params.clientIdempotencyKey } : {}),\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n\n    const approveTxRequestId = this.extractTxRequestId(approveResult);\n    const operationId = this.extractOperationId(approveResult);\n\n    if (!operationId) {\n      throw new Error('operationId not found in approve txRequest response');\n    }\n\n    // Step 2: Deposit txRequest via sendMany\n    const depositResult = await this.wallet.sendMany({\n      type: 'defiDeposit',\n      defiParams: {\n        vaultId: params.vaultId,\n        amount: params.amount,\n        operationId,\n        ...(params.clientIdempotencyKey ? { clientIdempotencyKey: params.clientIdempotencyKey } : {}),\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n    const depositTxRequestId = this.extractTxRequestId(depositResult);\n\n    return {\n      operationId,\n      txRequestIds: {\n        approve: approveTxRequestId,\n        deposit: depositTxRequestId,\n      },\n    };\n  }\n\n  /**\n   * Resume a partially-completed deposit. Call this when the SDK process died\n   * between the approve and deposit txRequest creation.\n   *\n   * @param params.operationId - the operationId from the original depositToVault call\n   * @param params.walletPassphrase - required for hot wallets, omit for custody\n   */\n  async resumeDeposit(params: ResumeDepositOptions): Promise<DepositResult> {\n    if (!params.operationId) {\n      throw new Error('operationId is required');\n    }\n\n    // Fetch the operation to get the vault and amount details\n    const operation = await this.getOperation({ operationId: params.operationId });\n\n    if (operation.associatedTxRequestId) {\n      throw new Error('Deposit txRequest already exists for this operation; nothing to resume');\n    }\n\n    if (!operation.txRequestId) {\n      throw new Error('Approve txRequest not found for this operation; cannot resume');\n    }\n\n    // Issue the deposit txRequest using the existing operation's details\n    const depositResult = await this.wallet.sendMany({\n      type: 'defiDeposit',\n      defiParams: {\n        vaultId: operation.vaultId,\n        amount: operation.assetAmount,\n        operationId: params.operationId,\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n\n    return {\n      operationId: params.operationId,\n      txRequestIds: {\n        approve: operation.txRequestId,\n        deposit: this.extractTxRequestId(depositResult),\n      },\n    };\n  }\n\n  /**\n   * Get the current state of a DeFi operation.\n   *\n   * @param params.operationId - the operation to retrieve\n   */\n  async getOperation(params: GetOperationOptions): Promise<DefiOperation> {\n    if (!params.operationId) {\n      throw new Error('operationId is required');\n    }\n\n    return await this.bitgo.get(this.bitgo.microservicesUrl(this.operationsUrl() + '/' + params.operationId)).result();\n  }\n\n  /**\n   * List operations for a vault filtered by walletId.\n   *\n   * @param params.vaultId - vault to list operations for\n   * @param params.state - optional state filter\n   * @param params.type - optional type filter (DEPOSIT | WITHDRAW)\n   * @param params.limit - page size\n   * @param params.cursor - pagination cursor\n   */\n  async listOperations(params: ListOperationsOptions): Promise<DefiOperationListResult> {\n    if (!params.vaultId) {\n      throw new Error('vaultId is required');\n    }\n\n    const query: Record<string, string | number> = {\n      vaultId: params.vaultId,\n    };\n    if (params.state) query.state = params.state;\n    if (params.type) query.type = params.type;\n    if (params.limit) query.limit = params.limit;\n    if (params.cursor) query.cursor = params.cursor;\n\n    return await this.bitgo.get(this.bitgo.microservicesUrl(this.operationsUrl())).query(query).result();\n  }\n\n  // ── Internal helpers ────────────────────────────────────────────────\n\n  /**\n   * Extract txRequestId from a sendMany result.\n   * sendMany returns different shapes depending on wallet type:\n   * - TSS full: { txRequest: { txRequestId } } or { pendingApproval, txRequest }\n   * - TSS lite: result from tssUtils.sendTxRequest\n   */\n  private extractTxRequestId(sendManyResult: Record<string, unknown>): string {\n    const txRequest = sendManyResult.txRequest as Record<string, unknown> | undefined;\n    if (txRequest?.txRequestId) {\n      return txRequest.txRequestId as string;\n    }\n    if (sendManyResult.txRequestId) {\n      return sendManyResult.txRequestId as string;\n    }\n    throw new Error('txRequestId not found in sendMany response');\n  }\n\n  /**\n   * Extract operationId from a sendMany result.\n   *\n   * The WP writes the defi-service-minted operationId into the built\n   * transaction's `coinSpecific` (alongside `assignedNonce`), not into the\n   * intent. Read it from there: the `full` apiVersion surfaces it at\n   * `transactions[0].unsignedTx.coinSpecific.operationId`, the `lite` version\n   * at `unsignedTxs[0].coinSpecific.operationId`. Fall back to\n   * `intent.operationId` for forward-compat in case the WP later also\n   * populates the intent.\n   */\n  private extractOperationId(sendManyResult: Record<string, unknown>): string | undefined {\n    const txRequest = sendManyResult.txRequest as Record<string, unknown> | undefined;\n    if (!txRequest) {\n      return undefined;\n    }\n\n    // full apiVersion: transactions[0].unsignedTx.coinSpecific.operationId\n    const transactions = txRequest.transactions as Array<Record<string, unknown>> | undefined;\n    const fullUnsignedTx = transactions?.[0]?.unsignedTx as Record<string, unknown> | undefined;\n    const fullCoinSpecific = fullUnsignedTx?.coinSpecific as Record<string, unknown> | undefined;\n    if (fullCoinSpecific?.operationId) {\n      return fullCoinSpecific.operationId as string;\n    }\n\n    // lite apiVersion: unsignedTxs[0].coinSpecific.operationId\n    const unsignedTxs = txRequest.unsignedTxs as Array<Record<string, unknown>> | undefined;\n    const liteCoinSpecific = unsignedTxs?.[0]?.coinSpecific as Record<string, unknown> | undefined;\n    if (liteCoinSpecific?.operationId) {\n      return liteCoinSpecific.operationId as string;\n    }\n\n    // forward-compat: intent.operationId (in case the WP later populates the intent)\n    const intent = txRequest.intent as Record<string, unknown> | undefined;\n    return intent?.operationId as string | undefined;\n  }\n\n  private operationsUrl(): string {\n    return `/api/defi-service/v1/wallets/${this.wallet.id()}/operations`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defiVault.js","sourceRoot":"","sources":["../../../../src/bitgo/defi/defiVault.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,yCAA2B;AAC3B,sDAAsE;AAgBtE,oCAA2C;AAE3C;;GAEG;AACH,MAAa,0BAA2B,SAAQ,KAAK;IAGnD,YAAY,WAAmB;QAC7B,KAAK,CAAC,+CAA+C,WAAW,EAAE,CAAC,CAAC;QACpE,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAC;QACzC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACjC,CAAC;CACF;AARD,gEAQC;AAED;;;;;;;;;;GAUG;AACH,MAAa,SAAS;IAIpB,YAAY,MAAe;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc,CAAC,MAA6B;QAChD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK;aACzB,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,+BAA+B,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;aACjF,MAAM,EAAE,CAAC;QACZ,OAAO,IAAA,uBAAe,EAAC,+BAAgB,EAAE,GAAG,EAAE,gBAAgB,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,cAAc,CAAC,MAA6B;QAChD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACxC,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QAEtE,IAAI,MAAM,CAAC,QAAQ,KAAK,4BAAa,CAAC,cAAc,EAAE,CAAC;YACrD,OAAO,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;QAC7C,CAAC;aAAM,IAAI,MAAM,CAAC,QAAQ,KAAK,4BAAa,CAAC,MAAM,EAAE,CAAC;YACpD,OAAO,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,+BAA+B,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,sBAAsB,CAAC,MAA6B;QAChE,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;YAChD,IAAI,EAAE,cAAc;YACpB,UAAU,EAAE;gBACV,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,UAAU,EAAE,cAAc;aAC3B;YACD,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAClF,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,4BAA4B,CAAC,cAAc,CAAC,CAAC;IAC3D,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,oBAAoB,CAAC,MAA6B;QAC9D,uEAAuE;QACvE,2EAA2E;QAC3E,8DAA8D;QAC9D,4DAA4D;QAC5D,yDAAyD;QACzD,eAAe;QACf,EAAE;QACF,uDAAuD;QACvD,0EAA0E;QAC1E,IAAI;QAEJ,yCAAyC;QACzC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;YAC/C,IAAI,EAAE,aAAa;YACnB,UAAU,EAAE;gBACV,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,oBAAoB,EAAE,MAAM,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC9F;YACD,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAClF,CAAC,CAAC;QAEH,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;QAClE,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;QAE3D,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,yCAAyC;QACzC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;YAC/C,IAAI,EAAE,aAAa;YACnB,UAAU,EAAE;gBACV,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,WAAW;gBACX,GAAG,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,oBAAoB,EAAE,MAAM,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC9F;YACD,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAClF,CAAC,CAAC;QACH,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;QAElE,OAAO;YACL,WAAW;YACX,YAAY,EAAE;gBACZ,OAAO,EAAE,kBAAkB;gBAC3B,OAAO,EAAE,kBAAkB;aAC5B;SACF,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,aAAa,CAAC,MAA4B;QAC9C,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QAED,0DAA0D;QAC1D,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;QAE/E,IAAI,SAAS,CAAC,qBAAqB,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;QAC5F,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACnF,CAAC;QAED,qEAAqE;QACrE,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;YAC/C,IAAI,EAAE,aAAa;YACnB,UAAU,EAAE;gBACV,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,MAAM,EAAE,SAAS,CAAC,WAAW;gBAC7B,WAAW,EAAE,MAAM,CAAC,WAAW;aAChC;YACD,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAClF,CAAC,CAAC;QAEH,OAAO;YACL,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,YAAY,EAAE;gBACZ,OAAO,EAAE,SAAS,CAAC,WAAW;gBAC9B,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC;aAChD;SACF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,MAA2B;QAC5C,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,GAAG,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACrH,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,cAAc,CAAC,MAA6B;QAChD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QAED,MAAM,KAAK,GAAoC;YAC7C,OAAO,EAAE,MAAM,CAAC,OAAO;SACxB,CAAC;QACF,IAAI,MAAM,CAAC,KAAK;YAAE,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC7C,IAAI,MAAM,CAAC,IAAI;YAAE,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QAC1C,IAAI,MAAM,CAAC,KAAK;YAAE,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC7C,IAAI,MAAM,CAAC,MAAM;YAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAEhD,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;IACvG,CAAC;IAED,uEAAuE;IAEvE;;;;;OAKG;IACK,kBAAkB,CAAC,cAAuC;QAChE,MAAM,SAAS,GAAG,cAAc,CAAC,SAAgD,CAAC;QAClF,IAAI,SAAS,EAAE,WAAW,EAAE,CAAC;YAC3B,OAAO,SAAS,CAAC,WAAqB,CAAC;QACzC,CAAC;QACD,IAAI,cAAc,CAAC,WAAW,EAAE,CAAC;YAC/B,OAAO,cAAc,CAAC,WAAqB,CAAC;QAC9C,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;;;;;OAUG;IACK,kBAAkB,CAAC,cAAuC;QAChE,MAAM,SAAS,GAAG,cAAc,CAAC,SAAgD,CAAC;QAClF,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,uEAAuE;QACvE,MAAM,YAAY,GAAG,SAAS,CAAC,YAA0D,CAAC;QAC1F,MAAM,cAAc,GAAG,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,UAAiD,CAAC;QAC5F,MAAM,gBAAgB,GAAG,cAAc,EAAE,YAAmD,CAAC;QAC7F,IAAI,gBAAgB,EAAE,WAAW,EAAE,CAAC;YAClC,OAAO,gBAAgB,CAAC,WAAqB,CAAC;QAChD,CAAC;QAED,2DAA2D;QAC3D,MAAM,WAAW,GAAG,SAAS,CAAC,WAAyD,CAAC;QACxF,MAAM,gBAAgB,GAAG,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,YAAmD,CAAC;QAC/F,IAAI,gBAAgB,EAAE,WAAW,EAAE,CAAC;YAClC,OAAO,gBAAgB,CAAC,WAAqB,CAAC;QAChD,CAAC;QAED,iFAAiF;QACjF,MAAM,MAAM,GAAG,SAAS,CAAC,MAA6C,CAAC;QACvE,OAAO,MAAM,EAAE,WAAiC,CAAC;IACnD,CAAC;IAED;;;;OAIG;IACK,4BAA4B,CAAC,cAAuC;QAC1E,MAAM,wBAAwB,GAAG,CAAC,CAAC,IAAI,CAAC;YACtC,eAAe,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;SAC5F,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,IAAA,uBAAe,EAAC,wBAAwB,EAAE,cAAc,EAAE,gCAAgC,CAAC,CAAC;QAC5G,OAAO;YACL,iBAAiB,EAAE,OAAO,CAAC,eAAe,CAAC,EAAE;YAC7C,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,KAAK,IAAI,mBAAmB;SAC5D,CAAC;IACJ,CAAC;IAEO,aAAa;QACnB,OAAO,gCAAgC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,aAAa,CAAC;IACvE,CAAC;CACF;AA7RD,8BA6RC","sourcesContent":["/**\n * @prettier\n */\nimport * as t from 'io-ts';\nimport { GetVaultResponse, VaultProtocol } from '@bitgo/public-types';\nimport {\n  ConcreteDepositResult,\n  MorphoDepositResult,\n  DefiOperation,\n  DefiOperationListResult,\n  DepositResult,\n  DepositToVaultOptions,\n  GetOperationOptions,\n  GetVaultConfigOptions,\n  IDefiVault,\n  ListOperationsOptions,\n  ResumeDepositOptions,\n} from './iDefiVault';\nimport { IWallet } from '../wallet';\nimport { BitGoBase } from '../bitgoBase';\nimport { decodeWithCodec } from '../utils';\n\n/**\n * Error thrown when a concurrent active deposit already exists for the (wallet, vault) pair.\n */\nexport class ActiveOperationExistsError extends Error {\n  public readonly operationId: string;\n\n  constructor(operationId: string) {\n    super(`An active deposit operation already exists: ${operationId}`);\n    this.name = 'ActiveOperationExistsError';\n    this.operationId = operationId;\n  }\n}\n\n/**\n * Orchestrates ERC-4626 vault deposit and withdraw flows for a wallet.\n *\n * Exposed as `wallet.defi` on the Wallet class. See TDD §6.3.1 for the full\n * design: the SDK sequences two sendMany calls (approve + deposit) and\n * returns an operationId that the UI uses for status tracking and recovery.\n *\n * Uses wallet.sendMany() under the hood so that both custody wallets\n * (txRequest creation only) and hot wallets (create + sign + broadcast)\n * are handled by the existing infrastructure.\n */\nexport class DefiVault implements IDefiVault {\n  private readonly wallet: IWallet;\n  private readonly bitgo: BitGoBase;\n\n  constructor(wallet: IWallet) {\n    this.wallet = wallet;\n    this.bitgo = wallet.bitgo;\n  }\n\n  /**\n   * Fetch vault config from defi-service. Used internally to determine\n   * which deposit path to take (Concrete vs Morpho).\n   */\n  async getVaultConfig(params: GetVaultConfigOptions): Promise<GetVaultResponse> {\n    if (!params.vaultId) {\n      throw new Error('vaultId is required');\n    }\n    const raw = await this.bitgo\n      .get(this.bitgo.microservicesUrl(`/api/defi-service/v1/vaults/${params.vaultId}`))\n      .result();\n    return decodeWithCodec(GetVaultResponse, raw, 'getVaultConfig');\n  }\n\n  /**\n   * Deposit an amount of underlying asset into a vault.\n   *\n   * Dispatches to the concrete or morpho path based on vault provider.\n   * The concrete path returns a pendingApproval (custodial wallet).\n   * The morpho path issues two sendMany calls (approve + deposit).\n   *\n   * @param params.vaultId - DeFi-service vault identifier\n   * @param params.amount - amount in base units of the underlying asset\n   * @param params.clientIdempotencyKey - optional client idempotency key\n   * @param params.walletPassphrase - required for hot wallets, omit for custody\n   */\n  async depositToVault(params: DepositToVaultOptions): Promise<DepositResult> {\n    if (!params.vaultId) {\n      throw new Error('vaultId is required');\n    }\n    if (!params.amount) {\n      throw new Error('amount is required');\n    }\n\n    const config = await this.getVaultConfig({ vaultId: params.vaultId });\n\n    if (config.protocol === VaultProtocol.CONCRETE_BTCCX) {\n      return this.depositToConcreteVault(params);\n    } else if (config.protocol === VaultProtocol.MORPHO) {\n      return this.depositToMorphoVault(params);\n    } else {\n      throw new Error(`Unsupported vault protocol: ${config.protocol}`);\n    }\n  }\n\n  /**\n   * Concrete BTC vault deposit path. The client BTC wallet is custodial, so\n   * sendMany returns a pendingApproval rather than a signed transfer.\n   * No recipients are sent — WP resolves the escrow destination server-side.\n   */\n  private async depositToConcreteVault(params: DepositToVaultOptions): Promise<ConcreteDepositResult> {\n    const sendManyResult = await this.wallet.sendMany({\n      type: 'defi-deposit',\n      defiParams: {\n        vaultId: params.vaultId,\n        amount: params.amount,\n        actionType: 'defi-deposit',\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n\n    return this.extractConcreteDepositResult(sendManyResult);\n  }\n\n  /**\n   * Morpho vault deposit path. Issues two sendMany calls (approve + deposit)\n   * and returns the operationId that links them.\n   */\n  private async depositToMorphoVault(params: DepositToVaultOptions): Promise<MorphoDepositResult> {\n    // TODO(CGD-1709): Re-enable active operation pre-flight check once the\n    // defi-service operations endpoint is deployed and returning active state.\n    // const activeOps: DefiOperationListResult = await this.bitgo\n    //   .get(this.bitgo.microservicesUrl(this.operationsUrl()))\n    //   .query({ vaultId: params.vaultId, state: 'active' })\n    //   .result();\n    //\n    // if (activeOps.items && activeOps.items.length > 0) {\n    //   throw new ActiveOperationExistsError(activeOps.items[0].operationId);\n    // }\n\n    // Step 1: Approve txRequest via sendMany\n    const approveResult = await this.wallet.sendMany({\n      type: 'defiApprove',\n      defiParams: {\n        vaultId: params.vaultId,\n        amount: params.amount,\n        ...(params.clientIdempotencyKey ? { clientIdempotencyKey: params.clientIdempotencyKey } : {}),\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n\n    const approveTxRequestId = this.extractTxRequestId(approveResult);\n    const operationId = this.extractOperationId(approveResult);\n\n    if (!operationId) {\n      throw new Error('operationId not found in approve txRequest response');\n    }\n\n    // Step 2: Deposit txRequest via sendMany\n    const depositResult = await this.wallet.sendMany({\n      type: 'defiDeposit',\n      defiParams: {\n        vaultId: params.vaultId,\n        amount: params.amount,\n        operationId,\n        ...(params.clientIdempotencyKey ? { clientIdempotencyKey: params.clientIdempotencyKey } : {}),\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n    const depositTxRequestId = this.extractTxRequestId(depositResult);\n\n    return {\n      operationId,\n      txRequestIds: {\n        approve: approveTxRequestId,\n        deposit: depositTxRequestId,\n      },\n    };\n  }\n\n  /**\n   * Resume a partially-completed deposit. Call this when the SDK process died\n   * between the approve and deposit txRequest creation.\n   *\n   * @param params.operationId - the operationId from the original depositToVault call\n   * @param params.walletPassphrase - required for hot wallets, omit for custody\n   */\n  async resumeDeposit(params: ResumeDepositOptions): Promise<DepositResult> {\n    if (!params.operationId) {\n      throw new Error('operationId is required');\n    }\n\n    // Fetch the operation to get the vault and amount details\n    const operation = await this.getOperation({ operationId: params.operationId });\n\n    if (operation.associatedTxRequestId) {\n      throw new Error('Deposit txRequest already exists for this operation; nothing to resume');\n    }\n\n    if (!operation.txRequestId) {\n      throw new Error('Approve txRequest not found for this operation; cannot resume');\n    }\n\n    // Issue the deposit txRequest using the existing operation's details\n    const depositResult = await this.wallet.sendMany({\n      type: 'defiDeposit',\n      defiParams: {\n        vaultId: operation.vaultId,\n        amount: operation.assetAmount,\n        operationId: params.operationId,\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n\n    return {\n      operationId: params.operationId,\n      txRequestIds: {\n        approve: operation.txRequestId,\n        deposit: this.extractTxRequestId(depositResult),\n      },\n    };\n  }\n\n  /**\n   * Get the current state of a DeFi operation.\n   *\n   * @param params.operationId - the operation to retrieve\n   */\n  async getOperation(params: GetOperationOptions): Promise<DefiOperation> {\n    if (!params.operationId) {\n      throw new Error('operationId is required');\n    }\n\n    return await this.bitgo.get(this.bitgo.microservicesUrl(this.operationsUrl() + '/' + params.operationId)).result();\n  }\n\n  /**\n   * List operations for a vault filtered by walletId.\n   *\n   * @param params.vaultId - vault to list operations for\n   * @param params.state - optional state filter\n   * @param params.type - optional type filter (DEPOSIT | WITHDRAW)\n   * @param params.limit - page size\n   * @param params.cursor - pagination cursor\n   */\n  async listOperations(params: ListOperationsOptions): Promise<DefiOperationListResult> {\n    if (!params.vaultId) {\n      throw new Error('vaultId is required');\n    }\n\n    const query: Record<string, string | number> = {\n      vaultId: params.vaultId,\n    };\n    if (params.state) query.state = params.state;\n    if (params.type) query.type = params.type;\n    if (params.limit) query.limit = params.limit;\n    if (params.cursor) query.cursor = params.cursor;\n\n    return await this.bitgo.get(this.bitgo.microservicesUrl(this.operationsUrl())).query(query).result();\n  }\n\n  // ── Internal helpers ────────────────────────────────────────────────\n\n  /**\n   * Extract txRequestId from a sendMany result.\n   * sendMany returns different shapes depending on wallet type:\n   * - TSS full: { txRequest: { txRequestId } } or { pendingApproval, txRequest }\n   * - TSS lite: result from tssUtils.sendTxRequest\n   */\n  private extractTxRequestId(sendManyResult: Record<string, unknown>): string {\n    const txRequest = sendManyResult.txRequest as Record<string, unknown> | undefined;\n    if (txRequest?.txRequestId) {\n      return txRequest.txRequestId as string;\n    }\n    if (sendManyResult.txRequestId) {\n      return sendManyResult.txRequestId as string;\n    }\n    throw new Error('txRequestId not found in sendMany response');\n  }\n\n  /**\n   * Extract operationId from a sendMany result.\n   *\n   * The WP writes the defi-service-minted operationId into the built\n   * transaction's `coinSpecific` (alongside `assignedNonce`), not into the\n   * intent. Read it from there: the `full` apiVersion surfaces it at\n   * `transactions[0].unsignedTx.coinSpecific.operationId`, the `lite` version\n   * at `unsignedTxs[0].coinSpecific.operationId`. Fall back to\n   * `intent.operationId` for forward-compat in case the WP later also\n   * populates the intent.\n   */\n  private extractOperationId(sendManyResult: Record<string, unknown>): string | undefined {\n    const txRequest = sendManyResult.txRequest as Record<string, unknown> | undefined;\n    if (!txRequest) {\n      return undefined;\n    }\n\n    // full apiVersion: transactions[0].unsignedTx.coinSpecific.operationId\n    const transactions = txRequest.transactions as Array<Record<string, unknown>> | undefined;\n    const fullUnsignedTx = transactions?.[0]?.unsignedTx as Record<string, unknown> | undefined;\n    const fullCoinSpecific = fullUnsignedTx?.coinSpecific as Record<string, unknown> | undefined;\n    if (fullCoinSpecific?.operationId) {\n      return fullCoinSpecific.operationId as string;\n    }\n\n    // lite apiVersion: unsignedTxs[0].coinSpecific.operationId\n    const unsignedTxs = txRequest.unsignedTxs as Array<Record<string, unknown>> | undefined;\n    const liteCoinSpecific = unsignedTxs?.[0]?.coinSpecific as Record<string, unknown> | undefined;\n    if (liteCoinSpecific?.operationId) {\n      return liteCoinSpecific.operationId as string;\n    }\n\n    // forward-compat: intent.operationId (in case the WP later populates the intent)\n    const intent = txRequest.intent as Record<string, unknown> | undefined;\n    return intent?.operationId as string | undefined;\n  }\n\n  /**\n   * Extracts {@link ConcreteDepositResult} from a custodial sendMany response.\n   * Concrete BTC deposits return a `pendingApproval` instead of a txRequest —\n   * throws if `pendingApproval.id` is absent, indicating an unexpected shape.\n   */\n  private extractConcreteDepositResult(sendManyResult: Record<string, unknown>): ConcreteDepositResult {\n    const SendManyConcreteResponse = t.type({\n      pendingApproval: t.intersection([t.type({ id: t.string }), t.partial({ state: t.string })]),\n    });\n    const decoded = decodeWithCodec(SendManyConcreteResponse, sendManyResult, 'defi-deposit sendMany response');\n    return {\n      pendingApprovalId: decoded.pendingApproval.id,\n      state: decoded.pendingApproval.state ?? 'awaitingSignature',\n    };\n  }\n\n  private operationsUrl(): string {\n    return `/api/defi-service/v1/wallets/${this.wallet.id()}/operations`;\n  }\n}\n"]}

package/dist/src/bitgo/defi/iDefiVault.d.ts

@@ -1,6 +1,7 @@
 /**
  * @prettier
  */
+import { GetVaultResponse } from '@bitgo/public-types';
 export interface DepositToVaultOptions {
     /** DeFi-service vault identifier */
     vaultId: string;
@@ -27,6 +28,9 @@ export interface ListOperationsOptions {
     limit?: number;
     cursor?: string;
 }
+export interface GetVaultConfigOptions {
+    vaultId: string;
+}
 export interface DefiOperation {
     operationId: string;
     walletId: string;
@@ -39,13 +43,18 @@ export interface DefiOperation {
     createdAt: string;
     updatedAt: string;
 }
-export interface DepositResult {
+export interface ConcreteDepositResult {
+    pendingApprovalId: string;
+    state: string;
+}
+export interface MorphoDepositResult {
     operationId: string;
     txRequestIds: {
         approve: string;
         deposit: string;
     };
 }
+export type DepositResult = ConcreteDepositResult | MorphoDepositResult;
 export interface DefiOperationListResult {
     items: DefiOperation[];
     nextCursor?: string;
@@ -55,5 +64,6 @@ export interface IDefiVault {
     resumeDeposit(params: ResumeDepositOptions): Promise<DepositResult>;
     getOperation(params: GetOperationOptions): Promise<DefiOperation>;
     listOperations(params: ListOperationsOptions): Promise<DefiOperationListResult>;
+    getVaultConfig(params: GetVaultConfigOptions): Promise<GetVaultResponse>;
 }
 //# sourceMappingURL=iDefiVault.d.ts.map

package/dist/src/bitgo/defi/iDefiVault.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iDefiVault.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/defi/iDefiVault.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,qBAAqB;IACpC,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,GAAG,UAAU,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACtE,aAAa,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACpE,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAClE,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACjF"}
+{"version":3,"file":"iDefiVault.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/defi/iDefiVault.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,WAAW,qBAAqB;IACpC,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,GAAG,UAAU,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACpD;AAED,MAAM,MAAM,aAAa,GAAG,qBAAqB,GAAG,mBAAmB,CAAC;AAExE,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACtE,aAAa,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACpE,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAClE,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAChF,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC1E"}

package/dist/src/bitgo/defi/iDefiVault.js

@@ -3,4 +3,4 @@
  * @prettier
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/enterprise/enterprise.d.ts

@@ -2,6 +2,7 @@ import { IBaseCoin } from '../baseCoin';
 import { BitGoBase } from '../bitgoBase';
 import { EnterpriseData, EnterpriseFeatureFlag, IEnterprise } from '../enterprise';
 import { ListWalletOptions, Wallet } from '../wallet';
+import { Safes } from '../safe';
 import { BitGoProofSignatures, SerializedNtildeWithVerifiers } from '../utils/tss/ecdsa';
 import { EcdsaTypes } from '@bitgo-beta/sdk-lib-mpc';
 import { Buffer } from 'buffer';
@@ -89,5 +90,10 @@ export declare class Enterprise implements IEnterprise {
      * @param flags
      */
     hasFeatureFlags(flags: EnterpriseFeatureFlag[]): boolean;
+    /**
+     * Get the safes collection accessor scoped to this Enterprise
+     * @experimental
+     */
+    safes(): Safes;
 }
 //# sourceMappingURL=enterprise.d.ts.map

package/dist/src/bitgo/enterprise/enterprise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enterprise.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/enterprise/enterprise.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAc,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AACrG,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,qBAAa,UAAW,YAAW,WAAW;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAY;IACrC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,WAAW,EAAE,cAAc,CAAC;gBAEhC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc;IAiBjF;;;OAGG;IACH,GAAG,CAAC,KAAK,SAAK,GAAG,MAAM;IAIvB;;;OAGG;IACH,OAAO,CAAC,KAAK,SAAK,GAAG,MAAM;IAI3B;;;OAGG;IACG,WAAW,CAAC,MAAM,GAAE,iBAAsB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAcpE;;;OAGG;IACG,KAAK,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAI7D;;;OAGG;IACG,oBAAoB,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAI5E;;;OAGG;IACG,OAAO,CAAC,MAAM,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAI7C;;;OAGG;IACG,UAAU,CAAC,MAAM,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAIhD;;;OAGG;IACG,0BAA0B,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAIlF;;;OAGG;IACG,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAI1F;;;;;;;;OAQG;IACG,8BAA8B,CAClC,YAAY,EAAE,MAAM,EACpB,gCAAgC,EAAE,MAAM,EACxC,iCAAiC,EAAE,MAAM,EACzC,YAAY,EAAE,UAAU,EACxB,SAAS,CAAC,EAAE,UAAU,CAAC,4BAA4B,GAClD,OAAO,CAAC,IAAI,CAAC;IAYhB;;;;OAIG;IACG,4BAA4B,IAAI,OAAO,CAAC,UAAU,CAAC,4BAA4B,CAAC;IAoBtF;;;;;;;;OAQG;IACG,0BAA0B,CAC9B,cAAc,EAAE,kBAAkB,EAClC,cAAc,EAAE,kBAAkB,EAClC,YAAY,EAAE,6BAA6B,EAC3C,kBAAkB,EAAE,6BAA6B,EACjD,mBAAmB,EAAE,6BAA6B,GACjD,OAAO,CAAC,IAAI,CAAC;IAwDhB;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO;CAGzD"}
+{"version":3,"file":"enterprise.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/enterprise/enterprise.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,oBAAoB,EAAc,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AACrG,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,qBAAa,UAAW,YAAW,WAAW;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAY;IACrC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,WAAW,EAAE,cAAc,CAAC;gBAEhC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc;IAiBjF;;;OAGG;IACH,GAAG,CAAC,KAAK,SAAK,GAAG,MAAM;IAIvB;;;OAGG;IACH,OAAO,CAAC,KAAK,SAAK,GAAG,MAAM;IAI3B;;;OAGG;IACG,WAAW,CAAC,MAAM,GAAE,iBAAsB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAcpE;;;OAGG;IACG,KAAK,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAI7D;;;OAGG;IACG,oBAAoB,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAI5E;;;OAGG;IACG,OAAO,CAAC,MAAM,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAI7C;;;OAGG;IACG,UAAU,CAAC,MAAM,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAIhD;;;OAGG;IACG,0BAA0B,CAAC,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAIlF;;;OAGG;IACG,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAI1F;;;;;;;;OAQG;IACG,8BAA8B,CAClC,YAAY,EAAE,MAAM,EACpB,gCAAgC,EAAE,MAAM,EACxC,iCAAiC,EAAE,MAAM,EACzC,YAAY,EAAE,UAAU,EACxB,SAAS,CAAC,EAAE,UAAU,CAAC,4BAA4B,GAClD,OAAO,CAAC,IAAI,CAAC;IAYhB;;;;OAIG;IACG,4BAA4B,IAAI,OAAO,CAAC,UAAU,CAAC,4BAA4B,CAAC;IAoBtF;;;;;;;;OAQG;IACG,0BAA0B,CAC9B,cAAc,EAAE,kBAAkB,EAClC,cAAc,EAAE,kBAAkB,EAClC,YAAY,EAAE,6BAA6B,EAC3C,kBAAkB,EAAE,6BAA6B,EACjD,mBAAmB,EAAE,6BAA6B,GACjD,OAAO,CAAC,IAAI,CAAC;IAwDhB;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO;IAIxD;;;OAGG;IACH,KAAK,IAAI,KAAK;CAGf"}

package/dist/src/bitgo/enterprise/enterprise.js

@@ -40,6 +40,7 @@ exports.Enterprise = void 0;
 const _ = __importStar(require("lodash"));
 const internal_1 = require("../internal");
 const wallet_1 = require("../wallet");
+const safe_1 = require("../safe");
 const ecdsa_1 = require("../utils/tss/ecdsa");
 const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
 const ecdh_1 = require("../ecdh");
@@ -200,6 +201,13 @@ class Enterprise {
     hasFeatureFlags(flags) {
         return flags.every((targetFlag) => this._enterprise.featureFlags?.includes(targetFlag));
     }
+    /**
+     * Get the safes collection accessor scoped to this Enterprise
+     * @experimental
+     */
+    safes() {
+        return new safe_1.Safes(this.bitgo, this.id);
+    }
 }
 exports.Enterprise = Enterprise;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enterprise.js","sourceRoot":"","sources":["../../../../src/bitgo/enterprise/enterprise.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,0CAA4B;AAI5B,0CAAyD;AACzD,sCAAsD;AACtD,8CAAqG;AACrG,yDAAqD;AACrD,kCAA8C;AAC9C,mCAAgC;AAGhC,MAAa,UAAU;IAOrB,YAAY,KAAgB,EAAE,QAAmB,EAAE,cAA8B;QAC/E,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACtD,CAAC;QACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,cAAc,CAAC;QAClC,IAAI,CAAC,EAAE,GAAG,cAAc,CAAC,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,KAAK,GAAG,EAAE;QACZ,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,KAAK,GAAG,EAAE;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,SAA4B,EAAE;QAC9C,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,UAAU,GAAG,CAAC,MAAM,IAAI,CAAC,KAAK;aACjC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,qBAAqB,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;aACvD,KAAK,CAAC,MAAM,CAAC;aACb,MAAM,EAAE,CAAQ,CAAC;QACpB,OAAO,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAClC,OAAO,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK,CAAC,SAAgC,EAAE;QAC5C,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,oBAAoB,CAAC,SAAgC,EAAE;QAC3D,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3E,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO,CAAC,SAAc,EAAE;QAC5B,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;IACxE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CAAC,SAAc,EAAE;QAC/B,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;IACvE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,0BAA0B,CAAC,SAAgC,EAAE;QACjE,OAAO,IAAA,qCAA0B,EAAC,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1F,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,+BAA+B,CAAC,YAAoB;QACxD,OAAO,kBAAU,CAAC,+BAA+B,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;IACvF,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,8BAA8B,CAClC,YAAoB,EACpB,gCAAwC,EACxC,iCAAyC,EACzC,YAAwB,EACxB,SAAmD;QAEnD,MAAM,kBAAU,CAAC,+BAA+B,CAC9C,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,EAAE,EACP,YAAY,EACZ,gCAAgC,EAChC,iCAAiC,EACjC,YAAY,EACZ,SAAS,CACV,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,4BAA4B;QAChC,MAAM,OAAO,GAAG,eAAe,IAAI,CAAC,EAAE,YAAY,CAAC;QACnD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;QACnF,MAAM,mBAAmB,GAAG,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC;QACnE,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CACb,sGAAsG,CACvG,CAAC;QACJ,CAAC;QACD,OAAO,wBAAU,CAAC,2BAA2B,CAAC;YAC5C,MAAM,EAAE,mBAAmB,CAAC,MAAM;YAClC,EAAE,EAAE,mBAAmB,CAAC,EAAE;YAC1B,EAAE,EAAE,mBAAmB,CAAC,EAAE;YAC1B,WAAW,EAAE,mBAAmB,CAAC,WAAW;SAC7C,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,0BAA0B,CAC9B,cAAkC,EAClC,cAAkC,EAClC,YAA2C,EAC3C,kBAAiD,EACjD,mBAAkD;QAElD,2DAA2D;QAC3D,IACE,CAAC,IAAA,0BAAmB,EAClB,kBAAU,CAAC,6BAA6B,CAAC,YAAY,CAAC,EACtD,YAAY,CAAC,SAAS,CAAC,cAAc,EACrC,eAAM,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CACjD,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,uEAAuE,CAAC,CAAC;QAC3F,CAAC;QACD,IACE,CAAC,IAAA,0BAAmB,EAClB,kBAAU,CAAC,6BAA6B,CAAC,kBAAkB,CAAC,EAC5D,kBAAkB,CAAC,SAAS,CAAC,cAAc,EAC3C,eAAM,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CACjD,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;QACpG,CAAC;QACD,IACE,CAAC,IAAA,0BAAmB,EAClB,kBAAU,CAAC,6BAA6B,CAAC,mBAAmB,CAAC,EAC7D,mBAAmB,CAAC,SAAS,CAAC,cAAc,EAC5C,eAAM,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CACjD,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;QAC5F,CAAC;QAED,kFAAkF;QAClF,MAAM,kBAAkB,GAAG,kBAAU,CAAC,aAAa,CACjD,YAAY,EACZ,cAAc,CAAC,IAAI,EACnB,cAAc,CAAC,cAAc,CAC9B,CAAC;QACF,MAAM,wBAAwB,GAAG,kBAAU,CAAC,aAAa,CACvD,kBAAkB,EAClB,cAAc,CAAC,IAAI,EACnB,cAAc,CAAC,cAAc,CAC9B,CAAC;QACF,MAAM,yBAAyB,GAAG,kBAAU,CAAC,aAAa,CACxD,mBAAmB,EACnB,cAAc,CAAC,IAAI,EACnB,cAAc,CAAC,cAAc,CAC9B,CAAC;QACF,MAAM,kBAAU,CAAC,4BAA4B,CAC3C,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,EAAE,EACP,YAAY,EACZ,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAClC,wBAAwB,CAAC,QAAQ,CAAC,KAAK,CAAC,EACxC,yBAAyB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAC1C,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,KAA8B;QAC5C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1F,CAAC;CACF;AA5OD,gCA4OC","sourcesContent":["/**\n * @prettier\n */\nimport * as _ from 'lodash';\nimport { IBaseCoin } from '../baseCoin';\nimport { BitGoBase } from '../bitgoBase';\nimport { EnterpriseData, EnterpriseFeatureFlag, IEnterprise } from '../enterprise';\nimport { getFirstPendingTransaction } from '../internal';\nimport { ListWalletOptions, Wallet } from '../wallet';\nimport { BitGoProofSignatures, EcdsaUtils, SerializedNtildeWithVerifiers } from '../utils/tss/ecdsa';\nimport { EcdsaTypes } from '@bitgo-beta/sdk-lib-mpc';\nimport { verifyEcdhSignature } from '../ecdh';\nimport { Buffer } from 'buffer';\nimport { EcdhDerivedKeypair } from '../keychain';\n\nexport class Enterprise implements IEnterprise {\n  private readonly bitgo: BitGoBase;\n  private readonly baseCoin: IBaseCoin;\n  public readonly id: string;\n  public readonly name: string;\n  public readonly _enterprise: EnterpriseData;\n\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin, enterpriseData: EnterpriseData) {\n    this.bitgo = bitgo;\n    this.baseCoin = baseCoin;\n    if (!_.isObject(enterpriseData)) {\n      throw new Error('enterpriseData has to be an object');\n    }\n    if (!_.isString(enterpriseData.id)) {\n      throw new Error('enterprise id has to be a string');\n    }\n    if (!_.isString(enterpriseData.name)) {\n      throw new Error('enterprise name has to be a string');\n    }\n    this._enterprise = enterpriseData;\n    this.id = enterpriseData.id;\n    this.name = enterpriseData.name;\n  }\n\n  /**\n   * Enterprise URL for v1 methods, such as getting users\n   * @param query\n   */\n  url(query = ''): string {\n    return this.bitgo.url(`/enterprise/${this.id}${query}`);\n  }\n\n  /**\n   * Enterprise URL for v2 methods, such as getting fee address balances\n   * @param query\n   */\n  coinUrl(query = ''): string {\n    return this.baseCoin.url(`/enterprise/${this.id}${query}`);\n  }\n\n  /**\n   * Get the wallets associated with this Enterprise\n   * @param params\n   */\n  async coinWallets(params: ListWalletOptions = {}): Promise<Wallet[]> {\n    if (params.skip && params.prevId) {\n      throw new Error('cannot specify both skip and prevId');\n    }\n\n    const walletData = (await this.bitgo\n      .get(this.baseCoin.url('/wallet/enterprise/' + this.id))\n      .query(params)\n      .result()) as any;\n    return walletData.wallets.map((w) => {\n      return new Wallet(this.bitgo, this.baseCoin, w);\n    });\n  }\n\n  /**\n   * Get the users associated with this Enterprise\n   * @param params\n   */\n  async users(params: Record<string, never> = {}): Promise<any> {\n    return await this.bitgo.get(this.url('/user')).result();\n  }\n\n  /**\n   * Get the fee address balance for this Enterprise\n   * @param params\n   */\n  async getFeeAddressBalance(params: Record<string, never> = {}): Promise<any> {\n    return await this.bitgo.get(this.coinUrl('/feeAddressBalance')).result();\n  }\n\n  /**\n   * Add a user to this Enterprise\n   * @param params\n   */\n  async addUser(params: any = {}): Promise<any> {\n    return await this.bitgo.post(this.url('/user')).send(params).result();\n  }\n\n  /**\n   * Remove a user from this Enterprise\n   * @param params\n   */\n  async removeUser(params: any = {}): Promise<any> {\n    return await this.bitgo.del(this.url('/user')).send(params).result();\n  }\n\n  /**\n   * Get the first pending transaction for this Enterprise\n   * @param params\n   */\n  async getFirstPendingTransaction(params: Record<string, never> = {}): Promise<any> {\n    return getFirstPendingTransaction({ enterpriseId: this.id }, this.baseCoin, this.bitgo);\n  }\n\n  /**\n   * Verifies and signs bitgo proofs for the enterprise\n   * @param userPassword - enterprise admin's login password\n   */\n  async verifyEcdsaBitGoChallengeProofs(userPassword: string): Promise<BitGoProofSignatures> {\n    return EcdsaUtils.getVerifyAndSignBitGoChallenges(this.bitgo, this.id, userPassword);\n  }\n\n  /**\n   * Manages all the challenges and signatures and uploads them to enable\n   * ECDSA signing on enterprise. Also generates a client side Ntilde challenge\n   * if not provided, but note that can take approx. a minute.\n   * @param userPassword\n   * @param bitgoInstChallengeProofSignature\n   * @param bitgoNitroChallengeProofSignature\n   * @param challenge\n   */\n  async uploadAndEnableTssEcdsaSigning(\n    userPassword: string,\n    bitgoInstChallengeProofSignature: Buffer,\n    bitgoNitroChallengeProofSignature: Buffer,\n    openSSLBytes: Uint8Array,\n    challenge?: EcdsaTypes.DeserializedNtildeWithProofs\n  ): Promise<void> {\n    await EcdsaUtils.initiateChallengesForEnterprise(\n      this.bitgo,\n      this.id,\n      userPassword,\n      bitgoInstChallengeProofSignature,\n      bitgoNitroChallengeProofSignature,\n      openSSLBytes,\n      challenge\n    );\n  }\n\n  /**\n   * Fetches the existing TSS ECDSA enterprise challenge if one exists.\n   * Can be used with uploadAndEnableTssEcdsaSigning to re-sign the\n   * enterprise challenge with new signatures.\n   */\n  async getExistingTssEcdsaChallenge(): Promise<EcdsaTypes.DeserializedNtildeWithProofs> {\n    const urlPath = `/enterprise/${this.id}/tssconfig`;\n    const tssConfig = await this.bitgo.get(this.bitgo.url(urlPath, 2)).send().result();\n    const enterpriseChallenge = tssConfig?.ecdsa.challenge?.enterprise;\n    if (!enterpriseChallenge) {\n      throw new Error('No existing ECDSA challenge on the enterprise.');\n    }\n    if (!enterpriseChallenge.ntildeProof) {\n      throw new Error(\n        'Existing ECDSA challenge does not have a proof. Please contact your enterprise admin to set this up.'\n      );\n    }\n    return EcdsaTypes.deserializeNtildeWithProofs({\n      ntilde: enterpriseChallenge.ntilde,\n      h1: enterpriseChallenge.h1,\n      h2: enterpriseChallenge.h2,\n      ntildeProof: enterpriseChallenge.ntildeProof,\n    });\n  }\n\n  /**\n   * Resigns the enterprise and bitgo challenges with a new ECDH keychain.\n   * Verifies that the old keychain signed the challenges previously.\n   * @param oldEcdhKeypair - the old keychain that signed the challenges\n   * @param newEcdhKeypair - the new keychain that will sign the challenges\n   * @param entChallenge - existing signed enterprise challenge\n   * @param bitgoInstChallenge - existing signed bitgo institutional challenge\n   * @param bitgoNitroChallenge - existing signed bitgo nitro challenge\n   */\n  async resignEnterpriseChallenges(\n    oldEcdhKeypair: EcdhDerivedKeypair,\n    newEcdhKeypair: EcdhDerivedKeypair,\n    entChallenge: SerializedNtildeWithVerifiers,\n    bitgoInstChallenge: SerializedNtildeWithVerifiers,\n    bitgoNitroChallenge: SerializedNtildeWithVerifiers\n  ): Promise<void> {\n    // Verify all the challenges were signed by the old keypair\n    if (\n      !verifyEcdhSignature(\n        EcdsaUtils.getMessageToSignFromChallenge(entChallenge),\n        entChallenge.verifiers.adminSignature,\n        Buffer.from(oldEcdhKeypair.derivedPubKey, 'hex')\n      )\n    ) {\n      throw new Error(`Cannot re-sign. The Enterprise TSS config was signed by another user.`);\n    }\n    if (\n      !verifyEcdhSignature(\n        EcdsaUtils.getMessageToSignFromChallenge(bitgoInstChallenge),\n        bitgoInstChallenge.verifiers.adminSignature,\n        Buffer.from(oldEcdhKeypair.derivedPubKey, 'hex')\n      )\n    ) {\n      throw new Error(`Cannot re-sign. The BitGo Institutional TSS config was signed by another user.`);\n    }\n    if (\n      !verifyEcdhSignature(\n        EcdsaUtils.getMessageToSignFromChallenge(bitgoNitroChallenge),\n        bitgoNitroChallenge.verifiers.adminSignature,\n        Buffer.from(oldEcdhKeypair.derivedPubKey, 'hex')\n      )\n    ) {\n      throw new Error(`Cannot re-sign. The BitGo Nitro TSS config was signed by another user.`);\n    }\n\n    // Once all the challenges are verified, we can re-sign them with the new keypair.\n    const signedEntChallenge = EcdsaUtils.signChallenge(\n      entChallenge,\n      newEcdhKeypair.xprv,\n      newEcdhKeypair.derivationPath\n    );\n    const signedBitGoInstChallenge = EcdsaUtils.signChallenge(\n      bitgoInstChallenge,\n      newEcdhKeypair.xprv,\n      newEcdhKeypair.derivationPath\n    );\n    const signedBitGoNitroChallenge = EcdsaUtils.signChallenge(\n      bitgoNitroChallenge,\n      newEcdhKeypair.xprv,\n      newEcdhKeypair.derivationPath\n    );\n    await EcdsaUtils.uploadChallengesToEnterprise(\n      this.bitgo,\n      this.id,\n      entChallenge,\n      signedEntChallenge.toString('hex'),\n      signedBitGoInstChallenge.toString('hex'),\n      signedBitGoNitroChallenge.toString('hex')\n    );\n  }\n\n  /**\n   *  Check if the enterprise has a set of featureFlags\n   * @param flags\n   */\n  hasFeatureFlags(flags: EnterpriseFeatureFlag[]): boolean {\n    return flags.every((targetFlag) => this._enterprise.featureFlags?.includes(targetFlag));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enterprise.js","sourceRoot":"","sources":["../../../../src/bitgo/enterprise/enterprise.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,0CAA4B;AAI5B,0CAAyD;AACzD,sCAAsD;AACtD,kCAAgC;AAChC,8CAAqG;AACrG,yDAAqD;AACrD,kCAA8C;AAC9C,mCAAgC;AAGhC,MAAa,UAAU;IAOrB,YAAY,KAAgB,EAAE,QAAmB,EAAE,cAA8B;QAC/E,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACtD,CAAC;QACD,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,cAAc,CAAC;QAClC,IAAI,CAAC,EAAE,GAAG,cAAc,CAAC,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,KAAK,GAAG,EAAE;QACZ,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,KAAK,GAAG,EAAE;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,SAA4B,EAAE;QAC9C,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,UAAU,GAAG,CAAC,MAAM,IAAI,CAAC,KAAK;aACjC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,qBAAqB,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;aACvD,KAAK,CAAC,MAAM,CAAC;aACb,MAAM,EAAE,CAAQ,CAAC;QACpB,OAAO,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAClC,OAAO,IAAI,eAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK,CAAC,SAAgC,EAAE;QAC5C,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,oBAAoB,CAAC,SAAgC,EAAE;QAC3D,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3E,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO,CAAC,SAAc,EAAE;QAC5B,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;IACxE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CAAC,SAAc,EAAE;QAC/B,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;IACvE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,0BAA0B,CAAC,SAAgC,EAAE;QACjE,OAAO,IAAA,qCAA0B,EAAC,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1F,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,+BAA+B,CAAC,YAAoB;QACxD,OAAO,kBAAU,CAAC,+BAA+B,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;IACvF,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,8BAA8B,CAClC,YAAoB,EACpB,gCAAwC,EACxC,iCAAyC,EACzC,YAAwB,EACxB,SAAmD;QAEnD,MAAM,kBAAU,CAAC,+BAA+B,CAC9C,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,EAAE,EACP,YAAY,EACZ,gCAAgC,EAChC,iCAAiC,EACjC,YAAY,EACZ,SAAS,CACV,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,4BAA4B;QAChC,MAAM,OAAO,GAAG,eAAe,IAAI,CAAC,EAAE,YAAY,CAAC;QACnD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;QACnF,MAAM,mBAAmB,GAAG,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC;QACnE,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CACb,sGAAsG,CACvG,CAAC;QACJ,CAAC;QACD,OAAO,wBAAU,CAAC,2BAA2B,CAAC;YAC5C,MAAM,EAAE,mBAAmB,CAAC,MAAM;YAClC,EAAE,EAAE,mBAAmB,CAAC,EAAE;YAC1B,EAAE,EAAE,mBAAmB,CAAC,EAAE;YAC1B,WAAW,EAAE,mBAAmB,CAAC,WAAW;SAC7C,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,0BAA0B,CAC9B,cAAkC,EAClC,cAAkC,EAClC,YAA2C,EAC3C,kBAAiD,EACjD,mBAAkD;QAElD,2DAA2D;QAC3D,IACE,CAAC,IAAA,0BAAmB,EAClB,kBAAU,CAAC,6BAA6B,CAAC,YAAY,CAAC,EACtD,YAAY,CAAC,SAAS,CAAC,cAAc,EACrC,eAAM,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CACjD,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,uEAAuE,CAAC,CAAC;QAC3F,CAAC;QACD,IACE,CAAC,IAAA,0BAAmB,EAClB,kBAAU,CAAC,6BAA6B,CAAC,kBAAkB,CAAC,EAC5D,kBAAkB,CAAC,SAAS,CAAC,cAAc,EAC3C,eAAM,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CACjD,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;QACpG,CAAC;QACD,IACE,CAAC,IAAA,0BAAmB,EAClB,kBAAU,CAAC,6BAA6B,CAAC,mBAAmB,CAAC,EAC7D,mBAAmB,CAAC,SAAS,CAAC,cAAc,EAC5C,eAAM,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,KAAK,CAAC,CACjD,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;QAC5F,CAAC;QAED,kFAAkF;QAClF,MAAM,kBAAkB,GAAG,kBAAU,CAAC,aAAa,CACjD,YAAY,EACZ,cAAc,CAAC,IAAI,EACnB,cAAc,CAAC,cAAc,CAC9B,CAAC;QACF,MAAM,wBAAwB,GAAG,kBAAU,CAAC,aAAa,CACvD,kBAAkB,EAClB,cAAc,CAAC,IAAI,EACnB,cAAc,CAAC,cAAc,CAC9B,CAAC;QACF,MAAM,yBAAyB,GAAG,kBAAU,CAAC,aAAa,CACxD,mBAAmB,EACnB,cAAc,CAAC,IAAI,EACnB,cAAc,CAAC,cAAc,CAC9B,CAAC;QACF,MAAM,kBAAU,CAAC,4BAA4B,CAC3C,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,EAAE,EACP,YAAY,EACZ,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAClC,wBAAwB,CAAC,QAAQ,CAAC,KAAK,CAAC,EACxC,yBAAyB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAC1C,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,KAA8B;QAC5C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1F,CAAC;IAED;;;OAGG;IACH,KAAK;QACH,OAAO,IAAI,YAAK,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IACxC,CAAC;CACF;AApPD,gCAoPC","sourcesContent":["/**\n * @prettier\n */\nimport * as _ from 'lodash';\nimport { IBaseCoin } from '../baseCoin';\nimport { BitGoBase } from '../bitgoBase';\nimport { EnterpriseData, EnterpriseFeatureFlag, IEnterprise } from '../enterprise';\nimport { getFirstPendingTransaction } from '../internal';\nimport { ListWalletOptions, Wallet } from '../wallet';\nimport { Safes } from '../safe';\nimport { BitGoProofSignatures, EcdsaUtils, SerializedNtildeWithVerifiers } from '../utils/tss/ecdsa';\nimport { EcdsaTypes } from '@bitgo-beta/sdk-lib-mpc';\nimport { verifyEcdhSignature } from '../ecdh';\nimport { Buffer } from 'buffer';\nimport { EcdhDerivedKeypair } from '../keychain';\n\nexport class Enterprise implements IEnterprise {\n  private readonly bitgo: BitGoBase;\n  private readonly baseCoin: IBaseCoin;\n  public readonly id: string;\n  public readonly name: string;\n  public readonly _enterprise: EnterpriseData;\n\n  constructor(bitgo: BitGoBase, baseCoin: IBaseCoin, enterpriseData: EnterpriseData) {\n    this.bitgo = bitgo;\n    this.baseCoin = baseCoin;\n    if (!_.isObject(enterpriseData)) {\n      throw new Error('enterpriseData has to be an object');\n    }\n    if (!_.isString(enterpriseData.id)) {\n      throw new Error('enterprise id has to be a string');\n    }\n    if (!_.isString(enterpriseData.name)) {\n      throw new Error('enterprise name has to be a string');\n    }\n    this._enterprise = enterpriseData;\n    this.id = enterpriseData.id;\n    this.name = enterpriseData.name;\n  }\n\n  /**\n   * Enterprise URL for v1 methods, such as getting users\n   * @param query\n   */\n  url(query = ''): string {\n    return this.bitgo.url(`/enterprise/${this.id}${query}`);\n  }\n\n  /**\n   * Enterprise URL for v2 methods, such as getting fee address balances\n   * @param query\n   */\n  coinUrl(query = ''): string {\n    return this.baseCoin.url(`/enterprise/${this.id}${query}`);\n  }\n\n  /**\n   * Get the wallets associated with this Enterprise\n   * @param params\n   */\n  async coinWallets(params: ListWalletOptions = {}): Promise<Wallet[]> {\n    if (params.skip && params.prevId) {\n      throw new Error('cannot specify both skip and prevId');\n    }\n\n    const walletData = (await this.bitgo\n      .get(this.baseCoin.url('/wallet/enterprise/' + this.id))\n      .query(params)\n      .result()) as any;\n    return walletData.wallets.map((w) => {\n      return new Wallet(this.bitgo, this.baseCoin, w);\n    });\n  }\n\n  /**\n   * Get the users associated with this Enterprise\n   * @param params\n   */\n  async users(params: Record<string, never> = {}): Promise<any> {\n    return await this.bitgo.get(this.url('/user')).result();\n  }\n\n  /**\n   * Get the fee address balance for this Enterprise\n   * @param params\n   */\n  async getFeeAddressBalance(params: Record<string, never> = {}): Promise<any> {\n    return await this.bitgo.get(this.coinUrl('/feeAddressBalance')).result();\n  }\n\n  /**\n   * Add a user to this Enterprise\n   * @param params\n   */\n  async addUser(params: any = {}): Promise<any> {\n    return await this.bitgo.post(this.url('/user')).send(params).result();\n  }\n\n  /**\n   * Remove a user from this Enterprise\n   * @param params\n   */\n  async removeUser(params: any = {}): Promise<any> {\n    return await this.bitgo.del(this.url('/user')).send(params).result();\n  }\n\n  /**\n   * Get the first pending transaction for this Enterprise\n   * @param params\n   */\n  async getFirstPendingTransaction(params: Record<string, never> = {}): Promise<any> {\n    return getFirstPendingTransaction({ enterpriseId: this.id }, this.baseCoin, this.bitgo);\n  }\n\n  /**\n   * Verifies and signs bitgo proofs for the enterprise\n   * @param userPassword - enterprise admin's login password\n   */\n  async verifyEcdsaBitGoChallengeProofs(userPassword: string): Promise<BitGoProofSignatures> {\n    return EcdsaUtils.getVerifyAndSignBitGoChallenges(this.bitgo, this.id, userPassword);\n  }\n\n  /**\n   * Manages all the challenges and signatures and uploads them to enable\n   * ECDSA signing on enterprise. Also generates a client side Ntilde challenge\n   * if not provided, but note that can take approx. a minute.\n   * @param userPassword\n   * @param bitgoInstChallengeProofSignature\n   * @param bitgoNitroChallengeProofSignature\n   * @param challenge\n   */\n  async uploadAndEnableTssEcdsaSigning(\n    userPassword: string,\n    bitgoInstChallengeProofSignature: Buffer,\n    bitgoNitroChallengeProofSignature: Buffer,\n    openSSLBytes: Uint8Array,\n    challenge?: EcdsaTypes.DeserializedNtildeWithProofs\n  ): Promise<void> {\n    await EcdsaUtils.initiateChallengesForEnterprise(\n      this.bitgo,\n      this.id,\n      userPassword,\n      bitgoInstChallengeProofSignature,\n      bitgoNitroChallengeProofSignature,\n      openSSLBytes,\n      challenge\n    );\n  }\n\n  /**\n   * Fetches the existing TSS ECDSA enterprise challenge if one exists.\n   * Can be used with uploadAndEnableTssEcdsaSigning to re-sign the\n   * enterprise challenge with new signatures.\n   */\n  async getExistingTssEcdsaChallenge(): Promise<EcdsaTypes.DeserializedNtildeWithProofs> {\n    const urlPath = `/enterprise/${this.id}/tssconfig`;\n    const tssConfig = await this.bitgo.get(this.bitgo.url(urlPath, 2)).send().result();\n    const enterpriseChallenge = tssConfig?.ecdsa.challenge?.enterprise;\n    if (!enterpriseChallenge) {\n      throw new Error('No existing ECDSA challenge on the enterprise.');\n    }\n    if (!enterpriseChallenge.ntildeProof) {\n      throw new Error(\n        'Existing ECDSA challenge does not have a proof. Please contact your enterprise admin to set this up.'\n      );\n    }\n    return EcdsaTypes.deserializeNtildeWithProofs({\n      ntilde: enterpriseChallenge.ntilde,\n      h1: enterpriseChallenge.h1,\n      h2: enterpriseChallenge.h2,\n      ntildeProof: enterpriseChallenge.ntildeProof,\n    });\n  }\n\n  /**\n   * Resigns the enterprise and bitgo challenges with a new ECDH keychain.\n   * Verifies that the old keychain signed the challenges previously.\n   * @param oldEcdhKeypair - the old keychain that signed the challenges\n   * @param newEcdhKeypair - the new keychain that will sign the challenges\n   * @param entChallenge - existing signed enterprise challenge\n   * @param bitgoInstChallenge - existing signed bitgo institutional challenge\n   * @param bitgoNitroChallenge - existing signed bitgo nitro challenge\n   */\n  async resignEnterpriseChallenges(\n    oldEcdhKeypair: EcdhDerivedKeypair,\n    newEcdhKeypair: EcdhDerivedKeypair,\n    entChallenge: SerializedNtildeWithVerifiers,\n    bitgoInstChallenge: SerializedNtildeWithVerifiers,\n    bitgoNitroChallenge: SerializedNtildeWithVerifiers\n  ): Promise<void> {\n    // Verify all the challenges were signed by the old keypair\n    if (\n      !verifyEcdhSignature(\n        EcdsaUtils.getMessageToSignFromChallenge(entChallenge),\n        entChallenge.verifiers.adminSignature,\n        Buffer.from(oldEcdhKeypair.derivedPubKey, 'hex')\n      )\n    ) {\n      throw new Error(`Cannot re-sign. The Enterprise TSS config was signed by another user.`);\n    }\n    if (\n      !verifyEcdhSignature(\n        EcdsaUtils.getMessageToSignFromChallenge(bitgoInstChallenge),\n        bitgoInstChallenge.verifiers.adminSignature,\n        Buffer.from(oldEcdhKeypair.derivedPubKey, 'hex')\n      )\n    ) {\n      throw new Error(`Cannot re-sign. The BitGo Institutional TSS config was signed by another user.`);\n    }\n    if (\n      !verifyEcdhSignature(\n        EcdsaUtils.getMessageToSignFromChallenge(bitgoNitroChallenge),\n        bitgoNitroChallenge.verifiers.adminSignature,\n        Buffer.from(oldEcdhKeypair.derivedPubKey, 'hex')\n      )\n    ) {\n      throw new Error(`Cannot re-sign. The BitGo Nitro TSS config was signed by another user.`);\n    }\n\n    // Once all the challenges are verified, we can re-sign them with the new keypair.\n    const signedEntChallenge = EcdsaUtils.signChallenge(\n      entChallenge,\n      newEcdhKeypair.xprv,\n      newEcdhKeypair.derivationPath\n    );\n    const signedBitGoInstChallenge = EcdsaUtils.signChallenge(\n      bitgoInstChallenge,\n      newEcdhKeypair.xprv,\n      newEcdhKeypair.derivationPath\n    );\n    const signedBitGoNitroChallenge = EcdsaUtils.signChallenge(\n      bitgoNitroChallenge,\n      newEcdhKeypair.xprv,\n      newEcdhKeypair.derivationPath\n    );\n    await EcdsaUtils.uploadChallengesToEnterprise(\n      this.bitgo,\n      this.id,\n      entChallenge,\n      signedEntChallenge.toString('hex'),\n      signedBitGoInstChallenge.toString('hex'),\n      signedBitGoNitroChallenge.toString('hex')\n    );\n  }\n\n  /**\n   *  Check if the enterprise has a set of featureFlags\n   * @param flags\n   */\n  hasFeatureFlags(flags: EnterpriseFeatureFlag[]): boolean {\n    return flags.every((targetFlag) => this._enterprise.featureFlags?.includes(targetFlag));\n  }\n\n  /**\n   * Get the safes collection accessor scoped to this Enterprise\n   * @experimental\n   */\n  safes(): Safes {\n    return new Safes(this.bitgo, this.id);\n  }\n}\n"]}

package/dist/src/bitgo/enterprise/iEnterprise.d.ts

@@ -3,6 +3,7 @@ import { IWallet } from '../wallet';
 import { Buffer } from 'buffer';
 import { BitGoProofSignatures, SerializedNtildeWithVerifiers } from '../utils/tss/ecdsa';
 import { EcdhDerivedKeypair } from '../keychain';
+import { ISafes } from '../safe';
 export type EnterpriseFeatureFlag = 'useEnterpriseEcdsaTssChallenge';
 export interface EnterpriseData {
     id: string;
@@ -23,5 +24,7 @@ export interface IEnterprise {
     getExistingTssEcdsaChallenge(): Promise<EcdsaTypes.DeserializedNtildeWithProofs>;
     resignEnterpriseChallenges(oldEcdhKeypair: EcdhDerivedKeypair, newEcdhKeypair: EcdhDerivedKeypair, entChallenge: SerializedNtildeWithVerifiers, bitgoInstChallenge: SerializedNtildeWithVerifiers, bitgoNitroChallenge: SerializedNtildeWithVerifiers): Promise<void>;
     hasFeatureFlags(flags: EnterpriseFeatureFlag[]): boolean;
+    /** @experimental */
+    safes(): ISafes;
 }
 //# sourceMappingURL=iEnterprise.d.ts.map

package/dist/src/bitgo/enterprise/iEnterprise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iEnterprise.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/enterprise/iEnterprise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGjD,MAAM,MAAM,qBAAqB,GAAG,gCAAgC,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAChE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACpD,oBAAoB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACnE,OAAO,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACpC,UAAU,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACvC,0BAA0B,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzE,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACrF,8BAA8B,CAC5B,YAAY,EAAE,MAAM,EACpB,gCAAgC,EAAE,MAAM,EACxC,iCAAiC,EAAE,MAAM,EACzC,YAAY,EAAE,UAAU,EACxB,SAAS,CAAC,EAAE,UAAU,CAAC,4BAA4B,GAClD,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,4BAA4B,IAAI,OAAO,CAAC,UAAU,CAAC,4BAA4B,CAAC,CAAC;IACjF,0BAA0B,CACxB,cAAc,EAAE,kBAAkB,EAClC,cAAc,EAAE,kBAAkB,EAClC,YAAY,EAAE,6BAA6B,EAC3C,kBAAkB,EAAE,6BAA6B,EACjD,mBAAmB,EAAE,6BAA6B,GACjD,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,eAAe,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC;CAC1D"}
+{"version":3,"file":"iEnterprise.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/enterprise/iEnterprise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,MAAM,MAAM,qBAAqB,GAAG,gCAAgC,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAChE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACpD,oBAAoB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACnE,OAAO,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACpC,UAAU,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACvC,0BAA0B,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzE,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACrF,8BAA8B,CAC5B,YAAY,EAAE,MAAM,EACpB,gCAAgC,EAAE,MAAM,EACxC,iCAAiC,EAAE,MAAM,EACzC,YAAY,EAAE,UAAU,EACxB,SAAS,CAAC,EAAE,UAAU,CAAC,4BAA4B,GAClD,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,4BAA4B,IAAI,OAAO,CAAC,UAAU,CAAC,4BAA4B,CAAC,CAAC;IACjF,0BAA0B,CACxB,cAAc,EAAE,kBAAkB,EAClC,cAAc,EAAE,kBAAkB,EAClC,YAAY,EAAE,6BAA6B,EAC3C,kBAAkB,EAAE,6BAA6B,EACjD,mBAAmB,EAAE,6BAA6B,GACjD,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,eAAe,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC;IACzD,oBAAoB;IACpB,KAAK,IAAI,MAAM,CAAC;CACjB"}

package/dist/src/bitgo/enterprise/iEnterprise.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/index.d.ts

@@ -26,6 +26,7 @@ export * from './tss';
 export { sendSignatureShare } from './tss';
 export * from './types';
 export * from './utils';
+export * from './safe';
 export * from './wallet';
 export * from './webhook';
 export { bitcoinUtil };

package/dist/src/bitgo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bitgo/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAE7B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EAAE,GAAG,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bitgo/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAE7B,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EAAE,GAAG,EAAE,CAAC"}

package/dist/src/bitgo/index.js

@@ -69,6 +69,7 @@ var tss_1 = require("./tss");
 Object.defineProperty(exports, "sendSignatureShare", { enumerable: true, get: function () { return tss_1.sendSignatureShare; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./safe"), exports);
 __exportStar(require("./wallet"), exports);
 __exportStar(require("./webhook"), exports);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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