@cubist-labs/cubesigner-sdk 0.2.28 → 0.3.1

package/dist/esm/src/schema_types.d.ts

@@ -0,0 +1,113 @@
+import { MfaPolicy } from "./role";
+import { components } from "./schema";
+import { JsonMap } from "./util";
+type schemas = components["schemas"];
+export type UserInfo = schemas["UserInfo"];
+export type ConfiguredMfa = schemas["ConfiguredMfa"];
+export type RatchetConfig = schemas["RatchetConfig"];
+export type IdentityProof = schemas["IdentityProof"];
+export type TotpInfo = schemas["TotpInfo"];
+export type OidcAuthResponse = schemas["NewSessionResponse"];
+export type ApiAddFidoChallenge = schemas["FidoCreateChallengeResponse"];
+export type ApiMfaFidoChallenge = schemas["FidoAssertChallenge"];
+export type PublicKeyCredentialCreationOptions = schemas["PublicKeyCredentialCreationOptions"];
+export type PublicKeyCredentialRequestOptions = schemas["PublicKeyCredentialRequestOptions"];
+export type PublicKeyCredentialParameters = schemas["PublicKeyCredentialParameters"];
+export type PublicKeyCredentialDescriptor = schemas["PublicKeyCredentialDescriptor"];
+export type AuthenticatorSelectionCriteria = schemas["AuthenticatorSelectionCriteria"];
+export type PublicKeyCredentialUserEntity = schemas["PublicKeyCredentialUserEntity"];
+export type PublicKeyCredential = schemas["PublicKeyCredential"];
+export type OrgInfo = schemas["OrgInfo"];
+export type UserIdInfo = schemas["UserIdInfo"];
+export type UpdateOrgRequest = schemas["UpdateOrgRequest"];
+export type UpdateOrgResponse = schemas["UpdateOrgResponse"];
+export type OidcIdentity = schemas["OIDCIdentity"];
+export type MemberRole = schemas["MemberRole"];
+export type SchemaKeyType = schemas["KeyType"];
+export type ListKeysResponse = schemas["PaginatedListKeysResponse"];
+export type UpdateKeyRequest = schemas["UpdateKeyRequest"];
+export type KeyInfoApi = schemas["KeyInfo"];
+export type KeyInRoleInfo = schemas["KeyInRoleInfo"];
+export type UserInRoleInfo = schemas["UserInRoleInfo"];
+export type KeyTypeApi = schemas["KeyType"];
+export type ListRolesResponse = schemas["PaginatedListRolesResponse"];
+export type ListRoleKeysResponse = schemas["PaginatedListRoleKeysResponse"];
+export type ListRoleUsersResponse = schemas["PaginatedListRoleUsersResponse"];
+export type UpdateRoleRequest = schemas["UpdateRoleRequest"];
+export type KeyWithPoliciesInfo = schemas["KeyInRoleInfo"];
+export type RoleInfo = schemas["RoleInfo"];
+export type SessionInfo = schemas["SessionInfo"];
+export type ClientSessionInfo = schemas["ClientSessionInfo"];
+export type NewSessionResponse = schemas["NewSessionResponse"];
+export type SessionsResponse = schemas["PaginatedSessionsResponse"];
+export type CreateSignerSessionRequest = schemas["CreateTokenRequest"];
+export type RefreshSignerSessionRequest = schemas["AuthData"];
+export type EvmSignRequest = schemas["Eth1SignRequest"];
+export type EvmSignResponse = schemas["Eth1SignResponse"];
+export type Eip191SignRequest = schemas["Eip191SignRequest"];
+export type Eip712SignRequest = schemas["Eip712SignRequest"];
+export type Eip191Or712SignResponse = schemas["Eip191Or712SignResponse"];
+export type Eth2SignRequest = schemas["Eth2SignRequest"];
+export type Eth2SignResponse = schemas["Eth2SignResponse"];
+export type Eth2StakeRequest = schemas["StakeRequest"];
+export type Eth2StakeResponse = schemas["StakeResponse"];
+export type Eth2UnstakeRequest = schemas["UnstakeRequest"];
+export type Eth2UnstakeResponse = schemas["UnstakeResponse"];
+export type BlobSignRequest = schemas["BlobSignRequest"];
+export type BlobSignResponse = schemas["BlobSignResponse"];
+export type BtcSignRequest = schemas["BtcSignRequest"];
+export type BtcSignResponse = schemas["BtcSignResponse"];
+export type SolanaSignRequest = schemas["SolanaSignRequest"];
+export type SolanaSignResponse = schemas["SolanaSignResponse"];
+export type AvaSignRequest = schemas["AvaSignRequest"];
+export type AvaSignResponse = schemas["AvaSignResponse"];
+export type AcceptedResponse = schemas["AcceptedResponse"];
+export type ErrorResponse = schemas["ErrorResponse"];
+export type BtcSignatureKind = schemas["BtcSignatureKind"];
+export type MfaType = schemas["MfaType"];
+export type MfaRequestInfo = schemas["MfaRequestInfo"];
+export type UserExportInitRequest = schemas["UserExportInitRequest"];
+export type UserExportInitResponse = schemas["UserExportInitResponse"];
+export type UserExportCompleteRequest = schemas["UserExportCompleteRequest"];
+export type UserExportCompleteResponse = schemas["UserExportCompleteResponse"];
+export type UserExportListResponse = schemas["PaginatedUserExportListResponse"];
+export type UserExportKeyMaterial = schemas["JsonKeyPackage"];
+export type Empty = schemas["EmptyImpl"];
+/** Options for a new OIDC user */
+export interface CreateOidcUserOptions {
+    /** The role of an OIDC user, default is "Alien" */
+    memberRole?: MemberRole;
+    /** Optional MFA policy to associate with the user account */
+    mfaPolicy?: MfaPolicy;
+}
+/** Ava P- or X-chain transaction */
+export type AvaTx = {
+    P: AvaPChainTx;
+} | {
+    X: AvaXChainTx;
+};
+/** Ava P-chain transaction */
+export type AvaPChainTx = {
+    AddPermissionlessValidator: JsonMap;
+} | {
+    AddSubnetValidator: JsonMap;
+} | {
+    AddValidator: JsonMap;
+} | {
+    CreateChain: JsonMap;
+} | {
+    CreateSubnet: JsonMap;
+} | {
+    Export: JsonMap;
+} | {
+    Import: JsonMap;
+};
+/** Ava X-chain transaction */
+export type AvaXChainTx = {
+    Base: JsonMap;
+} | {
+    Export: JsonMap;
+} | {
+    Import: JsonMap;
+};
+export {};

