@bitgo/public-types 6.40.1 → 6.41.0

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

@@ -9,3 +9,4 @@ export * from "./lightning";
 export * from "./enterprise";
 export * from "./webauthn";
 export * from "./defi";
+export * from "./safe";

package/dist/src/schema/index.js

@@ -25,4 +25,5 @@ __exportStar(require("./lightning"), exports);
 __exportStar(require("./enterprise"), exports);
 __exportStar(require("./webauthn"), exports);
 __exportStar(require("./defi"), exports);
+__exportStar(require("./safe"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/schema/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schema/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B;AAC/B,uDAAqC;AACrC,4CAA0B;AAC1B,0CAAwB;AACxB,2CAAyB;AACzB,2CAAyB;AACzB,wCAAsB;AACtB,8CAA4B;AAC5B,+CAA6B;AAC7B,6CAA2B;AAC3B,yCAAuB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schema/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B;AAC/B,uDAAqC;AACrC,4CAA0B;AAC1B,0CAAwB;AACxB,2CAAyB;AACzB,2CAAyB;AACzB,wCAAsB;AACtB,8CAA4B;AAC5B,+CAA6B;AAC7B,6CAA2B;AAC3B,yCAAuB;AACvB,yCAAuB"}

package/dist/src/schema/safe/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./rootKeys";
+export * from "./safe";
+export * from "./safeShare";
+export * from "./requests";

package/dist/src/schema/safe/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rootKeys"), exports);
+__exportStar(require("./safe"), exports);
+__exportStar(require("./safeShare"), exports);
+__exportStar(require("./requests"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/schema/safe/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/schema/safe/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,yCAAuB;AACvB,8CAA4B;AAC5B,6CAA2B"}

package/dist/src/schema/safe/requests.d.ts

@@ -0,0 +1,21 @@
+import * as t from "io-ts";
+export declare const InitializeSafeBody: t.TypeC<{
+    label: t.StringC;
+}>;
+export type InitializeSafeBody = t.TypeOf<typeof InitializeSafeBody>;
+export declare const FinalizeSafeBody: t.TypeC<{
+    rootKeys: t.TypeC<{
+        hot: t.TypeC<{
+            secp256k1Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+            ecdsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+            eddsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+            ed25519Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+        }>;
+    }>;
+}>;
+export type FinalizeSafeBody = t.TypeOf<typeof FinalizeSafeBody>;
+export declare const FreezeSafeBody: t.PartialC<{
+    expires: import("io-ts-types").DateFromISOStringC;
+    reason: t.StringC;
+}>;
+export type FreezeSafeBody = t.TypeOf<typeof FreezeSafeBody>;

package/dist/src/schema/safe/requests.js

@@ -0,0 +1,33 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreezeSafeBody = exports.FinalizeSafeBody = exports.InitializeSafeBody = void 0;
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const rootKeys_1 = require("./rootKeys");
+exports.InitializeSafeBody = t.type({ label: t.string }, "InitializeSafeBody");
+exports.FinalizeSafeBody = t.type({ rootKeys: rootKeys_1.SafeRootKeys }, "FinalizeSafeBody");
+exports.FreezeSafeBody = t.partial({ expires: io_ts_types_1.DateFromISOString, reason: t.string }, "FreezeSafeBody");
+//# sourceMappingURL=requests.js.map

package/dist/src/schema/safe/requests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests.js","sourceRoot":"","sources":["../../../../src/schema/safe/requests.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAC3B,6CAAgD;AAChD,yCAA0C;AAM7B,QAAA,kBAAkB,GAAG,CAAC,CAAC,IAAI,CACtC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,EACnB,oBAAoB,CACrB,CAAC;AAQW,QAAA,gBAAgB,GAAG,CAAC,CAAC,IAAI,CACpC,EAAE,QAAQ,EAAE,uBAAY,EAAE,EAC1B,kBAAkB,CACnB,CAAC;AAQW,QAAA,cAAc,GAAG,CAAC,CAAC,OAAO,CACrC,EAAE,OAAO,EAAE,+BAAiB,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,EAChD,gBAAgB,CACjB,CAAC"}

package/dist/src/schema/safe/rootKeys.d.ts

@@ -0,0 +1,32 @@
+import * as t from "io-ts";
+export declare const RootKeyType: t.KeyofC<{
+    secp256k1Multisig: null;
+    ecdsaMpc: null;
+    eddsaMpc: null;
+    ed25519Multisig: null;
+}>;
+export type RootKeyType = t.TypeOf<typeof RootKeyType>;
+export declare const RootKeyTriplet: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+export type RootKeyTriplet = t.TypeOf<typeof RootKeyTriplet>;
+export declare const RootKeysByType: t.TypeC<{
+    secp256k1Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+    ecdsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+    eddsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+    ed25519Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+}>;
+export type RootKeysByType = t.TypeOf<typeof RootKeysByType>;
+export declare const SafeCustodyType: t.KeyofC<{
+    hot: null;
+    cold: null;
+    custodial: null;
+}>;
+export type SafeCustodyType = t.TypeOf<typeof SafeCustodyType>;
+export declare const SafeRootKeys: t.TypeC<{
+    hot: t.TypeC<{
+        secp256k1Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+        ecdsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+        eddsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+        ed25519Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+    }>;
+}>;
+export type SafeRootKeys = t.TypeOf<typeof SafeRootKeys>;

package/dist/src/schema/safe/rootKeys.js

@@ -0,0 +1,49 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeRootKeys = exports.SafeCustodyType = exports.RootKeysByType = exports.RootKeyTriplet = exports.RootKeyType = void 0;
+const t = __importStar(require("io-ts"));
+exports.RootKeyType = t.keyof({
+    secp256k1Multisig: null,
+    ecdsaMpc: null,
+    eddsaMpc: null,
+    ed25519Multisig: null,
+}, "RootKeyType");
+exports.RootKeyTriplet = t.tuple([t.string, t.string, t.string], "RootKeyTriplet");
+exports.RootKeysByType = t.type({
+    secp256k1Multisig: exports.RootKeyTriplet,
+    ecdsaMpc: exports.RootKeyTriplet,
+    eddsaMpc: exports.RootKeyTriplet,
+    ed25519Multisig: exports.RootKeyTriplet,
+}, "RootKeysByType");
+exports.SafeCustodyType = t.keyof({
+    hot: null,
+    cold: null,
+    custodial: null,
+}, "SafeCustodyType");
+exports.SafeRootKeys = t.type({
+    hot: exports.RootKeysByType,
+}, "SafeRootKeys");
+//# sourceMappingURL=rootKeys.js.map

package/dist/src/schema/safe/rootKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootKeys.js","sourceRoot":"","sources":["../../../../src/schema/safe/rootKeys.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAUd,QAAA,WAAW,GAAG,CAAC,CAAC,KAAK,CAChC;IACE,iBAAiB,EAAE,IAAI;IACvB,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,eAAe,EAAE,IAAI;CACtB,EACD,aAAa,CACd,CAAC;AAQW,QAAA,cAAc,GAAG,CAAC,CAAC,KAAK,CACnC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,EAC9B,gBAAgB,CACjB,CAAC;AAQW,QAAA,cAAc,GAAG,CAAC,CAAC,IAAI,CAClC;IACE,iBAAiB,EAAE,sBAAc;IACjC,QAAQ,EAAE,sBAAc;IACxB,QAAQ,EAAE,sBAAc;IACxB,eAAe,EAAE,sBAAc;CAChC,EACD,gBAAgB,CACjB,CAAC;AASW,QAAA,eAAe,GAAG,CAAC,CAAC,KAAK,CACpC;IACE,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,IAAI;IACV,SAAS,EAAE,IAAI;CAChB,EACD,iBAAiB,CAClB,CAAC;AAQW,QAAA,YAAY,GAAG,CAAC,CAAC,IAAI,CAChC;IACE,GAAG,EAAE,sBAAc;CACpB,EACD,cAAc,CACf,CAAC"}

package/dist/src/schema/safe/safe.d.ts

@@ -0,0 +1,92 @@
+import * as t from "io-ts";
+export declare const SafePermission: t.KeyofC<{
+    view: null;
+    spend: null;
+    admin: null;
+    dapp: null;
+}>;
+export type SafePermission = t.TypeOf<typeof SafePermission>;
+export declare const SafeStatus: t.KeyofC<{
+    initializing: null;
+    active: null;
+    archived: null;
+}>;
+export type SafeStatus = t.TypeOf<typeof SafeStatus>;
+export declare const SafeMembershipData: t.IntersectionC<[t.TypeC<{
+    userId: t.StringC;
+    permissions: import("io-ts-types").NonEmptyArrayC<t.KeyofC<{
+        view: null;
+        spend: null;
+        admin: null;
+        dapp: null;
+    }>>;
+}>, t.PartialC<{
+    needsRecovery: t.BooleanC;
+}>]>;
+export type SafeMembershipData = t.TypeOf<typeof SafeMembershipData>;
+export declare const SafeShareRequest: t.TypeC<{
+    userId: t.StringC;
+    permissions: import("io-ts-types").NonEmptyArrayC<t.KeyofC<{
+        view: null;
+        spend: null;
+        admin: null;
+        dapp: null;
+    }>>;
+    createdAt: import("io-ts-types").DateFromISOStringC;
+}>;
+export type SafeShareRequest = t.TypeOf<typeof SafeShareRequest>;
+export declare const SafeFreeze: t.PartialC<{
+    time: import("io-ts-types").DateFromISOStringC;
+    expires: import("io-ts-types").DateFromISOStringC;
+    reason: t.StringC;
+}>;
+export type SafeFreeze = t.TypeOf<typeof SafeFreeze>;
+export declare const SafeData: t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+    enterpriseId: t.StringC;
+    label: t.StringC;
+    status: t.KeyofC<{
+        initializing: null;
+        active: null;
+        archived: null;
+    }>;
+    creator: t.StringC;
+    users: t.ArrayC<t.IntersectionC<[t.TypeC<{
+        userId: t.StringC;
+        permissions: import("io-ts-types").NonEmptyArrayC<t.KeyofC<{
+            view: null;
+            spend: null;
+            admin: null;
+            dapp: null;
+        }>>;
+    }>, t.PartialC<{
+        needsRecovery: t.BooleanC;
+    }>]>>;
+    createdAt: import("io-ts-types").DateFromISOStringC;
+}>, t.PartialC<{
+    safeShareRequests: t.ArrayC<t.TypeC<{
+        userId: t.StringC;
+        permissions: import("io-ts-types").NonEmptyArrayC<t.KeyofC<{
+            view: null;
+            spend: null;
+            admin: null;
+            dapp: null;
+        }>>;
+        createdAt: import("io-ts-types").DateFromISOStringC;
+    }>>;
+    freeze: t.PartialC<{
+        time: import("io-ts-types").DateFromISOStringC;
+        expires: import("io-ts-types").DateFromISOStringC;
+        reason: t.StringC;
+    }>;
+    rootKeys: t.TypeC<{
+        hot: t.TypeC<{
+            secp256k1Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+            ecdsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+            eddsaMpc: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+            ed25519Multisig: t.TupleC<[t.StringC, t.StringC, t.StringC]>;
+        }>;
+    }>;
+    archivedAt: import("io-ts-types").DateFromISOStringC;
+}>]>;
+export type SafeData = t.TypeOf<typeof SafeData>;

package/dist/src/schema/safe/safe.js

@@ -0,0 +1,77 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeData = exports.SafeFreeze = exports.SafeShareRequest = exports.SafeMembershipData = exports.SafeStatus = exports.SafePermission = void 0;
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const rootKeys_1 = require("./rootKeys");
+exports.SafePermission = t.keyof({
+    view: null,
+    spend: null,
+    admin: null,
+    dapp: null,
+}, "SafePermission");
+exports.SafeStatus = t.keyof({
+    initializing: null,
+    active: null,
+    archived: null,
+}, "SafeStatus");
+exports.SafeMembershipData = t.intersection([
+    t.type({
+        userId: t.string,
+        permissions: (0, io_ts_types_1.nonEmptyArray)(exports.SafePermission),
+    }),
+    t.partial({
+        needsRecovery: t.boolean,
+    }),
+], "SafeMembershipData");
+exports.SafeShareRequest = t.type({
+    userId: t.string,
+    permissions: (0, io_ts_types_1.nonEmptyArray)(exports.SafePermission),
+    createdAt: io_ts_types_1.DateFromISOString,
+}, "SafeShareRequest");
+exports.SafeFreeze = t.partial({
+    time: io_ts_types_1.DateFromISOString,
+    expires: io_ts_types_1.DateFromISOString,
+    reason: t.string,
+}, "SafeFreeze");
+exports.SafeData = t.intersection([
+    t.type({
+        id: t.string,
+        enterpriseId: t.string,
+        label: t.string,
+        status: exports.SafeStatus,
+        creator: t.string,
+        users: t.array(exports.SafeMembershipData),
+        createdAt: io_ts_types_1.DateFromISOString,
+    }),
+    t.partial({
+        safeShareRequests: t.array(exports.SafeShareRequest),
+        freeze: exports.SafeFreeze,
+        rootKeys: rootKeys_1.SafeRootKeys,
+        archivedAt: io_ts_types_1.DateFromISOString,
+    }),
+], "SafeData");
+//# sourceMappingURL=safe.js.map

package/dist/src/schema/safe/safe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe.js","sourceRoot":"","sources":["../../../../src/schema/safe/safe.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAC3B,6CAA+D;AAC/D,yCAA0C;AAG7B,QAAA,cAAc,GAAG,CAAC,CAAC,KAAK,CACnC;IACE,IAAI,EAAE,IAAI;IACV,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;IACX,IAAI,EAAE,IAAI;CACX,EACD,gBAAgB,CACjB,CAAC;AASW,QAAA,UAAU,GAAG,CAAC,CAAC,KAAK,CAC/B;IACE,YAAY,EAAE,IAAI;IAClB,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,IAAI;CACf,EACD,YAAY,CACb,CAAC;AAKW,QAAA,kBAAkB,GAAG,CAAC,CAAC,YAAY,CAC9C;IACE,CAAC,CAAC,IAAI,CAAC;QACL,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,WAAW,EAAE,IAAA,2BAAa,EAAC,sBAAc,CAAC;KAC3C,CAAC;IACF,CAAC,CAAC,OAAO,CAAC;QACR,aAAa,EAAE,CAAC,CAAC,OAAO;KACzB,CAAC;CACH,EACD,oBAAoB,CACrB,CAAC;AAQW,QAAA,gBAAgB,GAAG,CAAC,CAAC,IAAI,CACpC;IACE,MAAM,EAAE,CAAC,CAAC,MAAM;IAChB,WAAW,EAAE,IAAA,2BAAa,EAAC,sBAAc,CAAC;IAC1C,SAAS,EAAE,+BAAiB;CAC7B,EACD,kBAAkB,CACnB,CAAC;AAKW,QAAA,UAAU,GAAG,CAAC,CAAC,OAAO,CACjC;IACE,IAAI,EAAE,+BAAiB;IACvB,OAAO,EAAE,+BAAiB;IAC1B,MAAM,EAAE,CAAC,CAAC,MAAM;CACjB,EACD,YAAY,CACb,CAAC;AAKW,QAAA,QAAQ,GAAG,CAAC,CAAC,YAAY,CACpC;IACE,CAAC,CAAC,IAAI,CAAC;QACL,EAAE,EAAE,CAAC,CAAC,MAAM;QACZ,YAAY,EAAE,CAAC,CAAC,MAAM;QACtB,KAAK,EAAE,CAAC,CAAC,MAAM;QACf,MAAM,EAAE,kBAAU;QAClB,OAAO,EAAE,CAAC,CAAC,MAAM;QACjB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,0BAAkB,CAAC;QAClC,SAAS,EAAE,+BAAiB;KAC7B,CAAC;IACF,CAAC,CAAC,OAAO,CAAC;QACR,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAgB,CAAC;QAC5C,MAAM,EAAE,kBAAU;QAClB,QAAQ,EAAE,uBAAY;QACtB,UAAU,EAAE,+BAAiB;KAC9B,CAAC;CACH,EACD,UAAU,CACX,CAAC"}

package/dist/src/schema/safe/safeShare.d.ts

@@ -0,0 +1,163 @@
+import * as t from "io-ts";
+export declare const SafeShareState: t.KeyofC<{
+    pendingapproval: null;
+    active: null;
+    accepted: null;
+    canceled: null;
+    rejected: null;
+}>;
+export type SafeShareState = t.TypeOf<typeof SafeShareState>;
+export declare const SafeShareKeychain: t.TypeC<{
+    rootKeyType: t.KeyofC<{
+        secp256k1Multisig: null;
+        ecdsaMpc: null;
+        eddsaMpc: null;
+        ed25519Multisig: null;
+    }>;
+    rootKeyId: t.StringC;
+    encryptedPrv: t.StringC;
+    publicIdentifier: t.StringC;
+    fromPubKey: t.StringC;
+    toPubKey: t.StringC;
+    path: t.StringC;
+}>;
+export type SafeShareKeychain = t.TypeOf<typeof SafeShareKeychain>;
+export declare const SafeShareKeychains: t.TypeC<{
+    hot: t.TupleC<[t.TypeC<{
+        rootKeyType: t.KeyofC<{
+            secp256k1Multisig: null;
+            ecdsaMpc: null;
+            eddsaMpc: null;
+            ed25519Multisig: null;
+        }>;
+        rootKeyId: t.StringC;
+        encryptedPrv: t.StringC;
+        publicIdentifier: t.StringC;
+        fromPubKey: t.StringC;
+        toPubKey: t.StringC;
+        path: t.StringC;
+    }>, t.TypeC<{
+        rootKeyType: t.KeyofC<{
+            secp256k1Multisig: null;
+            ecdsaMpc: null;
+            eddsaMpc: null;
+            ed25519Multisig: null;
+        }>;
+        rootKeyId: t.StringC;
+        encryptedPrv: t.StringC;
+        publicIdentifier: t.StringC;
+        fromPubKey: t.StringC;
+        toPubKey: t.StringC;
+        path: t.StringC;
+    }>, t.TypeC<{
+        rootKeyType: t.KeyofC<{
+            secp256k1Multisig: null;
+            ecdsaMpc: null;
+            eddsaMpc: null;
+            ed25519Multisig: null;
+        }>;
+        rootKeyId: t.StringC;
+        encryptedPrv: t.StringC;
+        publicIdentifier: t.StringC;
+        fromPubKey: t.StringC;
+        toPubKey: t.StringC;
+        path: t.StringC;
+    }>, t.TypeC<{
+        rootKeyType: t.KeyofC<{
+            secp256k1Multisig: null;
+            ecdsaMpc: null;
+            eddsaMpc: null;
+            ed25519Multisig: null;
+        }>;
+        rootKeyId: t.StringC;
+        encryptedPrv: t.StringC;
+        publicIdentifier: t.StringC;
+        fromPubKey: t.StringC;
+        toPubKey: t.StringC;
+        path: t.StringC;
+    }>]>;
+}>;
+export type SafeShareKeychains = t.TypeOf<typeof SafeShareKeychains>;
+export declare const SafeShareData: t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+    enterpriseId: t.StringC;
+    safeId: t.StringC;
+    fromUser: t.StringC;
+    toUser: t.StringC;
+    permissions: import("io-ts-types").NonEmptyArrayC<t.KeyofC<{
+        view: null;
+        spend: null;
+        admin: null;
+        dapp: null;
+    }>>;
+    state: t.KeyofC<{
+        pendingapproval: null;
+        active: null;
+        accepted: null;
+        canceled: null;
+        rejected: null;
+    }>;
+    createdAt: import("io-ts-types").DateFromISOStringC;
+}>, t.PartialC<{
+    safeLabel: t.StringC;
+    message: t.StringC;
+    pendingApprovalId: t.StringC;
+    isUMSInitiated: t.BooleanC;
+    keychains: t.TypeC<{
+        hot: t.TupleC<[t.TypeC<{
+            rootKeyType: t.KeyofC<{
+                secp256k1Multisig: null;
+                ecdsaMpc: null;
+                eddsaMpc: null;
+                ed25519Multisig: null;
+            }>;
+            rootKeyId: t.StringC;
+            encryptedPrv: t.StringC;
+            publicIdentifier: t.StringC;
+            fromPubKey: t.StringC;
+            toPubKey: t.StringC;
+            path: t.StringC;
+        }>, t.TypeC<{
+            rootKeyType: t.KeyofC<{
+                secp256k1Multisig: null;
+                ecdsaMpc: null;
+                eddsaMpc: null;
+                ed25519Multisig: null;
+            }>;
+            rootKeyId: t.StringC;
+            encryptedPrv: t.StringC;
+            publicIdentifier: t.StringC;
+            fromPubKey: t.StringC;
+            toPubKey: t.StringC;
+            path: t.StringC;
+        }>, t.TypeC<{
+            rootKeyType: t.KeyofC<{
+                secp256k1Multisig: null;
+                ecdsaMpc: null;
+                eddsaMpc: null;
+                ed25519Multisig: null;
+            }>;
+            rootKeyId: t.StringC;
+            encryptedPrv: t.StringC;
+            publicIdentifier: t.StringC;
+            fromPubKey: t.StringC;
+            toPubKey: t.StringC;
+            path: t.StringC;
+        }>, t.TypeC<{
+            rootKeyType: t.KeyofC<{
+                secp256k1Multisig: null;
+                ecdsaMpc: null;
+                eddsaMpc: null;
+                ed25519Multisig: null;
+            }>;
+            rootKeyId: t.StringC;
+            encryptedPrv: t.StringC;
+            publicIdentifier: t.StringC;
+            fromPubKey: t.StringC;
+            toPubKey: t.StringC;
+            path: t.StringC;
+        }>]>;
+    }>;
+    updatedAt: import("io-ts-types").DateFromISOStringC;
+}>]>;
+export type SafeShareData = t.TypeOf<typeof SafeShareData>;

