@getpara/web-sdk 0.1.0

package/dist/utils/truncateEthAddress.js

@@ -0,0 +1,8 @@
+// Captures 0x + 4 characters, then the last 4 characters.
+const truncateRegex = /^(0x[a-zA-Z0-9]{4})[a-zA-Z0-9]+([a-zA-Z0-9]{4})$/;
+export const truncateEthAddress = (address) => {
+    const match = address.match(truncateRegex);
+    if (!match)
+        return address;
+    return `${match[1]}…${match[2]}`;
+};

package/dist/wallet/keygen.d.ts

@@ -0,0 +1,26 @@
+import { Ctx, TPregenIdentifierType } from '@getpara/core-sdk';
+import { BackupKitEmailProps, WalletType } from '@getpara/user-management-client';
+export declare function keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, 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: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, _skipDistribute: boolean, partnerId: string, sessionCookie?: string): Promise<{
+    signer: string;
+    walletId: string;
+    recoveryShare: string | null;
+}>;
+export declare function refresh(ctx: Ctx, sessionCookie: string, userId: string, walletId: string, share: string, oldPartnerId?: string, newPartnerId?: string, keyShareProtocolId?: string): Promise<{
+    signer: string;
+    protocolId: string;
+}>;
+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/wallet/keygen.js

