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

package/dist/src/bitgo/safe/safes.d.ts

@@ -0,0 +1,102 @@
+import { InitializeSafeResponse } from '@bitgo/public-types';
+import { BitGoBase } from '../bitgoBase';
+import { FinalizeSafeOptions, InitializeSafeOptions } from './iSafe';
+import { CreateSafeOptions, GetSafeOptions, ISafes, ListSafesOptions, SafeCreationHandle, SafeKeys } from './iSafes';
+import { Safe } from './safe';
+/**
+ * Collection accessor for a single enterprise's safes, mirroring Wallets / Enterprises.
+ * Safe routes are enterprise-scoped (/api/v2/enterprise/:eId/safes), so the accessor is
+ * constructed with the enterprise id (see Enterprise.safes()).
+ *
+ * @experimental
+ */
+export declare class Safes implements ISafes {
+    private readonly bitgo;
+    private readonly enterpriseId;
+    constructor(bitgo: BitGoBase, enterpriseId: string);
+    /**
+     * Enterprise-scoped v2 URL for the safes collection, e.g. /api/v2/enterprise/:eId/safes
+     * @param extra
+     */
+    private url;
+    /**
+     * One-call convenience wrapper chaining the three creation phases:
+     * initialize (Phase 1) → createSafeKeys (Phase 2, enabled-slot ceremonies) →
+     * finalize (Phase 3). HOT custody only in v1.
+     *
+     * If a key ceremony fails, `createSafeKeys` archives the safe before throwing, so a failed run
+     * leaves no half-created safe behind — create a new safe and retry.
+     * @experimental
+     */
+    generateSafe(params: CreateSafeOptions): Promise<Safe>;
+    /**
+     * Phase 1 — initialize a safe (metadata only, no key material).
+     * POST /api/v2/enterprise/:eId/safes { label }
+     * Response is `{ id, status }` plus optional `enabledRootSlots` (absent on older WP).
+     * @experimental
+     */
+    initializeSafe(params: InitializeSafeOptions): Promise<InitializeSafeResponse>;
+    /**
+     * Phase 2 — run the enabled root key ceremonies tagged with `safeId`; returns ordered
+     * [user, backup, bitgo] triplets for those slots. HOT custody only in v1.
+     *
+     * Absent `enabledRootSlots` (older WP, pre-gating) runs all 4 slots. Enabled ceremonies
+     * (2.1 multisig ①④, 2.2 MPC ②③) run in parallel. If any of them fail, the
+     * partially-created safe is archived (a legal `initializing → archived` transition, so the
+     * orphaned tagged keys are inert) and an error listing every ceremony failure is thrown —
+     * create a new safe and retry.
+     *
+     * Not independently idempotent: re-running against a safe that already has some roots hits WP's
+     * unique root-slot index.
+     * @experimental
+     */
+    createSafeKeys(params: CreateSafeOptions & SafeCreationHandle): Promise<SafeKeys>;
+    /**
+     * Archive a safe. Also the abandonment path for a stuck `initializing` safe (used by
+     * `createSafeKeys` to clean up after a failed ceremony).
+     * POST /api/v2/enterprise/:eId/safes/:safeId/archive
+     * @experimental
+     */
+    archiveSafe(safeId: string): Promise<Safe>;
+    /**
+     * Phase 3 — finalize a safe with the minted root key ids as ordered [user, backup, bitgo] triplets.
+     * POST /api/v2/enterprise/:eId/safes/:safeId/finalize { rootKeys }.
+     * Idempotent: re-finalizing with the same `rootKeys` returns the active safe again (200).
+     * @experimental
+     */
+    finalizeSafe(safeId: string, params: FinalizeSafeOptions): Promise<Safe>;
+    /**
+     * Phase 2.1 helper — mint one onchain-multisig root (cold model, as wallet creation does today):
+     * generate user/backup keypairs locally, encrypt with `passphrase`, register via POST /:coin/key
+     * with `safeId`; the BitGo key is created through the same route's `source:'bitgo'` path.
+     * Returns the [user, backup, bitgo] key id triplet.
+     * @experimental
+     */
+    private createMultisigRoot;
+    /**
+     * Phase 2.2 helper — run one MPC ceremony (DKLS for ecdsaMpc, EdDSA for eddsaMpc) via the
+     * existing `createMpc` flow with `safeId` threaded through, so the resulting user/backup/bitgo
+     * keys land tagged. Returns the [user, backup, bitgo] key id triplet.
+     * @experimental
+     */
+    private createMpcRoot;
+    /**
+     * List the enterprise's safes the caller is a member of (cursor pagination).
+     * GET /api/v2/enterprise/:eId/safes?limit&prevId
+     *
+     * `cursor` is the opaque `nextCursor` returned by a previous call; page forward until
+     * `nextCursor` is absent.
+     * @experimental
+     */
+    list(params?: ListSafesOptions): Promise<{
+        safes: Safe[];
+        nextCursor?: string;
+    }>;
+    /**
+     * Fetch a single safe by id. Non-members get a 404 (existence is not leaked).
+     * GET /api/v2/enterprise/:eId/safes/:safeId
+     * @experimental
+     */
+    get(params: GetSafeOptions): Promise<Safe>;
+}
+//# sourceMappingURL=safes.d.ts.map

package/dist/src/bitgo/safe/safes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safes.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/safe/safes.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,sBAAsB,EAKvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAKzC,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAErH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAa9B;;;;;;GAMG;AACH,qBAAa,KAAM,YAAW,MAAM;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAE1B,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM;IAKlD;;;OAGG;IACH,OAAO,CAAC,GAAG;IAIX;;;;;;;;OAQG;IACG,YAAY,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5D;;;;;OAKG;IACG,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAKpF;;;;;;;;;;;;;OAaG;IACG,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAuDvF;;;;;OAKG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAShD;;;;;OAKG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAW9E;;;;;;OAMG;YACW,kBAAkB;IAwChC;;;;;OAKG;YACW,aAAa;IAY3B;;;;;;;OAOG;IACG,IAAI,CAAC,MAAM,GAAE,gBAAqB,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAiB1F;;;;OAIG;IACG,GAAG,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAKjD"}

package/dist/src/bitgo/safe/safes.js

