@getpara/web-sdk 1.4.2 → 1.4.4

package/dist/workers/worker.js

@@ -1,3 +1,994 @@
 "use client";
-(()=>{let t=()=>{let o=new Error("not implemented");return o.code="ENOSYS",o};if(!globalThis.fs){let o="";globalThis.fs={constants:{O_WRONLY:-1,O_RDWR:-1,O_CREAT:-1,O_TRUNC:-1,O_APPEND:-1,O_EXCL:-1},writeSync(r,s){o+=l.decode(s);let n=o.lastIndexOf(`
-`);return n!=-1&&(console.log(o.substring(0,n)),o=o.substring(n+1)),s.length},write(r,s,n,a,g,u){if(n!==0||a!==s.length||g!==null){u(t());return}let d=this.writeSync(r,s);u(null,d)},chmod(r,s,n){n(t())},chown(r,s,n,a){a(t())},close(r,s){s(t())},fchmod(r,s,n){n(t())},fchown(r,s,n,a){a(t())},fstat(r,s){s(t())},fsync(r,s){s(null)},ftruncate(r,s,n){n(t())},lchown(r,s,n,a){a(t())},link(r,s,n){n(t())},lstat(r,s){s(t())},mkdir(r,s,n){n(t())},open(r,s,n,a){a(t())},read(r,s,n,a,g,u){u(t())},readdir(r,s){s(t())},readlink(r,s){s(t())},rename(r,s,n){n(t())},rmdir(r,s){s(t())},stat(r,s){s(t())},symlink(r,s,n){n(t())},truncate(r,s,n){n(t())},unlink(r,s){s(t())},utimes(r,s,n,a){a(t())}}}if(globalThis.process||(globalThis.process={getuid(){return-1},getgid(){return-1},geteuid(){return-1},getegid(){return-1},getgroups(){throw t()},pid:-1,ppid:-1,umask(){throw t()},cwd(){throw t()},chdir(){throw t()}}),!globalThis.crypto)throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");if(globalThis.performance||(globalThis.performance=Date),!globalThis.TextEncoder)throw new Error("globalThis.TextEncoder is not available, polyfill required");if(!globalThis.TextDecoder)throw new Error("globalThis.TextDecoder is not available, polyfill required");let c=new TextEncoder("utf-8"),l=new TextDecoder("utf-8");globalThis.Go=class{constructor(){this.argv=["js"],this.env={},this.exit=e=>{e!==0&&console.warn("exit code:",e)},this._exitPromise=new Promise(e=>{this._resolveExitPromise=e}),this._pendingEvent=null,this._scheduledTimeouts=new Map,this._nextCallbackTimeoutID=1;let o=(e,i)=>{this.mem.setUint32(e+0,i,!0),this.mem.setUint32(e+4,Math.floor(i/4294967296),!0)},r=(e,i)=>{this.mem.setUint32(e+0,i,!0)},s=e=>{let i=this.mem.getUint32(e+0,!0),f=this.mem.getInt32(e+4,!0);return i+f*4294967296},n=e=>{let i=this.mem.getFloat64(e,!0);if(i===0)return;if(!isNaN(i))return i;let f=this.mem.getUint32(e,!0);return this._values[f]},a=(e,i)=>{if(typeof i=="number"&&i!==0){if(isNaN(i)){this.mem.setUint32(e+4,2146959360,!0),this.mem.setUint32(e,0,!0);return}this.mem.setFloat64(e,i,!0);return}if(i===void 0){this.mem.setFloat64(e,0,!0);return}let m=this._ids.get(i);m===void 0&&(m=this._idPool.pop(),m===void 0&&(m=this._values.length),this._values[m]=i,this._goRefCounts[m]=0,this._ids.set(i,m)),this._goRefCounts[m]++;let w=0;switch(typeof i){case"object":i!==null&&(w=1);break;case"string":w=2;break;case"symbol":w=3;break;case"function":w=4;break}this.mem.setUint32(e+4,2146959360|w,!0),this.mem.setUint32(e,m,!0)},g=e=>{let i=s(e+0),f=s(e+8);return new Uint8Array(this._inst.exports.mem.buffer,i,f)},u=e=>{let i=s(e+0),f=s(e+8),m=new Array(f);for(let w=0;w<f;w++)m[w]=n(i+w*8);return m},d=e=>{let i=s(e+0),f=s(e+8);return l.decode(new DataView(this._inst.exports.mem.buffer,i,f))},h=Date.now()-performance.now();this.importObject={_gotest:{add:(e,i)=>e+i},gojs:{"runtime.wasmExit":e=>{e>>>=0;let i=this.mem.getInt32(e+8,!0);this.exited=!0,delete this._inst,delete this._values,delete this._goRefCounts,delete this._ids,delete this._idPool,this.exit(i)},"runtime.wasmWrite":e=>{e>>>=0;let i=s(e+8),f=s(e+16),m=this.mem.getInt32(e+24,!0);fs.writeSync(i,new Uint8Array(this._inst.exports.mem.buffer,f,m))},"runtime.resetMemoryDataView":e=>{e>>>=0,this.mem=new DataView(this._inst.exports.mem.buffer)},"runtime.nanotime1":e=>{e>>>=0,o(e+8,(h+performance.now())*1e6)},"runtime.walltime":e=>{e>>>=0;let i=new Date().getTime();o(e+8,i/1e3),this.mem.setInt32(e+16,i%1e3*1e6,!0)},"runtime.scheduleTimeoutEvent":e=>{e>>>=0;let i=this._nextCallbackTimeoutID;this._nextCallbackTimeoutID++,this._scheduledTimeouts.set(i,setTimeout(()=>{for(this._resume();this._scheduledTimeouts.has(i);)console.warn("scheduleTimeoutEvent: missed timeout event"),this._resume()},s(e+8))),this.mem.setInt32(e+16,i,!0)},"runtime.clearTimeoutEvent":e=>{e>>>=0;let i=this.mem.getInt32(e+8,!0);clearTimeout(this._scheduledTimeouts.get(i)),this._scheduledTimeouts.delete(i)},"runtime.getRandomData":e=>{e>>>=0,crypto.getRandomValues(g(e+8))},"syscall/js.finalizeRef":e=>{e>>>=0;let i=this.mem.getUint32(e+8,!0);if(this._goRefCounts[i]--,this._goRefCounts[i]===0){let f=this._values[i];this._values[i]=null,this._ids.delete(f),this._idPool.push(i)}},"syscall/js.stringVal":e=>{e>>>=0,a(e+24,d(e+8))},"syscall/js.valueGet":e=>{e>>>=0;let i=Reflect.get(n(e+8),d(e+16));e=this._inst.exports.getsp()>>>0,a(e+32,i)},"syscall/js.valueSet":e=>{e>>>=0,Reflect.set(n(e+8),d(e+16),n(e+32))},"syscall/js.valueDelete":e=>{e>>>=0,Reflect.deleteProperty(n(e+8),d(e+16))},"syscall/js.valueIndex":e=>{e>>>=0,a(e+24,Reflect.get(n(e+8),s(e+16)))},"syscall/js.valueSetIndex":e=>{e>>>=0,Reflect.set(n(e+8),s(e+16),n(e+24))},"syscall/js.valueCall":e=>{e>>>=0;try{let i=n(e+8),f=Reflect.get(i,d(e+16)),m=u(e+32),w=Reflect.apply(f,i,m);e=this._inst.exports.getsp()>>>0,a(e+56,w),this.mem.setUint8(e+64,1)}catch(i){e=this._inst.exports.getsp()>>>0,a(e+56,i),this.mem.setUint8(e+64,0)}},"syscall/js.valueInvoke":e=>{e>>>=0;try{let i=n(e+8),f=u(e+16),m=Reflect.apply(i,void 0,f);e=this._inst.exports.getsp()>>>0,a(e+40,m),this.mem.setUint8(e+48,1)}catch(i){e=this._inst.exports.getsp()>>>0,a(e+40,i),this.mem.setUint8(e+48,0)}},"syscall/js.valueNew":e=>{e>>>=0;try{let i=n(e+8),f=u(e+16),m=Reflect.construct(i,f);e=this._inst.exports.getsp()>>>0,a(e+40,m),this.mem.setUint8(e+48,1)}catch(i){e=this._inst.exports.getsp()>>>0,a(e+40,i),this.mem.setUint8(e+48,0)}},"syscall/js.valueLength":e=>{e>>>=0,o(e+16,parseInt(n(e+8).length))},"syscall/js.valuePrepareString":e=>{e>>>=0;let i=c.encode(String(n(e+8)));a(e+16,i),o(e+24,i.length)},"syscall/js.valueLoadString":e=>{e>>>=0;let i=n(e+8);g(e+16).set(i)},"syscall/js.valueInstanceOf":e=>{e>>>=0,this.mem.setUint8(e+24,n(e+8)instanceof n(e+16)?1:0)},"syscall/js.copyBytesToGo":e=>{e>>>=0;let i=g(e+8),f=n(e+32);if(!(f instanceof Uint8Array||f instanceof Uint8ClampedArray)){this.mem.setUint8(e+48,0);return}let m=f.subarray(0,i.length);i.set(m),o(e+40,m.length),this.mem.setUint8(e+48,1)},"syscall/js.copyBytesToJS":e=>{e>>>=0;let i=n(e+8),f=g(e+16);if(!(i instanceof Uint8Array||i instanceof Uint8ClampedArray)){this.mem.setUint8(e+48,0);return}let m=f.subarray(0,i.length);i.set(m),o(e+40,m.length),this.mem.setUint8(e+48,1)},debug:e=>{console.log(e)}}}}async run(o){if(!(o instanceof WebAssembly.Instance))throw new Error("Go.run: WebAssembly.Instance expected");this._inst=o,this.mem=new DataView(this._inst.exports.mem.buffer),this._values=[NaN,0,null,!0,!1,globalThis,this],this._goRefCounts=new Array(this._values.length).fill(1/0),this._ids=new Map([[0,1],[null,2],[!0,3],[!1,4],[globalThis,5],[this,6]]),this._idPool=[],this.exited=!1;let r=4096,s=h=>{let e=r,i=c.encode(h+"\0");return new Uint8Array(this.mem.buffer,r,i.length).set(i),r+=i.length,r%8!==0&&(r+=8-r%8),e},n=this.argv.length,a=[];this.argv.forEach(h=>{a.push(s(h))}),a.push(0),Object.keys(this.env).sort().forEach(h=>{a.push(s(`${h}=${this.env[h]}`))}),a.push(0);let u=r;if(a.forEach(h=>{this.mem.setUint32(r,h,!0),this.mem.setUint32(r+4,0,!0),r+=8}),r>=12288)throw new Error("total length of command line and environment variables exceeds limit");this._inst.exports.run(n,u),this.exited&&this._resolveExitPromise(),await this._exitPromise}_resume(){if(this.exited)throw new Error("Go program has already exited");this._inst.exports.resume(),this.exited&&this._resolveExitPromise()}_makeFuncWrapper(o){let r=this;return function(){let s={id:o,this:this,args:arguments};return r._pendingEvent=s,r._resume(),s.result}}}})();import{getBaseMPCNetworkUrl as y,WalletScheme as b,WalletType as S}from"@getpara/core-sdk";var D=(t,c,l)=>`{"ServerUrl":"${t}", "WalletId": "${c}", "Id":"${l}", "Ids":["USER","CAPSULE"], "Threshold":1}`,p=(t,c,l)=>`{"walletId": "${t}", "id":"${c}", "otherId":"CAPSULE", "isReceiver": false, "disableWebSockets": ${l}}`;async function L(t,c,l,o){let{data:r}=await t.mpcComputationClient.post("/wallets",{userId:c,walletId:l,protocolId:o});return r}async function O(t,c,l,o,r,s){let{data:n}=await t.mpcComputationClient.post(`/wallets/${l}/messages/sign`,{userId:c,protocolId:o,message:r,signer:s});return n}async function C(t,c,l,o,r,s,n){let{data:a}=await t.mpcComputationClient.post(`/wallets/${l}/transactions/send`,{userId:c,protocolId:o,transaction:r,signer:s,chainId:n});return a}async function T(t,c){let{walletId:l,protocolId:o}=await t.client.createWallet(c,{scheme:b.ED25519,type:S.SOLANA}),r=y(t.env,!t.disableWebSockets);try{return{signer:await new Promise((n,a)=>globalThis.ed25519CreateAccount(r,l,o,(g,u)=>{g&&a(g),n(u)})),walletId:l}}catch{throw new Error(`error creating account of type SOLANA with userId ${c} and walletId ${l}`)}}async function E(t,c,l){let{walletId:o,protocolId:r}=await t.client.createPregenWallet({pregenIdentifier:c,pregenIdentifierType:l,scheme:b.ED25519,type:S.SOLANA}),s=y(t.env,!t.disableWebSockets);try{return{signer:await new Promise((a,g)=>globalThis.ed25519CreateAccount(s,o,r,(u,d)=>{u&&g(u),a(d)})),walletId:o}}catch{throw new Error(`error creating account of type SOLANA with walletId ${o}`)}}async function I(t,c,l,o,r){let{protocolId:s}=await t.client.preSignMessage(l,o,r,b.ED25519);try{return{signature:await new Promise((a,g)=>globalThis.ed25519Sign(c,s,r,(u,d)=>{u&&g(u),a(d)}))}}catch{throw new Error(`error signing for account of type SOLANA with userId ${l} and walletId ${o}`)}}async function P(t,c,l,o){let{walletId:r,protocolId:s}=await t.client.createWallet(c,{useTwoSigners:!0,scheme:t.useDKLS?b.DKLS:b.CGGMP,type:l,cosmosPrefix:l===S.COSMOS?t.cosmosPrefix:void 0});if(t.offloadMPCComputationURL&&!t.useDKLS)return{signer:(await L(t,c,r,s)).signer,walletId:r};let n=y(t.env,!t.disableWebSockets),a=t.useDKLS?p(r,"USER",t.disableWebSockets):D(n,r,"USER"),g=t.useDKLS?globalThis.dklsCreateAccount:globalThis.createAccountV2;try{return{signer:await new Promise((d,h)=>g(a,n,s,o,()=>{},(e,i)=>{e&&h(e),d(i)})),walletId:r}}catch{throw new Error(`error creating account of type ${l} with userId ${c} and walletId ${r}`)}}async function _(t,c,l,o,r,s){let{walletId:n,protocolId:a}=await t.client.createPregenWallet({pregenIdentifier:l,pregenIdentifierType:o,type:r,cosmosPrefix:r===S.COSMOS?t.cosmosPrefix:void 0}),g=y(t.env,!t.disableWebSockets),u=p(n,"USER",t.disableWebSockets);try{return{signer:await new Promise((h,e)=>globalThis.dklsCreateAccount(u,g,a,s,()=>{},(i,f)=>{i&&e(i),h(f)})),walletId:n}}catch{throw new Error(`error creating account of type ${r} with walletId ${n}`)}}async function k(t,c,l,o,r,s){let{protocolId:n,pendingTransactionId:a}=await t.client.preSignMessage(o,l,r,null,s);if(a)return{pendingTransactionId:a};if(t.offloadMPCComputationURL&&!t.useDKLS)return O(t,o,l,n,r,c);let g=y(t.env,!t.disableWebSockets),u=t.useDKLS?globalThis.dklsSignMessage:globalThis.signMessage,d=JSON.parse(c);!d.disableWebSockets!=!t.disableWebSockets&&(d.disableWebSockets=t.disableWebSockets),c=JSON.stringify(d);try{return await new Promise((h,e)=>u(c,g,r,n,(i,f)=>{i&&e(i),h({signature:f})}))}catch{throw new Error(`error signing for account with userId ${o} and walletId ${l}`)}}async function v(t,c,l,o,r,s){let{data:{protocolId:n,pendingTransactionId:a}}=await t.client.signTransaction(o,l,{transaction:r,chainId:s});if(a)return{pendingTransactionId:a};if(t.offloadMPCComputationURL&&!t.useDKLS)return C(t,o,l,n,r,c,s);let g=y(t.env,!t.disableWebSockets),u=t.useDKLS?globalThis.dklsSendTransaction:globalThis.sendTransaction,d=JSON.parse(c);!d.disableWebSockets!=!t.disableWebSockets&&(d.disableWebSockets=t.disableWebSockets),c=JSON.stringify(d);try{return await new Promise((h,e)=>u(c,g,r,s,n,(i,f)=>{i&&e(i),h({signature:f})}))}catch{throw new Error(`error signing transaction for account with userId ${o} and walletId ${l}`)}}async function U(t,c,l,o,r,s){let{data:{protocolId:n,pendingTransactionId:a}}=await t.client.sendTransaction(o,l,{transaction:r,chainId:s});if(a)return{pendingTransactionId:a};if(t.offloadMPCComputationURL&&!t.useDKLS)return C(t,o,l,n,r,c,s);let g=y(t.env,!t.disableWebSockets),u=t.useDKLS?globalThis.dklsSendTransaction:globalThis.sendTransaction,d=JSON.parse(c);!d.disableWebSockets!=!t.disableWebSockets&&(d.disableWebSockets=t.disableWebSockets),c=JSON.stringify(d);try{return await new Promise((h,e)=>u(c,g,r,s,n,(i,f)=>{i&&e(i),h({signature:f})}))}catch{throw new Error(`error signing transaction to send for account with userId ${o} and walletId ${l}`)}}async function R(t,c,l,o,r,s,n){let{data:{protocolId:a}}=await t.client.refreshKeys(o,l,r,s,n),g=y(t.env,!t.disableWebSockets),u=t.useDKLS?globalThis.dklsRefresh:globalThis.refresh,d=JSON.parse(c);!d.disableWebSockets!=!t.disableWebSockets&&(d.disableWebSockets=t.disableWebSockets),c=JSON.stringify(d);try{return await new Promise((h,e)=>u(c,g,a,(i,f)=>{i&&e(i),h({protocolId:a,signer:f})}))}catch{throw new Error(`error refreshing keys for account with userId ${o} and walletId ${l}`)}}async function W(t,c,l,o){let r=await t.client.getParaShare(o,l);if(!r)return"";try{return await new Promise((s,n)=>globalThis.getPrivateKey(c,r,(a,g)=>{a&&n(a),s(g)}))}catch{throw new Error(`error getting private key for account with userId ${o} and walletId ${l}`)}}import{getPortalBaseURL as M,initClient as K,mpcComputationClient as $,paraVersion as j,WalletType as A}from"@getpara/core-sdk";async function x(t,c){if(typeof self>"u")return;let l=new self.Go,o=c;if(!o){if(process.env.DISABLE_WASM_FETCH==="true")throw new Error("fetching wasm file is disabled");o=await(await fetch(`${M(t)}/static/js/main.wasm`,{mode:"cors"})).arrayBuffer()}let r=await WebAssembly.instantiate(o,l.importObject);l.run(r.instance)}async function G(t,c){let{functionType:l,params:o,returnObject:r}=c;switch(l){case"KEYGEN":{let{userId:s,secretKey:n,type:a=A.EVM}=o;return await P(t,s,a,n)}case"SIGN_TRANSACTION":{let{share:s,walletId:n,userId:a,tx:g,chainId:u}=o;return v(t,s,n,a,g,u)}case"SEND_TRANSACTION":{let{share:s,walletId:n,userId:a,tx:g,chainId:u}=o;return U(t,s,n,a,g,u)}case"SIGN_MESSAGE":{let{share:s,walletId:n,userId:a,message:g,cosmosSignDoc:u}=o;return k(t,s,n,a,g,u)}case"REFRESH":{let{share:s,walletId:n,userId:a,oldPartnerId:g,newPartnerId:u,keyShareProtocolId:d}=o,{protocolId:h,signer:e}=await R(t,s,n,a,g,u,d);return r?{protocolId:h,signer:e}:e}case"PREKEYGEN":{let{email:s,partnerId:n,secretKey:a,type:g=A.EVM}=o,{pregenIdentifier:u,pregenIdentifierType:d}=o;return s!=="null"&&s!=="undefined"&&s!==""&&s!=null&&(u=s,d="EMAIL"),await _(t,n,u,d,g,a)}case"GET_PRIVATE_KEY":{let{share:s,walletId:n,userId:a}=o;return await W(t,s,n,a)}case"ED25519_KEYGEN":{let{userId:s}=o;return T(t,s)}case"ED25519_SIGN":{let{share:s,walletId:n,userId:a,base64Bytes:g}=o;return I(t,s,a,n,g)}case"ED25519_PREKEYGEN":{let{email:s}=o,{pregenIdentifier:n,pregenIdentifierType:a}=o;return s!=="null"&&s!=="undefined"&&s!==""&&s!=null&&(n=s,a="EMAIL"),E(t,n,a)}default:throw new Error(`functionType: ${l} not supported`)}}async function Q(t,c,l){let{env:o,apiKey:r,cosmosPrefix:s="cosmos",offloadMPCComputationURL:n,disableWorkers:a,sessionCookie:g,useDKLS:u,disableWebSockets:d,wasmOverride:h}=t.data;if(!o)return!0;let e={env:o,apiKey:r,cosmosPrefix:s,client:K({env:o,version:j,apiKey:r,useFetchAdapter:l,retrieveSessionCookie:()=>g}),offloadMPCComputationURL:n,mpcComputationClient:n?$.initClient(n,!!a):void 0,useDKLS:u,disableWebSockets:!!d,wasmOverride:h};(!e.offloadMPCComputationURL||e.useDKLS)&&await x(e,h);let i=await G(e,t.data);return c(i),!1}export{Q as handleMessage};
+
+// src/wasm/wasm_exec.js
+(() => {
+  const enosys = () => {
+    const err = new Error("not implemented");
+    err.code = "ENOSYS";
+    return err;
+  };
+  if (!globalThis.fs) {
+    let outputBuf = "";
+    globalThis.fs = {
+      constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 },
+      // unused
+      writeSync(fd, buf) {
+        outputBuf += decoder.decode(buf);
+        const nl = outputBuf.lastIndexOf("\n");
+        if (nl != -1) {
+          console.log(outputBuf.substring(0, nl));
+          outputBuf = outputBuf.substring(nl + 1);
+        }
+        return buf.length;
+      },
+      write(fd, buf, offset, length, position, callback) {
+        if (offset !== 0 || length !== buf.length || position !== null) {
+          callback(enosys());
+          return;
+        }
+        const n = this.writeSync(fd, buf);
+        callback(null, n);
+      },
+      chmod(path, mode, callback) {
+        callback(enosys());
+      },
+      chown(path, uid, gid, callback) {
+        callback(enosys());
+      },
+      close(fd, callback) {
+        callback(enosys());
+      },
+      fchmod(fd, mode, callback) {
+        callback(enosys());
+      },
+      fchown(fd, uid, gid, callback) {
+        callback(enosys());
+      },
+      fstat(fd, callback) {
+        callback(enosys());
+      },
+      fsync(fd, callback) {
+        callback(null);
+      },
+      ftruncate(fd, length, callback) {
+        callback(enosys());
+      },
+      lchown(path, uid, gid, callback) {
+        callback(enosys());
+      },
+      link(path, link, callback) {
+        callback(enosys());
+      },
+      lstat(path, callback) {
+        callback(enosys());
+      },
+      mkdir(path, perm, callback) {
+        callback(enosys());
+      },
+      open(path, flags, mode, callback) {
+        callback(enosys());
+      },
+      read(fd, buffer, offset, length, position, callback) {
+        callback(enosys());
+      },
+      readdir(path, callback) {
+        callback(enosys());
+      },
+      readlink(path, callback) {
+        callback(enosys());
+      },
+      rename(from, to, callback) {
+        callback(enosys());
+      },
+      rmdir(path, callback) {
+        callback(enosys());
+      },
+      stat(path, callback) {
+        callback(enosys());
+      },
+      symlink(path, link, callback) {
+        callback(enosys());
+      },
+      truncate(path, length, callback) {
+        callback(enosys());
+      },
+      unlink(path, callback) {
+        callback(enosys());
+      },
+      utimes(path, atime, mtime, callback) {
+        callback(enosys());
+      }
+    };
+  }
+  if (!globalThis.process) {
+    globalThis.process = {
+      getuid() {
+        return -1;
+      },
+      getgid() {
+        return -1;
+      },
+      geteuid() {
+        return -1;
+      },
+      getegid() {
+        return -1;
+      },
+      getgroups() {
+        throw enosys();
+      },
+      pid: -1,
+      ppid: -1,
+      umask() {
+        throw enosys();
+      },
+      cwd() {
+        throw enosys();
+      },
+      chdir() {
+        throw enosys();
+      }
+    };
+  }
+  if (!globalThis.crypto) {
+    throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
+  }
+  if (!globalThis.performance) {
+    globalThis.performance = Date;
+  }
+  if (!globalThis.TextEncoder) {
+    throw new Error("globalThis.TextEncoder is not available, polyfill required");
+  }
+  if (!globalThis.TextDecoder) {
+    throw new Error("globalThis.TextDecoder is not available, polyfill required");
+  }
+  const encoder = new TextEncoder("utf-8");
+  const decoder = new TextDecoder("utf-8");
+  globalThis.Go = class {
+    constructor() {
+      this.argv = ["js"];
+      this.env = {};
+      this.exit = (code) => {
+        if (code !== 0) {
+          console.warn("exit code:", code);
+        }
+      };
+      this._exitPromise = new Promise((resolve) => {
+        this._resolveExitPromise = resolve;
+      });
+      this._pendingEvent = null;
+      this._scheduledTimeouts = /* @__PURE__ */ new Map();
+      this._nextCallbackTimeoutID = 1;
+      const setInt64 = (addr, v) => {
+        this.mem.setUint32(addr + 0, v, true);
+        this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
+      };
+      const setInt32 = (addr, v) => {
+        this.mem.setUint32(addr + 0, v, true);
+      };
+      const getInt64 = (addr) => {
+        const low = this.mem.getUint32(addr + 0, true);
+        const high = this.mem.getInt32(addr + 4, true);
+        return low + high * 4294967296;
+      };
+      const loadValue = (addr) => {
+        const f = this.mem.getFloat64(addr, true);
+        if (f === 0) {
+          return void 0;
+        }
+        if (!isNaN(f)) {
+          return f;
+        }
+        const id = this.mem.getUint32(addr, true);
+        return this._values[id];
+      };
+      const storeValue = (addr, v) => {
+        const nanHead = 2146959360;
+        if (typeof v === "number" && v !== 0) {
+          if (isNaN(v)) {
+            this.mem.setUint32(addr + 4, nanHead, true);
+            this.mem.setUint32(addr, 0, true);
+            return;
+          }
+          this.mem.setFloat64(addr, v, true);
+          return;
+        }
+        if (v === void 0) {
+          this.mem.setFloat64(addr, 0, true);
+          return;
+        }
+        let id = this._ids.get(v);
+        if (id === void 0) {
+          id = this._idPool.pop();
+          if (id === void 0) {
+            id = this._values.length;
+          }
+          this._values[id] = v;
+          this._goRefCounts[id] = 0;
+          this._ids.set(v, id);
+        }
+        this._goRefCounts[id]++;
+        let typeFlag = 0;
+        switch (typeof v) {
+          case "object":
+            if (v !== null) {
+              typeFlag = 1;
+            }
+            break;
+          case "string":
+            typeFlag = 2;
+            break;
+          case "symbol":
+            typeFlag = 3;
+            break;
+          case "function":
+            typeFlag = 4;
+            break;
+        }
+        this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
+        this.mem.setUint32(addr, id, true);
+      };
+      const loadSlice = (addr) => {
+        const array = getInt64(addr + 0);
+        const len = getInt64(addr + 8);
+        return new Uint8Array(this._inst.exports.mem.buffer, array, len);
+      };
+      const loadSliceOfValues = (addr) => {
+        const array = getInt64(addr + 0);
+        const len = getInt64(addr + 8);
+        const a = new Array(len);
+        for (let i = 0; i < len; i++) {
+          a[i] = loadValue(array + i * 8);
+        }
+        return a;
+      };
+      const loadString = (addr) => {
+        const saddr = getInt64(addr + 0);
+        const len = getInt64(addr + 8);
+        return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
+      };
+      const timeOrigin = Date.now() - performance.now();
+      this.importObject = {
+        _gotest: {
+          add: (a, b) => a + b
+        },
+        gojs: {
+          // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
+          // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
+          // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
+          // This changes the SP, thus we have to update the SP used by the imported function.
+          // func wasmExit(code int32)
+          "runtime.wasmExit": (sp) => {
+            sp >>>= 0;
+            const code = this.mem.getInt32(sp + 8, true);
+            this.exited = true;
+            delete this._inst;
+            delete this._values;
+            delete this._goRefCounts;
+            delete this._ids;
+            delete this._idPool;
+            this.exit(code);
+          },
+          // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
+          "runtime.wasmWrite": (sp) => {
+            sp >>>= 0;
+            const fd = getInt64(sp + 8);
+            const p = getInt64(sp + 16);
+            const n = this.mem.getInt32(sp + 24, true);
+            fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
+          },
+          // func resetMemoryDataView()
+          "runtime.resetMemoryDataView": (sp) => {
+            sp >>>= 0;
+            this.mem = new DataView(this._inst.exports.mem.buffer);
+          },
+          // func nanotime1() int64
+          "runtime.nanotime1": (sp) => {
+            sp >>>= 0;
+            setInt64(sp + 8, (timeOrigin + performance.now()) * 1e6);
+          },
+          // func walltime() (sec int64, nsec int32)
+          "runtime.walltime": (sp) => {
+            sp >>>= 0;
+            const msec = (/* @__PURE__ */ new Date()).getTime();
+            setInt64(sp + 8, msec / 1e3);
+            this.mem.setInt32(sp + 16, msec % 1e3 * 1e6, true);
+          },
+          // func scheduleTimeoutEvent(delay int64) int32
+          "runtime.scheduleTimeoutEvent": (sp) => {
+            sp >>>= 0;
+            const id = this._nextCallbackTimeoutID;
+            this._nextCallbackTimeoutID++;
+            this._scheduledTimeouts.set(id, setTimeout(
+              () => {
+                this._resume();
+                while (this._scheduledTimeouts.has(id)) {
+                  console.warn("scheduleTimeoutEvent: missed timeout event");
+                  this._resume();
+                }
+              },
+              getInt64(sp + 8)
+            ));
+            this.mem.setInt32(sp + 16, id, true);
+          },
+          // func clearTimeoutEvent(id int32)
+          "runtime.clearTimeoutEvent": (sp) => {
+            sp >>>= 0;
+            const id = this.mem.getInt32(sp + 8, true);
+            clearTimeout(this._scheduledTimeouts.get(id));
+            this._scheduledTimeouts.delete(id);
+          },
+          // func getRandomData(r []byte)
+          "runtime.getRandomData": (sp) => {
+            sp >>>= 0;
+            crypto.getRandomValues(loadSlice(sp + 8));
+          },
+          // func finalizeRef(v ref)
+          "syscall/js.finalizeRef": (sp) => {
+            sp >>>= 0;
+            const id = this.mem.getUint32(sp + 8, true);
+            this._goRefCounts[id]--;
+            if (this._goRefCounts[id] === 0) {
+              const v = this._values[id];
+              this._values[id] = null;
+              this._ids.delete(v);
+              this._idPool.push(id);
+            }
+          },
+          // func stringVal(value string) ref
+          "syscall/js.stringVal": (sp) => {
+            sp >>>= 0;
+            storeValue(sp + 24, loadString(sp + 8));
+          },
+          // func valueGet(v ref, p string) ref
+          "syscall/js.valueGet": (sp) => {
+            sp >>>= 0;
+            const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
+            sp = this._inst.exports.getsp() >>> 0;
+            storeValue(sp + 32, result);
+          },
+          // func valueSet(v ref, p string, x ref)
+          "syscall/js.valueSet": (sp) => {
+            sp >>>= 0;
+            Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
+          },
+          // func valueDelete(v ref, p string)
+          "syscall/js.valueDelete": (sp) => {
+            sp >>>= 0;
+            Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
+          },
+          // func valueIndex(v ref, i int) ref
+          "syscall/js.valueIndex": (sp) => {
+            sp >>>= 0;
+            storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
+          },
+          // valueSetIndex(v ref, i int, x ref)
+          "syscall/js.valueSetIndex": (sp) => {
+            sp >>>= 0;
+            Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
+          },
+          // func valueCall(v ref, m string, args []ref) (ref, bool)
+          "syscall/js.valueCall": (sp) => {
+            sp >>>= 0;
+            try {
+              const v = loadValue(sp + 8);
+              const m = Reflect.get(v, loadString(sp + 16));
+              const args = loadSliceOfValues(sp + 32);
+              const result = Reflect.apply(m, v, args);
+              sp = this._inst.exports.getsp() >>> 0;
+              storeValue(sp + 56, result);
+              this.mem.setUint8(sp + 64, 1);
+            } catch (err) {
+              sp = this._inst.exports.getsp() >>> 0;
+              storeValue(sp + 56, err);
+              this.mem.setUint8(sp + 64, 0);
+            }
+          },
+          // func valueInvoke(v ref, args []ref) (ref, bool)
+          "syscall/js.valueInvoke": (sp) => {
+            sp >>>= 0;
+            try {
+              const v = loadValue(sp + 8);
+              const args = loadSliceOfValues(sp + 16);
+              const result = Reflect.apply(v, void 0, args);
+              sp = this._inst.exports.getsp() >>> 0;
+              storeValue(sp + 40, result);
+              this.mem.setUint8(sp + 48, 1);
+            } catch (err) {
+              sp = this._inst.exports.getsp() >>> 0;
+              storeValue(sp + 40, err);
+              this.mem.setUint8(sp + 48, 0);
+            }
+          },
+          // func valueNew(v ref, args []ref) (ref, bool)
+          "syscall/js.valueNew": (sp) => {
+            sp >>>= 0;
+            try {
+              const v = loadValue(sp + 8);
+              const args = loadSliceOfValues(sp + 16);
+              const result = Reflect.construct(v, args);
+              sp = this._inst.exports.getsp() >>> 0;
+              storeValue(sp + 40, result);
+              this.mem.setUint8(sp + 48, 1);
+            } catch (err) {
+              sp = this._inst.exports.getsp() >>> 0;
+              storeValue(sp + 40, err);
+              this.mem.setUint8(sp + 48, 0);
+            }
+          },
+          // func valueLength(v ref) int
+          "syscall/js.valueLength": (sp) => {
+            sp >>>= 0;
+            setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
+          },
+          // valuePrepareString(v ref) (ref, int)
+          "syscall/js.valuePrepareString": (sp) => {
+            sp >>>= 0;
+            const str = encoder.encode(String(loadValue(sp + 8)));
+            storeValue(sp + 16, str);
+            setInt64(sp + 24, str.length);
+          },
+          // valueLoadString(v ref, b []byte)
+          "syscall/js.valueLoadString": (sp) => {
+            sp >>>= 0;
+            const str = loadValue(sp + 8);
+            loadSlice(sp + 16).set(str);
+          },
+          // func valueInstanceOf(v ref, t ref) bool
+          "syscall/js.valueInstanceOf": (sp) => {
+            sp >>>= 0;
+            this.mem.setUint8(sp + 24, loadValue(sp + 8) instanceof loadValue(sp + 16) ? 1 : 0);
+          },
+          // func copyBytesToGo(dst []byte, src ref) (int, bool)
+          "syscall/js.copyBytesToGo": (sp) => {
+            sp >>>= 0;
+            const dst = loadSlice(sp + 8);
+            const src = loadValue(sp + 32);
+            if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
+              this.mem.setUint8(sp + 48, 0);
+              return;
+            }
+            const toCopy = src.subarray(0, dst.length);
+            dst.set(toCopy);
+            setInt64(sp + 40, toCopy.length);
+            this.mem.setUint8(sp + 48, 1);
+          },
+          // func copyBytesToJS(dst ref, src []byte) (int, bool)
+          "syscall/js.copyBytesToJS": (sp) => {
+            sp >>>= 0;
+            const dst = loadValue(sp + 8);
+            const src = loadSlice(sp + 16);
+            if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
+              this.mem.setUint8(sp + 48, 0);
+              return;
+            }
+            const toCopy = src.subarray(0, dst.length);
+            dst.set(toCopy);
+            setInt64(sp + 40, toCopy.length);
+            this.mem.setUint8(sp + 48, 1);
+          },
+          "debug": (value) => {
+            console.log(value);
+          }
+        }
+      };
+    }
+    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;
+        }
+        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) {
+        throw new Error("Go program has already exited");
+      }
+      this._inst.exports.resume();
+      if (this.exited) {
+        this._resolveExitPromise();
+      }
+    }
+    _makeFuncWrapper(id) {
+      const go = this;
+      return function() {
+        const event = { id, this: this, args: arguments };
+        go._pendingEvent = event;
+        go._resume();
+        return event.result;
+      };
+    }
+  };
+})();
+
+// src/workers/walletUtils.ts
+import { getBaseMPCNetworkUrl, WalletScheme, WalletType } from "@getpara/core-sdk";
+var configCGGMPBase = (serverUrl, walletId, id) => `{"ServerUrl":"${serverUrl}", "WalletId": "${walletId}", "Id":"${id}", "Ids":["USER","CAPSULE"], "Threshold":1}`;
+var 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: WalletScheme.ED25519,
+    type: WalletType.SOLANA
+  });
+  const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+  try {
+    const newSigner = await new Promise(
+      (resolve, reject) => globalThis.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: WalletScheme.ED25519,
+    type: WalletType.SOLANA
+  });
+  const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+  try {
+    const newSigner = await new Promise(
+      (resolve, reject) => globalThis.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 } = await ctx.client.preSignMessage(userId, walletId, base64Bytes, WalletScheme.ED25519);
+  try {
+    const base64Sig = await new Promise(
+      (resolve, reject) => globalThis.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}`);
+  }
+}
+async function keygen(ctx, userId, type, secretKey) {
+  const { walletId, protocolId } = await ctx.client.createWallet(userId, {
+    useTwoSigners: true,
+    scheme: ctx.useDKLS ? WalletScheme.DKLS : WalletScheme.CGGMP,
+    type,
+    cosmosPrefix: type === WalletType.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 ? globalThis.dklsCreateAccount : globalThis.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 === WalletType.COSMOS ? ctx.cosmosPrefix : void 0
+  });
+  const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+  const signerConfigUser = configDKLSBase(walletId, "USER", ctx.disableWebSockets);
+  try {
+    const newSigner = await new Promise(
+      (resolve, reject) => globalThis.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 };
+  } catch (e) {
+    throw new Error(`error creating account of type ${type} with walletId ${walletId}`);
+  }
+}
+async function signMessage(ctx, share, walletId, userId, message, cosmosSignDoc) {
+  const { protocolId, pendingTransactionId } = await 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 ? globalThis.dklsSignMessage : globalThis.signMessage;
+  const parsedShare = JSON.parse(share);
+  if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+    parsedShare.disableWebSockets = ctx.disableWebSockets;
+  }
+  share = JSON.stringify(parsedShare);
+  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}`);
+  }
+}
+async function signTransaction(ctx, share, walletId, userId, tx, chainId) {
+  const {
+    data: { protocolId, pendingTransactionId }
+  } = await 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 ? globalThis.dklsSendTransaction : globalThis.sendTransaction;
+  const parsedShare = JSON.parse(share);
+  if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+    parsedShare.disableWebSockets = ctx.disableWebSockets;
+  }
+  share = JSON.stringify(parsedShare);
+  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}`);
+  }
+}
+async function sendTransaction(ctx, share, walletId, userId, tx, chainId) {
+  const {
+    data: { protocolId, pendingTransactionId }
+  } = await 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 ? globalThis.dklsSendTransaction : globalThis.sendTransaction;
+  const parsedShare = JSON.parse(share);
+  if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+    parsedShare.disableWebSockets = ctx.disableWebSockets;
+  }
+  share = JSON.stringify(parsedShare);
+  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}`);
+  }
+}
+async function refresh(ctx, share, walletId, userId, oldPartnerId, newPartnerId, keyShareProtocolId) {
+  const {
+    data: { protocolId }
+  } = await ctx.client.refreshKeys(userId, walletId, oldPartnerId, newPartnerId, keyShareProtocolId);
+  const serverUrl = getBaseMPCNetworkUrl(ctx.env, !ctx.disableWebSockets);
+  const refreshFn = ctx.useDKLS ? globalThis.dklsRefresh : globalThis.refresh;
+  const parsedShare = JSON.parse(share);
+  if (!parsedShare.disableWebSockets !== !ctx.disableWebSockets) {
+    parsedShare.disableWebSockets = ctx.disableWebSockets;
+  }
+  share = JSON.stringify(parsedShare);
+  try {
+    return await new Promise(
+      (resolve, reject) => refreshFn(share, serverUrl, protocolId, (err, result) => {
+        if (err) {
+          reject(err);
+        }
+        resolve({ protocolId, signer: 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) {
+    return "";
+  }
+  try {
+    return await new Promise(
+      (resolve, reject) => globalThis.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}`);
+  }
+}
+
+// src/workers/worker.ts
+import {
+  getPortalBaseURL,
+  initClient,
+  mpcComputationClient,
+  paraVersion,
+  WalletType as WalletType2
+} from "@getpara/core-sdk";
+async function loadWasm(ctx, wasmOverride) {
+  if (typeof self === "undefined") {
+    return;
+  }
+  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 = await fetch(`${getPortalBaseURL(ctx)}/static/js/main.wasm`, { mode: "cors" });
+    wasmArrayBuffer = await fetchedWasm.arrayBuffer();
+  }
+  const newRes = await WebAssembly.instantiate(wasmArrayBuffer, goWasm.importObject);
+  goWasm.run(newRes.instance);
+}
+async function executeMessage(ctx, message) {
+  const { functionType, params, returnObject } = message;
+  switch (functionType) {
+    case "KEYGEN": {
+      const { userId, secretKey, type = WalletType2.EVM } = params;
+      const keygenRes = await keygen(ctx, userId, type, secretKey);
+      return keygenRes;
+    }
+    case "SIGN_TRANSACTION": {
+      const { share, walletId, userId, tx, chainId } = params;
+      return signTransaction(ctx, share, walletId, userId, tx, chainId);
+    }
+    case "SEND_TRANSACTION": {
+      const { share, walletId, userId, tx, chainId } = params;
+      return sendTransaction(ctx, share, walletId, userId, tx, chainId);
+    }
+    case "SIGN_MESSAGE": {
+      const { share, walletId, userId, message: message2, cosmosSignDoc } = params;
+      return signMessage(ctx, share, walletId, userId, message2, cosmosSignDoc);
+    }
+    case "REFRESH": {
+      const { share, walletId, userId, oldPartnerId, newPartnerId, keyShareProtocolId } = params;
+      const { protocolId, signer } = await refresh(
+        ctx,
+        share,
+        walletId,
+        userId,
+        oldPartnerId,
+        newPartnerId,
+        keyShareProtocolId
+      );
+      return returnObject ? { protocolId, signer } : signer;
+    }
+    case "PREKEYGEN": {
+      const { email, partnerId, secretKey, type = WalletType2.EVM } = params;
+      let { pregenIdentifier, pregenIdentifierType } = params;
+      if (email !== "null" && email !== "undefined" && email !== "" && email != null) {
+        pregenIdentifier = email;
+        pregenIdentifierType = "EMAIL";
+      }
+      const keygenRes = await preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey);
+      return keygenRes;
+    }
+    case "GET_PRIVATE_KEY": {
+      const { share, walletId, userId } = params;
+      return await getPrivateKey(ctx, share, walletId, userId);
+    }
+    case "ED25519_KEYGEN": {
+      const { userId } = params;
+      return ed25519Keygen(ctx, userId);
+    }
+    case "ED25519_SIGN": {
+      const { share, walletId, userId, base64Bytes } = params;
+      return 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 ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType);
+    }
+    default: {
+      throw new Error(`functionType: ${functionType} not supported`);
+    }
+  }
+}
+async function handleMessage(e, postMessage, useFetchAdapter) {
+  const {
+    env,
+    apiKey,
+    cosmosPrefix = "cosmos",
+    offloadMPCComputationURL,
+    disableWorkers,
+    sessionCookie,
+    useDKLS,
+    disableWebSockets,
+    wasmOverride
+  } = e.data;
+  if (!env) {
+    return true;
+  }
+  const ctx = {
+    env,
+    apiKey,
+    cosmosPrefix,
+    client: initClient({
+      env,
+      version: paraVersion,
+      apiKey,
+      useFetchAdapter,
+      retrieveSessionCookie: () => sessionCookie
+    }),
+    offloadMPCComputationURL,
+    mpcComputationClient: offloadMPCComputationURL ? mpcComputationClient.initClient(offloadMPCComputationURL, !!disableWorkers) : void 0,
+    useDKLS,
+    disableWebSockets: !!disableWebSockets,
+    wasmOverride
+  };
+  if (!ctx.offloadMPCComputationURL || ctx.useDKLS) {
+    await loadWasm(ctx, wasmOverride);
+  }
+  const result = await executeMessage(ctx, e.data);
+  postMessage(result);
+  return false;
+}
+export {
+  handleMessage
+};