package/dist/src/schema/safe/safeShare.js

@@ -0,0 +1,71 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeShareData = exports.SafeShareKeychains = exports.SafeShareKeychain = exports.SafeShareState = void 0;
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const rootKeys_1 = require("./rootKeys");
+const safe_1 = require("./safe");
+exports.SafeShareState = t.keyof({
+    pendingapproval: null,
+    active: null,
+    accepted: null,
+    canceled: null,
+    rejected: null,
+}, "SafeShareState");
+exports.SafeShareKeychain = t.type({
+    rootKeyType: rootKeys_1.RootKeyType,
+    rootKeyId: t.string,
+    encryptedPrv: t.string,
+    publicIdentifier: t.string,
+    fromPubKey: t.string,
+    toPubKey: t.string,
+    path: t.string,
+}, "SafeShareKeychain");
+const SafeShareKeychainQuad = t.tuple([exports.SafeShareKeychain, exports.SafeShareKeychain, exports.SafeShareKeychain, exports.SafeShareKeychain], "SafeShareKeychainQuad");
+exports.SafeShareKeychains = t.type({
+    hot: SafeShareKeychainQuad,
+}, "SafeShareKeychains");
+exports.SafeShareData = t.intersection([
+    t.type({
+        id: t.string,
+        enterpriseId: t.string,
+        safeId: t.string,
+        fromUser: t.string,
+        toUser: t.string,
+        permissions: (0, io_ts_types_1.nonEmptyArray)(safe_1.SafePermission),
+        state: exports.SafeShareState,
+        createdAt: io_ts_types_1.DateFromISOString,
+    }),
+    t.partial({
+        safeLabel: t.string,
+        message: t.string,
+        pendingApprovalId: t.string,
+        isUMSInitiated: t.boolean,
+        keychains: exports.SafeShareKeychains,
+        updatedAt: io_ts_types_1.DateFromISOString,
+    }),
+], "SafeShareData");
+//# sourceMappingURL=safeShare.js.map