@@ -0,0 +1,281 @@
+"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.Safes = void 0;
+/**
+ * @prettier
+ *
+ * @experimental The safe client surface is experimental and may change (including breaking
+ * changes) before the public release.
+ */
+const t = __importStar(require("io-ts"));
+const public_types_1 = require("@bitgo/public-types");
+const errors_1 = require("../errors");
+const codecs_1 = require("../utils/codecs");
+const sdk_lib_safes_1 = require("@bitgo-beta/sdk-lib-safes");
+const postWithCodec_1 = require("../utils/postWithCodec");
+const rootCoin_1 = require("./rootCoin");
+const safe_1 = require("./safe");
+/**
+ * Wire shape of the paginated `GET /enterprise/:eId/safes` response. WP paginates with the v2
+ * `prevId`/`nextBatchPrevId` convention; the SDK re-exposes it as an opaque `cursor`/`nextCursor`
+ * (see `list`).
+ * @experimental
+ */
+const ListSafesResponse = t.intersection([
+    t.type({ safes: t.array(public_types_1.SafeData) }),
+    t.partial({ nextBatchPrevId: t.string }),
+]);
+/**
+ * Collection accessor for a single enterprise's safes, mirroring Wallets / Enterprises.
+ * Safe routes are enterprise-scoped (/api/v2/enterprise/:eId/safes), so the accessor is
+ * constructed with the enterprise id (see Enterprise.safes()).
+ *
+ * @experimental
+ */
+class Safes {
+    constructor(bitgo, enterpriseId) {
+        this.bitgo = bitgo;
+        this.enterpriseId = enterpriseId;
+    }
+    /**
+     * Enterprise-scoped v2 URL for the safes collection, e.g. /api/v2/enterprise/:eId/safes
+     * @param extra
+     */
+    url(extra = '') {
+        return this.bitgo.url(`/enterprise/${this.enterpriseId}/safes${extra}`, 2);
+    }
+    /**
+     * One-call convenience wrapper chaining the three creation phases:
+     * initialize (Phase 1) → createSafeKeys (Phase 2, enabled-slot ceremonies) →
+     * finalize (Phase 3). HOT custody only in v1.
+     *
+     * If a key ceremony fails, `createSafeKeys` archives the safe before throwing, so a failed run
+     * leaves no half-created safe behind — create a new safe and retry.
+     * @experimental
+     */
+    async generateSafe(params) {
+        const safe = await this.initializeSafe({ label: params.label });
+        const rootKeys = await this.createSafeKeys({
+            ...params,
+            safeId: safe.id,
+            enabledRootSlots: safe.enabledRootSlots,
+        });
+        return await this.finalizeSafe(safe.id, rootKeys);
+    }
+    /**
+     * Phase 1 — initialize a safe (metadata only, no key material).
+     * POST /api/v2/enterprise/:eId/safes { label }
+     * Response is `{ id, status }` plus optional `enabledRootSlots` (absent on older WP).
+     * @experimental
+     */
+    async initializeSafe(params) {
+        const response = await (0, postWithCodec_1.postWithCodec)(this.bitgo, this.url(), public_types_1.InitializeSafeBody, params).result();
+        return (0, codecs_1.decodeWithCodec)(public_types_1.InitializeSafeResponse, response, 'InitializeSafeResponse');
+    }
+    /**
+     * Phase 2 — run the enabled root key ceremonies tagged with `safeId`; returns ordered
+     * [user, backup, bitgo] triplets for those slots. HOT custody only in v1.
+     *
+     * Absent `enabledRootSlots` (older WP, pre-gating) runs all 4 slots. Enabled ceremonies
+     * (2.1 multisig ①④, 2.2 MPC ②③) run in parallel. If any of them fail, the
+     * partially-created safe is archived (a legal `initializing → archived` transition, so the
+     * orphaned tagged keys are inert) and an error listing every ceremony failure is thrown —
+     * create a new safe and retry.
+     *
+     * Not independently idempotent: re-running against a safe that already has some roots hits WP's
+     * unique root-slot index.
+     * @experimental
+     */
+    async createSafeKeys(params) {
+        const { safeId, passphrase, enabledRootSlots } = params;
+        const enterprise = this.enterpriseId;
+        // Absent `enabledRootSlots` (older WP, pre-gating) ⇒ all 4, preserving current behavior.
+        // Ordered by scheme: the two multisig roots first, then the two MPC roots.
+        const enabled = new Set(enabledRootSlots ?? rootCoin_1.SAFE_ROOT_SLOTS);
+        const slots = rootCoin_1.SAFE_ROOT_SLOTS.filter((slot) => enabled.has(slot));
+        const ceremonies = {
+            // Phase 2.1 — multisig roots (①④): local user/backup keypairs + BitGo key, all safeId-tagged.
+            secp256k1Multisig: () => this.createMultisigRoot('secp256k1Multisig', safeId, passphrase, enterprise),
+            ed25519Multisig: () => this.createMultisigRoot('ed25519Multisig', safeId, passphrase, enterprise),
+            // Phase 2.2 — MPC roots (②③): the existing DKLS (②) and EdDSA (③) ceremonies, safeId threaded.
+            ecdsaMpc: () => this.createMpcRoot('ecdsaMpc', safeId, passphrase, enterprise),
+            eddsaMpc: () => this.createMpcRoot('eddsaMpc', safeId, passphrase, enterprise),
+        };
+        const results = await Promise.allSettled(slots.map((slot) => ceremonies[slot]()));
+        // Single pass over the settled results: `status === 'fulfilled'` narrows `.value` to a
+        // RootKeyTriplet, and rejections are collected per-slot for the error below.
+        const hot = {};
+        const failures = [];
+        results.forEach((result, i) => {
+            if (result.status === 'fulfilled') {
+                hot[slots[i]] = result.value;
+            }
+            else {
+                const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+                // ApiResponseError carries the server-echoed `Request-ID` header — include it (when
+                // present) so a failed ceremony can be correlated with WP's server-side logs.
+                const requestId = result.reason instanceof errors_1.ApiResponseError ? result.reason.requestId : undefined;
+                failures.push(`${slots[i]}: ${reason}${requestId ? ` (requestId: ${requestId})` : ''}`);
+            }
+        });
+        if (failures.length > 0) {
+            // Best-effort abandon the partially-created safe so a retry starts from a clean slate. Keep
+            // the ceremony failures as the primary error; note it if the cleanup archive also failed.
+            let archiveError;
+            try {
+                await this.archiveSafe(safeId);
+            }
+            catch (e) {
+                archiveError = e instanceof Error ? e : new Error(String(e));
+            }
+            let message = `Safe key generation failed for ${failures.length} root ceremony/ies ` +
+                `[${failures.join('; ')}]. The safe (${safeId}) has been archived; create a new safe and retry.`;
+            if (archiveError) {
+                message += ` NOTE: archiving the safe also failed (${archiveError.message}); archive it manually before retrying.`;
+            }
+            throw new Error(message);
+        }
+        return { rootKeys: { hot } };
+    }
+    /**
+     * Archive a safe. Also the abandonment path for a stuck `initializing` safe (used by
+     * `createSafeKeys` to clean up after a failed ceremony).
+     * POST /api/v2/enterprise/:eId/safes/:safeId/archive
+     * @experimental
+     */
+    async archiveSafe(safeId) {
+        const response = await this.bitgo
+            .post(this.url(`/${safeId}/archive`))
+            .send()
+            .result();
+        const safeData = (0, codecs_1.decodeWithCodec)(public_types_1.SafeData, response, 'SafeData');
+        return new safe_1.Safe(this.bitgo, safeData);
+    }
+    /**
+     * Phase 3 — finalize a safe with the minted root key ids as ordered [user, backup, bitgo] triplets.
+     * POST /api/v2/enterprise/:eId/safes/:safeId/finalize { rootKeys }.
+     * Idempotent: re-finalizing with the same `rootKeys` returns the active safe again (200).
+     * @experimental
+     */
+    async finalizeSafe(safeId, params) {
+        const response = await (0, postWithCodec_1.postWithCodec)(this.bitgo, this.url(`/${safeId}/finalize`), public_types_1.FinalizeSafeBody, params).result();
+        const safeData = (0, codecs_1.decodeWithCodec)(public_types_1.SafeData, response, 'SafeData');
+        return new safe_1.Safe(this.bitgo, safeData);
+    }
+    /**
+     * Phase 2.1 helper — mint one onchain-multisig root (cold model, as wallet creation does today):
+     * generate user/backup keypairs locally, encrypt with `passphrase`, register via POST /:coin/key
+     * with `safeId`; the BitGo key is created through the same route's `source:'bitgo'` path.
+     * Returns the [user, backup, bitgo] key id triplet.
+     * @experimental
+     */
+    async createMultisigRoot(slot, safeId, passphrase, enterprise) {
+        const keychains = (0, rootCoin_1.coinForRoot)(this.bitgo, slot).keychains();
+        const userKeyPair = keychains.create();
+        const userKeychainPromise = keychains.add({
+            pub: userKeyPair.pub,
+            encryptedPrv: await this.bitgo.encrypt({ input: userKeyPair.prv, password: passphrase }),
+            source: 'user',
+            safeId,
+        });
+        const backupKeychainPromise = keychains.createBackup({ passphrase, safeId });
+        const bitgoKeychainPromise = keychains.createBitGo({ enterprise, safeId });
+        const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([
+            userKeychainPromise,
+            backupKeychainPromise,
+            bitgoKeychainPromise,
+        ]);
+        // Slot ④ roots use neutral raw public derivation material (32-byte public key plus 32-byte
+        // chain code), serialized together as canonical unpadded RFC 4648 base32 (103 characters).
+        // Coin-specific child encoding is performed by Wallet Platform after soft derivation.
+        if (slot === 'ed25519Multisig' &&
+            (!backupKeychain.pub ||
+                !(0, sdk_lib_safes_1.isDerivableEd25519Pub)(backupKeychain.pub) ||
+                !bitgoKeychain.pub ||
+                !(0, sdk_lib_safes_1.isDerivableEd25519Pub)(bitgoKeychain.pub))) {
+            throw new Error('Safe ed25519Multisig roots are not derivable: expected 64-byte canonical base32 material');
+        }
+        return [userKeychain.id, backupKeychain.id, bitgoKeychain.id];
+    }
+    /**
+     * Phase 2.2 helper — run one MPC ceremony (DKLS for ecdsaMpc, EdDSA for eddsaMpc) via the
+     * existing `createMpc` flow with `safeId` threaded through, so the resulting user/backup/bitgo
+     * keys land tagged. Returns the [user, backup, bitgo] key id triplet.
+     * @experimental
+     */
+    async createMpcRoot(slot, safeId, passphrase, enterprise) {
+        const { userKeychain, backupKeychain, bitgoKeychain } = await (0, rootCoin_1.coinForRoot)(this.bitgo, slot)
+            .keychains()
+            .createMpc({ multisigType: 'tss', passphrase, enterprise, safeId });
+        return [userKeychain.id, backupKeychain.id, bitgoKeychain.id];
+    }
+    /**
+     * List the enterprise's safes the caller is a member of (cursor pagination).
+     * GET /api/v2/enterprise/:eId/safes?limit&prevId
+     *
+     * `cursor` is the opaque `nextCursor` returned by a previous call; page forward until
+     * `nextCursor` is absent.
+     * @experimental
+     */
+    async list(params = {}) {
+        // SDK exposes an opaque cursor; WP speaks prevId/nextBatchPrevId (v2 list convention).
+        const query = {};
+        if (params.limit !== undefined) {
+            query.limit = params.limit;
+        }
+        if (params.cursor !== undefined) {
+            query.prevId = params.cursor;
+        }
+        const response = await this.bitgo.get(this.url()).query(query).result();
+        const { safes, nextBatchPrevId } = (0, codecs_1.decodeWithCodec)(ListSafesResponse, response, 'ListSafesResponse');
+        return {
+            safes: safes.map((safeData) => new safe_1.Safe(this.bitgo, safeData)),
+            nextCursor: nextBatchPrevId,
+        };
+    }
+    /**
+     * Fetch a single safe by id. Non-members get a 404 (existence is not leaked).
+     * GET /api/v2/enterprise/:eId/safes/:safeId
+     * @experimental
+     */
+    async get(params) {
+        const response = await this.bitgo.get(this.url(`/${params.id}`)).result();
+        const safeData = (0, codecs_1.decodeWithCodec)(public_types_1.SafeData, response, 'SafeData');
+        return new safe_1.Safe(this.bitgo, safeData);
+    }
+}
+exports.Safes = Safes;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safes.js","sourceRoot":"","sources":["../../../../src/bitgo/safe/safes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * @experimental The safe client surface is experimental and may change (including breaking\n * changes) before the public release.\n */\nimport * as t from 'io-ts';\nimport {\n  FinalizeSafeBody,\n  InitializeSafeBody,\n  InitializeSafeResponse,\n  RootKeysByType,\n  RootKeyTriplet,\n  RootKeyType,\n  SafeData,\n} from '@bitgo/public-types';\nimport { BitGoBase } from '../bitgoBase';\nimport { ApiResponseError } from '../errors';\nimport { decodeWithCodec } from '../utils/codecs';\nimport { isDerivableEd25519Pub } from '@bitgo-beta/sdk-lib-safes';\nimport { postWithCodec } from '../utils/postWithCodec';\nimport { FinalizeSafeOptions, InitializeSafeOptions } from './iSafe';\nimport { CreateSafeOptions, GetSafeOptions, ISafes, ListSafesOptions, SafeCreationHandle, SafeKeys } from './iSafes';\nimport { coinForRoot, SAFE_ROOT_SLOTS } from './rootCoin';\nimport { Safe } from './safe';\n\n/**\n * Wire shape of the paginated `GET /enterprise/:eId/safes` response. WP paginates with the v2\n * `prevId`/`nextBatchPrevId` convention; the SDK re-exposes it as an opaque `cursor`/`nextCursor`\n * (see `list`).\n * @experimental\n */\nconst ListSafesResponse = t.intersection([\n  t.type({ safes: t.array(SafeData) }),\n  t.partial({ nextBatchPrevId: t.string }),\n]);\n\n/**\n * Collection accessor for a single enterprise's safes, mirroring Wallets / Enterprises.\n * Safe routes are enterprise-scoped (/api/v2/enterprise/:eId/safes), so the accessor is\n * constructed with the enterprise id (see Enterprise.safes()).\n *\n * @experimental\n */\nexport class Safes implements ISafes {\n  private readonly bitgo: BitGoBase;\n  private readonly enterpriseId: string;\n\n  constructor(bitgo: BitGoBase, enterpriseId: string) {\n    this.bitgo = bitgo;\n    this.enterpriseId = enterpriseId;\n  }\n\n  /**\n   * Enterprise-scoped v2 URL for the safes collection, e.g. /api/v2/enterprise/:eId/safes\n   * @param extra\n   */\n  private url(extra = ''): string {\n    return this.bitgo.url(`/enterprise/${this.enterpriseId}/safes${extra}`, 2);\n  }\n\n  /**\n   * One-call convenience wrapper chaining the three creation phases:\n   * initialize (Phase 1) → createSafeKeys (Phase 2, enabled-slot ceremonies) →\n   * finalize (Phase 3). HOT custody only in v1.\n   *\n   * If a key ceremony fails, `createSafeKeys` archives the safe before throwing, so a failed run\n   * leaves no half-created safe behind — create a new safe and retry.\n   * @experimental\n   */\n  async generateSafe(params: CreateSafeOptions): Promise<Safe> {\n    const safe = await this.initializeSafe({ label: params.label });\n    const rootKeys = await this.createSafeKeys({\n      ...params,\n      safeId: safe.id,\n      enabledRootSlots: safe.enabledRootSlots,\n    });\n    return await this.finalizeSafe(safe.id, rootKeys);\n  }\n\n  /**\n   * Phase 1 — initialize a safe (metadata only, no key material).\n   * POST /api/v2/enterprise/:eId/safes { label }\n   * Response is `{ id, status }` plus optional `enabledRootSlots` (absent on older WP).\n   * @experimental\n   */\n  async initializeSafe(params: InitializeSafeOptions): Promise<InitializeSafeResponse> {\n    const response = await postWithCodec(this.bitgo, this.url(), InitializeSafeBody, params).result();\n    return decodeWithCodec(InitializeSafeResponse, response, 'InitializeSafeResponse');\n  }\n\n  /**\n   * Phase 2 — run the enabled root key ceremonies tagged with `safeId`; returns ordered\n   * [user, backup, bitgo] triplets for those slots. HOT custody only in v1.\n   *\n   * Absent `enabledRootSlots` (older WP, pre-gating) runs all 4 slots. Enabled ceremonies\n   * (2.1 multisig ①④, 2.2 MPC ②③) run in parallel. If any of them fail, the\n   * partially-created safe is archived (a legal `initializing → archived` transition, so the\n   * orphaned tagged keys are inert) and an error listing every ceremony failure is thrown —\n   * create a new safe and retry.\n   *\n   * Not independently idempotent: re-running against a safe that already has some roots hits WP's\n   * unique root-slot index.\n   * @experimental\n   */\n  async createSafeKeys(params: CreateSafeOptions & SafeCreationHandle): Promise<SafeKeys> {\n    const { safeId, passphrase, enabledRootSlots } = params;\n    const enterprise = this.enterpriseId;\n\n    // Absent `enabledRootSlots` (older WP, pre-gating) ⇒ all 4, preserving current behavior.\n    // Ordered by scheme: the two multisig roots first, then the two MPC roots.\n    const enabled = new Set(enabledRootSlots ?? SAFE_ROOT_SLOTS);\n    const slots = SAFE_ROOT_SLOTS.filter((slot) => enabled.has(slot));\n    const ceremonies: Record<RootKeyType, () => Promise<RootKeyTriplet>> = {\n      // Phase 2.1 — multisig roots (①④): local user/backup keypairs + BitGo key, all safeId-tagged.\n      secp256k1Multisig: () => this.createMultisigRoot('secp256k1Multisig', safeId, passphrase, enterprise),\n      ed25519Multisig: () => this.createMultisigRoot('ed25519Multisig', safeId, passphrase, enterprise),\n      // Phase 2.2 — MPC roots (②③): the existing DKLS (②) and EdDSA (③) ceremonies, safeId threaded.\n      ecdsaMpc: () => this.createMpcRoot('ecdsaMpc', safeId, passphrase, enterprise),\n      eddsaMpc: () => this.createMpcRoot('eddsaMpc', safeId, passphrase, enterprise),\n    };\n    const results = await Promise.allSettled(slots.map((slot) => ceremonies[slot]()));\n\n    // Single pass over the settled results: `status === 'fulfilled'` narrows `.value` to a\n    // RootKeyTriplet, and rejections are collected per-slot for the error below.\n    const hot: RootKeysByType = {};\n    const failures: string[] = [];\n    results.forEach((result, i) => {\n      if (result.status === 'fulfilled') {\n        hot[slots[i]] = result.value;\n      } else {\n        const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);\n        // ApiResponseError carries the server-echoed `Request-ID` header — include it (when\n        // present) so a failed ceremony can be correlated with WP's server-side logs.\n        const requestId = result.reason instanceof ApiResponseError ? result.reason.requestId : undefined;\n        failures.push(`${slots[i]}: ${reason}${requestId ? ` (requestId: ${requestId})` : ''}`);\n      }\n    });\n\n    if (failures.length > 0) {\n      // Best-effort abandon the partially-created safe so a retry starts from a clean slate. Keep\n      // the ceremony failures as the primary error; note it if the cleanup archive also failed.\n      let archiveError: Error | undefined;\n      try {\n        await this.archiveSafe(safeId);\n      } catch (e) {\n        archiveError = e instanceof Error ? e : new Error(String(e));\n      }\n      let message =\n        `Safe key generation failed for ${failures.length} root ceremony/ies ` +\n        `[${failures.join('; ')}]. The safe (${safeId}) has been archived; create a new safe and retry.`;\n      if (archiveError) {\n        message += ` NOTE: archiving the safe also failed (${archiveError.message}); archive it manually before retrying.`;\n      }\n      throw new Error(message);\n    }\n\n    return { rootKeys: { hot } };\n  }\n\n  /**\n   * Archive a safe. Also the abandonment path for a stuck `initializing` safe (used by\n   * `createSafeKeys` to clean up after a failed ceremony).\n   * POST /api/v2/enterprise/:eId/safes/:safeId/archive\n   * @experimental\n   */\n  async archiveSafe(safeId: string): Promise<Safe> {\n    const response = await this.bitgo\n      .post(this.url(`/${safeId}/archive`))\n      .send()\n      .result();\n    const safeData = decodeWithCodec(SafeData, response, 'SafeData');\n    return new Safe(this.bitgo, safeData);\n  }\n\n  /**\n   * Phase 3 — finalize a safe with the minted root key ids as ordered [user, backup, bitgo] triplets.\n   * POST /api/v2/enterprise/:eId/safes/:safeId/finalize { rootKeys }.\n   * Idempotent: re-finalizing with the same `rootKeys` returns the active safe again (200).\n   * @experimental\n   */\n  async finalizeSafe(safeId: string, params: FinalizeSafeOptions): Promise<Safe> {\n    const response = await postWithCodec(\n      this.bitgo,\n      this.url(`/${safeId}/finalize`),\n      FinalizeSafeBody,\n      params\n    ).result();\n    const safeData = decodeWithCodec(SafeData, response, 'SafeData');\n    return new Safe(this.bitgo, safeData);\n  }\n\n  /**\n   * Phase 2.1 helper — mint one onchain-multisig root (cold model, as wallet creation does today):\n   * generate user/backup keypairs locally, encrypt with `passphrase`, register via POST /:coin/key\n   * with `safeId`; the BitGo key is created through the same route's `source:'bitgo'` path.\n   * Returns the [user, backup, bitgo] key id triplet.\n   * @experimental\n   */\n  private async createMultisigRoot(\n    slot: 'secp256k1Multisig' | 'ed25519Multisig',\n    safeId: string,\n    passphrase: string,\n    enterprise: string\n  ): Promise<RootKeyTriplet> {\n    const keychains = coinForRoot(this.bitgo, slot).keychains();\n\n    const userKeyPair = keychains.create();\n    const userKeychainPromise = keychains.add({\n      pub: userKeyPair.pub,\n      encryptedPrv: await this.bitgo.encrypt({ input: userKeyPair.prv, password: passphrase }),\n      source: 'user',\n      safeId,\n    });\n    const backupKeychainPromise = keychains.createBackup({ passphrase, safeId });\n    const bitgoKeychainPromise = keychains.createBitGo({ enterprise, safeId });\n\n    const [userKeychain, backupKeychain, bitgoKeychain] = await Promise.all([\n      userKeychainPromise,\n      backupKeychainPromise,\n      bitgoKeychainPromise,\n    ]);\n\n    // Slot ④ roots use neutral raw public derivation material (32-byte public key plus 32-byte\n    // chain code), serialized together as canonical unpadded RFC 4648 base32 (103 characters).\n    // Coin-specific child encoding is performed by Wallet Platform after soft derivation.\n    if (\n      slot === 'ed25519Multisig' &&\n      (!backupKeychain.pub ||\n        !isDerivableEd25519Pub(backupKeychain.pub) ||\n        !bitgoKeychain.pub ||\n        !isDerivableEd25519Pub(bitgoKeychain.pub))\n    ) {\n      throw new Error('Safe ed25519Multisig roots are not derivable: expected 64-byte canonical base32 material');\n    }\n\n    return [userKeychain.id, backupKeychain.id, bitgoKeychain.id];\n  }\n\n  /**\n   * Phase 2.2 helper — run one MPC ceremony (DKLS for ecdsaMpc, EdDSA for eddsaMpc) via the\n   * existing `createMpc` flow with `safeId` threaded through, so the resulting user/backup/bitgo\n   * keys land tagged. Returns the [user, backup, bitgo] key id triplet.\n   * @experimental\n   */\n  private async createMpcRoot(\n    slot: 'ecdsaMpc' | 'eddsaMpc',\n    safeId: string,\n    passphrase: string,\n    enterprise: string\n  ): Promise<RootKeyTriplet> {\n    const { userKeychain, backupKeychain, bitgoKeychain } = await coinForRoot(this.bitgo, slot)\n      .keychains()\n      .createMpc({ multisigType: 'tss', passphrase, enterprise, safeId });\n    return [userKeychain.id, backupKeychain.id, bitgoKeychain.id];\n  }\n\n  /**\n   * List the enterprise's safes the caller is a member of (cursor pagination).\n   * GET /api/v2/enterprise/:eId/safes?limit&prevId\n   *\n   * `cursor` is the opaque `nextCursor` returned by a previous call; page forward until\n   * `nextCursor` is absent.\n   * @experimental\n   */\n  async list(params: ListSafesOptions = {}): Promise<{ safes: Safe[]; nextCursor?: string }> {\n    // SDK exposes an opaque cursor; WP speaks prevId/nextBatchPrevId (v2 list convention).\n    const query: { limit?: number; prevId?: string } = {};\n    if (params.limit !== undefined) {\n      query.limit = params.limit;\n    }\n    if (params.cursor !== undefined) {\n      query.prevId = params.cursor;\n    }\n    const response = await this.bitgo.get(this.url()).query(query).result();\n    const { safes, nextBatchPrevId } = decodeWithCodec(ListSafesResponse, response, 'ListSafesResponse');\n    return {\n      safes: safes.map((safeData) => new Safe(this.bitgo, safeData)),\n      nextCursor: nextBatchPrevId,\n    };\n  }\n\n  /**\n   * Fetch a single safe by id. Non-members get a 404 (existence is not leaked).\n   * GET /api/v2/enterprise/:eId/safes/:safeId\n   * @experimental\n   */\n  async get(params: GetSafeOptions): Promise<Safe> {\n    const response = await this.bitgo.get(this.url(`/${params.id}`)).result();\n    const safeData = decodeWithCodec(SafeData, response, 'SafeData');\n    return new Safe(this.bitgo, safeData);\n  }\n}\n"]}

package/dist/src/bitgo/staking/goStakingInterfaces.d.ts

@@ -0,0 +1,136 @@
+import { FrontTransferSendRequest } from './iGoStakingWallet';
+export interface UnsignedGoStakingRequest {
+    payload: string;
+    coin: string;
+    token: string;
+    feeInfo: FeeInfo;
+}
+interface FeeInfo {
+    feeString: string;
+}
+export interface GoStakingRequest {
+    id: string;
+    clientId?: string;
+    goAccountId: string;
+    amount: string;
+    type: 'STAKE' | 'UNSTAKE';
+    coin: string;
+    status: string;
+    error?: string;
+    statusModifiedDate: string;
+    createdDate: string;
+    properties?: GoStakingRequestProperties;
+}
+interface GoStakingRequestProperties {
+    amount: string;
+}
+export interface GoStakeOptions {
+    amount: string;
+    clientId?: string;
+    /**
+     * Passphrase used to decrypt the user key and sign locally. Optional: omitted for OFC wallets that
+     * sign remotely via the BitGo key (userKeySigningRequired === false).
+     */
+    walletPassphrase?: string;
+}
+export interface BaseGoStakeOptions {
+    amount: string;
+    clientId?: string;
+}
+export interface GoStakeFinalizeOptions extends BaseGoStakeOptions {
+    frontTransferSendRequest: FrontTransferSendRequest;
+}
+export interface GoStakingRequestOptions {
+    status?: string;
+    page?: number;
+    pageSize?: number;
+    createdDateGte?: string;
+    createdDateLt?: string;
+    sortBy?: string;
+}
+export interface GoStakingRequestResults {
+    requests: GoStakingRequest[];
+    page: number;
+    totalPages: number;
+    totalElements: number;
+}
+export interface GoStakingWalletResults {
+    coins: GoStakingWalletObject[];
+    page: number;
+    totalPages: number;
+    totalElements: number;
+}
+export interface StakingPermissionAttributes {
+    enabled: boolean;
+    disabledReason?: string;
+    allowClientToUseOwnValidator: boolean;
+}
+export interface UnstakingPermissionAttributes {
+    enabled: boolean;
+    disabledReason?: string;
+}
+export interface WalletPermissionAttributes {
+    useValidatorList: boolean;
+    allowPartialUnstake: boolean;
+    validatorNotNeededForStake: boolean;
+}
+export interface PermissionAttributes {
+    staking: StakingPermissionAttributes;
+    unstaking: UnstakingPermissionAttributes;
+    wallet: WalletPermissionAttributes;
+}
+export interface StakingSpendableAttributes {
+    fee: string;
+    max: string;
+    min: string;
+    netMax: string;
+    netMin: string;
+    minStakeMore: string;
+    minDuration?: string;
+    maxDuration?: string;
+}
+export interface UnstakingSpendableAttributes {
+    fee?: string;
+    max?: string;
+    min?: string;
+    multipleDelegations: boolean;
+    requiresAmount: boolean;
+    requiresDelegationId: boolean;
+    requiresDelegationIds: boolean;
+}
+export interface SpendableAttributes {
+    staking: StakingSpendableAttributes;
+    unstaking: UnstakingSpendableAttributes;
+}
+export interface StakingDisclaimer {
+    info: string[];
+    rewardPercentageRate?: string;
+    stakeWarmupPeriodDesc?: string;
+}
+export interface UnstakingDisclaimer {
+    info: string[];
+    unStakeCooldownPeriodDesc?: string;
+}
+export interface NextRewardsDisclaimer {
+    rewardCycle: number;
+}
+export interface DisclaimerAttributes {
+    staking: StakingDisclaimer;
+    unstaking: UnstakingDisclaimer;
+    nextRewards?: NextRewardsDisclaimer;
+}
+export interface GoStakingAttributes {
+    permissionAttributes: PermissionAttributes;
+    spendableAttributes: SpendableAttributes;
+    disclaimerAttributes: DisclaimerAttributes;
+}
+export interface GoStakingWalletObject {
+    coin: string;
+    activeStake: string;
+    pendingStake: string;
+    pendingUnstake: string;
+    rewards: string;
+    attributes: GoStakingAttributes;
+}
+export {};
+//# sourceMappingURL=goStakingInterfaces.d.ts.map

package/dist/src/bitgo/staking/goStakingInterfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goStakingInterfaces.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/staking/goStakingInterfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,OAAO;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC;AAED,UAAU,0BAA0B;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,wBAAwB,EAAE,wBAAwB,CAAC;CACpD;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,qBAAqB,EAAE,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4BAA4B,EAAE,OAAO,CAAC;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,0BAA0B;IACzC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,0BAA0B,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,2BAA2B,CAAC;IACrC,SAAS,EAAE,6BAA6B,CAAC;IACzC,MAAM,EAAE,0BAA0B,CAAC;CACpC;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,4BAA4B;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,mBAAmB,EAAE,OAAO,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;IACxB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,0BAA0B,CAAC;IACpC,SAAS,EAAE,4BAA4B,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,SAAS,EAAE,mBAAmB,CAAC;IAC/B,WAAW,CAAC,EAAE,qBAAqB,CAAC;CACrC;AAED,MAAM,WAAW,mBAAmB;IAClC,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,oBAAoB,EAAE,oBAAoB,CAAC;CAC5C;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,mBAAmB,CAAC;CACjC"}

package/dist/src/bitgo/staking/goStakingInterfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ29TdGFraW5nSW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iaXRnby9zdGFraW5nL2dvU3Rha2luZ0ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZyb250VHJhbnNmZXJTZW5kUmVxdWVzdCB9IGZyb20gJy4vaUdvU3Rha2luZ1dhbGxldCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVW5zaWduZWRHb1N0YWtpbmdSZXF1ZXN0IHtcbiAgcGF5bG9hZDogc3RyaW5nO1xuICBjb2luOiBzdHJpbmc7XG4gIHRva2VuOiBzdHJpbmc7XG4gIGZlZUluZm86IEZlZUluZm87XG59XG5cbmludGVyZmFjZSBGZWVJbmZvIHtcbiAgZmVlU3RyaW5nOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgR29TdGFraW5nUmVxdWVzdCB7XG4gIGlkOiBzdHJpbmc7XG4gIGNsaWVudElkPzogc3RyaW5nO1xuICBnb0FjY291bnRJZDogc3RyaW5nO1xuICBhbW91bnQ6IHN0cmluZztcbiAgdHlwZTogJ1NUQUtFJyB8ICdVTlNUQUtFJztcbiAgY29pbjogc3RyaW5nO1xuICBzdGF0dXM6IHN0cmluZztcbiAgZXJyb3I/OiBzdHJpbmc7XG4gIHN0YXR1c01vZGlmaWVkRGF0ZTogc3RyaW5nO1xuICBjcmVhdGVkRGF0ZTogc3RyaW5nO1xuICBwcm9wZXJ0aWVzPzogR29TdGFraW5nUmVxdWVzdFByb3BlcnRpZXM7XG59XG5cbmludGVyZmFjZSBHb1N0YWtpbmdSZXF1ZXN0UHJvcGVydGllcyB7XG4gIGFtb3VudDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdvU3Rha2VPcHRpb25zIHtcbiAgYW1vdW50OiBzdHJpbmc7XG4gIGNsaWVudElkPzogc3RyaW5nO1xuICAvKipcbiAgICogUGFzc3BocmFzZSB1c2VkIHRvIGRlY3J5cHQgdGhlIHVzZXIga2V5IGFuZCBzaWduIGxvY2FsbHkuIE9wdGlvbmFsOiBvbWl0dGVkIGZvciBPRkMgd2FsbGV0cyB0aGF0XG4gICAqIHNpZ24gcmVtb3RlbHkgdmlhIHRoZSBCaXRHbyBrZXkgKHVzZXJLZXlTaWduaW5nUmVxdWlyZWQgPT09IGZhbHNlKS5cbiAgICovXG4gIHdhbGxldFBhc3NwaHJhc2U/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQmFzZUdvU3Rha2VPcHRpb25zIHtcbiAgYW1vdW50OiBzdHJpbmc7XG4gIGNsaWVudElkPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdvU3Rha2VGaW5hbGl6ZU9wdGlvbnMgZXh0ZW5kcyBCYXNlR29TdGFrZU9wdGlvbnMge1xuICBmcm9udFRyYW5zZmVyU2VuZFJlcXVlc3Q6IEZyb250VHJhbnNmZXJTZW5kUmVxdWVzdDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBHb1N0YWtpbmdSZXF1ZXN0T3B0aW9ucyB7XG4gIHN0YXR1cz86IHN0cmluZztcbiAgcGFnZT86IG51bWJlcjtcbiAgcGFnZVNpemU/OiBudW1iZXI7XG4gIGNyZWF0ZWREYXRlR3RlPzogc3RyaW5nO1xuICBjcmVhdGVkRGF0ZUx0Pzogc3RyaW5nO1xuICBzb3J0Qnk/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgR29TdGFraW5nUmVxdWVzdFJlc3VsdHMge1xuICByZXF1ZXN0czogR29TdGFraW5nUmVxdWVzdFtdO1xuICBwYWdlOiBudW1iZXI7XG4gIHRvdGFsUGFnZXM6IG51bWJlcjtcbiAgdG90YWxFbGVtZW50czogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdvU3Rha2luZ1dhbGxldFJlc3VsdHMge1xuICBjb2luczogR29TdGFraW5nV2FsbGV0T2JqZWN0W107XG4gIHBhZ2U6IG51bWJlcjtcbiAgdG90YWxQYWdlczogbnVtYmVyO1xuICB0b3RhbEVsZW1lbnRzOiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3Rha2luZ1Blcm1pc3Npb25BdHRyaWJ1dGVzIHtcbiAgZW5hYmxlZDogYm9vbGVhbjtcbiAgZGlzYWJsZWRSZWFzb24/OiBzdHJpbmc7XG4gIGFsbG93Q2xpZW50VG9Vc2VPd25WYWxpZGF0b3I6IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVW5zdGFraW5nUGVybWlzc2lvbkF0dHJpYnV0ZXMge1xuICBlbmFibGVkOiBib29sZWFuO1xuICBkaXNhYmxlZFJlYXNvbj86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXYWxsZXRQZXJtaXNzaW9uQXR0cmlidXRlcyB7XG4gIHVzZVZhbGlkYXRvckxpc3Q6IGJvb2xlYW47XG4gIGFsbG93UGFydGlhbFVuc3Rha2U6IGJvb2xlYW47XG4gIHZhbGlkYXRvck5vdE5lZWRlZEZvclN0YWtlOiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFBlcm1pc3Npb25BdHRyaWJ1dGVzIHtcbiAgc3Rha2luZzogU3Rha2luZ1Blcm1pc3Npb25BdHRyaWJ1dGVzO1xuICB1bnN0YWtpbmc6IFVuc3Rha2luZ1Blcm1pc3Npb25BdHRyaWJ1dGVzO1xuICB3YWxsZXQ6IFdhbGxldFBlcm1pc3Npb25BdHRyaWJ1dGVzO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFN0YWtpbmdTcGVuZGFibGVBdHRyaWJ1dGVzIHtcbiAgZmVlOiBzdHJpbmc7XG4gIG1heDogc3RyaW5nO1xuICBtaW46IHN0cmluZztcbiAgbmV0TWF4OiBzdHJpbmc7XG4gIG5ldE1pbjogc3RyaW5nO1xuICBtaW5TdGFrZU1vcmU6IHN0cmluZztcbiAgbWluRHVyYXRpb24/OiBzdHJpbmc7XG4gIG1heER1cmF0aW9uPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVuc3Rha2luZ1NwZW5kYWJsZUF0dHJpYnV0ZXMge1xuICBmZWU/OiBzdHJpbmc7XG4gIG1heD86IHN0cmluZztcbiAgbWluPzogc3RyaW5nO1xuICBtdWx0aXBsZURlbGVnYXRpb25zOiBib29sZWFuO1xuICByZXF1aXJlc0Ftb3VudDogYm9vbGVhbjtcbiAgcmVxdWlyZXNEZWxlZ2F0aW9uSWQ6IGJvb2xlYW47XG4gIHJlcXVpcmVzRGVsZWdhdGlvbklkczogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTcGVuZGFibGVBdHRyaWJ1dGVzIHtcbiAgc3Rha2luZzogU3Rha2luZ1NwZW5kYWJsZUF0dHJpYnV0ZXM7XG4gIHVuc3Rha2luZzogVW5zdGFraW5nU3BlbmRhYmxlQXR0cmlidXRlcztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTdGFraW5nRGlzY2xhaW1lciB7XG4gIGluZm86IHN0cmluZ1tdO1xuICByZXdhcmRQZXJjZW50YWdlUmF0ZT86IHN0cmluZztcbiAgc3Rha2VXYXJtdXBQZXJpb2REZXNjPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVuc3Rha2luZ0Rpc2NsYWltZXIge1xuICBpbmZvOiBzdHJpbmdbXTtcbiAgdW5TdGFrZUNvb2xkb3duUGVyaW9kRGVzYz86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBOZXh0UmV3YXJkc0Rpc2NsYWltZXIge1xuICByZXdhcmRDeWNsZTogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIERpc2NsYWltZXJBdHRyaWJ1dGVzIHtcbiAgc3Rha2luZzogU3Rha2luZ0Rpc2NsYWltZXI7XG4gIHVuc3Rha2luZzogVW5zdGFraW5nRGlzY2xhaW1lcjtcbiAgbmV4dFJld2FyZHM/OiBOZXh0UmV3YXJkc0Rpc2NsYWltZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgR29TdGFraW5nQXR0cmlidXRlcyB7XG4gIHBlcm1pc3Npb25BdHRyaWJ1dGVzOiBQZXJtaXNzaW9uQXR0cmlidXRlcztcbiAgc3BlbmRhYmxlQXR0cmlidXRlczogU3BlbmRhYmxlQXR0cmlidXRlcztcbiAgZGlzY2xhaW1lckF0dHJpYnV0ZXM6IERpc2NsYWltZXJBdHRyaWJ1dGVzO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdvU3Rha2luZ1dhbGxldE9iamVjdCB7XG4gIGNvaW46IHN0cmluZztcbiAgYWN0aXZlU3Rha2U6IHN0cmluZztcbiAgcGVuZGluZ1N0YWtlOiBzdHJpbmc7XG4gIHBlbmRpbmdVbnN0YWtlOiBzdHJpbmc7XG4gIHJld2FyZHM6IHN0cmluZztcbiAgYXR0cmlidXRlczogR29TdGFraW5nQXR0cmlidXRlcztcbn1cbiJdfQ==

package/dist/src/bitgo/staking/goStakingWallet.d.ts

@@ -0,0 +1,62 @@
+import { IWallet } from '../wallet';
+import { BaseGoStakeOptions, GoStakeOptions, GoStakingRequest, GoStakingRequestOptions, GoStakingRequestResults, GoStakingWalletObject, GoStakingWalletResults } from './goStakingInterfaces';
+import { IGoStakingWallet } from './iGoStakingWallet';
+export declare class GoStakingWallet implements IGoStakingWallet {
+    private readonly bitgo;
+    wallet: IWallet;
+    constructor(wallet: IWallet);
+    get accountId(): string;
+    stake(options: GoStakeOptions): Promise<GoStakingRequest>;
+    /**
+     * Unstake request
+     * @param options
+     */
+    unstake(options: BaseGoStakeOptions): Promise<GoStakingRequest>;
+    /**
+     * Preview staking request
+     * @param options
+     */
+    private previewStake;
+    /**
+     * Finalize staking request
+     * will prepare the payload and sign the transaction
+     * and submit it to the go-staking-service
+     * @param options
+     */
+    private finalizeStake;
+    /**
+     * Get go staking request
+     * @param goStakingRequestId
+     */
+    getGoStakingRequest(goStakingRequestId: string): Promise<GoStakingRequest>;
+    /**
+     * Get go staking requests by coin
+     * @param options
+     */
+    getGoStakingRequestsByWalletCoin(options?: GoStakingRequestOptions): Promise<GoStakingRequestResults>;
+    /**
+     * Get all go staking requests for the account
+     * @param options
+     */
+    getGoStakingRequests(options?: GoStakingRequestOptions): Promise<GoStakingRequestResults>;
+    /**
+     * Get go staking wallets for the account
+     * @param options
+     */
+    getGoStakingWallets(options?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<GoStakingWalletResults>;
+    /**
+     * Get go staking wallets for the account
+     */
+    getGoStakingWallet(): Promise<GoStakingWalletObject>;
+    private createGoStakingRequest;
+    private goStakingBaseURL;
+    private goStakingRequestBaseURL;
+    private getGoStakingRequestURL;
+    private getGoStakingRequestsUrl;
+    private getGoStakingWalletsUrl;
+    private getGoStakingWalletUrl;
+}
+//# sourceMappingURL=goStakingWallet.d.ts.map