@getpara/server-sdk 0.1.0

package/dist/esm/workers/walletUtils.js

@@ -0,0 +1,234 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getBaseMPCNetworkUrl, WalletScheme, WalletType } from '@getpara/core-sdk';
+const configCGGMPBase = (serverUrl, walletId, id) => `{"ServerUrl":"${serverUrl}", "WalletId": "${walletId}", "Id":"${id}", "Ids":["USER","CAPSULE"], "Threshold":1}`;
+const configDKLSBase = (walletId, id, disableWebSockets) => `{"walletId": "${walletId}", "id":"${id}", "otherId":"CAPSULE", "isReceiver": false, "disableWebSockets": ${disableWebSockets}}`;
+function keygenRequest(ctx, userId, walletId, protocolId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data } = yield ctx.mpcComputationClient.post('/wallets', {
+            userId,
+            walletId,
+            protocolId,
+        });
+        return data;
+    });
+}
+function signMessageRequest(ctx, userId, walletId, protocolId, message, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data } = yield ctx.mpcComputationClient.post(`/wallets/${walletId}/messages/sign`, {
+            userId,
+            protocolId,
+            message,
+            signer,
+        });
+        return data;
+    });
+}
+function sendTransactionRequest(ctx, userId, walletId, protocolId, transaction, signer, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data } = yield ctx.mpcComputationClient.post(`/wallets/${walletId}/transactions/send`, {
+            userId,
+            protocolId,
+            transaction,
+            signer,
+            chainId,
+        });
+        return data;
+    });
+}
+export function ed25519Keygen(ctx, userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { walletId, protocolId } = yield ctx.client.createWallet(userId, {
+            scheme: WalletScheme.ED25519,
+            type: WalletType.SOLANA,
+        });
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const newSigner = (yield new Promise((resolve, reject) => global.ed25519CreateAccount(serverUrl, walletId, protocolId, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        })));
+        return { signer: newSigner, walletId };
+    });
+}
+export function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { walletId, protocolId } = yield ctx.client.createWalletPreGen({
+            pregenIdentifier,
+            pregenIdentifierType,
+            scheme: WalletScheme.ED25519,
+            type: WalletType.SOLANA,
+        });
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const newSigner = (yield new Promise((resolve, reject) => global.ed25519CreateAccount(serverUrl, walletId, protocolId, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        })));
+        return { signer: newSigner, walletId };
+    });
+}
+export function ed25519Sign(ctx, share, userId, walletId, base64Bytes) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { protocolId } = yield ctx.client.preSignMessage(userId, walletId, base64Bytes, WalletScheme.ED25519);
+        const base64Sig = (yield new Promise((resolve, reject) => global.ed25519Sign(share, protocolId, base64Bytes, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        })));
+        return { signature: base64Sig };
+    });
+}
+export function keygen(ctx, userId, type, secretKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { walletId, protocolId } = yield ctx.client.createWallet(userId, {
+            useTwoSigners: true,
+            scheme: ctx.useDKLS ? WalletScheme.DKLS : WalletScheme.CGGMP,
+            type,
+            cosmosPrefix: type === WalletType.COSMOS ? ctx.cosmosPrefix : undefined,
+        });
+        if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
+            return {
+                signer: (yield keygenRequest(ctx, userId, walletId, protocolId)).signer,
+                walletId,
+            };
+        }
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const signerConfigUser = ctx.useDKLS
+            ? configDKLSBase(walletId, 'USER', ctx.disableWebSockets)
+            : configCGGMPBase(serverUrl, walletId, 'USER');
+        const createAccountFn = ctx.useDKLS ? global.dklsCreateAccount : global.createAccountV2;
+        const newSigner = (yield new Promise((resolve, reject) => createAccountFn(signerConfigUser, serverUrl, protocolId, secretKey, () => { }, // no-op for deprecated callback to update progress percentage
+        (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        })));
+        return { signer: newSigner, walletId };
+    });
+}
+export function preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { walletId, protocolId } = yield ctx.client.createWalletPreGen({
+            pregenIdentifier,
+            pregenIdentifierType,
+            type,
+            cosmosPrefix: type === WalletType.COSMOS ? ctx.cosmosPrefix : undefined,
+        });
+        if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
+            return {
+                signer: (yield keygenRequest(ctx, partnerId, walletId, protocolId)).signer,
+                walletId,
+            };
+        }
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const signerConfigUser = ctx.useDKLS
+            ? configDKLSBase(walletId, 'USER', ctx.disableWebSockets)
+            : configCGGMPBase(serverUrl, walletId, 'USER');
+        const createAccountFn = ctx.useDKLS ? global.dklsCreateAccount : global.createAccountV2;
+        const newSigner = (yield new Promise((resolve, reject) => createAccountFn(signerConfigUser, serverUrl, protocolId, secretKey, () => { }, // no-op for deprecated callback to update progress percentage
+        (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        })));
+        return { signer: newSigner, walletId };
+    });
+}
+export function signMessage(ctx, share, walletId, userId, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { protocolId, pendingTransactionId } = yield ctx.client.preSignMessage(userId, walletId, message);
+        if (pendingTransactionId) {
+            return { pendingTransactionId };
+        }
+        if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
+            return signMessageRequest(ctx, userId, walletId, protocolId, message, share);
+        }
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const signMessageFn = ctx.useDKLS ? global.dklsSignMessage : global.signMessage;
+        return new Promise((resolve, reject) => signMessageFn(share, serverUrl, message, protocolId, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve({ signature: result });
+        }));
+    });
+}
+export function signTransaction(ctx, share, walletId, userId, tx, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data: { protocolId, pendingTransactionId }, } = yield ctx.client.signTransaction(userId, walletId, { transaction: tx, chainId });
+        if (pendingTransactionId) {
+            return { pendingTransactionId };
+        }
+        if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
+            return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
+        }
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const signTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
+        return new Promise((resolve, reject) => signTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve({ signature: result });
+        }));
+    });
+}
+export function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data: { protocolId, pendingTransactionId }, } = yield ctx.client.sendTransaction(userId, walletId, { transaction: tx, chainId });
+        if (pendingTransactionId) {
+            return { pendingTransactionId };
+        }
+        if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
+            return sendTransactionRequest(ctx, userId, walletId, protocolId, tx, share, chainId);
+        }
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const sendTransactionFn = ctx.useDKLS ? global.dklsSendTransaction : global.sendTransaction;
+        return new Promise((resolve, reject) => sendTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve({ signature: result });
+        }));
+    });
+}
+export function refresh(ctx, share, walletId, userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data: { protocolId }, } = yield ctx.client.refreshKeys(userId, walletId);
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const refreshFn = ctx.useDKLS ? global.dklsRefresh : global.refresh;
+        return new Promise((resolve, reject) => refreshFn(share, serverUrl, protocolId, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        }));
+    });
+}
+export function getPrivateKey(ctx, share, walletId, userId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const paraShare = yield ctx.client.getParaShare(userId, walletId);
+        if (!paraShare) {
+            console.error('unable to retrieve Para share');
+            return '';
+        }
+        return new Promise((resolve, reject) => global.getPrivateKey(share, paraShare, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        }));
+    });
+}