package/dist/src/schema/safe/safeShare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeShare.js","sourceRoot":"","sources":["../../../../src/schema/safe/safeShare.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAC3B,6CAA+D;AAC/D,yCAAyC;AACzC,iCAAwC;AAM3B,QAAA,cAAc,GAAG,CAAC,CAAC,KAAK,CACnC;IACE,eAAe,EAAE,IAAI;IACrB,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;CACf,EACD,gBAAgB,CACjB,CAAC;AAQW,QAAA,iBAAiB,GAAG,CAAC,CAAC,IAAI,CACrC;IACE,WAAW,EAAE,sBAAW;IACxB,SAAS,EAAE,CAAC,CAAC,MAAM;IACnB,YAAY,EAAE,CAAC,CAAC,MAAM;IACtB,gBAAgB,EAAE,CAAC,CAAC,MAAM;IAC1B,UAAU,EAAE,CAAC,CAAC,MAAM;IACpB,QAAQ,EAAE,CAAC,CAAC,MAAM;IAClB,IAAI,EAAE,CAAC,CAAC,MAAM;CACf,EACD,mBAAmB,CACpB,CAAC;AAKF,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CACnC,CAAC,yBAAiB,EAAE,yBAAiB,EAAE,yBAAiB,EAAE,yBAAiB,CAAC,EAC5E,uBAAuB,CACxB,CAAC;AAOW,QAAA,kBAAkB,GAAG,CAAC,CAAC,IAAI,CACtC;IACE,GAAG,EAAE,qBAAqB;CAC3B,EACD,oBAAoB,CACrB,CAAC;AAKW,QAAA,aAAa,GAAG,CAAC,CAAC,YAAY,CACzC;IACE,CAAC,CAAC,IAAI,CAAC;QACL,EAAE,EAAE,CAAC,CAAC,MAAM;QACZ,YAAY,EAAE,CAAC,CAAC,MAAM;QACtB,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,QAAQ,EAAE,CAAC,CAAC,MAAM;QAClB,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,WAAW,EAAE,IAAA,2BAAa,EAAC,qBAAc,CAAC;QAC1C,KAAK,EAAE,sBAAc;QACrB,SAAS,EAAE,+BAAiB;KAC7B,CAAC;IACF,CAAC,CAAC,OAAO,CAAC;QACR,SAAS,EAAE,CAAC,CAAC,MAAM;QACnB,OAAO,EAAE,CAAC,CAAC,MAAM;QACjB,iBAAiB,EAAE,CAAC,CAAC,MAAM;QAC3B,cAAc,EAAE,CAAC,CAAC,OAAO;QACzB,SAAS,EAAE,0BAAkB;QAC7B,SAAS,EAAE,+BAAiB;KAC7B,CAAC;CACH,EACD,eAAe,CAChB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo/public-types",
-  "version": "6.40.1",
+  "version": "6.41.0",
   "description": "Collection of types exposed externally as part of the BitGo public API",
   "license": "UNLICENSED",
   "author": "",

