@dfns/sdk 0.8.19 → 0.8.21

package/generated/signers/client.d.ts

@@ -3,6 +3,26 @@ import * as T from './types';
 export declare class SignersClient {
     private apiOptions;
     constructor(apiOptions: DfnsApiClientOptions);
+    createCloneInput(request: T.CreateCloneInputRequest): Promise<T.CreateCloneInputResponse>;
+    createGenesisInput(request: T.CreateGenesisInputRequest): Promise<T.CreateGenesisInputResponse>;
+    createOnchainSignInput(request: T.CreateOnchainSignInputRequest): Promise<T.CreateOnchainSignInputResponse>;
+    createProofOfControlInput(request: T.CreateProofOfControlInputRequest): Promise<T.CreateProofOfControlInputResponse>;
     listKeyStores(): Promise<T.ListKeyStoresResponse>;
     listSigners(): Promise<T.ListSignersResponse>;
+    submitCloneOutput(request: T.SubmitCloneOutputRequest, file: {
+        bytes: Uint8Array;
+        name?: string;
+    }): Promise<T.SubmitCloneOutputResponse>;
+    submitGenesisOutput(request: T.SubmitGenesisOutputRequest, file: {
+        bytes: Uint8Array;
+        name?: string;
+    }): Promise<T.SubmitGenesisOutputResponse>;
+    submitOnchainSignOutput(request: T.SubmitOnchainSignOutputRequest, file: {
+        bytes: Uint8Array;
+        name?: string;
+    }): Promise<T.SubmitOnchainSignOutputResponse>;
+    submitProofOfControlOutput(request: T.SubmitProofOfControlOutputRequest, file: {
+        bytes: Uint8Array;
+        name?: string;
+    }): Promise<T.SubmitProofOfControlOutputResponse>;
 }

package/generated/signers/client.js

@@ -3,11 +3,60 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignersClient = void 0;
 const fetch_1 = require("../../utils/fetch");