package/dist/esm/src/schema_types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/src/session/session_storage.d.ts

@@ -0,0 +1,27 @@
+/** Interface for storing sessions. */
+export interface SessionStorage<U> {
+    /** Store session information */
+    save(data: U): Promise<void>;
+    /** Retrieve session information */
+    retrieve(): Promise<U>;
+}
+/** Stores session information in memory */
+export declare class MemorySessionStorage<U> implements SessionStorage<U> {
+    #private;
+    /**
+     * Store session information.
+     * @param {U} data The session information to store
+     * @return {Promise<void>}
+     */
+    save(data: U): Promise<void>;
+    /**
+     * Retrieve session information.
+     * @return {Promise<U>} The session information
+     */
+    retrieve(): Promise<U>;
+    /**
+     * Constructor.
+     * @param {U?} data The initial data
+     */
+    constructor(data?: U);
+}

package/dist/esm/src/session/session_storage.js

@@ -0,0 +1,43 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MemorySessionStorage_data;
+/** Stores session information in memory */
+export class MemorySessionStorage {
+    /**
+     * Store session information.
+     * @param {U} data The session information to store
+     * @return {Promise<void>}
+     */
+    async save(data) {
+        __classPrivateFieldSet(this, _MemorySessionStorage_data, data, "f");
+    }
+    /**
+     * Retrieve session information.
+     * @return {Promise<U>} The session information
+     */
+    async retrieve() {
+        if (!__classPrivateFieldGet(this, _MemorySessionStorage_data, "f")) {
+            throw new Error("Missing session information");
+        }
+        return __classPrivateFieldGet(this, _MemorySessionStorage_data, "f");
+    }
+    /**
+     * Constructor.
+     * @param {U?} data The initial data
+     */
+    constructor(data) {
+        _MemorySessionStorage_data.set(this, void 0);
+        __classPrivateFieldSet(this, _MemorySessionStorage_data, data, "f");
+    }
+}
+_MemorySessionStorage_data = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/src/session/signer_session_manager.d.ts