package/src/schema/index.ts

@@ -9,3 +9,4 @@ export * from "./lightning";
 export * from "./enterprise";
 export * from "./webauthn";
 export * from "./defi";
+export * from "./safe";

package/src/schema/safe/index.ts

@@ -0,0 +1,4 @@
+export * from "./rootKeys";
+export * from "./safe";
+export * from "./safeShare";
+export * from "./requests";

package/src/schema/safe/requests.ts

@@ -0,0 +1,36 @@
+import * as t from "io-ts";
+import { DateFromISOString } from "io-ts-types";
+import { SafeRootKeys } from "./rootKeys";
+
+/**
+ * POST /enterprise/:eId/safes — Phase 1 carries no key material.
+ * @experimental
+ */
+export const InitializeSafeBody = t.type(
+  { label: t.string },
+  "InitializeSafeBody",
+);
+/** @experimental */
+export type InitializeSafeBody = t.TypeOf<typeof InitializeSafeBody>;
+
+/**
+ * POST /enterprise/:eId/safes/:safeId/finalize — the 12 key ids as 4 ordered triplets.
+ * @experimental
+ */
+export const FinalizeSafeBody = t.type(
+  { rootKeys: SafeRootKeys },
+  "FinalizeSafeBody",
+);
+/** @experimental */
+export type FinalizeSafeBody = t.TypeOf<typeof FinalizeSafeBody>;
+
+/**
+ * POST / DELETE /enterprise/:eId/safes/:safeId/freeze
+ * @experimental
+ */
+export const FreezeSafeBody = t.partial(
+  { expires: DateFromISOString, reason: t.string },
+  "FreezeSafeBody",
+);
+/** @experimental */
+export type FreezeSafeBody = t.TypeOf<typeof FreezeSafeBody>;

