@getpara/web-sdk 0.1.0

package/dist/workers/walletUtils.js

@@ -0,0 +1,244 @@
+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,
+        });
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const signerConfigUser = configDKLSBase(walletId, 'USER', ctx.disableWebSockets);
+        const newSigner = (yield new Promise((resolve, reject) => global.dklsCreateAccount(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, cosmosSignDoc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { protocolId, pendingTransactionId } = yield ctx.client.preSignMessage(userId, walletId, message, null, cosmosSignDoc);
+        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;
+        const parsedShare = JSON.parse(share);
+        if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+            parsedShare.disableWebSockets = ctx.disableWebSockets;
+        }
+        share = JSON.stringify(parsedShare);
+        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;
+        const parsedShare = JSON.parse(share);
+        if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+            parsedShare.disableWebSockets = ctx.disableWebSockets;
+        }
+        share = JSON.stringify(parsedShare);
+        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;
+        const parsedShare = JSON.parse(share);
+        if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+            parsedShare.disableWebSockets = ctx.disableWebSockets;
+        }
+        share = JSON.stringify(parsedShare);
+        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, oldPartnerId, newPartnerId, keyShareProtocolId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data: { protocolId }, } = yield ctx.client.refreshKeys(userId, walletId, oldPartnerId, newPartnerId, keyShareProtocolId);
+        const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+        const refreshFn = ctx.useDKLS ? global.dklsRefresh : global.refresh;
+        const parsedShare = JSON.parse(share);
+        if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+            parsedShare.disableWebSockets = ctx.disableWebSockets;
+        }
+        share = JSON.stringify(parsedShare);
+        return new Promise((resolve, reject) => refreshFn(share, serverUrl, protocolId, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve({ protocolId, signer: 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) {
+            return '';
+        }
+        return new Promise((resolve, reject) => global.getPrivateKey(share, paraShare, (err, result) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(result);
+        }));
+    });
+}

package/dist/workers/worker.d.ts

@@ -0,0 +1,19 @@
+import '../wasm/wasm_exec.js';
+import { Environment } from '@getpara/core-sdk';
+export interface Message {
+    env: Environment;
+    apiKey?: string;
+    cosmosPrefix?: string;
+    offloadMPCComputationURL?: string;
+    disableWorkers?: boolean;
+    functionType: string;
+    params: Record<string, any>;
+    sessionCookie?: string;
+    useDKLS?: boolean;
+    disableWebSockets?: boolean;
+    wasmOverride?: ArrayBuffer;
+    returnObject?: boolean;
+}
+export declare function handleMessage(e: {
+    data: Message;
+}, postMessage: (message: any) => void, useFetchAdapter?: boolean): Promise<boolean>;

package/dist/workers/worker.js

@@ -0,0 +1,128 @@
+// ANY CHANGES TO THIS FILE REQUIRE A REBUILD OF THE WORKER
+// FILE IN THE PORTAL!
+// run `yarn build` to rebuild the worker file
+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 '../wasm/wasm_exec.js';
+import * as walletUtils from './walletUtils.js';
+import { getPortalBaseURL, initClient, mpcComputationClient, paraVersion, WalletType, } from '@getpara/core-sdk';
+function loadWasm(ctx, wasmOverride) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // @ts-ignore
+        const goWasm = new self.Go();
+        let wasmArrayBuffer = wasmOverride;
+        if (!wasmArrayBuffer) {
+            if (process.env.DISABLE_WASM_FETCH === 'true') {
+                throw new Error('fetching wasm file is disabled');
+            }
+            const fetchedWasm = yield fetch(`${getPortalBaseURL(ctx)}/static/js/main.wasm`, { mode: 'cors' });
+            wasmArrayBuffer = yield fetchedWasm.arrayBuffer();
+        }
+        const newRes = yield WebAssembly.instantiate(wasmArrayBuffer, goWasm.importObject);
+        goWasm.run(newRes.instance);
+    });
+}
+function executeMessage(ctx, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functionType, params, returnObject } = message;
+        switch (functionType) {
+            case 'KEYGEN': {
+                const { userId, secretKey, type = WalletType.EVM } = params;
+                const keygenRes = yield walletUtils.keygen(ctx, userId, type, secretKey);
+                return keygenRes;
+            }
+            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, cosmosSignDoc } = params;
+                return walletUtils.signMessage(ctx, share, walletId, userId, message, cosmosSignDoc);
+            }
+            case 'REFRESH': {
+                const { share, walletId, userId, oldPartnerId, newPartnerId, keyShareProtocolId } = params;
+                const { protocolId, signer } = yield walletUtils.refresh(ctx, share, walletId, userId, oldPartnerId, newPartnerId, keyShareProtocolId);
+                return returnObject ? { protocolId, signer } : signer;
+            }
+            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, postMessage, useFetchAdapter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { env, apiKey, cosmosPrefix = 'cosmos', offloadMPCComputationURL, disableWorkers, sessionCookie, useDKLS, disableWebSockets, wasmOverride, } = e.data;
+        if (!env) {
+            // this means a message we didn't send was received and we want to ignore it
+            return true;
+        }
+        const ctx = {
+            env,
+            apiKey,
+            cosmosPrefix,
+            client: initClient({
+                env,
+                version: paraVersion,
+                apiKey,
+                useFetchAdapter,
+                retrieveSessionCookie: () => sessionCookie,
+            }),
+            offloadMPCComputationURL: offloadMPCComputationURL,
+            mpcComputationClient: offloadMPCComputationURL
+                ? mpcComputationClient.initClient(offloadMPCComputationURL, !!disableWorkers)
+                : undefined,
+            useDKLS,
+            disableWebSockets: !!disableWebSockets,
+            wasmOverride,
+        };
+        if (!ctx.offloadMPCComputationURL || ctx.useDKLS) {
+            yield loadWasm(ctx, wasmOverride);
+        }
+        const result = yield executeMessage(ctx, e.data);
+        postMessage(result);
+        return false;
+    });
+}

