@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

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

@@ -0,0 +1,445 @@
+"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 statics_1 = require("@bitgo-beta/statics");
+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.
+ */
+class ActiveOperationExistsError extends Error {
+    constructor(operationId) {
+        super(`An active deposit operation already exists: ${operationId}`);
+        this.name = 'ActiveOperationExistsError';
+        this.operationId = operationId;
+    }
+}
+exports.ActiveOperationExistsError = ActiveOperationExistsError;
+/**
+ * Orchestrates ERC-4626 vault deposit and withdraw flows for a wallet.
+ *
+ * Exposed as `wallet.defi` on the Wallet class. See TDD §6.3.1 for the full
+ * design: the SDK sequences two sendMany calls (approve + deposit) and
+ * returns an operationId that the UI uses for status tracking and recovery.
+ *
+ * Uses wallet.sendMany() under the hood so that both custody wallets
+ * (txRequest creation only) and hot wallets (create + sign + broadcast)
+ * are handled by the existing infrastructure.
+ */
+class DefiVault {
+    constructor(wallet) {
+        this.wallet = wallet;
+        this.bitgo = wallet.bitgo;
+    }
+    /**
+     * Fetch the raw vault config from defi-service. Shared by callers that
+     * decode the full response and callers that decode only what they use.
+     */
+    async fetchVaultRaw(vaultId) {
+        if (!vaultId) {
+            throw new Error('vaultId is required');
+        }
+        return await this.bitgo
+            .get(this.bitgo.microservicesUrl(`/api/defi-service/v1/vaults/${vaultId}`))
+            .set('enterprise-id', this.wallet.toJSON().enterprise)
+            .result();
+    }
+    /**
+     * Fetch vault config from defi-service. Used internally to determine
+     * which deposit path to take (Concrete vs Morpho vs Aave V3).
+     */
+    async getVaultConfig(params) {
+        return (0, utils_1.decodeWithCodec)(public_types_1.GetVaultResponse, await this.fetchVaultRaw(params.vaultId), 'getVaultConfig');
+    }
+    /**
+     * Fetch only the vault protocol from defi-service. Decodes the minimal
+     * `VaultDispatch` shape rather than the full `GetVaultResponse`, so callers
+     * that need only the protocol are not hostage to the validity of unrelated
+     * response fields (e.g. `composition[]`) they never consume.
+     */
+    async getVaultProtocol(params) {
+        const { protocol } = (0, utils_1.decodeWithCodec)(DefiVault.VaultDispatch, await this.fetchVaultRaw(params.vaultId), 'vaultDispatch');
+        return protocol;
+    }
+    /**
+     * Deposit an amount of underlying asset into a vault.
+     *
+     * Dispatches to the concrete, Morpho, or Aave V3 path based on vault provider.
+     * The concrete path returns a pendingApproval (custodial wallet).
+     * The Morpho and Aave V3 paths issue two sendMany calls (approve + deposit).
+     *
+     * @param params.vaultId - DeFi-service vault identifier
+     * @param params.amount - amount in base units of the underlying asset
+     * @param params.walletPassphrase - required for hot wallets, omit for custody
+     */
+    async depositToVault(params) {
+        if (!params.vaultId) {
+            throw new Error('vaultId is required');
+        }
+        if (!params.amount) {
+            throw new Error('amount is required');
+        }
+        const protocol = await this.getVaultProtocol({ vaultId: params.vaultId });
+        if (protocol === public_types_1.VaultProtocol.CONCRETE_BTCCX) {
+            return this.depositToConcreteVault(params);
+        }
+        else if (protocol === public_types_1.VaultProtocol.MORPHO || protocol === public_types_1.VaultProtocol.AAVE_V3) {
+            return this.depositToErc4626Vault(params);
+        }
+        else {
+            throw new Error(`Unsupported vault protocol: ${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);
+    }
+    /**
+     * ERC-4626 vault deposit path (Morpho, Aave V3, ...). Issues two sendMany
+     * calls (approve + deposit) and returns the operationId that links them.
+     */
+    async depositToErc4626Vault(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
+        //   .get(this.bitgo.microservicesUrl(this.operationsUrl()))
+        //   .query({ vaultId: params.vaultId, state: 'active' })
+        //   .result();
+        //
+        // if (activeOps.items && activeOps.items.length > 0) {
+        //   throw new ActiveOperationExistsError(activeOps.items[0].operationId);
+        // }
+        // Step 1: Approve txRequest via sendMany
+        const approveResult = await this.wallet.sendMany({
+            type: 'defiApprove',
+            defiParams: {
+                vaultId: params.vaultId,
+                amount: params.amount,
+            },
+            ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),
+        });
+        const approveTxRequestId = this.extractTxRequestId(approveResult);
+        const operationId = this.extractOperationId(approveResult);
+        if (!operationId) {
+            throw new Error('operationId not found in approve txRequest response');
+        }
+        // Step 2: Deposit txRequest via sendMany
+        const depositResult = await this.wallet.sendMany({
+            type: 'defiDeposit',
+            defiParams: {
+                vaultId: params.vaultId,
+                amount: params.amount,
+                operationId,
+            },
+            ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),
+        });
+        const depositTxRequestId = this.extractTxRequestId(depositResult);
+        return {
+            operationId,
+            txRequestIds: {
+                approve: approveTxRequestId,
+                deposit: depositTxRequestId,
+            },
+        };
+    }
+    /**
+     * Resume a partially-completed deposit. Call this when the SDK process died
+     * between the approve and deposit txRequest creation.
+     *
+     * @param params.operationId - the operationId from the original depositToVault call
+     * @param params.walletPassphrase - required for hot wallets, omit for custody
+     */
+    async resumeDeposit(params) {
+        if (!params.operationId) {
+            throw new Error('operationId is required');
+        }
+        // Fetch the operation to get the vault and amount details
+        const operation = await this.getOperation({ operationId: params.operationId });
+        if (operation.associatedTxRequestId) {
+            throw new Error('Deposit txRequest already exists for this operation; nothing to resume');
+        }
+        if (!operation.txRequestId) {
+            throw new Error('Approve txRequest not found for this operation; cannot resume');
+        }
+        // Issue the deposit txRequest using the existing operation's details
+        const depositResult = await this.wallet.sendMany({
+            type: 'defiDeposit',
+            defiParams: {
+                vaultId: operation.vaultId,
+                amount: operation.assetAmount,
+                operationId: params.operationId,
+            },
+            ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),
+        });
+        return {
+            operationId: params.operationId,
+            txRequestIds: {
+                approve: operation.txRequestId,
+                deposit: this.extractTxRequestId(depositResult),
+            },
+        };
+    }
+    /**
+     * Get the current state of a DeFi operation.
+     *
+     * @param params.operationId - the operation to retrieve
+     */
+    async getOperation(params) {
+        if (!params.operationId) {
+            throw new Error('operationId is required');
+        }
+        return await this.bitgo.get(this.bitgo.microservicesUrl(this.operationsUrl() + '/' + params.operationId)).result();
+    }
+    /**
+     * List operations for a vault filtered by walletId.
+     *
+     * @param params.vaultId - vault to list operations for
+     * @param params.state - optional state filter
+     * @param params.type - optional type filter (DEPOSIT | WITHDRAW)
+     * @param params.limit - page size
+     * @param params.cursor - pagination cursor
+     */
+    async listOperations(params) {
+        if (!params.vaultId) {
+            throw new Error('vaultId is required');
+        }
+        const query = {
+            vaultId: params.vaultId,
+        };
+        if (params.state)
+            query.state = params.state;
+        if (params.type)
+            query.type = params.type;
+        if (params.limit)
+            query.limit = params.limit;
+        if (params.cursor)
+            query.cursor = params.cursor;
+        return await this.bitgo.get(this.bitgo.microservicesUrl(this.operationsUrl())).query(query).result();
+    }
+    /**
+     * Withdraw vault shares from a DeFi vault.
+     *
+     * Issues a single sendMany call (defiWithdraw) and returns the operationId
+     * and txRequestId. The state machine for withdrawal is simpler than deposit:
+     * CREATED → WITHDRAW_TX_REQUESTED → WITHDRAW_SIGNED → WITHDRAW_CONFIRMED → COMPLETED
+     *
+     * @param params.vaultId - DeFi-service vault identifier
+     * @param params.amount - amount in base units of the vault share token
+     * @param params.walletPassphrase - required for hot wallets, omit for custody
+     */
+    async withdrawFromVault(params) {
+        if (!params.vaultId) {
+            throw new Error('vaultId is required');
+        }
+        if (!params.amount) {
+            throw new Error('amount is required');
+        }
+        const withdrawResult = await this.wallet.sendMany({
+            type: 'defiWithdraw',
+            defiParams: {
+                vaultId: params.vaultId,
+                amount: params.amount,
+            },
+            ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),
+        });
+        const txRequestId = this.extractTxRequestId(withdrawResult);
+        const operationId = this.extractOperationId(withdrawResult);
+        if (!operationId) {
+            throw new Error('operationId not found in withdraw txRequest response');
+        }
+        return { operationId, txRequestId };
+    }
+    /**
+     * Wrap native currency into its canonical wrapped-native ERC-20
+     * (ETH → WETH via the WETH9 `deposit()` call).
+     *
+     * A thin orchestrator over a single sendMany, like {@link withdrawFromVault}.
+     * WP builds the calldata and resolves the WETH9 address server-side from the
+     * vault binding; the SDK only forwards vaultId and amount.
+     *
+     * @param params.vaultId - DeFi-service vault identifier. Required in v1: binding
+     *   the wrap to a vault is what supplies the per-enterprise authorization gate
+     *   and the address-whitelist path server-side (TDD §3.6). M7 makes it optional,
+     *   which is backward-compatible.
+     * @param params.amount - amount in base units of the native coin (18dp for ETH)
+     * @param params.walletPassphrase - required for hot wallets, omit for custody
+     */
+    async wrap(params) {
+        return this.sendWrapIntent('wrapNative', params);
+    }
+    /**
+     * Unwrap the canonical wrapped-native ERC-20 back to native currency
+     * (WETH → ETH via the WETH9 `withdraw(uint256)` call).
+     *
+     * @param params.vaultId - DeFi-service vault identifier (see {@link wrap})
+     * @param params.amount - amount in base units of the wrapped token (18dp for WETH)
+     * @param params.walletPassphrase - required for hot wallets, omit for custody
+     */
+    async unwrap(params) {
+        return this.sendWrapIntent('unwrapNative', params);
+    }
+    // ── Internal helpers ────────────────────────────────────────────────
+    /**
+     * Shared body of {@link wrap} and {@link unwrap} — the two differ only in the
+     * sendMany type they issue.
+     *
+     * Deliberately does not call {@link extractOperationId}: no operation is minted
+     * for wrap/unwrap in v1, so it would only ever return undefined. Operation
+     * tracking arrives in milestone M5.
+     */
+    async sendWrapIntent(type, params) {
+        const vaultId = params.vaultId?.trim();
+        if (!vaultId) {
+            throw new Error('vaultId is required');
+        }
+        // The downstream BigIntFromString codec (wallet.ts) accepts anything JS's BigInt() constructor
+        // does - negative amounts, hex strings like '0xabc', and zero - and this amount forwards
+        // straight into a value-moving WETH9 deposit()/withdraw() call. Require a positive unsigned
+        // decimal integer string here; zero is deliberately rejected too, since a zero-amount wrap/
+        // unwrap has no on-chain effect but would still spend gas.
+        if (!params.amount || !/^\d+$/.test(params.amount) || BigInt(params.amount) === 0n) {
+            throw new Error('amount must be a positive unsigned decimal integer string');
+        }
+        // Wrapped-native vaults (WETH9 deposit()/withdraw()) only exist on EVM chains. Fail fast here
+        // instead of letting an unsupported coin reach wallet-platform and return an opaque prebuild error.
+        if (!this.wallet.baseCoin.getConfig().features.includes(statics_1.CoinFeature.EVM_COIN)) {
+            throw new Error(`wrap/unwrap is not supported for ${this.wallet.baseCoin.getFamily()} wallets`);
+        }
+        const result = await this.wallet.sendMany({
+            type,
+            defiParams: {
+                vaultId,
+                amount: params.amount,
+            },
+            ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),
+        });
+        return { txRequestId: this.extractTxRequestId(result) };
+    }
+    /**
+     * Extract txRequestId from a sendMany result.
+     * sendMany returns different shapes depending on wallet type:
+     * - TSS full: { txRequest: { txRequestId } } or { pendingApproval, txRequest }
+     * - TSS lite: result from tssUtils.sendTxRequest
+     */
+    extractTxRequestId(sendManyResult) {
+        const txRequest = sendManyResult.txRequest;
+        if (txRequest?.txRequestId) {
+            return txRequest.txRequestId;
+        }
+        if (sendManyResult.txRequestId) {
+            return sendManyResult.txRequestId;
+        }
+        throw new Error('txRequestId not found in sendMany response');
+    }
+    /**
+     * Extract operationId from a sendMany result.
+     *
+     * The WP writes the defi-service-minted operationId into the built
+     * transaction's `coinSpecific` (alongside `assignedNonce`), not into the
+     * intent. Read it from there: the `full` apiVersion surfaces it at
+     * `transactions[0].unsignedTx.coinSpecific.operationId`, the `lite` version
+     * at `unsignedTxs[0].coinSpecific.operationId`. Fall back to
+     * `intent.operationId` for forward-compat in case the WP later also
+     * populates the intent.
+     */
+    extractOperationId(sendManyResult) {
+        const txRequest = sendManyResult.txRequest;
+        if (!txRequest) {
+            return undefined;
+        }
+        // full apiVersion: transactions[0].unsignedTx.coinSpecific.operationId
+        const transactions = txRequest.transactions;
+        const fullUnsignedTx = transactions?.[0]?.unsignedTx;
+        const fullCoinSpecific = fullUnsignedTx?.coinSpecific;
+        if (fullCoinSpecific?.operationId) {
+            return fullCoinSpecific.operationId;
+        }
+        // lite apiVersion: unsignedTxs[0].coinSpecific.operationId
+        const unsignedTxs = txRequest.unsignedTxs;
+        const liteCoinSpecific = unsignedTxs?.[0]?.coinSpecific;
+        if (liteCoinSpecific?.operationId) {
+            return liteCoinSpecific.operationId;
+        }
+        // forward-compat: intent.operationId (in case the WP later populates the intent)
+        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;
+/**
+ * Minimal dispatch codec. The deposit path reads only `protocol` to choose
+ * between the concrete, Morpho, and Aave flows, so it must not hard-fail on the
+ * validity of unrelated response fields (e.g. `composition[]`) it never
+ * consumes. A code path must not fail on the validity of data it does not
+ * consume.
+ */
+DefiVault.VaultDispatch = t.type({ protocol: public_types_1.VaultProtocolType });
+//# 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 * as t from 'io-ts';\nimport { CoinFeature } from '@bitgo-beta/statics';\nimport { GetVaultResponse, VaultProtocol, VaultProtocolType } from '@bitgo/public-types';\nimport {\n  ConcreteDepositResult,\n  Erc4626DepositResult,\n  DefiOperation,\n  DefiOperationListResult,\n  DepositResult,\n  DepositToVaultOptions,\n  GetOperationOptions,\n  GetVaultConfigOptions,\n  IDefiVault,\n  ListOperationsOptions,\n  ResumeDepositOptions,\n  WithdrawFromVaultOptions,\n  WithdrawResult,\n  WrapOptions,\n  WrapResult,\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   * Minimal dispatch codec. The deposit path reads only `protocol` to choose\n   * between the concrete, Morpho, and Aave flows, so it must not hard-fail on the\n   * validity of unrelated response fields (e.g. `composition[]`) it never\n   * consumes. A code path must not fail on the validity of data it does not\n   * consume.\n   */\n  private static readonly VaultDispatch = t.type({ protocol: VaultProtocolType });\n\n  /**\n   * Fetch the raw vault config from defi-service. Shared by callers that\n   * decode the full response and callers that decode only what they use.\n   */\n  private async fetchVaultRaw(vaultId: string): Promise<unknown> {\n    if (!vaultId) {\n      throw new Error('vaultId is required');\n    }\n    return await this.bitgo\n      .get(this.bitgo.microservicesUrl(`/api/defi-service/v1/vaults/${vaultId}`))\n      .set('enterprise-id', this.wallet.toJSON().enterprise)\n      .result();\n  }\n\n  /**\n   * Fetch vault config from defi-service. Used internally to determine\n   * which deposit path to take (Concrete vs Morpho vs Aave V3).\n   */\n  async getVaultConfig(params: GetVaultConfigOptions): Promise<GetVaultResponse> {\n    return decodeWithCodec(GetVaultResponse, await this.fetchVaultRaw(params.vaultId), 'getVaultConfig');\n  }\n\n  /**\n   * Fetch only the vault protocol from defi-service. Decodes the minimal\n   * `VaultDispatch` shape rather than the full `GetVaultResponse`, so callers\n   * that need only the protocol are not hostage to the validity of unrelated\n   * response fields (e.g. `composition[]`) they never consume.\n   */\n  async getVaultProtocol(params: GetVaultConfigOptions): Promise<VaultProtocol> {\n    const { protocol } = decodeWithCodec(\n      DefiVault.VaultDispatch,\n      await this.fetchVaultRaw(params.vaultId),\n      'vaultDispatch'\n    );\n    return protocol;\n  }\n\n  /**\n   * Deposit an amount of underlying asset into a vault.\n   *\n   * Dispatches to the concrete, Morpho, or Aave V3 path based on vault provider.\n   * The concrete path returns a pendingApproval (custodial wallet).\n   * The Morpho and Aave V3 paths issue 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.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 protocol = await this.getVaultProtocol({ vaultId: params.vaultId });\n\n    if (protocol === VaultProtocol.CONCRETE_BTCCX) {\n      return this.depositToConcreteVault(params);\n    } else if (protocol === VaultProtocol.MORPHO || protocol === VaultProtocol.AAVE_V3) {\n      return this.depositToErc4626Vault(params);\n    } else {\n      throw new Error(`Unsupported vault protocol: ${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   * ERC-4626 vault deposit path (Morpho, Aave V3, ...). Issues two sendMany\n   * calls (approve + deposit) and returns the operationId that links them.\n   */\n  private async depositToErc4626Vault(params: DepositToVaultOptions): Promise<Erc4626DepositResult> {\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      },\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      },\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  /**\n   * Withdraw vault shares from a DeFi vault.\n   *\n   * Issues a single sendMany call (defiWithdraw) and returns the operationId\n   * and txRequestId. The state machine for withdrawal is simpler than deposit:\n   * CREATED → WITHDRAW_TX_REQUESTED → WITHDRAW_SIGNED → WITHDRAW_CONFIRMED → COMPLETED\n   *\n   * @param params.vaultId - DeFi-service vault identifier\n   * @param params.amount - amount in base units of the vault share token\n   * @param params.walletPassphrase - required for hot wallets, omit for custody\n   */\n  async withdrawFromVault(params: WithdrawFromVaultOptions): Promise<WithdrawResult> {\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 withdrawResult = await this.wallet.sendMany({\n      type: 'defiWithdraw',\n      defiParams: {\n        vaultId: params.vaultId,\n        amount: params.amount,\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n\n    const txRequestId = this.extractTxRequestId(withdrawResult);\n    const operationId = this.extractOperationId(withdrawResult);\n\n    if (!operationId) {\n      throw new Error('operationId not found in withdraw txRequest response');\n    }\n\n    return { operationId, txRequestId };\n  }\n\n  /**\n   * Wrap native currency into its canonical wrapped-native ERC-20\n   * (ETH → WETH via the WETH9 `deposit()` call).\n   *\n   * A thin orchestrator over a single sendMany, like {@link withdrawFromVault}.\n   * WP builds the calldata and resolves the WETH9 address server-side from the\n   * vault binding; the SDK only forwards vaultId and amount.\n   *\n   * @param params.vaultId - DeFi-service vault identifier. Required in v1: binding\n   *   the wrap to a vault is what supplies the per-enterprise authorization gate\n   *   and the address-whitelist path server-side (TDD §3.6). M7 makes it optional,\n   *   which is backward-compatible.\n   * @param params.amount - amount in base units of the native coin (18dp for ETH)\n   * @param params.walletPassphrase - required for hot wallets, omit for custody\n   */\n  async wrap(params: WrapOptions): Promise<WrapResult> {\n    return this.sendWrapIntent('wrapNative', params);\n  }\n\n  /**\n   * Unwrap the canonical wrapped-native ERC-20 back to native currency\n   * (WETH → ETH via the WETH9 `withdraw(uint256)` call).\n   *\n   * @param params.vaultId - DeFi-service vault identifier (see {@link wrap})\n   * @param params.amount - amount in base units of the wrapped token (18dp for WETH)\n   * @param params.walletPassphrase - required for hot wallets, omit for custody\n   */\n  async unwrap(params: WrapOptions): Promise<WrapResult> {\n    return this.sendWrapIntent('unwrapNative', params);\n  }\n\n  // ── Internal helpers ────────────────────────────────────────────────\n\n  /**\n   * Shared body of {@link wrap} and {@link unwrap} — the two differ only in the\n   * sendMany type they issue.\n   *\n   * Deliberately does not call {@link extractOperationId}: no operation is minted\n   * for wrap/unwrap in v1, so it would only ever return undefined. Operation\n   * tracking arrives in milestone M5.\n   */\n  private async sendWrapIntent(type: 'wrapNative' | 'unwrapNative', params: WrapOptions): Promise<WrapResult> {\n    const vaultId = params.vaultId?.trim();\n    if (!vaultId) {\n      throw new Error('vaultId is required');\n    }\n    // The downstream BigIntFromString codec (wallet.ts) accepts anything JS's BigInt() constructor\n    // does - negative amounts, hex strings like '0xabc', and zero - and this amount forwards\n    // straight into a value-moving WETH9 deposit()/withdraw() call. Require a positive unsigned\n    // decimal integer string here; zero is deliberately rejected too, since a zero-amount wrap/\n    // unwrap has no on-chain effect but would still spend gas.\n    if (!params.amount || !/^\\d+$/.test(params.amount) || BigInt(params.amount) === 0n) {\n      throw new Error('amount must be a positive unsigned decimal integer string');\n    }\n    // Wrapped-native vaults (WETH9 deposit()/withdraw()) only exist on EVM chains. Fail fast here\n    // instead of letting an unsupported coin reach wallet-platform and return an opaque prebuild error.\n    if (!this.wallet.baseCoin.getConfig().features.includes(CoinFeature.EVM_COIN)) {\n      throw new Error(`wrap/unwrap is not supported for ${this.wallet.baseCoin.getFamily()} wallets`);\n    }\n\n    const result = await this.wallet.sendMany({\n      type,\n      defiParams: {\n        vaultId,\n        amount: params.amount,\n      },\n      ...(params.walletPassphrase ? { walletPassphrase: params.walletPassphrase } : {}),\n    });\n\n    return { txRequestId: this.extractTxRequestId(result) };\n  }\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

@@ -0,0 +1,101 @@
+/**
+ * @prettier
+ */
+import { GetVaultResponse, VaultProtocol } from '@bitgo/public-types';
+export interface DepositToVaultOptions {
+    /** DeFi-service vault identifier */
+    vaultId: string;
+    /** Amount in base units of the underlying asset */
+    amount: string;
+    /** Wallet passphrase — required for hot wallets, omit for custody */
+    walletPassphrase?: string;
+}
+export interface ResumeDepositOptions {
+    /** operationId of the partially-completed deposit */
+    operationId: string;
+    /** Wallet passphrase — required for hot wallets, omit for custody */
+    walletPassphrase?: string;
+}
+export interface GetOperationOptions {
+    operationId: string;
+}
+export interface ListOperationsOptions {
+    vaultId: string;
+    state?: string;
+    type?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface GetVaultConfigOptions {
+    vaultId: string;
+}
+export interface DefiOperation {
+    operationId: string;
+    walletId: string;
+    vaultId: string;
+    type: 'DEPOSIT' | 'WITHDRAW';
+    assetAmount: string;
+    state: string;
+    txRequestId?: string;
+    associatedTxRequestId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConcreteDepositResult {
+    pendingApprovalId: string;
+    state: string;
+}
+export interface Erc4626DepositResult {
+    operationId: string;
+    txRequestIds: {
+        approve: string;
+        deposit: string;
+    };
+}
+/**
+ * @deprecated Renamed to {@link Erc4626DepositResult}. Alias kept for
+ * backward compatibility with the published sdk-core API.
+ */
+export type MorphoDepositResult = Erc4626DepositResult;
+export type DepositResult = ConcreteDepositResult | Erc4626DepositResult;
+export interface DefiOperationListResult {
+    items: DefiOperation[];
+    nextCursor?: string;
+}
+export interface WithdrawFromVaultOptions {
+    /** DeFi-service vault identifier */
+    vaultId: string;
+    /** Amount in base units of the vault share token */
+    amount: string;
+    /** Wallet passphrase — required for hot wallets, omit for custody */
+    walletPassphrase?: string;
+}
+export interface WithdrawResult {
+    operationId: string;
+    txRequestId: string;
+}
+export interface WrapOptions {
+    /** DeFi-service vault identifier — required in v1, see note below */
+    vaultId: string;
+    /** Amount in base units (18dp for ETH/WETH) */
+    amount: string;
+    /** Wallet passphrase — required for hot wallets, omit for custody */
+    walletPassphrase?: string;
+}
+export interface WrapResult {
+    txRequestId: string;
+    /** Reserved — populated from milestone M5 onward, absent in v1 */
+    operationId?: string;
+}
+export interface IDefiVault {
+    depositToVault(params: DepositToVaultOptions): Promise<DepositResult>;
+    resumeDeposit(params: ResumeDepositOptions): Promise<DepositResult>;
+    getOperation(params: GetOperationOptions): Promise<DefiOperation>;
+    listOperations(params: ListOperationsOptions): Promise<DefiOperationListResult>;
+    getVaultConfig(params: GetVaultConfigOptions): Promise<GetVaultResponse>;
+    getVaultProtocol(params: GetVaultConfigOptions): Promise<VaultProtocol>;
+    withdrawFromVault(params: WithdrawFromVaultOptions): Promise<WithdrawResult>;
+    wrap(params: WrapOptions): Promise<WrapResult>;
+    unwrap(params: WrapOptions): Promise<WrapResult>;
+}
+//# sourceMappingURL=iDefiVault.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iDefiVault.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/defi/iDefiVault.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @prettier
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaURlZmlWYXVsdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iaXRnby9kZWZpL2lEZWZpVmF1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcHJldHRpZXJcbiAqL1xuXG5pbXBvcnQgeyBHZXRWYXVsdFJlc3BvbnNlLCBWYXVsdFByb3RvY29sIH0gZnJvbSAnQGJpdGdvL3B1YmxpYy10eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGVwb3NpdFRvVmF1bHRPcHRpb25zIHtcbiAgLyoqIERlRmktc2VydmljZSB2YXVsdCBpZGVudGlmaWVyICovXG4gIHZhdWx0SWQ6IHN0cmluZztcbiAgLyoqIEFtb3VudCBpbiBiYXNlIHVuaXRzIG9mIHRoZSB1bmRlcmx5aW5nIGFzc2V0ICovXG4gIGFtb3VudDogc3RyaW5nO1xuICAvKiogV2FsbGV0IHBhc3NwaHJhc2Ug4oCUIHJlcXVpcmVkIGZvciBob3Qgd2FsbGV0cywgb21pdCBmb3IgY3VzdG9keSAqL1xuICB3YWxsZXRQYXNzcGhyYXNlPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFJlc3VtZURlcG9zaXRPcHRpb25zIHtcbiAgLyoqIG9wZXJhdGlvbklkIG9mIHRoZSBwYXJ0aWFsbHktY29tcGxldGVkIGRlcG9zaXQgKi9cbiAgb3BlcmF0aW9uSWQ6IHN0cmluZztcbiAgLyoqIFdhbGxldCBwYXNzcGhyYXNlIOKAlCByZXF1aXJlZCBmb3IgaG90IHdhbGxldHMsIG9taXQgZm9yIGN1c3RvZHkgKi9cbiAgd2FsbGV0UGFzc3BocmFzZT86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBHZXRPcGVyYXRpb25PcHRpb25zIHtcbiAgb3BlcmF0aW9uSWQ6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBMaXN0T3BlcmF0aW9uc09wdGlvbnMge1xuICB2YXVsdElkOiBzdHJpbmc7XG4gIHN0YXRlPzogc3RyaW5nO1xuICB0eXBlPzogc3RyaW5nO1xuICBsaW1pdD86IG51bWJlcjtcbiAgY3Vyc29yPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdldFZhdWx0Q29uZmlnT3B0aW9ucyB7XG4gIHZhdWx0SWQ6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEZWZpT3BlcmF0aW9uIHtcbiAgb3BlcmF0aW9uSWQ6IHN0cmluZztcbiAgd2FsbGV0SWQ6IHN0cmluZztcbiAgdmF1bHRJZDogc3RyaW5nO1xuICB0eXBlOiAnREVQT1NJVCcgfCAnV0lUSERSQVcnO1xuICBhc3NldEFtb3VudDogc3RyaW5nO1xuICBzdGF0ZTogc3RyaW5nO1xuICB0eFJlcXVlc3RJZD86IHN0cmluZztcbiAgYXNzb2NpYXRlZFR4UmVxdWVzdElkPzogc3RyaW5nO1xuICBjcmVhdGVkQXQ6IHN0cmluZztcbiAgdXBkYXRlZEF0OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29uY3JldGVEZXBvc2l0UmVzdWx0IHtcbiAgcGVuZGluZ0FwcHJvdmFsSWQ6IHN0cmluZztcbiAgc3RhdGU6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBFcmM0NjI2RGVwb3NpdFJlc3VsdCB7XG4gIG9wZXJhdGlvbklkOiBzdHJpbmc7XG4gIHR4UmVxdWVzdElkczogeyBhcHByb3ZlOiBzdHJpbmc7IGRlcG9zaXQ6IHN0cmluZyB9O1xufVxuXG4vKipcbiAqIEBkZXByZWNhdGVkIFJlbmFtZWQgdG8ge0BsaW5rIEVyYzQ2MjZEZXBvc2l0UmVzdWx0fS4gQWxpYXMga2VwdCBmb3JcbiAqIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgd2l0aCB0aGUgcHVibGlzaGVkIHNkay1jb3JlIEFQSS5cbiAqL1xuZXhwb3J0IHR5cGUgTW9ycGhvRGVwb3NpdFJlc3VsdCA9IEVyYzQ2MjZEZXBvc2l0UmVzdWx0O1xuXG5leHBvcnQgdHlwZSBEZXBvc2l0UmVzdWx0ID0gQ29uY3JldGVEZXBvc2l0UmVzdWx0IHwgRXJjNDYyNkRlcG9zaXRSZXN1bHQ7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGVmaU9wZXJhdGlvbkxpc3RSZXN1bHQge1xuICBpdGVtczogRGVmaU9wZXJhdGlvbltdO1xuICBuZXh0Q3Vyc29yPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFdpdGhkcmF3RnJvbVZhdWx0T3B0aW9ucyB7XG4gIC8qKiBEZUZpLXNlcnZpY2UgdmF1bHQgaWRlbnRpZmllciAqL1xuICB2YXVsdElkOiBzdHJpbmc7XG4gIC8qKiBBbW91bnQgaW4gYmFzZSB1bml0cyBvZiB0aGUgdmF1bHQgc2hhcmUgdG9rZW4gKi9cbiAgYW1vdW50OiBzdHJpbmc7XG4gIC8qKiBXYWxsZXQgcGFzc3BocmFzZSDigJQgcmVxdWlyZWQgZm9yIGhvdCB3YWxsZXRzLCBvbWl0IGZvciBjdXN0b2R5ICovXG4gIHdhbGxldFBhc3NwaHJhc2U/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgV2l0aGRyYXdSZXN1bHQge1xuICBvcGVyYXRpb25JZDogc3RyaW5nO1xuICB0eFJlcXVlc3RJZDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFdyYXBPcHRpb25zIHtcbiAgLyoqIERlRmktc2VydmljZSB2YXVsdCBpZGVudGlmaWVyIOKAlCByZXF1aXJlZCBpbiB2MSwgc2VlIG5vdGUgYmVsb3cgKi9cbiAgdmF1bHRJZDogc3RyaW5nO1xuICAvKiogQW1vdW50IGluIGJhc2UgdW5pdHMgKDE4ZHAgZm9yIEVUSC9XRVRIKSAqL1xuICBhbW91bnQ6IHN0cmluZztcbiAgLyoqIFdhbGxldCBwYXNzcGhyYXNlIOKAlCByZXF1aXJlZCBmb3IgaG90IHdhbGxldHMsIG9taXQgZm9yIGN1c3RvZHkgKi9cbiAgd2FsbGV0UGFzc3BocmFzZT86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXcmFwUmVzdWx0IHtcbiAgdHhSZXF1ZXN0SWQ6IHN0cmluZztcbiAgLyoqIFJlc2VydmVkIOKAlCBwb3B1bGF0ZWQgZnJvbSBtaWxlc3RvbmUgTTUgb253YXJkLCBhYnNlbnQgaW4gdjEgKi9cbiAgb3BlcmF0aW9uSWQ/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSURlZmlWYXVsdCB7XG4gIGRlcG9zaXRUb1ZhdWx0KHBhcmFtczogRGVwb3NpdFRvVmF1bHRPcHRpb25zKTogUHJvbWlzZTxEZXBvc2l0UmVzdWx0PjtcbiAgcmVzdW1lRGVwb3NpdChwYXJhbXM6IFJlc3VtZURlcG9zaXRPcHRpb25zKTogUHJvbWlzZTxEZXBvc2l0UmVzdWx0PjtcbiAgZ2V0T3BlcmF0aW9uKHBhcmFtczogR2V0T3BlcmF0aW9uT3B0aW9ucyk6IFByb21pc2U8RGVmaU9wZXJhdGlvbj47XG4gIGxpc3RPcGVyYXRpb25zKHBhcmFtczogTGlzdE9wZXJhdGlvbnNPcHRpb25zKTogUHJvbWlzZTxEZWZpT3BlcmF0aW9uTGlzdFJlc3VsdD47XG4gIGdldFZhdWx0Q29uZmlnKHBhcmFtczogR2V0VmF1bHRDb25maWdPcHRpb25zKTogUHJvbWlzZTxHZXRWYXVsdFJlc3BvbnNlPjtcbiAgZ2V0VmF1bHRQcm90b2NvbChwYXJhbXM6IEdldFZhdWx0Q29uZmlnT3B0aW9ucyk6IFByb21pc2U8VmF1bHRQcm90b2NvbD47XG4gIHdpdGhkcmF3RnJvbVZhdWx0KHBhcmFtczogV2l0aGRyYXdGcm9tVmF1bHRPcHRpb25zKTogUHJvbWlzZTxXaXRoZHJhd1Jlc3VsdD47XG4gIHdyYXAocGFyYW1zOiBXcmFwT3B0aW9ucyk6IFByb21pc2U8V3JhcFJlc3VsdD47XG4gIHVud3JhcChwYXJhbXM6IFdyYXBPcHRpb25zKTogUHJvbWlzZTxXcmFwUmVzdWx0Pjtcbn1cbiJdfQ==

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

@@ -0,0 +1,3 @@
+export * from './iDefiVault';
+export { DefiVault, ActiveOperationExistsError } from './defiVault';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/defi/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC"}