package/src/schema/safe/rootKeys.ts

@@ -0,0 +1,77 @@
+import * as t from "io-ts";
+
+/**
+ * The four static root-key slots of a safe, keyed by (curve, scheme):
+ * - secp256k1Multisig — ex. UTXO/XRP/XTZ/TRX/EOS
+ * - ecdsaMpc          — ex. EVM/Cosmos (DKLS)
+ * - eddsaMpc          — ex. SOL/SUI/NEAR/TON/APT/DOT
+ * - ed25519Multisig   — ex. ALGO/XLM/HBAR
+ * @experimental
+ */
+export const RootKeyType = t.keyof(
+  {
+    secp256k1Multisig: null,
+    ecdsaMpc: null,
+    eddsaMpc: null,
+    ed25519Multisig: null,
+  },
+  "RootKeyType",
+);
+/** @experimental */
+export type RootKeyType = t.TypeOf<typeof RootKeyType>;
+
+/**
+ * An ordered [userKeyId, backupKeyId, bitgoKeyId] triplet — same shape/order as wallet.keys[].
+ * @experimental
+ */
+export const RootKeyTriplet = t.tuple(
+  [t.string, t.string, t.string],
+  "RootKeyTriplet",
+);
+/** @experimental */
+export type RootKeyTriplet = t.TypeOf<typeof RootKeyTriplet>;
+
+/**
+ * The 12 root key ids for a single custody model, keyed by (curve, scheme).
+ * @experimental
+ */
+export const RootKeysByType = t.type(
+  {
+    secp256k1Multisig: RootKeyTriplet,
+    ecdsaMpc: RootKeyTriplet,
+    eddsaMpc: RootKeyTriplet,
+    ed25519Multisig: RootKeyTriplet,
+  },
+  "RootKeysByType",
+);
+/** @experimental */
+export type RootKeysByType = t.TypeOf<typeof RootKeysByType>;
+
+/**
+ * Custody models a safe's roots can be created under. v1 implements `hot` only; this is a subset
+ * of the broader wallet `WalletTypes`.
+ * @experimental
+ */
+export const SafeCustodyType = t.keyof(
+  {
+    hot: null,
+    cold: null,
+    custodial: null,
+  },
+  "SafeCustodyType",
+);
+/** @experimental */
+export type SafeCustodyType = t.TypeOf<typeof SafeCustodyType>;
+
+/**
+ * A safe's root keys — the set of 4 (curve, scheme) root triplets.
+ * @experimental
+ */
+export const SafeRootKeys = t.type(
+  {
+    hot: RootKeysByType,
+  },
+  "SafeRootKeys",
+);
+/** @experimental */
+export type SafeRootKeys = t.TypeOf<typeof SafeRootKeys>;