@@ -0,0 +1,125 @@
+import { Events } from "../events";
+import { EnvInterface } from "../env";
+import { Client } from "../api";
+import { SessionStorage } from "./session_storage";
+import { ClientSessionInfo, NewSessionResponse } from "../schema_types";
+import { operations } from "../schema";
+/** JSON representation of our "signer session" file format */
+export interface SignerSessionData {
+    /** The organization ID */
+    org_id: string;
+    /** The role ID */
+    role_id?: string;
+    /** The purpose of the session token */
+    purpose?: string;
+    /** The token to include in Authorization header */
+    token: string;
+    /** Session info */
+    session_info: ClientSessionInfo;
+    /** Session expiration (in seconds since UNIX epoch) beyond which it cannot be refreshed */
+    session_exp: number | undefined;
+    /** The environment */
+    env: {
+        ["Dev-CubeSignerStack"]: EnvInterface;
+    };
+}
+/** Type of storage required for signer sessions */
+export type SignerSessionStorage = SessionStorage<SignerSessionData>;
+export interface SignerSessionLifetime {
+    /** Session lifetime (in seconds). Defaults to one week (604800). */
+    session?: number;
+    /** Auth token lifetime (in seconds). Defaults to five minutes (300). */
+    auth: number;
+    /** Refresh token lifetime (in seconds). Defaults to one day (86400). */
+    refresh?: number;
+    /** Grace lifetime (in seconds). Defaults to 30 seconds (30). */
+    grace?: number;
+}
+/** Generic session manager interface. */
+export declare class SignerSessionManager {
+    #private;
+    readonly env: EnvInterface;
+    readonly orgId: string;
+    readonly storage: SignerSessionStorage;
+    readonly events: Events;
+    /**
+     * @return {string} The current auth token.
+     * @internal
+     */
+    token(): Promise<string>;
+    /**
+     * Refreshes the current session if needed, then returns a client using the current session.
+     *
+     * May **UPDATE/MUTATE** self.
+     *
+     * @param {operations} operation The operation that this client will be
+     *   used for. This parameter is used exclusively for more accurate error
+     *   reporting and does not affect functionality.
+     * @return {Client} The client with the current session
+     */
+    client(operation?: keyof operations): Promise<Client>;
+    /** Revokes the session. */
+    revoke(): Promise<void>;
+    /**
+     * Refreshes the session and **UPDATES/MUTATES** self.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Returns whether it's time to refresh this token.
+     * @return {boolean} Whether it's time to refresh this token.
+     * @internal
+     */
+    isStale(): Promise<boolean>;
+    /**
+     * Return whether this session has expired and cannot be refreshed anymore.
+     * @return {boolean} Whether this session has expired.
+     * @internal
+     */
+    hasExpired(): boolean;
+    /**
+     * Refreshes the session if it is about to expire.
+     * @return {boolean} Whether the session token was refreshed.
+     * @internal
+     */
+    refreshIfNeeded(): Promise<boolean>;
+    /**
+     * Automatically refreshes the session in the background (if needed) every
+     * minute. This is a simple wrapper around `setInterval`.
+     * @return {number} The interval ID of the refresh timer.
+     */
+    autoRefresh(): RefreshId;
+    /**
+     * Clears the auto refresh timer.
+     * @param {number} timer The timer ID to clear.
+     */
+    clearAutoRefresh(timer: RefreshId): void;
+    /**
+     * @param {EnvInterface} env The CubeSigner environment
+     * @param {string} orgId The organization ID
+     * @param {NewSessionResponse} session The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static createFromSessionInfo(env: EnvInterface, orgId: string, session: NewSessionResponse, storage?: SignerSessionStorage): Promise<SignerSessionManager>;
+    /**
+     * @param {SignerSessionData} sessionData The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static createFromSessionData(sessionData: SignerSessionData, storage?: SignerSessionStorage): Promise<SignerSessionManager>;
+    /**
+     * Uses an existing session to create a new signer session manager.
+     *
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @return {Promise<SingerSession>} New signer session manager
+     */
+    static loadFromStorage(storage: SignerSessionStorage): Promise<SignerSessionManager>;
+    /**
+     * Constructor.
+     * @param {SignerSessionData} sessionData Session data
+     * @param {SignerSessionStorage} storage The session storage to use.
+     */
+    constructor(sessionData: SignerSessionData, storage: SignerSessionStorage);
+}
+/** Type of the refresh timer ID. */
+export type RefreshId = ReturnType<typeof setInterval>;