package/dist/workers/workerWrapper.d.ts

@@ -0,0 +1,6 @@
+import { Ctx } from '@getpara/core-sdk';
+export interface SyncWorker {
+    postMessage: (message: any) => void;
+    terminate: () => void;
+}
+export declare function setupWorker(ctx: Ctx, resFunction: (arg: any) => void): Promise<Worker | SyncWorker>;

package/dist/workers/workerWrapper.js

@@ -0,0 +1,50 @@
+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 { getPortalBaseURL } from '@getpara/core-sdk';
+import { handleMessage } from './worker.js';
+export function setupWorker(ctx, resFunction) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const onmessage = event => {
+            if (event.data.functionType === 'CUSTOM') {
+                // safe to remove this block once this code is live in prod!
+                return;
+            }
+            resFunction(event.data);
+        };
+        if (ctx.disableWorkers) {
+            const syncWorker = {
+                postMessage: function (message) {
+                    (function () {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            yield handleMessage({ data: message }, data => onmessage({ data }), ctx.disableWorkers);
+                        });
+                    })();
+                },
+                terminate: () => {
+                    return;
+                },
+            };
+            return syncWorker;
+        }
+        let worker;
+        if (ctx.useLocalFiles) {
+            // worker = new Worker(new URL('./worker.js', import.meta.url));
+            throw new Error('useLocalFiles only supported locally');
+        }
+        else {
+            const workerRes = yield fetch(`${getPortalBaseURL(ctx)}/static/js/mpcWorker-bundle.js`);
+            const workerBlob = new Blob([yield workerRes.text()], { type: 'application/javascript' });
+            const workerScriptURL = URL.createObjectURL(workerBlob);
+            worker = new Worker(workerScriptURL);
+        }
+        worker.onmessage = onmessage;
+        return worker;
+    });
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@getpara/web-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": [
+    "wasm_exec.js"
+  ],
+  "dependencies": {
+    "@getpara/core-sdk": "0.1.0",
+    "@getpara/user-management-client": "0.1.0",
+    "assert": "^2.1.0",
+    "base64url": "3.0.1",
+    "buffer": "6.0.3",
+    "cbor-web": "8.1.0",
+    "node-forge": "1.3.1",
+    "ua-parser-js": "1.0.39"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc && yarn post-build",
+    "post-build": "./scripts/post-build.sh",
+    "test": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/node-forge": "1.3.1",
+    "@types/ua-parser-js": "0.7.39",
+    "crypto-browserify": "3.12.0",
+    "stream-browserify": "3.0.0",
+    "typescript": "5.1.6",
+    "webpack": "5.76.3",
+    "webpack-cli": "5.0.1"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "gitHead": "625aaa94001a5461dcde8d6775c3b73f3862c76c"
+}