@getpara/server-sdk 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/esm/wallet/privateKey.js

@@ -0,0 +1,45 @@
+import "../chunk-FTA5RKYX.js";
+import * as uuid from "uuid";
+import { setupWorker } from "../workers/workerWrapper.js";
+async function getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
+  return new Promise(async (resolve, reject) => {
+    const workId = uuid.v4();
+    try {
+      const worker = await setupWorker(
+        ctx,
+        async (res) => {
+          resolve(res.privateKey);
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          params: { walletId, userId },
+          functionType: "GET_PRIVATE_KEY",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      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,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+export {
+  getPrivateKey
+};

package/dist/esm/wallet/signing.js

@@ -0,0 +1,161 @@
+import "../chunk-FTA5RKYX.js";
+import * as uuid from "uuid";
+import { setupWorker } from "../workers/workerWrapper.js";
+async function signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return new Promise(async (resolve, reject) => {
+    const workId = uuid.v4();
+    try {
+      const worker = await setupWorker(
+        ctx,
+        async (sendTransactionRes) => {
+          resolve(sendTransactionRes);
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          params: { walletId, userId, tx, chainId },
+          functionType: "SIGN_TRANSACTION",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      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,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+async function sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+  return new Promise(async (resolve, reject) => {
+    const workId = uuid.v4();
+    try {
+      const worker = await setupWorker(
+        ctx,
+        async (sendTransactionRes) => {
+          resolve(sendTransactionRes);
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          params: { walletId, userId, tx, chainId },
+          functionType: "SEND_TRANSACTION",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        params: { share, walletId, userId, tx, chainId },
+        functionType: "SEND_TRANSACTION",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: isDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+async function signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS) {
+  return new Promise(async (resolve, reject) => {
+    const workId = uuid.v4();
+    try {
+      const worker = await setupWorker(
+        ctx,
+        async (signMessageRes) => {
+          resolve(signMessageRes);
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          params: { walletId, userId, message },
+          functionType: "SIGN_MESSAGE",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        params: { share, walletId, userId, message },
+        functionType: "SIGN_MESSAGE",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        useDKLS: isDKLS,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+async function ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
+  return new Promise(async (resolve, reject) => {
+    const workId = uuid.v4();
+    try {
+      const worker = await setupWorker(
+        ctx,
+        async (signMessageRes) => {
+          resolve(signMessageRes);
+        },
+        (error) => {
+          reject(error);
+        },
+        workId,
+        {
+          params: { walletId, userId, base64Bytes },
+          functionType: "ED25519_SIGN",
+          disableWorkers: ctx.disableWorkers,
+          disableWebSockets: ctx.disableWebSockets
+        }
+      );
+      worker.postMessage({
+        env: ctx.env,
+        apiKey: ctx.apiKey,
+        params: { share, walletId, userId, base64Bytes },
+        functionType: "ED25519_SIGN",
+        offloadMPCComputationURL: ctx.offloadMPCComputationURL,
+        disableWorkers: ctx.disableWorkers,
+        sessionCookie,
+        disableWebSockets: ctx.disableWebSockets,
+        wasmOverride: ctx.wasmOverride,
+        workId
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+export {
+  ed25519Sign,
+  sendTransaction,
+  signMessage,
+  signTransaction
+};

package/dist/esm/{workers/wasm_exec-CFNSOXDO.js → wasm/wasm_exec.js}

@@ -1,17 +1,13 @@
 import {
-  __async,
-  __commonJS,
-  __require
-} from "./chunk-ILICZWQV.js";
-
-// src/wasm/wasm_exec.js
+  __commonJS
+} from "../chunk-FTA5RKYX.js";
 var require_wasm_exec = __commonJS({
   "src/wasm/wasm_exec.js"(exports, module) {
-    var globalThisCopy = global;
+    const globalThisCopy = global;
     if (!globalThisCopy.crypto) {
-      globalThisCopy.crypto = __require("crypto");
+      globalThisCopy.crypto = require("crypto");
     }
-    var crypto = globalThisCopy.crypto;
+    const crypto = globalThisCopy.crypto;
     (() => {
       const enosys = () => {
         const err = new Error("not implemented");
@@ -484,73 +480,71 @@ var require_wasm_exec = __commonJS({
             }
           };
         }
-        run(instance) {
-          return __async(this, null, function* () {
-            if (!(instance instanceof WebAssembly.Instance)) {
-              throw new Error("Go.run: WebAssembly.Instance expected");
-            }
-            this._inst = instance;
-            this.mem = new DataView(this._inst.exports.mem.buffer);
-            this._values = [
-              // JS values that Go currently has references to, indexed by reference id
-              NaN,
-              0,
-              null,
-              true,
-              false,
-              globalThis,
-              this
-            ];
-            this._goRefCounts = new Array(this._values.length).fill(Infinity);
-            this._ids = /* @__PURE__ */ new Map([
-              // mapping from JS values to reference ids
-              [0, 1],
-              [null, 2],
-              [true, 3],
-              [false, 4],
-              [globalThis, 5],
-              [this, 6]
-            ]);
-            this._idPool = [];
-            this.exited = false;
-            let offset = 4096;
-            const strPtr = (str) => {
-              const ptr = offset;
-              const bytes = encoder.encode(str + "\0");
-              new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
-              offset += bytes.length;
-              if (offset % 8 !== 0) {
-                offset += 8 - offset % 8;
-              }
-              return ptr;
-            };
-            const argc = this.argv.length;
-            const argvPtrs = [];
-            this.argv.forEach((arg) => {
-              argvPtrs.push(strPtr(arg));
-            });
-            argvPtrs.push(0);
-            const keys = Object.keys(this.env).sort();
-            keys.forEach((key) => {
-              argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
-            });
-            argvPtrs.push(0);
-            const argv = offset;
-            argvPtrs.forEach((ptr) => {
-              this.mem.setUint32(offset, ptr, true);
-              this.mem.setUint32(offset + 4, 0, true);
-              offset += 8;
-            });
-            const wasmMinDataAddr = 4096 + 8192;
-            if (offset >= wasmMinDataAddr) {
-              throw new Error("total length of command line and environment variables exceeds limit");
-            }
-            this._inst.exports.run(argc, argv);
-            if (this.exited) {
-              this._resolveExitPromise();
+        async run(instance) {
+          if (!(instance instanceof WebAssembly.Instance)) {
+            throw new Error("Go.run: WebAssembly.Instance expected");
+          }
+          this._inst = instance;
+          this.mem = new DataView(this._inst.exports.mem.buffer);
+          this._values = [
+            // JS values that Go currently has references to, indexed by reference id
+            NaN,
+            0,
+            null,
+            true,
+            false,
+            globalThis,
+            this
+          ];
+          this._goRefCounts = new Array(this._values.length).fill(Infinity);
+          this._ids = /* @__PURE__ */ new Map([
+            // mapping from JS values to reference ids
+            [0, 1],
+            [null, 2],
+            [true, 3],
+            [false, 4],
+            [globalThis, 5],
+            [this, 6]
+          ]);
+          this._idPool = [];
+          this.exited = false;
+          let offset = 4096;
+          const strPtr = (str) => {
+            const ptr = offset;
+            const bytes = encoder.encode(str + "\0");
+            new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
+            offset += bytes.length;
+            if (offset % 8 !== 0) {
+              offset += 8 - offset % 8;
             }
-            yield this._exitPromise;
+            return ptr;
+          };
+          const argc = this.argv.length;
+          const argvPtrs = [];
+          this.argv.forEach((arg) => {
+            argvPtrs.push(strPtr(arg));
+          });
+          argvPtrs.push(0);
+          const keys = Object.keys(this.env).sort();
+          keys.forEach((key) => {
+            argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
           });
+          argvPtrs.push(0);
+          const argv = offset;
+          argvPtrs.forEach((ptr) => {
+            this.mem.setUint32(offset, ptr, true);
+            this.mem.setUint32(offset + 4, 0, true);
+            offset += 8;
+          });
+          const wasmMinDataAddr = 4096 + 8192;
+          if (offset >= wasmMinDataAddr) {
+            throw new Error("total length of command line and environment variables exceeds limit");
+          }
+          this._inst.exports.run(argc, argv);
+          if (this.exited) {
+            this._resolveExitPromise();
+          }
+          await this._exitPromise;
         }
         _resume() {
           if (this.exited) {

package/dist/esm/workers/walletUtils.js

@@ -0,0 +1,314 @@
+import "../chunk-FTA5RKYX.js";
+import { getBaseMPCNetworkUrl } from "@getpara/core-sdk";
+import * as uuid from "uuid";
+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}}`;
+async function keygenRequest(ctx, userId, walletId, protocolId) {
+  const { data } = await ctx.mpcComputationClient.post("/wallets", {
+    userId,
+    walletId,
+    protocolId
+  });
+  return data;
+}
+async function signMessageRequest(ctx, userId, walletId, protocolId, message, signer) {
+  const { data } = await ctx.mpcComputationClient.post(`/wallets/${walletId}/messages/sign`, {
+    userId,
+    protocolId,
+    message,
+    signer
+  });
+  return data;
+}
+async function sendTransactionRequest(ctx, userId, walletId, protocolId, transaction, signer, chainId) {
+  const { data } = await ctx.mpcComputationClient.post(`/wallets/${walletId}/transactions/send`, {
+    userId,
+    protocolId,
+    transaction,
+    signer,
+    chainId
+  });
+  return data;
+}
+async function ed25519Keygen(ctx, userId) {
+  const { walletId, protocolId } = await ctx.client.createWallet(userId, {
+    scheme: "ED25519",
+    type: "SOLANA"
+  });
+  const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+  try {
+    const newSigner = await new Promise(
+      (resolve, reject) => global.ed25519CreateAccount(serverUrl, walletId, protocolId, (err, result) => {
+        if (err) {
+          reject(err);
+        }
+        resolve(result);
+      })
+    );
+    return { signer: newSigner, walletId };
+  } catch (e) {
+    throw new Error(`error creating account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+  }
+}
+async function ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType) {
+  const { walletId, protocolId } = await ctx.client.createPregenWallet({
+    pregenIdentifier,
+    pregenIdentifierType,
+    scheme: "ED25519",
+    type: "SOLANA"
+  });
+  const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+  try {
+    const newSigner = await new Promise(
+      (resolve, reject) => global.ed25519CreateAccount(serverUrl, walletId, protocolId, (err, result) => {
+        if (err) {
+          reject(err);
+        }
+        resolve(result);
+      })
+    );
+    return { signer: newSigner, walletId };
+  } catch (e) {
+    throw new Error(`error creating account of type SOLANA with walletId ${walletId}`);
+  }
+}
+async function ed25519Sign(ctx, share, userId, walletId, base64Bytes) {
+  const protocolId = uuid.v4();
+  const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, base64Bytes, "ED25519", void 0, protocolId);
+  const signRes = async function() {
+    try {
+      const base64Sig = await new Promise(
+        (resolve, reject) => global.ed25519Sign(share, protocolId, base64Bytes, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve(result);
+        })
+      );
+      return { signature: base64Sig };
+    } catch (e) {
+      throw new Error(`error signing for account of type SOLANA with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  const { pendingTransactionId } = await preSignMessageRes;
+  if (pendingTransactionId) {
+    return { pendingTransactionId };
+  }
+  return await signRes;
+}
+async function keygen(ctx, userId, type, secretKey) {
+  const { walletId, protocolId } = await ctx.client.createWallet(userId, {
+    useTwoSigners: true,
+    scheme: ctx.useDKLS ? "DKLS" : "CGGMP",
+    type,
+    cosmosPrefix: type === "COSMOS" ? ctx.cosmosPrefix : void 0
+  });
+  if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
+    return {
+      signer: (await 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;
+  try {
+    const newSigner = await 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 };
+  } catch (e) {
+    throw new Error(`error creating account of type ${type} with userId ${userId} and walletId ${walletId}`);
+  }
+}
+async function preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey) {
+  const { walletId, protocolId } = await ctx.client.createPregenWallet({
+    pregenIdentifier,
+    pregenIdentifierType,
+    type,
+    cosmosPrefix: type === "COSMOS" ? ctx.cosmosPrefix : void 0
+  });
+  if (ctx.offloadMPCComputationURL && !ctx.useDKLS) {
+    return {
+      signer: (await 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;
+  try {
+    const newSigner = await 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 };
+  } catch (e) {
+    throw new Error(`error creating account of type ${type} with walletId ${walletId}`);
+  }
+}
+async function signMessage(ctx, share, walletId, userId, message) {
+  const protocolId = uuid.v4();
+  const preSignMessageRes = ctx.client.preSignMessage(userId, walletId, message, null, null, protocolId);
+  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 signMessageRes = async function() {
+    try {
+      return await new Promise(
+        (resolve, reject) => signMessageFn(share, serverUrl, message, protocolId, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve({ signature: result });
+        })
+      );
+    } catch (e) {
+      throw new Error(`error signing for account with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  const { pendingTransactionId } = await preSignMessageRes;
+  if (pendingTransactionId) {
+    return { pendingTransactionId };
+  }
+  return await signMessageRes;
+}
+async function signTransaction(ctx, share, walletId, userId, tx, chainId) {
+  const protocolId = uuid.v4();
+  const signTransactionRes = ctx.client.signTransaction(userId, walletId, { transaction: tx, chainId, protocolId });
+  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 signTxRes = async function() {
+    try {
+      return await new Promise(
+        (resolve, reject) => signTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve({ signature: result });
+        })
+      );
+    } catch (e) {
+      throw new Error(`error signing transaction for account with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  const {
+    data: { pendingTransactionId }
+  } = await signTransactionRes;
+  if (pendingTransactionId) {
+    return { pendingTransactionId };
+  }
+  return await signTxRes;
+}
+async function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
+  const protocolId = uuid.v4();
+  const sendTransactionRes = ctx.client.sendTransaction(userId, walletId, { transaction: tx, chainId, protocolId });
+  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 sendTxRes = async function() {
+    try {
+      return await new Promise(
+        (resolve, reject) => sendTransactionFn(share, serverUrl, tx, chainId, protocolId, (err, result) => {
+          if (err) {
+            reject(err);
+          }
+          resolve({ signature: result });
+        })
+      );
+    } catch (e) {
+      throw new Error(`error signing transaction to send for account with userId ${userId} and walletId ${walletId}`);
+    }
+  }();
+  const {
+    data: { pendingTransactionId }
+  } = await sendTransactionRes;
+  if (pendingTransactionId) {
+    return { pendingTransactionId };
+  }
+  return await sendTxRes;
+}
+async function refresh(ctx, share, walletId, userId) {
+  const {
+    data: { protocolId }
+  } = await ctx.client.refreshKeys(userId, walletId);
+  const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+  const refreshFn = ctx.useDKLS ? global.dklsRefresh : global.refresh;
+  try {
+    return await new Promise(
+      (resolve, reject) => refreshFn(share, serverUrl, protocolId, (err, result) => {
+        if (err) {
+          reject(err);
+        }
+        resolve(result);
+      })
+    );
+  } catch (e) {
+    throw new Error(`error refreshing keys for account with userId ${userId} and walletId ${walletId}`);
+  }
+}
+async function getPrivateKey(ctx, share, walletId, userId) {
+  const paraShare = await ctx.client.getParaShare(userId, walletId);
+  if (!paraShare) {
+    console.error("unable to retrieve Para share");
+    return "";
+  }
+  try {
+    return await new Promise(
+      (resolve, reject) => global.getPrivateKey(share, paraShare, (err, result) => {
+        if (err) {
+          reject(err);
+        }
+        resolve(result);
+      })
+    );
+  } catch (e) {
+    throw new Error(`error getting private key for account with userId ${userId} and walletId ${walletId}`);
+  }
+}
+export {
+  ed25519Keygen,
+  ed25519PreKeygen,
+  ed25519Sign,
+  getPrivateKey,
+  keygen,
+  preKeygen,
+  refresh,
+  sendTransaction,
+  signMessage,
+  signTransaction
+};