package/dist/esm/src/session/signer_session_manager.js

@@ -0,0 +1,235 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _SignerSessionManager_instances, _a, _SignerSessionManager_eventEmitter, _SignerSessionManager_refreshing, _SignerSessionManager_client, _SignerSessionManager_createClient, _SignerSessionManager_hasTimestampExpired;
+import { Events } from "../events";
+import { createHttpClient, OpClient } from "../api";
+import { MemorySessionStorage } from "./session_storage";
+import { delay } from "../util";
+import { EventEmitter } from "../events";
+import { SessionExpiredError } from "../error";
+const DEFAULT_EXPIRATION_BUFFER_SECS = 30;
+/**
+ * Constructs {@link Date} from a number representing seconds since unix epoch.
+ * @param {number} secs Seconds since unix epoch.
+ * @return {Date} The equivalent date.
+ */
+function secondsSinceEpochToDate(secs) {
+    return new Date(secs * 1000);
+}
+/** Generic session manager interface. */
+export class SignerSessionManager {
+    /**
+     * @return {string} The current auth token.
+     * @internal
+     */
+    async token() {
+        const session = await this.storage.retrieve();
+        return session.token;
+    }
+    /**
+     * Refreshes the current session if needed, then returns a client using the current session.
+     *
+     * May **UPDATE/MUTATE** self.
+     *
+     * @param {operations} operation The operation that this client will be
+     *   used for. This parameter is used exclusively for more accurate error
+     *   reporting and does not affect functionality.
+     * @return {Client} The client with the current session
+     */
+    async client(operation) {
+        await this.refreshIfNeeded();
+        // trigger "session expired" if the session as a whole has expired
+        // or if (for whatever reason) the token is still stale
+        if (__classPrivateFieldGet(_a, _a, "m", _SignerSessionManager_hasTimestampExpired).call(_a, __classPrivateFieldGet(this, _SignerSessionManager_client, "f").token_exp) || this.hasExpired()) {
+            await __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f").emitSessionExpired();
+            throw new SessionExpiredError(operation);
+        }
+        return __classPrivateFieldGet(this, _SignerSessionManager_client, "f").client;
+    }
+    /** Revokes the session. */
+    async revoke() {
+        const client = new OpClient("revokeCurrentSession", await this.client(), __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f"));
+        await client.del("/v0/org/{org_id}/session/self", {
+            params: { path: { org_id: this.orgId } },
+        });
+    }
+    /**
+     * Refreshes the session and **UPDATES/MUTATES** self.
+     */
+    async refresh() {
+        if (this.hasExpired()) {
+            await __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f").emitSessionExpired();
+            throw new SessionExpiredError("signerSessionRefresh");
+        }
+        const currSession = await this.storage.retrieve();
+        const client = new OpClient("signerSessionRefresh", __classPrivateFieldGet(this, _SignerSessionManager_client, "f").client, __classPrivateFieldGet(this, _SignerSessionManager_eventEmitter, "f"));
+        const csi = currSession.session_info;
+        const data = await client.patch("/v1/org/{org_id}/token/refresh", {
+            params: { path: { org_id: this.orgId } },
+            body: {
+                epoch_num: csi.epoch,
+                epoch_token: csi.epoch_token,
+                other_token: csi.refresh_token,
+            },
+        });
+        const newSession = {
+            ...currSession,
+            session_info: data.session_info,
+            token: data.token,
+        };
+        await this.storage.save(newSession);
+        __classPrivateFieldSet(this, _SignerSessionManager_client, {
+            client: __classPrivateFieldGet(this, _SignerSessionManager_instances, "m", _SignerSessionManager_createClient).call(this, newSession.token),
+            token_exp: secondsSinceEpochToDate(newSession.session_info.auth_token_exp),
+            session_exp: newSession.session_exp
+                ? secondsSinceEpochToDate(newSession.session_exp)
+                : undefined,
+        }, "f");
+    }
+    /**
+     * Returns whether it's time to refresh this token.
+     * @return {boolean} Whether it's time to refresh this token.
+     * @internal
+     */
+    async isStale() {
+        return __classPrivateFieldGet(_a, _a, "m", _SignerSessionManager_hasTimestampExpired).call(_a, __classPrivateFieldGet(this, _SignerSessionManager_client, "f").token_exp, DEFAULT_EXPIRATION_BUFFER_SECS);
+    }
+    /**
+     * Return whether this session has expired and cannot be refreshed anymore.
+     * @return {boolean} Whether this session has expired.
+     * @internal
+     */
+    hasExpired() {
+        return ((__classPrivateFieldGet(this, _SignerSessionManager_client, "f").session_exp || false) &&
+            __classPrivateFieldGet(_a, _a, "m", _SignerSessionManager_hasTimestampExpired).call(_a, __classPrivateFieldGet(this, _SignerSessionManager_client, "f").session_exp));
+    }
+    /**
+     * Refreshes the session if it is about to expire.
+     * @return {boolean} Whether the session token was refreshed.
+     * @internal
+     */
+    async refreshIfNeeded() {
+        if (await this.isStale()) {
+            if (__classPrivateFieldGet(this, _SignerSessionManager_refreshing, "f")) {
+                // wait until done refreshing
+                while (__classPrivateFieldGet(this, _SignerSessionManager_refreshing, "f")) {
+                    await delay(100);
+                }
+                return false;
+            }
+            else {
+                // refresh
+                __classPrivateFieldSet(this, _SignerSessionManager_refreshing, true, "f");
+                try {
+                    await this.refresh();
+                    return true;
+                }
+                finally {
+                    __classPrivateFieldSet(this, _SignerSessionManager_refreshing, false, "f");
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Automatically refreshes the session in the background (if needed) every
+     * minute. This is a simple wrapper around `setInterval`.
+     * @return {number} The interval ID of the refresh timer.
+     */
+    autoRefresh() {
+        return setInterval(async () => {
+            await this.refreshIfNeeded();
+        }, 60 * 1000);
+    }
+    /**
+     * Clears the auto refresh timer.
+     * @param {number} timer The timer ID to clear.
+     */
+    clearAutoRefresh(timer) {
+        clearInterval(timer);
+    }
+    /**
+     * @param {EnvInterface} env The CubeSigner environment
+     * @param {string} orgId The organization ID
+     * @param {NewSessionResponse} session The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static async createFromSessionInfo(env, orgId, session, storage) {
+        const sessionData = {
+            env: {
+                ["Dev-CubeSignerStack"]: env,
+            },
+            org_id: orgId,
+            token: session.token,
+            purpose: "sign via oidc",
+            session_info: session.session_info,
+            session_exp: session.expiration,
+        };
+        storage ??= new MemorySessionStorage();
+        await storage.save(sessionData);
+        return await _a.loadFromStorage(storage);
+    }
+    /**
+     * @param {SignerSessionData} sessionData The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static async createFromSessionData(sessionData, storage) {
+        storage ??= new MemorySessionStorage();
+        await storage.save(sessionData);
+        return await _a.loadFromStorage(storage);
+    }
+    /**
+     * Uses an existing session to create a new signer session manager.
+     *
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @return {Promise<SingerSession>} New signer session manager
+     */
+    static async loadFromStorage(storage) {
+        const session = await storage.retrieve();
+        return new _a(session, storage);
+    }
+    /**
+     * Constructor.
+     * @param {SignerSessionData} sessionData Session data
+     * @param {SignerSessionStorage} storage The session storage to use.
+     */
+    constructor(sessionData, storage) {
+        _SignerSessionManager_instances.add(this);
+        this.events = new Events();
+        _SignerSessionManager_eventEmitter.set(this, void 0);
+        _SignerSessionManager_refreshing.set(this, false);
+        _SignerSessionManager_client.set(this, void 0);
+        this.env = sessionData.env["Dev-CubeSignerStack"];
+        this.orgId = sessionData.org_id;
+        this.storage = storage;
+        __classPrivateFieldSet(this, _SignerSessionManager_eventEmitter, new EventEmitter([this.events]), "f");
+        __classPrivateFieldSet(this, _SignerSessionManager_client, {
+            client: __classPrivateFieldGet(this, _SignerSessionManager_instances, "m", _SignerSessionManager_createClient).call(this, sessionData.token),
+            token_exp: secondsSinceEpochToDate(sessionData.session_info.auth_token_exp),
+            session_exp: sessionData.session_exp
+                ? secondsSinceEpochToDate(sessionData.session_exp)
+                : undefined,
+        }, "f");
+    }
+}
+_a = SignerSessionManager, _SignerSessionManager_eventEmitter = new WeakMap(), _SignerSessionManager_refreshing = new WeakMap(), _SignerSessionManager_client = new WeakMap(), _SignerSessionManager_instances = new WeakSet(), _SignerSessionManager_createClient = function _SignerSessionManager_createClient(token) {
+    return createHttpClient(this.env.SignerApiRoot, token);
+}, _SignerSessionManager_hasTimestampExpired = function _SignerSessionManager_hasTimestampExpired(exp, bufferSeconds) {
+    bufferSeconds ??= 0;
+    const expMsSinceEpoch = exp.getTime();
+    const nowMsSinceEpoch = new Date().getTime();
+    const bufferMs = bufferSeconds * 1000;
+    return expMsSinceEpoch < nowMsSinceEpoch + bufferMs;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signer_session_manager.js","sourceRoot":"","sources":["../../../../src/session/signer_session_manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Events } from \"../events\";\nimport { EnvInterface } from \"../env\";\nimport { Client, createHttpClient, OpClient } from \"../api\";\nimport { MemorySessionStorage, SessionStorage } from \"./session_storage\";\nimport { delay } from \"../util\";\nimport {\n  ClientSessionInfo,\n  NewSessionResponse,\n  RefreshSignerSessionRequest,\n} from \"../schema_types\";\nimport { EventEmitter } from \"../events\";\nimport { SessionExpiredError } from \"../error\";\nimport { operations } from \"../schema\";\n\nconst DEFAULT_EXPIRATION_BUFFER_SECS = 30;\n\n/** JSON representation of our \"signer session\" file format */\nexport interface SignerSessionData {\n  /** The organization ID */\n  org_id: string;\n  /** The role ID */\n  role_id?: string;\n  /** The purpose of the session token */\n  purpose?: string;\n  /** The token to include in Authorization header */\n  token: string;\n  /** Session info */\n  session_info: ClientSessionInfo;\n  /** Session expiration (in seconds since UNIX epoch) beyond which it cannot be refreshed */\n  session_exp: number | undefined; // may be missing in legacy session files\n  /** The environment */\n  env: {\n    [\"Dev-CubeSignerStack\"]: EnvInterface;\n  };\n}\n\n/**\n * Constructs {@link Date} from a number representing seconds since unix epoch.\n * @param {number} secs Seconds since unix epoch.\n * @return {Date} The equivalent date.\n */\nfunction secondsSinceEpochToDate(secs: number): Date {\n  return new Date(secs * 1000);\n}\n\n/** Type of storage required for signer sessions */\nexport type SignerSessionStorage = SessionStorage<SignerSessionData>;\n\nexport interface SignerSessionLifetime {\n  /** Session lifetime (in seconds). Defaults to one week (604800). */\n  session?: number;\n  /** Auth token lifetime (in seconds). Defaults to five minutes (300). */\n  auth: number;\n  /** Refresh token lifetime (in seconds). Defaults to one day (86400). */\n  refresh?: number;\n  /** Grace lifetime (in seconds). Defaults to 30 seconds (30). */\n  grace?: number;\n}\n\n/** Generic session manager interface. */\nexport class SignerSessionManager {\n  readonly env: EnvInterface;\n  readonly orgId: string;\n  readonly storage: SignerSessionStorage;\n  readonly events = new Events();\n  readonly #eventEmitter: EventEmitter;\n  #refreshing: boolean = false;\n  #client: { client: Client; token_exp: Date; session_exp?: Date };\n\n  /**\n   * @return {string} The current auth token.\n   * @internal\n   */\n  async token(): Promise<string> {\n    const session = await this.storage.retrieve();\n    return session.token;\n  }\n\n  /**\n   * Refreshes the current session if needed, then returns a client using the current session.\n   *\n   * May **UPDATE/MUTATE** self.\n   *\n   * @param {operations} operation The operation that this client will be\n   *   used for. This parameter is used exclusively for more accurate error\n   *   reporting and does not affect functionality.\n   * @return {Client} The client with the current session\n   */\n  async client(operation?: keyof operations): Promise<Client> {\n    await this.refreshIfNeeded();\n\n    // trigger \"session expired\" if the session as a whole has expired\n    // or if (for whatever reason) the token is still stale\n    if (SignerSessionManager.#hasTimestampExpired(this.#client.token_exp) || this.hasExpired()) {\n      await this.#eventEmitter.emitSessionExpired();\n      throw new SessionExpiredError(operation);\n    }\n\n    return this.#client.client;\n  }\n\n  /** Revokes the session. */\n  async revoke(): Promise<void> {\n    const client = new OpClient(\"revokeCurrentSession\", await this.client(), this.#eventEmitter);\n    await client.del(\"/v0/org/{org_id}/session/self\", {\n      params: { path: { org_id: this.orgId } },\n    });\n  }\n\n  /**\n   * Refreshes the session and **UPDATES/MUTATES** self.\n   */\n  async refresh(): Promise<void> {\n    if (this.hasExpired()) {\n      await this.#eventEmitter.emitSessionExpired();\n      throw new SessionExpiredError(\"signerSessionRefresh\");\n    }\n\n    const currSession = await this.storage.retrieve();\n\n    const client = new OpClient(\"signerSessionRefresh\", this.#client.client, this.#eventEmitter);\n    const csi = currSession.session_info;\n    const data = await client.patch(\"/v1/org/{org_id}/token/refresh\", {\n      params: { path: { org_id: this.orgId } },\n      body: <RefreshSignerSessionRequest>{\n        epoch_num: csi.epoch,\n        epoch_token: csi.epoch_token,\n        other_token: csi.refresh_token,\n      },\n    });\n    const newSession = <SignerSessionData>{\n      ...currSession,\n      session_info: data.session_info,\n      token: data.token,\n    };\n\n    await this.storage.save(newSession);\n    this.#client = {\n      client: this.#createClient(newSession.token),\n      token_exp: secondsSinceEpochToDate(newSession.session_info.auth_token_exp),\n      session_exp: newSession.session_exp\n        ? secondsSinceEpochToDate(newSession.session_exp)\n        : undefined,\n    };\n  }\n\n  /**\n   * Returns whether it's time to refresh this token.\n   * @return {boolean} Whether it's time to refresh this token.\n   * @internal\n   */\n  async isStale(): Promise<boolean> {\n    return SignerSessionManager.#hasTimestampExpired(\n      this.#client.token_exp,\n      DEFAULT_EXPIRATION_BUFFER_SECS,\n    );\n  }\n\n  /**\n   * Return whether this session has expired and cannot be refreshed anymore.\n   * @return {boolean} Whether this session has expired.\n   * @internal\n   */\n  hasExpired(): boolean {\n    return (\n      (this.#client.session_exp || false) &&\n      SignerSessionManager.#hasTimestampExpired(this.#client.session_exp)\n    );\n  }\n\n  /**\n   * Refreshes the session if it is about to expire.\n   * @return {boolean} Whether the session token was refreshed.\n   * @internal\n   */\n  async refreshIfNeeded(): Promise<boolean> {\n    if (await this.isStale()) {\n      if (this.#refreshing) {\n        // wait until done refreshing\n        while (this.#refreshing) {\n          await delay(100);\n        }\n        return false;\n      } else {\n        // refresh\n        this.#refreshing = true;\n        try {\n          await this.refresh();\n          return true;\n        } finally {\n          this.#refreshing = false;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Automatically refreshes the session in the background (if needed) every\n   * minute. This is a simple wrapper around `setInterval`.\n   * @return {number} The interval ID of the refresh timer.\n   */\n  autoRefresh(): RefreshId {\n    return setInterval(async () => {\n      await this.refreshIfNeeded();\n    }, 60 * 1000);\n  }\n\n  /**\n   * Clears the auto refresh timer.\n   * @param {number} timer The timer ID to clear.\n   */\n  clearAutoRefresh(timer: RefreshId): void {\n    clearInterval(timer);\n  }\n\n  /**\n   * @param {EnvInterface} env The CubeSigner environment\n   * @param {string} orgId The organization ID\n   * @param {NewSessionResponse} session The session information.\n   * @param {SignerSessionStorage} storage The storage to use for saving the session.\n   * @return {Promise<SignerSessionManager>} New signer session manager.\n   */\n  static async createFromSessionInfo(\n    env: EnvInterface,\n    orgId: string,\n    session: NewSessionResponse,\n    storage?: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    const sessionData = {\n      env: {\n        [\"Dev-CubeSignerStack\"]: env,\n      },\n      org_id: orgId,\n      token: session.token,\n      purpose: \"sign via oidc\",\n      session_info: session.session_info,\n      session_exp: session.expiration!,\n    };\n    storage ??= new MemorySessionStorage();\n    await storage.save(sessionData);\n    return await SignerSessionManager.loadFromStorage(storage);\n  }\n\n  /**\n   * @param {SignerSessionData} sessionData The session information.\n   * @param {SignerSessionStorage} storage The storage to use for saving the session.\n   * @return {Promise<SignerSessionManager>} New signer session manager.\n   */\n  static async createFromSessionData(\n    sessionData: SignerSessionData,\n    storage?: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    storage ??= new MemorySessionStorage();\n    await storage.save(sessionData);\n    return await SignerSessionManager.loadFromStorage(storage);\n  }\n\n  /**\n   * Uses an existing session to create a new signer session manager.\n   *\n   * @param {SignerSessionStorage} storage The session storage to use\n   * @return {Promise<SingerSession>} New signer session manager\n   */\n  static async loadFromStorage(storage: SignerSessionStorage): Promise<SignerSessionManager> {\n    const session = await storage.retrieve();\n    return new SignerSessionManager(session, storage);\n  }\n\n  /**\n   * Constructor.\n   * @param {SignerSessionData} sessionData Session data\n   * @param {SignerSessionStorage} storage The session storage to use.\n   */\n  constructor(sessionData: SignerSessionData, storage: SignerSessionStorage) {\n    this.env = sessionData.env[\"Dev-CubeSignerStack\"];\n    this.orgId = sessionData.org_id;\n    this.storage = storage;\n    this.#eventEmitter = new EventEmitter([this.events]);\n    this.#client = {\n      client: this.#createClient(sessionData.token),\n      token_exp: secondsSinceEpochToDate(sessionData.session_info.auth_token_exp),\n      session_exp: sessionData.session_exp\n        ? secondsSinceEpochToDate(sessionData.session_exp)\n        : undefined,\n    };\n  }\n\n  /**\n   * Creates a new REST client with a given token\n   * @param {string} token The authorization token to use for the client\n   * @return {Client} The new REST client\n   */\n  #createClient(token: string): Client {\n    return createHttpClient(this.env.SignerApiRoot, token);\n  }\n\n  /**\n   * Check if a timestamp is within {@link bufferSeconds} seconds from expiration.\n   * @param {Date} exp The timestamp to check\n   * @param {number} bufferSeconds Time buffer in seconds (defaults to 0s)\n   * @return {boolean} True if the timestamp has expired\n   */\n  static #hasTimestampExpired(exp: Date, bufferSeconds?: number): boolean {\n    bufferSeconds ??= 0;\n    const expMsSinceEpoch = exp.getTime();\n    const nowMsSinceEpoch = new Date().getTime();\n    const bufferMs = bufferSeconds * 1000;\n    return expMsSinceEpoch < nowMsSinceEpoch + bufferMs;\n  }\n}\n\n/** Type of the refresh timer ID. */\nexport type RefreshId = ReturnType<typeof setInterval>;\n"]}

package/dist/esm/src/signer_session.d.ts

@@ -0,0 +1,41 @@
+import { CubeSignerClient } from "./client";
+import { KeyInfo } from "./key";
+import { SignerSessionManager, SignerSessionStorage } from "./session/signer_session_manager";
+/** Signer session info. Can only be used to revoke a token, but not for authentication. */
+export declare class SignerSessionInfo {
+    #private;
+    readonly purpose: string;
+    /** Revoke this session */
+    revoke(): Promise<void>;
+    /**
+     * Internal constructor.
+     * @param {CubeSignerClient} cs CubeSigner instance to use when calling `revoke`
+     * @param {string} sessionId The ID of the session; can be used for revocation but not for auth
+     * @param {string} purpose Session purpose
+     * @internal
+     */
+    constructor(cs: CubeSignerClient, sessionId: string, purpose: string);
+}
+/**
+ * Signer session.
+ * Extends {@link CubeSignerClient} and provides a few convenience methods on top.
+ */
+export declare class SignerSession extends CubeSignerClient {
+    /**
+     * Loads an existing signer session from storage.
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @return {Promise<SingerSession>} New signer session
+     */
+    static loadSignerSession(storage: SignerSessionStorage): Promise<SignerSession>;
+    /**
+     * Constructor.
+     * @param {SignerSessionManager} sessionMgr The session manager to use
+     * @internal
+     */
+    constructor(sessionMgr: SignerSessionManager);
+    /**
+     * Returns the list of keys that this token grants access to.
+     * @return {KeyInfo[]} The list of keys.
+     */
+    keys(): Promise<KeyInfo[]>;
+}