package/dist/esm/workers/worker.d.ts

@@ -0,0 +1,18 @@
+import { Environment } from '@getpara/core-sdk';
+interface Message {
+    env: Environment;
+    apiKey?: string;
+    cosmosPrefix?: string;
+    offloadMPCComputationURL?: string;
+    disableWorkers?: boolean;
+    functionType: string;
+    params: Record<string, any>;
+    sessionCookie?: string;
+    useDKLS?: boolean;
+    disableWebSockets?: boolean;
+    workId: string;
+}
+export declare function handleMessage(e: {
+    data: Message;
+}): Promise<any>;
+export {};

package/dist/esm/workers/worker.js

@@ -0,0 +1,124 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import axios from 'axios';
+import { getPortalBaseURL, initClient, mpcComputationClient, paraVersion, WalletType, } from '@getpara/core-sdk';
+import * as walletUtils from './walletUtils.js';
+let rawWasm;
+function requestWasmWithRetries(ctx, retries = 3) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (let i = 0; i < retries; i++) {
+            try {
+                return yield axios.get(`${getPortalBaseURL(ctx, true, true)}/static/js/main.wasm`, { responseType: 'arraybuffer' });
+            }
+            catch (e) {
+                if (i === retries - 1) {
+                    throw e;
+                }
+            }
+        }
+    });
+}
+function loadWasm(ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield import('../wasm/wasm_exec.js');
+        global.WebSocket = require('ws');
+        const goWasm = new global.Go();
+        if (!rawWasm) {
+            rawWasm = (yield requestWasmWithRetries(ctx)).data;
+        }
+        const wasmBuffer = new Uint8Array(rawWasm);
+        const webAssemblySource = yield WebAssembly.instantiate(wasmBuffer, goWasm.importObject);
+        goWasm.run(webAssemblySource.instance);
+    });
+}
+function executeMessage(ctx, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functionType, params } = message;
+        switch (functionType) {
+            case 'KEYGEN': {
+                const { userId, secretKey, type = WalletType.EVM } = params;
+                return walletUtils.keygen(ctx, userId, type, secretKey);
+            }
+            case 'SIGN_TRANSACTION': {
+                const { share, walletId, userId, tx, chainId } = params;
+                return walletUtils.signTransaction(ctx, share, walletId, userId, tx, chainId);
+            }
+            case 'SEND_TRANSACTION': {
+                const { share, walletId, userId, tx, chainId } = params;
+                return walletUtils.sendTransaction(ctx, share, walletId, userId, tx, chainId);
+            }
+            case 'SIGN_MESSAGE': {
+                const { share, walletId, userId, message } = params;
+                return walletUtils.signMessage(ctx, share, walletId, userId, message);
+            }
+            case 'REFRESH': {
+                const { share, walletId, userId } = params;
+                return walletUtils.refresh(ctx, share, walletId, userId);
+            }
+            case 'PREKEYGEN': {
+                const { email, partnerId, secretKey, type = WalletType.EVM } = params;
+                let { pregenIdentifier, pregenIdentifierType } = params;
+                if (email !== 'null' && email !== 'undefined' && email !== '' && email != null) {
+                    pregenIdentifier = email;
+                    pregenIdentifierType = 'EMAIL';
+                }
+                const keygenRes = yield walletUtils.preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey);
+                return keygenRes;
+            }
+            case 'GET_PRIVATE_KEY': {
+                const { share, walletId, userId } = params;
+                return yield walletUtils.getPrivateKey(ctx, share, walletId, userId);
+            }
+            case 'ED25519_KEYGEN': {
+                const { userId } = params;
+                return walletUtils.ed25519Keygen(ctx, userId);
+            }
+            case 'ED25519_SIGN': {
+                const { share, walletId, userId, base64Bytes } = params;
+                return walletUtils.ed25519Sign(ctx, share, userId, walletId, base64Bytes);
+            }
+            case 'ED25519_PREKEYGEN': {
+                const { email } = params;
+                let { pregenIdentifier, pregenIdentifierType } = params;
+                if (email !== 'null' && email !== 'undefined' && email !== '' && email != null) {
+                    pregenIdentifier = email;
+                    pregenIdentifierType = 'EMAIL';
+                }
+                return walletUtils.ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType);
+            }
+            default: {
+                throw new Error(`functionType: ${functionType} not supported`);
+            }
+        }
+    });
+}
+export function handleMessage(e) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { env, apiKey, cosmosPrefix = 'cosmos', offloadMPCComputationURL, disableWorkers, sessionCookie, useDKLS, disableWebSockets, workId, } = e.data;
+        const ctx = {
+            env,
+            apiKey,
+            client: initClient({ env, version: paraVersion, apiKey, retrieveSessionCookie: () => sessionCookie }),
+            offloadMPCComputationURL: offloadMPCComputationURL,
+            mpcComputationClient: offloadMPCComputationURL
+                ? mpcComputationClient.initClient(offloadMPCComputationURL, !!disableWorkers)
+                : undefined,
+            useDKLS,
+            disableWebSockets: !!disableWebSockets,
+            cosmosPrefix,
+        };
+        if (!ctx.offloadMPCComputationURL || ctx.useDKLS) {
+            yield loadWasm(ctx);
+        }
+        const result = yield executeMessage(ctx, e.data);
+        result.workId = workId;
+        return result;
+    });
+}