package/src/schema/safe/safe.ts

@@ -0,0 +1,99 @@
+import * as t from "io-ts";
+import { DateFromISOString, nonEmptyArray } from "io-ts-types";
+import { SafeRootKeys } from "./rootKeys";
+
+/** @experimental */
+export const SafePermission = t.keyof(
+  {
+    view: null,
+    spend: null,
+    admin: null,
+    dapp: null,
+  },
+  "SafePermission",
+);
+/** @experimental */
+export type SafePermission = t.TypeOf<typeof SafePermission>;
+
+/**
+ * A safe's lifecycle status. freeze is NOT a status — a frozen safe stays `active` with the freeze
+ * field set (wallet precedent).
+ * @experimental
+ */
+export const SafeStatus = t.keyof(
+  {
+    initializing: null,
+    active: null,
+    archived: null,
+  },
+  "SafeStatus",
+);
+/** @experimental */
+export type SafeStatus = t.TypeOf<typeof SafeStatus>;
+
+/** @experimental */
+export const SafeMembershipData = t.intersection(
+  [
+    t.type({
+      userId: t.string,
+      permissions: nonEmptyArray(SafePermission),
+    }),
+    t.partial({
+      needsRecovery: t.boolean,
+    }),
+  ],
+  "SafeMembershipData",
+);
+/** @experimental */
+export type SafeMembershipData = t.TypeOf<typeof SafeMembershipData>;
+
+/**
+ * A pending UMS spend grant awaiting a key share — mirror of the wallet's walletShareRequests[].
+ * @experimental
+ */
+export const SafeShareRequest = t.type(
+  {
+    userId: t.string,
+    permissions: nonEmptyArray(SafePermission),
+    createdAt: DateFromISOString,
+  },
+  "SafeShareRequest",
+);
+/** @experimental */
+export type SafeShareRequest = t.TypeOf<typeof SafeShareRequest>;
+
+/** @experimental */
+export const SafeFreeze = t.partial(
+  {
+    time: DateFromISOString,
+    expires: DateFromISOString,
+    reason: t.string,
+  },
+  "SafeFreeze",
+);
+/** @experimental */
+export type SafeFreeze = t.TypeOf<typeof SafeFreeze>;
+
+/** @experimental */
+export const SafeData = t.intersection(
+  [
+    t.type({
+      id: t.string,
+      enterpriseId: t.string,
+      label: t.string,
+      status: SafeStatus,
+      creator: t.string,
+      users: t.array(SafeMembershipData),
+      createdAt: DateFromISOString,
+    }),
+    t.partial({
+      safeShareRequests: t.array(SafeShareRequest),
+      freeze: SafeFreeze,
+      rootKeys: SafeRootKeys,
+      archivedAt: DateFromISOString,
+    }),
+  ],
+  "SafeData",
+);
+/** @experimental */
+export type SafeData = t.TypeOf<typeof SafeData>;