+const userActionFetch_1 = require("../../utils/userActionFetch");
 const url_1 = require("../../utils/url");
 class SignersClient {
     constructor(apiOptions) {
         this.apiOptions = apiOptions;
     }
+    async createCloneInput(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/clone/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createGenesisInput(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/genesis/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createOnchainSignInput(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/onchain-sign/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createProofOfControlInput(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/proof-of-control/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
     async listKeyStores() {
         const path = (0, url_1.buildPathAndQuery)('/key-stores', {
             path: {},
@@ -30,5 +79,57 @@ class SignersClient {
         });
         return response.json();
     }
+    async submitCloneOutput(request, file) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/clone/output', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            file,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async submitGenesisOutput(request, file) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/genesis/output', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            file,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async submitOnchainSignOutput(request, file) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/onchain-sign/output', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            file,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async submitProofOfControlOutput(request, file) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/proof-of-control/output', {
+            path: request ?? {},
+            query: {},
+        });
+        const response = await (0, userActionFetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            file,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
 }
 exports.SignersClient = SignersClient;

package/generated/signers/delegatedClient.d.ts

@@ -1,8 +1,17 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
 import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
 import * as T from './types';
 export declare class DelegatedSignersClient {
     private apiOptions;
     constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    createCloneInputInit(request: T.CreateCloneInputRequest): Promise<UserActionChallengeResponse>;
+    createCloneInputComplete(request: T.CreateCloneInputRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateCloneInputResponse>;
+    createGenesisInputInit(request: T.CreateGenesisInputRequest): Promise<UserActionChallengeResponse>;
+    createGenesisInputComplete(request: T.CreateGenesisInputRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateGenesisInputResponse>;
+    createOnchainSignInputInit(request: T.CreateOnchainSignInputRequest): Promise<UserActionChallengeResponse>;
+    createOnchainSignInputComplete(request: T.CreateOnchainSignInputRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateOnchainSignInputResponse>;
+    createProofOfControlInputInit(request: T.CreateProofOfControlInputRequest): Promise<UserActionChallengeResponse>;
+    createProofOfControlInputComplete(request: T.CreateProofOfControlInputRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateProofOfControlInputResponse>;
     listKeyStores(): Promise<T.ListKeyStoresResponse>;
     listSigners(): Promise<T.ListSignersResponse>;
 }

package/generated/signers/delegatedClient.js

@@ -1,12 +1,121 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DelegatedSignersClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
 const fetch_1 = require("../../utils/fetch");
 const url_1 = require("../../utils/url");
 class DelegatedSignersClient {
     constructor(apiOptions) {
         this.apiOptions = apiOptions;
     }
+    async createCloneInputInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/clone/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createCloneInputComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/clone/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createGenesisInputInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/genesis/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createGenesisInputComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/genesis/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createOnchainSignInputInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/onchain-sign/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createOnchainSignInputComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/onchain-sign/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createProofOfControlInputInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/proof-of-control/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createProofOfControlInputComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/key-stores/:storeId/proof-of-control/input', {
+            path: request ?? {},
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
     async listKeyStores() {
         const path = (0, url_1.buildPathAndQuery)('/key-stores', {
             path: {},

package/generated/signers/types.d.ts

@@ -1,7 +1,52 @@
+export type CreateCloneInputBody = {
+    kind: "Clone";
+    hsmSourceSerial: string;
+    hsmTargetSerial: string;
+};
+export type CreateCloneInputParams = {
+    storeId: string;
+};
+export type CreateCloneInputResponse = string;
+export type CreateCloneInputRequest = CreateCloneInputParams & {
+    body: CreateCloneInputBody;
+};
+export type CreateGenesisInputBody = {
+    kind: "Genesis";
+    numProvisioners: number;
+    numSecp256k1: number;
+    numEd25519: number;
+    hsmGenesisSerial: string;
+    hsmGenesisFirmwareVersion?: ("2.2" | "2.4") | undefined;
+};
+export type CreateGenesisInputParams = {
+    storeId: string;
+};
+export type CreateGenesisInputResponse = string;
+export type CreateGenesisInputRequest = CreateGenesisInputParams & {
+    body: CreateGenesisInputBody;
+};
+export type CreateOnchainSignInputBody = {};
+export type CreateOnchainSignInputParams = {
+    storeId: string;
+};
+export type CreateOnchainSignInputResponse = string;
+export type CreateOnchainSignInputRequest = CreateOnchainSignInputParams & {
+    body: CreateOnchainSignInputBody;
+};
+export type CreateProofOfControlInputBody = {
+    walletIds: string[];
+};
+export type CreateProofOfControlInputParams = {
+    storeId: string;
+};
+export type CreateProofOfControlInputResponse = string;
+export type CreateProofOfControlInputRequest = CreateProofOfControlInputParams & {
+    body: CreateProofOfControlInputBody;
+};
 export type ListKeyStoresResponse = {
     items: {
         id: string;
-        kind: "Hsm" | "Mpc";
+        kind: "Hsm" | "Mpc" | "OfflineSigner";
         name?: string | undefined;
         primary: boolean;
     }[];
@@ -15,3 +60,223 @@ export type ListSignersResponse = {
         }[];
     }[];
 };
+export type __WireSubmitCloneOutputBody = {
+    fileChecksum: string;
+    outputJson: {
+        type: "fleet-output";
+        version: 1;
+        status: "success";
+        org_id: string;
+        fleet_id: string;
+        fleet_label: string;
+        keystore_id: string;
+        outputs: {
+            [x: string]: {
+                success: {
+                    type: "genesis-registration";
+                    ceremony_mode: string;
+                    hsm_serial: string;
+                    hsm_identity_key: string;
+                    mac_serial: string;
+                    mac_se_wrap_key_pub_key: string;
+                    provisioners: {
+                        [x: string]: string;
+                    };
+                    hsm_sealed?: unknown | null;
+                    key_harvest: {
+                        "ed25519-start": number;
+                        ed25519: number;
+                        error: string | null;
+                        "secp256k1-start": number;
+                        secp256k1: number;
+                    };
+                } | {
+                    type: "clone-registration";
+                    ceremony_mode: string;
+                    hsm_target_serial: string;
+                    hsm_identity_key: string;
+                    mac_target_serial: string;
+                    mac_se_wrap_key_pub_key: string;
+                    hsm_sealed?: unknown | null;
+                };
+            };
+        };
+    };
+};
+export type SubmitCloneOutputBody = Omit<__WireSubmitCloneOutputBody, 'fileChecksum'>;
+export type SubmitCloneOutputParams = {
+    storeId: string;
+};
+export type SubmitCloneOutputResponse = {
+    message: string;
+};
+export type SubmitCloneOutputRequest = SubmitCloneOutputParams & {
+    body: SubmitCloneOutputBody;
+};
+export type __WireSubmitGenesisOutputBody = {
+    fileChecksum: string;
+    outputJson: {
+        type: "fleet-output";
+        version: 1;
+        status: "success";
+        org_id: string;
+        fleet_id: string;
+        fleet_label: string;
+        keystore_id: string;
+        outputs: {
+            [x: string]: {
+                success: {
+                    type: "genesis-registration";
+                    ceremony_mode: string;
+                    hsm_serial: string;
+                    hsm_identity_key: string;
+                    mac_serial: string;
+                    mac_se_wrap_key_pub_key: string;
+                    provisioners: {
+                        [x: string]: string;
+                    };
+                    hsm_sealed?: unknown | null;
+                    key_harvest: {
+                        "ed25519-start": number;
+                        ed25519: number;
+                        error: string | null;
+                        "secp256k1-start": number;
+                        secp256k1: number;
+                    };
+                } | {
+                    type: "clone-registration";
+                    ceremony_mode: string;
+                    hsm_target_serial: string;
+                    hsm_identity_key: string;
+                    mac_target_serial: string;
+                    mac_se_wrap_key_pub_key: string;
+                    hsm_sealed?: unknown | null;
+                };
+            };
+        };
+    };
+};
+export type SubmitGenesisOutputBody = Omit<__WireSubmitGenesisOutputBody, 'fileChecksum'>;
+export type SubmitGenesisOutputParams = {
+    storeId: string;
+};
+export type SubmitGenesisOutputResponse = {
+    message: string;
+};
+export type SubmitGenesisOutputRequest = SubmitGenesisOutputParams & {
+    body: SubmitGenesisOutputBody;
+};
+export type __WireSubmitOnchainSignOutputBody = {
+    fileChecksum: string;
+    outputJson: {
+        type: "keystore-output";
+        version: 1;
+        org_id: string;
+        fleet_id: string;
+        keystore_id: string;
+        group_id: string;
+        status: "success" | "partial" | "fail";
+        outputs: {
+            [x: string]: {
+                type: "proof-of-control-v1";
+                result: {
+                    success: {
+                        signer_public_key: string;
+                        prefix: string;
+                        message: string;
+                        exact_bytes_signed: string;
+                        signature: string;
+                    };
+                } | {
+                    fail: {
+                        message: string;
+                        code: string;
+                    };
+                };
+            } | {
+                type: "onchain-sign-v1";
+                result: {
+                    success: {
+                        [x: string]: {
+                            signer_public_key: string;
+                            exact_bytes_signed: string;
+                            signature: string;
+                        };
+                    };
+                } | {
+                    fail: {
+                        message: string;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export type SubmitOnchainSignOutputBody = Omit<__WireSubmitOnchainSignOutputBody, 'fileChecksum'>;
+export type SubmitOnchainSignOutputParams = {
+    storeId: string;
+};
+export type SubmitOnchainSignOutputResponse = {
+    status: "success" | "partial";
+};
+export type SubmitOnchainSignOutputRequest = SubmitOnchainSignOutputParams & {
+    body: SubmitOnchainSignOutputBody;
+};
+export type __WireSubmitProofOfControlOutputBody = {
+    fileChecksum: string;
+    outputJson: {
+        type: "keystore-output";
+        version: 1;
+        org_id: string;
+        fleet_id: string;
+        keystore_id: string;
+        group_id: string;
+        status: "success" | "partial" | "fail";
+        outputs: {
+            [x: string]: {
+                type: "proof-of-control-v1";
+                result: {
+                    success: {
+                        signer_public_key: string;
+                        prefix: string;
+                        message: string;
+                        exact_bytes_signed: string;
+                        signature: string;
+                    };
+                } | {
+                    fail: {
+                        message: string;
+                        code: string;
+                    };
+                };
+            } | {
+                type: "onchain-sign-v1";
+                result: {
+                    success: {
+                        [x: string]: {
+                            signer_public_key: string;
+                            exact_bytes_signed: string;
+                            signature: string;
+                        };
+                    };
+                } | {
+                    fail: {
+                        message: string;
+                        code: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export type SubmitProofOfControlOutputBody = Omit<__WireSubmitProofOfControlOutputBody, 'fileChecksum'>;
+export type SubmitProofOfControlOutputParams = {
+    storeId: string;
+};
+export type SubmitProofOfControlOutputResponse = {
+    status: "success" | "partial";
+};
+export type SubmitProofOfControlOutputRequest = SubmitProofOfControlOutputParams & {
+    body: SubmitProofOfControlOutputBody;
+};