package/dist/esm/workers/workerWrapper.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Worker } from 'worker_threads';
+import { Ctx } from '@getpara/core-sdk';
+export declare function setupWorker(ctx: Ctx, resFunction: (arg: any) => Promise<void>, workId: string): Promise<Worker>;

package/dist/esm/workers/workerWrapper.js

@@ -0,0 +1,51 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Worker } from 'worker_threads';
+import { getPortalBaseURL } from '@getpara/core-sdk';
+const CLEAR_WORKER_TIMEOUT_MS = 1000 * 90;
+let worker;
+const resFunctionMap = {};
+function removeWorkId(workId, skipClearTimeout) {
+    const { timeoutId } = resFunctionMap[workId];
+    delete resFunctionMap[workId];
+    if (skipClearTimeout) {
+        return;
+    }
+    clearTimeout(timeoutId);
+}
+export function setupWorker(ctx, resFunction, workId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const timeoutId = setTimeout(() => {
+            removeWorkId(workId, true);
+        }, CLEAR_WORKER_TIMEOUT_MS);
+        resFunctionMap[workId] = {
+            fn: resFunction,
+            timeoutId,
+        };
+        if (!worker || !worker.threadId) {
+            const workerRes = yield fetch(`${getPortalBaseURL(ctx)}/static/js/mpcWorkerServer-bundle.js`);
+            worker = new Worker(yield workerRes.text(), { eval: true });
+            const onmessage = (message) => __awaiter(this, void 0, void 0, function* () {
+                const { workId: messageWorkId } = message;
+                delete message.workId;
+                yield resFunctionMap[messageWorkId].fn(message);
+                removeWorkId(messageWorkId);
+            });
+            worker.on('message', onmessage);
+            worker.on('error', err => {
+                throw err;
+            });
+            worker.on('exit', code => {
+                console.error(`worker stopped with exit code ${code}`);
+            });
+        }
+        return worker;
+    });
+}