@@ -0,0 +1,185 @@
+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 { setupWorker } from '../workers/workerWrapper.js';
+import { distributeNewShare, waitUntilTrue } from '@getpara/core-sdk';
+function isKeygenComplete(ctx, userId, walletId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const wallets = yield ctx.client.getWallets(userId);
+        const wallet = wallets.data.wallets.find(w => w.id === walletId);
+        return !!wallet.address;
+    });
+}
+function isRefreshComplete(ctx, userId, walletId, partnerId, protocolId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { isDone } = yield ctx.client.isRefreshDone(userId, walletId, partnerId, protocolId);
+        return isDone;
+    });
+}
+function isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, walletId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const wallets = yield ctx.client.getPregenWallets({ [pregenIdentifierType]: [pregenIdentifier] });
+        const wallet = wallets.wallets.find(w => w.id === walletId);
+        return !!wallet.address;
+    });
+}
+export function keygen(ctx, userId, type, secretKey, skipDistribute = false, sessionCookie, emailProps = {}) {
+    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        const worker = yield setupWorker(ctx, (res) => __awaiter(this, void 0, void 0, function* () {
+            yield waitUntilTrue(() => __awaiter(this, void 0, void 0, function* () { return isKeygenComplete(ctx, userId, res.walletId); }), 15000, 1000);
+            if (skipDistribute) {
+                resolve({
+                    signer: res.signer,
+                    walletId: res.walletId,
+                    recoveryShare: null,
+                });
+                worker.terminate();
+                return;
+            }
+            const recoveryShare = yield distributeNewShare({
+                ctx,
+                userId,
+                walletId: res.walletId,
+                userShare: res.signer,
+                emailProps,
+            });
+            resolve({
+                signer: res.signer,
+                walletId: res.walletId,
+                recoveryShare,
+            });
+            worker.terminate();
+        }));
+        worker.postMessage({
+            env: ctx.env,
+            apiKey: ctx.apiKey,
+            cosmosPrefix: ctx.cosmosPrefix,
+            params: { userId, secretKey, type },
+            functionType: 'KEYGEN',
+            offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+            disableWorkers: ctx.disableWorkers,
+            sessionCookie,
+            useDKLS: ctx.useDKLS,
+            disableWebSockets: ctx.disableWebSockets,
+            wasmOverride: ctx.wasmOverride,
+        });
+    }));
+}
+export function preKeygen(ctx, pregenIdentifier, pregenIdentifierType, type, secretKey, _skipDistribute = false, partnerId, sessionCookie) {
+    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        const worker = yield setupWorker(ctx, (res) => __awaiter(this, void 0, void 0, function* () {
+            yield waitUntilTrue(() => __awaiter(this, void 0, void 0, function* () { return isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId); }), 15000, 1000);
+            resolve({
+                signer: res.signer,
+                walletId: res.walletId,
+                recoveryShare: null,
+            });
+            worker.terminate();
+        }));
+        const email = undefined;
+        const params = { pregenIdentifier, pregenIdentifierType, type, secretKey, partnerId, email };
+        if (pregenIdentifierType === 'EMAIL') {
+            params.email = pregenIdentifier;
+        }
+        worker.postMessage({
+            env: ctx.env,
+            apiKey: ctx.apiKey,
+            cosmosPrefix: ctx.cosmosPrefix,
+            params: params,
+            functionType: 'PREKEYGEN',
+            offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+            disableWorkers: ctx.disableWorkers,
+            sessionCookie,
+            useDKLS: ctx.useDKLS,
+            disableWebSockets: ctx.disableWebSockets,
+            wasmOverride: ctx.wasmOverride,
+        });
+    }));
+}
+export function refresh(ctx, sessionCookie, userId, walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId) {
+    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        const worker = yield setupWorker(ctx, (res) => __awaiter(this, void 0, void 0, function* () {
+            /* v8 ignore next 3 */
+            if (!(yield waitUntilTrue(() => __awaiter(this, void 0, void 0, function* () { return isRefreshComplete(ctx, userId, walletId, newPartnerId); }), 15000, 1000))) {
+                throw new Error('refresh failed');
+            }
+            const { protocolId, signer } = res;
+            resolve({
+                signer,
+                protocolId,
+            });
+            worker.terminate();
+        }));
+        worker.postMessage({
+            env: ctx.env,
+            apiKey: ctx.apiKey,
+            params: { userId, walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId },
+            functionType: 'REFRESH',
+            disableWorkers: ctx.disableWorkers,
+            sessionCookie,
+            useDKLS: ctx.useDKLS,
+            disableWebSockets: ctx.disableWebSockets,
+            wasmOverride: ctx.wasmOverride,
+            returnObject: true,
+        });
+    }));
+}
+export function ed25519Keygen(ctx, userId, sessionCookie, _emailProps = {}) {
+    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        const worker = yield setupWorker(ctx, (res) => __awaiter(this, void 0, void 0, function* () {
+            yield waitUntilTrue(() => __awaiter(this, void 0, void 0, function* () { return isKeygenComplete(ctx, userId, res.walletId); }), 15000, 1000);
+            resolve({
+                signer: res.signer,
+                walletId: res.walletId,
+                recoveryShare: null,
+            });
+            worker.terminate();
+        }));
+        worker.postMessage({
+            env: ctx.env,
+            apiKey: ctx.apiKey,
+            cosmosPrefix: ctx.cosmosPrefix,
+            params: { userId },
+            functionType: 'ED25519_KEYGEN',
+            disableWorkers: ctx.disableWorkers,
+            sessionCookie,
+            disableWebSockets: ctx.disableWebSockets,
+            wasmOverride: ctx.wasmOverride,
+        });
+    }));
+}
+export function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie) {
+    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        const worker = yield setupWorker(ctx, (res) => __awaiter(this, void 0, void 0, function* () {
+            yield waitUntilTrue(() => __awaiter(this, void 0, void 0, function* () { return isPreKeygenComplete(ctx, pregenIdentifier, pregenIdentifierType, res.walletId); }), 15000, 1000);
+            resolve({
+                signer: res.signer,
+                walletId: res.walletId,
+                recoveryShare: null,
+            });
+            worker.terminate();
+        }));
+        const email = undefined;
+        const params = { pregenIdentifier, pregenIdentifierType, email };
+        if (pregenIdentifierType === 'EMAIL') {
+            params.email = pregenIdentifier;
+        }
+        worker.postMessage({
+            env: ctx.env,
+            apiKey: ctx.apiKey,
+            cosmosPrefix: ctx.cosmosPrefix,
+            params: params,
+            functionType: 'ED25519_PREKEYGEN',
+            disableWorkers: ctx.disableWorkers,
+            sessionCookie,
+            disableWebSockets: ctx.disableWebSockets,
+            wasmOverride: ctx.wasmOverride,
+        });
+    }));
+}

package/dist/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/wallet/privateKey.js