package/src/schema/safe/safeShare.ts

@@ -0,0 +1,87 @@
+import * as t from "io-ts";
+import { DateFromISOString, nonEmptyArray } from "io-ts-types";
+import { RootKeyType } from "./rootKeys";
+import { SafePermission } from "./safe";
+
+/**
+ * Safe key-share states — identical to WalletShare states, no new states.
+ * @experimental
+ */
+export const SafeShareState = t.keyof(
+  {
+    pendingapproval: null,
+    active: null,
+    accepted: null,
+    canceled: null,
+    rejected: null,
+  },
+  "SafeShareState",
+);
+/** @experimental */
+export type SafeShareState = t.TypeOf<typeof SafeShareState>;
+
+/**
+ * One of the 4 root USER keyshares carried on a SafeShare, ECDH-re-encrypted to the recipient.
+ * @experimental
+ */
+export const SafeShareKeychain = t.type(
+  {
+    rootKeyType: RootKeyType,
+    rootKeyId: t.string,
+    encryptedPrv: t.string,
+    publicIdentifier: t.string,
+    fromPubKey: t.string,
+    toPubKey: t.string,
+    path: t.string,
+  },
+  "SafeShareKeychain",
+);
+/** @experimental */
+export type SafeShareKeychain = t.TypeOf<typeof SafeShareKeychain>;
+
+/** Exactly 4 keyshares — one per (curve, scheme) root. */
+const SafeShareKeychainQuad = t.tuple(
+  [SafeShareKeychain, SafeShareKeychain, SafeShareKeychain, SafeShareKeychain],
+  "SafeShareKeychainQuad",
+);
+
+/**
+ * A safe's keyshares grouped by custody model — mirrors the SafeRootKeys structure so callers
+ * can correlate keychains with the correct custody root.
+ * @experimental
+ */
+export const SafeShareKeychains = t.type(
+  {
+    hot: SafeShareKeychainQuad,
+  },
+  "SafeShareKeychains",
+);
+/** @experimental */
+export type SafeShareKeychains = t.TypeOf<typeof SafeShareKeychains>;
+
+/** @experimental */
+export const SafeShareData = t.intersection(
+  [
+    t.type({
+      id: t.string,
+      enterpriseId: t.string,
+      safeId: t.string,
+      fromUser: t.string,
+      toUser: t.string,
+      permissions: nonEmptyArray(SafePermission),
+      state: SafeShareState,
+      createdAt: DateFromISOString,
+    }),
+    t.partial({
+      safeLabel: t.string,
+      message: t.string,
+      pendingApprovalId: t.string,
+      isUMSInitiated: t.boolean,
+      keychains: SafeShareKeychains,
+      updatedAt: DateFromISOString,
+    }),
+  ],
+  "SafeShareData",
+);
+/** @experimental */
+export type SafeShareData = t.TypeOf<typeof SafeShareData>;