package/dist/types/ParaServer.d.ts

@@ -0,0 +1,4 @@
+import ParaCore, { PlatformUtils } from '@getpara/core-sdk';
+export declare class Para extends ParaCore {
+    protected getPlatformUtils(): PlatformUtils;
+}

package/dist/types/ServerLocalStorage.d.ts

@@ -0,0 +1,12 @@
+import type { StorageUtils } from '@getpara/core-sdk';
+/**
+ * Implements `StorageUtils`
+ * @internal
+ */
+export declare class ServerLocalStorage implements StorageUtils {
+    private localStorage;
+    get: (key: string) => string | null;
+    set: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    clear: (prefix: string) => void;
+}

package/dist/types/ServerSessionStorage.d.ts

@@ -0,0 +1,12 @@
+import type { StorageUtils } from '@getpara/core-sdk';
+/**
+ * Implements `StorageUtils` using a JavaScript object.
+ * @internal
+ */
+export declare class ServerSessionStorage implements StorageUtils {
+    private sessionStorage;
+    get: (key: string) => string | null;
+    set: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    clear: (prefix: string) => void;
+}

package/dist/types/ServerUtils.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import type { Ctx, SignatureRes, PlatformUtils, TPregenIdentifierType, WalletType } from '@getpara/core-sdk';
+import { BackupKitEmailProps } from '@getpara/user-management-client';
+import { ServerLocalStorage } from './ServerLocalStorage.js';
+import { ServerSessionStorage } from './ServerSessionStorage.js';
+export declare class ServerUtils implements PlatformUtils {
+    getPrivateKey(ctx: Ctx, userId: string, walletId: string, share: string, sessionCookie: string): Promise<string>;
+    keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, sessionCookie: string, emailProps?: BackupKitEmailProps): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    refresh(_ctx: Ctx, _sessionCookie: string, _userId: string, _walletId: string, _share: string, _oldPartnerId?: string, _newPartnerId?: string): Promise<{
+        signer: string;
+    }>;
+    preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
+    sessionCookie: string): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    signMessage(ctx: Ctx, userId: string, walletId: string, share: string, message: string, sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    signTransaction(ctx: Ctx, userId: string, walletId: string, share: string, message: string, chainId: string, sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    sendTransaction(ctx: Ctx, userId: string, walletId: string, share: string, tx: string, chainId: string, sessionCookie: string, isDKLS?: boolean): Promise<SignatureRes>;
+    signHash(_address: string, _hash: string): Promise<{
+        v: number;
+        r: Buffer;
+        s: Buffer;
+    }>;
+    ed25519Keygen(ctx: Ctx, userId: string, sessionCookie: string, emailProps?: BackupKitEmailProps): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    ed25519PreKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, sessionCookie: string): Promise<{
+        signer: string;
+        walletId: string;
+    }>;
+    ed25519Sign(ctx: Ctx, userId: string, walletId: string, share: string, base64Bytes: string, sessionCookie: string): Promise<SignatureRes>;
+    localStorage: ServerLocalStorage;
+    sessionStorage: ServerSessionStorage;
+    secureStorage: any;
+    isSyncStorage: boolean;
+    disableProviderModal: boolean;
+    openPopup(_popupUrl: string): Window;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@getpara/core-sdk';
+export type { PlatformUtils, StorageUtils } from '@getpara/core-sdk';
+import { Para as ParaServer } from './ParaServer.js';
+export { ParaServer as Para };
+export default ParaServer;

package/dist/types/wallet/keygen.d.ts

@@ -0,0 +1,22 @@
+import { Ctx, TPregenIdentifierType } from '@getpara/core-sdk';
+import { BackupKitEmailProps, WalletType } from '@getpara/user-management-client';
+export declare function keygen(ctx: Ctx, userId: string, type: WalletType, secretKey: string | null, skipDistribute?: boolean, sessionCookie?: string, _emailProps?: BackupKitEmailProps): Promise<{
+    signer: string;
+    walletId: string;
+    recoveryShare: string | null;
+}>;
+export declare function preKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: WalletType, secretKey: string | null, _skipDistribute: boolean, partnerId: string, sessionCookie?: string): Promise<{
+    signer: string;
+    walletId: string;
+    recoveryShare: string | null;
+}>;
+export declare function ed25519Keygen(ctx: Ctx, userId: string, sessionCookie?: string, _emailProps?: BackupKitEmailProps): Promise<{
+    signer: string;
+    walletId: string;
+    recoveryShare: string | null;
+}>;
+export declare function ed25519PreKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, sessionCookie?: string): Promise<{
+    signer: string;
+    walletId: string;
+    recoveryShare: string | null;
+}>;