@@ -0,0 +1,33 @@
+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 { setupWorker } from '../workers/workerWrapper.js';
+export function getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            const worker = yield setupWorker(ctx, (res) => __awaiter(this, void 0, void 0, function* () {
+                resolve(res);
+                worker.terminate();
+            }));
+            worker.postMessage({
+                env: ctx.env,
+                apiKey: ctx.apiKey,
+                cosmosPrefix: ctx.cosmosPrefix,
+                params: { share, walletId, userId },
+                functionType: 'GET_PRIVATE_KEY',
+                offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+                disableWorkers: ctx.disableWorkers,
+                sessionCookie,
+                useDKLS: ctx.useDKLS,
+                disableWebSockets: ctx.disableWebSockets,
+                wasmOverride: ctx.wasmOverride,
+            });
+        }));
+    });
+}

package/dist/wallet/signing.d.ts

@@ -0,0 +1,5 @@
+import { 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, cosmosSignDoc?: string): Promise<SignatureRes>;
+export declare function ed25519Sign(ctx: Ctx, userId: string, walletId: string, share: string, base64Bytes: string, sessionCookie: string): Promise<SignatureRes>;

package/dist/wallet/signing.js

@@ -0,0 +1,100 @@
+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 { setupWorker } from '../workers/workerWrapper.js';
+export function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            const worker = yield setupWorker(ctx, (sendTransactionRes) => __awaiter(this, void 0, void 0, function* () {
+                resolve(sendTransactionRes);
+                worker.terminate();
+            }));
+            worker.postMessage({
+                env: ctx.env,
+                apiKey: ctx.apiKey,
+                cosmosPrefix: ctx.cosmosPrefix,
+                params: { share, walletId, userId, tx, chainId },
+                functionType: 'SIGN_TRANSACTION',
+                offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+                disableWorkers: ctx.disableWorkers,
+                sessionCookie,
+                useDKLS: isDKLS,
+                disableWebSockets: ctx.disableWebSockets,
+                wasmOverride: ctx.wasmOverride,
+            });
+        }));
+    });
+}
+export function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            const worker = yield setupWorker(ctx, (sendTransactionRes) => __awaiter(this, void 0, void 0, function* () {
+                resolve(sendTransactionRes);
+                worker.terminate();
+            }));
+            worker.postMessage({
+                env: ctx.env,
+                apiKey: ctx.apiKey,
+                cosmosPrefix: ctx.cosmosPrefix,
+                params: { share, walletId, userId, tx, chainId },
+                functionType: 'SEND_TRANSACTION',
+                offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+                disableWorkers: ctx.disableWorkers,
+                sessionCookie,
+                useDKLS: isDKLS,
+                disableWebSockets: ctx.disableWebSockets,
+                wasmOverride: ctx.wasmOverride,
+            });
+        }));
+    });
+}
+export function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS, cosmosSignDoc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            const worker = yield setupWorker(ctx, (signMessageRes) => __awaiter(this, void 0, void 0, function* () {
+                resolve(signMessageRes);
+                worker.terminate();
+            }));
+            worker.postMessage({
+                env: ctx.env,
+                apiKey: ctx.apiKey,
+                cosmosPrefix: ctx.cosmosPrefix,
+                params: { share, walletId, userId, message, cosmosSignDoc },
+                functionType: 'SIGN_MESSAGE',
+                offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+                disableWorkers: ctx.disableWorkers,
+                sessionCookie,
+                useDKLS: isDKLS,
+                disableWebSockets: ctx.disableWebSockets,
+                wasmOverride: ctx.wasmOverride,
+            });
+        }));
+    });
+}
+export function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            const worker = yield setupWorker(ctx, (signMessageRes) => __awaiter(this, void 0, void 0, function* () {
+                resolve(signMessageRes);
+                worker.terminate();
+            }));
+            worker.postMessage({
+                env: ctx.env,
+                apiKey: ctx.apiKey,
+                cosmosPrefix: ctx.cosmosPrefix,
+                params: { share, walletId, userId, base64Bytes },
+                functionType: 'ED25519_SIGN',
+                disableWorkers: ctx.disableWorkers,
+                sessionCookie,
+                disableWebSockets: ctx.disableWebSockets,
+                wasmOverride: ctx.wasmOverride,
+            });
+        }));
+    });
+}