package/dist/types/wallet/privateKey.d.ts

@@ -0,0 +1,2 @@
+import { Ctx } from '@getpara/core-sdk';
+export declare function getPrivateKey(ctx: Ctx, userId: string, walletId: string, share: string, sessionCookie?: string): Promise<string>;

package/dist/types/wallet/signing.d.ts

@@ -0,0 +1,5 @@
+import type { Ctx, SignatureRes } from '@getpara/core-sdk';
+export declare function signTransaction(ctx: Ctx, userId: string, walletId: string, share: string, tx: string, chainId: string, sessionCookie?: string, isDKLS?: boolean): Promise<SignatureRes>;
+export declare function sendTransaction(ctx: Ctx, userId: string, walletId: string, share: string, tx: string, chainId: string, sessionCookie?: string, isDKLS?: boolean): Promise<SignatureRes>;
+export declare function signMessage(ctx: Ctx, userId: string, walletId: string, share: string, message: string, sessionCookie?: string, isDKLS?: boolean): Promise<SignatureRes>;
+export declare function ed25519Sign(ctx: Ctx, userId: string, walletId: string, share: string, base64Bytes: string, sessionCookie?: string): Promise<SignatureRes>;

package/dist/types/wasm/wasm_exec.d.ts

@@ -0,0 +1 @@
+export const globalThisCopy: typeof globalThis;

package/dist/types/workers/walletUtils.d.ts

@@ -0,0 +1,25 @@
+import { Ctx, TPregenIdentifierType, SignatureRes, WalletType } from '@getpara/core-sdk';
+export declare function ed25519Keygen(ctx: Ctx, userId: string): Promise<{
+    signer: string;
+    walletId: string;
+}>;
+export declare function ed25519PreKeygen(ctx: Ctx, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType): Promise<{
+    signer: string;
+    walletId: string;
+}>;
+export declare function ed25519Sign(ctx: Ctx, share: string, userId: string, walletId: string, base64Bytes: string): Promise<{
+    signature: string;
+}>;
+export declare function keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null): Promise<{
+    signer: string;
+    walletId: string;
+}>;
+export declare function preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null): Promise<{
+    signer: string;
+    walletId: string;
+}>;
+export declare function signMessage(ctx: Ctx, share: string, walletId: string, userId: string, message: string): Promise<SignatureRes>;
+export declare function signTransaction(ctx: Ctx, share: string, walletId: string, userId: string, tx: string, chainId: string): Promise<SignatureRes>;
+export declare function sendTransaction(ctx: Ctx, share: string, walletId: string, userId: string, tx: string, chainId: string): Promise<SignatureRes>;
+export declare function refresh(ctx: Ctx, share: string, walletId: string, userId: string): Promise<string>;
+export declare function getPrivateKey(ctx: Ctx, share: string, walletId: string, userId: string): Promise<string>;

package/dist/types/workers/worker.d.ts

@@ -0,0 +1,18 @@
+import { Environment } from '@getpara/core-sdk';
+interface Message {
+    env: Environment;
+    apiKey?: string;
+    cosmosPrefix?: string;
+    offloadMPCComputationURL?: string;
+    disableWorkers?: boolean;
+    functionType: string;
+    params: Record<string, any>;
+    sessionCookie?: string;
+    useDKLS?: boolean;
+    disableWebSockets?: boolean;
+    workId: string;
+}
+export declare function handleMessage(e: {
+    data: Message;
+}): Promise<any>;
+export {};

package/dist/types/workers/workerWrapper.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Worker } from 'worker_threads';
+import { Ctx } from '@getpara/core-sdk';
+export declare function setupWorker(ctx: Ctx, resFunction: (arg: any) => Promise<void>, workId: string): Promise<Worker>;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@getpara/server-sdk",
+  "version": "0.1.0",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "typings": "dist/types/index.d.ts",
+  "sideEffects": [
+    "wasm_exec.js"
+  ],
+  "dependencies": {
+    "@getpara/core-sdk": "0.1.0",
+    "@getpara/user-management-client": "0.1.0",
+    "uuid": "^9.0.1",
+    "ws": "^8.14.2"
+  },
+  "scripts": {
+    "build": "yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "rm -rf dist/cjs && tsc --module commonjs --outDir dist/cjs && printf '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "build:esm": "rm -rf dist/esm && tsc --module es2020 --outDir dist/esm && printf '{\"type\":\"module\",\"sideEffects\":[\"wasm_exec.js\"]}' > dist/esm/package.json",
+    "build:types": "rm -rf dist/types && tsc --module es2020 --declarationDir dist/types --emitDeclarationOnly --declaration",
+    "test": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.7",
+    "typescript": "5.1.6"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "gitHead": "625aaa94001a5461dcde8d6775c3b73f3862c76c"
+}