@walletconnect/types - npm Package Compare versions

Comparing version 2.15.0-canary-lm.7 to 2.15.0-canary-lm.8

dist/index.cjs.js

@@ -1,2 +0,158 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("@walletconnect/events"),c=require("events");function i(t){return t&&typeof t=="object"&&"default"in t?t:{default:t}}var n=i(c);class l extends r.IEvents{constructor(s){super(),this.opts=s,this.protocol="wc",this.version=2}}class a{constructor(s,e,o){this.core=s,this.logger=e}}class u extends r.IEvents{constructor(s,e){super(),this.core=s,this.logger=e,this.records=new Map}}class I{constructor(s,e){this.logger=s,this.core=e}}class h extends r.IEvents{constructor(s,e){super(),this.relayer=s,this.logger=e}}class g extends r.IEvents{constructor(s){super()}}class p{constructor(s,e,o,_){this.core=s,this.logger=e,this.name=o}}class E{constructor(){this.map=new Map}}class v extends r.IEvents{constructor(s,e){super(),this.relayer=s,this.logger=e}}class d{constructor(s,e){this.core=s,this.logger=e}}class y extends r.IEvents{constructor(s,e){super(),this.core=s,this.logger=e}}class b{constructor(s,e){this.logger=s,this.core=e}}class C{constructor(s,e,o){this.core=s,this.logger=e,this.store=o}}class f{constructor(s,e){this.projectId=s,this.logger=e}}class x extends n.default{constructor(){super()}}class S{constructor(s){this.opts=s,this.protocol="wc",this.version=2}}class M extends c.EventEmitter{constructor(){super()}}class P{constructor(s){this.client=s}}exports.ICore=l,exports.ICrypto=a,exports.IEchoClient=f,exports.IEngine=P,exports.IEngineEvents=M,exports.IExpirer=y,exports.IJsonRpcHistory=u,exports.IKeyChain=d,exports.IMessageTracker=I,exports.IPairing=b,exports.IPublisher=h,exports.IRelayer=g,exports.ISignClient=S,exports.ISignClientEvents=x,exports.IStore=p,exports.ISubscriber=v,exports.ISubscriberTopicMap=E,exports.IVerify=C;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var events = require('@walletconnect/events');
+var EventEmmiter = require('events');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmmiter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmmiter);
+
+class ICore extends events.IEvents {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.protocol = "wc";
+    this.version = 2;
+  }
+}
+
+class ICrypto {
+  constructor(core, logger, keychain) {
+    this.core = core;
+    this.logger = logger;
+  }
+}
+
+class IJsonRpcHistory extends events.IEvents {
+  constructor(core, logger) {
+    super();
+    this.core = core;
+    this.logger = logger;
+    this.records = /* @__PURE__ */ new Map();
+  }
+}
+
+class IMessageTracker {
+  constructor(logger, core) {
+    this.logger = logger;
+    this.core = core;
+  }
+}
+
+class IPublisher extends events.IEvents {
+  constructor(relayer, logger) {
+    super();
+    this.relayer = relayer;
+    this.logger = logger;
+  }
+}
+
+class IRelayer extends events.IEvents {
+  constructor(opts) {
+    super();
+  }
+}
+
+class IStore {
+  constructor(core, logger, name, storagePrefix) {
+    this.core = core;
+    this.logger = logger;
+    this.name = name;
+  }
+}
+
+class ISubscriberTopicMap {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+}
+class ISubscriber extends events.IEvents {
+  constructor(relayer, logger) {
+    super();
+    this.relayer = relayer;
+    this.logger = logger;
+  }
+}
+
+class IKeyChain {
+  constructor(core, logger) {
+    this.core = core;
+    this.logger = logger;
+  }
+}
+
+class IExpirer extends events.IEvents {
+  constructor(core, logger) {
+    super();
+    this.core = core;
+    this.logger = logger;
+  }
+}
+
+class IPairing {
+  constructor(logger, core) {
+    this.logger = logger;
+    this.core = core;
+  }
+}
+
+class IVerify {
+  constructor(core, logger, store) {
+    this.core = core;
+    this.logger = logger;
+    this.store = store;
+  }
+}
+
+class IEchoClient {
+  constructor(projectId, logger) {
+    this.projectId = projectId;
+    this.logger = logger;
+  }
+}
+
+class ISignClientEvents extends EventEmmiter__default["default"] {
+  constructor() {
+    super();
+  }
+}
+class ISignClient {
+  constructor(opts) {
+    this.opts = opts;
+    this.protocol = "wc";
+    this.version = 2;
+  }
+}
+
+class IEngineEvents extends EventEmmiter.EventEmitter {
+  constructor() {
+    super();
+  }
+}
+class IEngine {
+  constructor(client) {
+    this.client = client;
+  }
+}
+
+exports.ICore = ICore;
+exports.ICrypto = ICrypto;
+exports.IEchoClient = IEchoClient;
+exports.IEngine = IEngine;
+exports.IEngineEvents = IEngineEvents;
+exports.IExpirer = IExpirer;
+exports.IJsonRpcHistory = IJsonRpcHistory;
+exports.IKeyChain = IKeyChain;
+exports.IMessageTracker = IMessageTracker;
+exports.IPairing = IPairing;
+exports.IPublisher = IPublisher;
+exports.IRelayer = IRelayer;
+exports.ISignClient = ISignClient;
+exports.ISignClientEvents = ISignClientEvents;
+exports.IStore = IStore;
+exports.ISubscriber = ISubscriber;
+exports.ISubscriberTopicMap = ISubscriberTopicMap;
+exports.IVerify = IVerify;
 //# sourceMappingURL=index.cjs.js.map

dist/index.es.js

@@ -1,2 +0,133 @@
-import{IEvents as e}from"@walletconnect/events";import c,{EventEmitter as i}from"events";class n extends e{constructor(s){super(),this.opts=s,this.protocol="wc",this.version=2}}class l{constructor(s,t,o){this.core=s,this.logger=t}}class h extends e{constructor(s,t){super(),this.core=s,this.logger=t,this.records=new Map}}class a{constructor(s,t){this.logger=s,this.core=t}}class u extends e{constructor(s,t){super(),this.relayer=s,this.logger=t}}class g extends e{constructor(s){super()}}class p{constructor(s,t,o,M){this.core=s,this.logger=t,this.name=o}}class I{constructor(){this.map=new Map}}class d extends e{constructor(s,t){super(),this.relayer=s,this.logger=t}}class x{constructor(s,t){this.core=s,this.logger=t}}class E extends e{constructor(s,t){super(),this.core=s,this.logger=t}}class m{constructor(s,t){this.logger=s,this.core=t}}class y{constructor(s,t,o){this.core=s,this.logger=t,this.store=o}}class v{constructor(s,t){this.projectId=s,this.logger=t}}class C extends c{constructor(){super()}}class b{constructor(s){this.opts=s,this.protocol="wc",this.version=2}}class S extends i{constructor(){super()}}class w{constructor(s){this.client=s}}export{n as ICore,l as ICrypto,v as IEchoClient,w as IEngine,S as IEngineEvents,E as IExpirer,h as IJsonRpcHistory,x as IKeyChain,a as IMessageTracker,m as IPairing,u as IPublisher,g as IRelayer,b as ISignClient,C as ISignClientEvents,p as IStore,d as ISubscriber,I as ISubscriberTopicMap,y as IVerify};
+import { IEvents } from '@walletconnect/events';
+import EventEmmiter, { EventEmitter } from 'events';
+
+class ICore extends IEvents {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.protocol = "wc";
+    this.version = 2;
+  }
+}
+
+class ICrypto {
+  constructor(core, logger, keychain) {
+    this.core = core;
+    this.logger = logger;
+  }
+}
+
+class IJsonRpcHistory extends IEvents {
+  constructor(core, logger) {
+    super();
+    this.core = core;
+    this.logger = logger;
+    this.records = /* @__PURE__ */ new Map();
+  }
+}
+
+class IMessageTracker {
+  constructor(logger, core) {
+    this.logger = logger;
+    this.core = core;
+  }
+}
+
+class IPublisher extends IEvents {
+  constructor(relayer, logger) {
+    super();
+    this.relayer = relayer;
+    this.logger = logger;
+  }
+}
+
+class IRelayer extends IEvents {
+  constructor(opts) {
+    super();
+  }
+}
+
+class IStore {
+  constructor(core, logger, name, storagePrefix) {
+    this.core = core;
+    this.logger = logger;
+    this.name = name;
+  }
+}
+
+class ISubscriberTopicMap {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+}
+class ISubscriber extends IEvents {
+  constructor(relayer, logger) {
+    super();
+    this.relayer = relayer;
+    this.logger = logger;
+  }
+}
+
+class IKeyChain {
+  constructor(core, logger) {
+    this.core = core;
+    this.logger = logger;
+  }
+}
+
+class IExpirer extends IEvents {
+  constructor(core, logger) {
+    super();
+    this.core = core;
+    this.logger = logger;
+  }
+}
+
+class IPairing {
+  constructor(logger, core) {
+    this.logger = logger;
+    this.core = core;
+  }
+}
+
+class IVerify {
+  constructor(core, logger, store) {
+    this.core = core;
+    this.logger = logger;
+    this.store = store;
+  }
+}
+
+class IEchoClient {
+  constructor(projectId, logger) {
+    this.projectId = projectId;
+    this.logger = logger;
+  }
+}
+
+class ISignClientEvents extends EventEmmiter {
+  constructor() {
+    super();
+  }
+}
+class ISignClient {
+  constructor(opts) {
+    this.opts = opts;
+    this.protocol = "wc";
+    this.version = 2;
+  }
+}
+
+class IEngineEvents extends EventEmitter {
+  constructor() {
+    super();
+  }
+}
+class IEngine {
+  constructor(client) {
+    this.client = client;
+  }
+}
+
+export { ICore, ICrypto, IEchoClient, IEngine, IEngineEvents, IExpirer, IJsonRpcHistory, IKeyChain, IMessageTracker, IPairing, IPublisher, IRelayer, ISignClient, ISignClientEvents, IStore, ISubscriber, ISubscriberTopicMap, IVerify };
 //# sourceMappingURL=index.es.js.map

dist/index.umd.js

@@ -1,2 +0,636 @@
-(function(c,a){typeof exports=="object"&&typeof module<"u"?a(exports):typeof define=="function"&&define.amd?define(["exports"],a):(c=typeof globalThis<"u"?globalThis:c||self,a(c["@walletconnect/types"]={}))})(this,function(c){"use strict";class a{}class M extends a{constructor(e){super(),this.opts=e,this.protocol="wc",this.version=2}}class R{constructor(e,n,r){this.core=e,this.logger=n}}class j extends a{constructor(e,n){super(),this.core=e,this.logger=n,this.records=new Map}}class x{constructor(e,n){this.logger=e,this.core=n}}class P extends a{constructor(e,n){super(),this.relayer=e,this.logger=n}}class N extends a{constructor(e){super()}}class S{constructor(e,n,r,s){this.core=e,this.logger=n,this.name=r}}class T{constructor(){this.map=new Map}}class A extends a{constructor(e,n){super(),this.relayer=e,this.logger=n}}class K{constructor(e,n){this.core=e,this.logger=n}}class F extends a{constructor(e,n){super(),this.core=e,this.logger=n}}class W{constructor(e,n){this.logger=e,this.core=n}}class k{constructor(e,n,r){this.core=e,this.logger=n,this.store=r}}class H{constructor(e,n){this.projectId=e,this.logger=n}}var p={exports:{}},l=typeof Reflect=="object"?Reflect:null,g=l&&typeof l.apply=="function"?l.apply:function(e,n,r){return Function.prototype.apply.call(e,n,r)},v;l&&typeof l.ownKeys=="function"?v=l.ownKeys:Object.getOwnPropertySymbols?v=function(e){return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e))}:v=function(e){return Object.getOwnPropertyNames(e)};function J(t){console&&console.warn&&console.warn(t)}var y=Number.isNaN||function(e){return e!==e};function o(){o.init.call(this)}p.exports=o,p.exports.once=z,o.EventEmitter=o,o.prototype._events=void 0,o.prototype._eventsCount=0,o.prototype._maxListeners=void 0;var m=10;function d(t){if(typeof t!="function")throw new TypeError('The "listener" argument must be of type Function. Received type '+typeof t)}Object.defineProperty(o,"defaultMaxListeners",{enumerable:!0,get:function(){return m},set:function(t){if(typeof t!="number"||t<0||y(t))throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received '+t+".");m=t}}),o.init=function(){(this._events===void 0||this._events===Object.getPrototypeOf(this)._events)&&(this._events=Object.create(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0},o.prototype.setMaxListeners=function(e){if(typeof e!="number"||e<0||y(e))throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received '+e+".");return this._maxListeners=e,this};function L(t){return t._maxListeners===void 0?o.defaultMaxListeners:t._maxListeners}o.prototype.getMaxListeners=function(){return L(this)},o.prototype.emit=function(e){for(var n=[],r=1;r<arguments.length;r++)n.push(arguments[r]);var s=e==="error",u=this._events;if(u!==void 0)s=s&&u.error===void 0;else if(!s)return!1;if(s){var i;if(n.length>0&&(i=n[0]),i instanceof Error)throw i;var f=new Error("Unhandled error."+(i?" ("+i.message+")":""));throw f.context=i,f}var h=u[e];if(h===void 0)return!1;if(typeof h=="function")g(h,this,n);else for(var O=h.length,Y=w(h,O),r=0;r<O;++r)g(Y[r],this,n);return!0};function b(t,e,n,r){var s,u,i;if(d(n),u=t._events,u===void 0?(u=t._events=Object.create(null),t._eventsCount=0):(u.newListener!==void 0&&(t.emit("newListener",e,n.listener?n.listener:n),u=t._events),i=u[e]),i===void 0)i=u[e]=n,++t._eventsCount;else if(typeof i=="function"?i=u[e]=r?[n,i]:[i,n]:r?i.unshift(n):i.push(n),s=L(t),s>0&&i.length>s&&!i.warned){i.warned=!0;var f=new Error("Possible EventEmitter memory leak detected. "+i.length+" "+String(e)+" listeners added. Use emitter.setMaxListeners() to increase limit");f.name="MaxListenersExceededWarning",f.emitter=t,f.type=e,f.count=i.length,J(f)}return t}o.prototype.addListener=function(e,n){return b(this,e,n,!1)},o.prototype.on=o.prototype.addListener,o.prototype.prependListener=function(e,n){return b(this,e,n,!0)};function U(){if(!this.fired)return this.target.removeListener(this.type,this.wrapFn),this.fired=!0,arguments.length===0?this.listener.call(this.target):this.listener.apply(this.target,arguments)}function I(t,e,n){var r={fired:!1,wrapFn:void 0,target:t,type:e,listener:n},s=U.bind(r);return s.listener=n,r.wrapFn=s,s}o.prototype.once=function(e,n){return d(n),this.on(e,I(this,e,n)),this},o.prototype.prependOnceListener=function(e,n){return d(n),this.prependListener(e,I(this,e,n)),this},o.prototype.removeListener=function(e,n){var r,s,u,i,f;if(d(n),s=this._events,s===void 0)return this;if(r=s[e],r===void 0)return this;if(r===n||r.listener===n)--this._eventsCount===0?this._events=Object.create(null):(delete s[e],s.removeListener&&this.emit("removeListener",e,r.listener||n));else if(typeof r!="function"){for(u=-1,i=r.length-1;i>=0;i--)if(r[i]===n||r[i].listener===n){f=r[i].listener,u=i;break}if(u<0)return this;u===0?r.shift():V(r,u),r.length===1&&(s[e]=r[0]),s.removeListener!==void 0&&this.emit("removeListener",e,f||n)}return this},o.prototype.off=o.prototype.removeListener,o.prototype.removeAllListeners=function(e){var n,r,s;if(r=this._events,r===void 0)return this;if(r.removeListener===void 0)return arguments.length===0?(this._events=Object.create(null),this._eventsCount=0):r[e]!==void 0&&(--this._eventsCount===0?this._events=Object.create(null):delete r[e]),this;if(arguments.length===0){var u=Object.keys(r),i;for(s=0;s<u.length;++s)i=u[s],i!=="removeListener"&&this.removeAllListeners(i);return this.removeAllListeners("removeListener"),this._events=Object.create(null),this._eventsCount=0,this}if(n=r[e],typeof n=="function")this.removeListener(e,n);else if(n!==void 0)for(s=n.length-1;s>=0;s--)this.removeListener(e,n[s]);return this};function E(t,e,n){var r=t._events;if(r===void 0)return[];var s=r[e];return s===void 0?[]:typeof s=="function"?n?[s.listener||s]:[s]:n?q(s):w(s,s.length)}o.prototype.listeners=function(e){return E(this,e,!0)},o.prototype.rawListeners=function(e){return E(this,e,!1)},o.listenerCount=function(t,e){return typeof t.listenerCount=="function"?t.listenerCount(e):_.call(t,e)},o.prototype.listenerCount=_;function _(t){var e=this._events;if(e!==void 0){var n=e[t];if(typeof n=="function")return 1;if(n!==void 0)return n.length}return 0}o.prototype.eventNames=function(){return this._eventsCount>0?v(this._events):[]};function w(t,e){for(var n=new Array(e),r=0;r<e;++r)n[r]=t[r];return n}function V(t,e){for(;e+1<t.length;e++)t[e]=t[e+1];t.pop()}function q(t){for(var e=new Array(t.length),n=0;n<e.length;++n)e[n]=t[n].listener||t[n];return e}function z(t,e){return new Promise(function(n,r){function s(i){t.removeListener(e,u),r(i)}function u(){typeof t.removeListener=="function"&&t.removeListener("error",s),n([].slice.call(arguments))}C(t,e,u,{once:!0}),e!=="error"&&B(t,s,{once:!0})})}function B(t,e,n){typeof t.on=="function"&&C(t,"error",e,n)}function C(t,e,n,r){if(typeof t.on=="function")r.once?t.once(e,n):t.on(e,n);else if(typeof t.addEventListener=="function")t.addEventListener(e,function s(u){r.once&&t.removeEventListener(e,s),n(u)});else throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type '+typeof t)}class D extends p.exports{constructor(){super()}}class G{constructor(e){this.opts=e,this.protocol="wc",this.version=2}}class Q extends p.exports.EventEmitter{constructor(){super()}}class X{constructor(e){this.client=e}}c.ICore=M,c.ICrypto=R,c.IEchoClient=H,c.IEngine=X,c.IEngineEvents=Q,c.IExpirer=F,c.IJsonRpcHistory=j,c.IKeyChain=K,c.IMessageTracker=x,c.IPairing=W,c.IPublisher=P,c.IRelayer=N,c.ISignClient=G,c.ISignClientEvents=D,c.IStore=S,c.ISubscriber=A,c.ISubscriberTopicMap=T,c.IVerify=k,Object.defineProperty(c,"__esModule",{value:!0})});
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@walletconnect/types"] = {}));
+})(this, (function (exports) { 'use strict';
+
+  class IEvents {
+  }
+
+  class ICore extends IEvents {
+    constructor(opts) {
+      super();
+      this.opts = opts;
+      this.protocol = "wc";
+      this.version = 2;
+    }
+  }
+
+  class ICrypto {
+    constructor(core, logger, keychain) {
+      this.core = core;
+      this.logger = logger;
+    }
+  }
+
+  class IJsonRpcHistory extends IEvents {
+    constructor(core, logger) {
+      super();
+      this.core = core;
+      this.logger = logger;
+      this.records = /* @__PURE__ */ new Map();
+    }
+  }
+
+  class IMessageTracker {
+    constructor(logger, core) {
+      this.logger = logger;
+      this.core = core;
+    }
+  }
+
+  class IPublisher extends IEvents {
+    constructor(relayer, logger) {
+      super();
+      this.relayer = relayer;
+      this.logger = logger;
+    }
+  }
+
+  class IRelayer extends IEvents {
+    constructor(opts) {
+      super();
+    }
+  }
+
+  class IStore {
+    constructor(core, logger, name, storagePrefix) {
+      this.core = core;
+      this.logger = logger;
+      this.name = name;
+    }
+  }
+
+  class ISubscriberTopicMap {
+    constructor() {
+      this.map = /* @__PURE__ */ new Map();
+    }
+  }
+  class ISubscriber extends IEvents {
+    constructor(relayer, logger) {
+      super();
+      this.relayer = relayer;
+      this.logger = logger;
+    }
+  }
+
+  class IKeyChain {
+    constructor(core, logger) {
+      this.core = core;
+      this.logger = logger;
+    }
+  }
+
+  class IExpirer extends IEvents {
+    constructor(core, logger) {
+      super();
+      this.core = core;
+      this.logger = logger;
+    }
+  }
+
+  class IPairing {
+    constructor(logger, core) {
+      this.logger = logger;
+      this.core = core;
+    }
+  }
+
+  class IVerify {
+    constructor(core, logger, store) {
+      this.core = core;
+      this.logger = logger;
+      this.store = store;
+    }
+  }
+
+  class IEchoClient {
+    constructor(projectId, logger) {
+      this.projectId = projectId;
+      this.logger = logger;
+    }
+  }
+
+  var events = {exports: {}};
+
+  var R = typeof Reflect === 'object' ? Reflect : null;
+  var ReflectApply = R && typeof R.apply === 'function'
+    ? R.apply
+    : function ReflectApply(target, receiver, args) {
+      return Function.prototype.apply.call(target, receiver, args);
+    };
+
+  var ReflectOwnKeys;
+  if (R && typeof R.ownKeys === 'function') {
+    ReflectOwnKeys = R.ownKeys;
+  } else if (Object.getOwnPropertySymbols) {
+    ReflectOwnKeys = function ReflectOwnKeys(target) {
+      return Object.getOwnPropertyNames(target)
+        .concat(Object.getOwnPropertySymbols(target));
+    };
+  } else {
+    ReflectOwnKeys = function ReflectOwnKeys(target) {
+      return Object.getOwnPropertyNames(target);
+    };
+  }
+
+  function ProcessEmitWarning(warning) {
+    if (console && console.warn) console.warn(warning);
+  }
+
+  var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+    return value !== value;
+  };
+
+  function EventEmitter() {
+    EventEmitter.init.call(this);
+  }
+  events.exports = EventEmitter;
+  events.exports.once = once;
+
+  // Backwards-compat with node 0.10.x
+  EventEmitter.EventEmitter = EventEmitter;
+
+  EventEmitter.prototype._events = undefined;
+  EventEmitter.prototype._eventsCount = 0;
+  EventEmitter.prototype._maxListeners = undefined;
+
+  // By default EventEmitters will print a warning if more than 10 listeners are
+  // added to it. This is a useful default which helps finding memory leaks.
+  var defaultMaxListeners = 10;
+
+  function checkListener(listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+    }
+  }
+
+  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+    enumerable: true,
+    get: function() {
+      return defaultMaxListeners;
+    },
+    set: function(arg) {
+      if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+      }
+      defaultMaxListeners = arg;
+    }
+  });
+
+  EventEmitter.init = function() {
+
+    if (this._events === undefined ||
+        this._events === Object.getPrototypeOf(this)._events) {
+      this._events = Object.create(null);
+      this._eventsCount = 0;
+    }
+
+    this._maxListeners = this._maxListeners || undefined;
+  };
+
+  // Obviously not all Emitters should be limited to 10. This function allows
+  // that to be increased. Set to zero for unlimited.
+  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+    }
+    this._maxListeners = n;
+    return this;
+  };
+
+  function _getMaxListeners(that) {
+    if (that._maxListeners === undefined)
+      return EventEmitter.defaultMaxListeners;
+    return that._maxListeners;
+  }
+
+  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+    return _getMaxListeners(this);
+  };
+
+  EventEmitter.prototype.emit = function emit(type) {
+    var args = [];
+    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+    var doError = (type === 'error');
+
+    var events = this._events;
+    if (events !== undefined)
+      doError = (doError && events.error === undefined);
+    else if (!doError)
+      return false;
+
+    // If there is no 'error' event listener then throw.
+    if (doError) {
+      var er;
+      if (args.length > 0)
+        er = args[0];
+      if (er instanceof Error) {
+        // Note: The comments on the `throw` lines are intentional, they show
+        // up in Node's output if this results in an unhandled exception.
+        throw er; // Unhandled 'error' event
+      }
+      // At least give some kind of context to the user
+      var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+      err.context = er;
+      throw err; // Unhandled 'error' event
+    }
+
+    var handler = events[type];
+
+    if (handler === undefined)
+      return false;
+
+    if (typeof handler === 'function') {
+      ReflectApply(handler, this, args);
+    } else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        ReflectApply(listeners[i], this, args);
+    }
+
+    return true;
+  };
+
+  function _addListener(target, type, listener, prepend) {
+    var m;
+    var events;
+    var existing;
+
+    checkListener(listener);
+
+    events = target._events;
+    if (events === undefined) {
+      events = target._events = Object.create(null);
+      target._eventsCount = 0;
+    } else {
+      // To avoid recursion in the case that type === "newListener"! Before
+      // adding it to the listeners, first emit "newListener".
+      if (events.newListener !== undefined) {
+        target.emit('newListener', type,
+                    listener.listener ? listener.listener : listener);
+
+        // Re-assign `events` because a newListener handler could have caused the
+        // this._events to be assigned to a new object
+        events = target._events;
+      }
+      existing = events[type];
+    }
+
+    if (existing === undefined) {
+      // Optimize the case of one listener. Don't need the extra array object.
+      existing = events[type] = listener;
+      ++target._eventsCount;
+    } else {
+      if (typeof existing === 'function') {
+        // Adding the second element, need to change to array.
+        existing = events[type] =
+          prepend ? [listener, existing] : [existing, listener];
+        // If we've already got an array, just append.
+      } else if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+
+      // Check for listener leak
+      m = _getMaxListeners(target);
+      if (m > 0 && existing.length > m && !existing.warned) {
+        existing.warned = true;
+        // No error code for this since it is a Warning
+        // eslint-disable-next-line no-restricted-syntax
+        var w = new Error('Possible EventEmitter memory leak detected. ' +
+                            existing.length + ' ' + String(type) + ' listeners ' +
+                            'added. Use emitter.setMaxListeners() to ' +
+                            'increase limit');
+        w.name = 'MaxListenersExceededWarning';
+        w.emitter = target;
+        w.type = type;
+        w.count = existing.length;
+        ProcessEmitWarning(w);
+      }
+    }
+
+    return target;
+  }
+
+  EventEmitter.prototype.addListener = function addListener(type, listener) {
+    return _addListener(this, type, listener, false);
+  };
+
+  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+  EventEmitter.prototype.prependListener =
+      function prependListener(type, listener) {
+        return _addListener(this, type, listener, true);
+      };
+
+  function onceWrapper() {
+    if (!this.fired) {
+      this.target.removeListener(this.type, this.wrapFn);
+      this.fired = true;
+      if (arguments.length === 0)
+        return this.listener.call(this.target);
+      return this.listener.apply(this.target, arguments);
+    }
+  }
+
+  function _onceWrap(target, type, listener) {
+    var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+    var wrapped = onceWrapper.bind(state);
+    wrapped.listener = listener;
+    state.wrapFn = wrapped;
+    return wrapped;
+  }
+
+  EventEmitter.prototype.once = function once(type, listener) {
+    checkListener(listener);
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+  };
+
+  EventEmitter.prototype.prependOnceListener =
+      function prependOnceListener(type, listener) {
+        checkListener(listener);
+        this.prependListener(type, _onceWrap(this, type, listener));
+        return this;
+      };
+
+  // Emits a 'removeListener' event if and only if the listener was removed.
+  EventEmitter.prototype.removeListener =
+      function removeListener(type, listener) {
+        var list, events, position, i, originalListener;
+
+        checkListener(listener);
+
+        events = this._events;
+        if (events === undefined)
+          return this;
+
+        list = events[type];
+        if (list === undefined)
+          return this;
+
+        if (list === listener || list.listener === listener) {
+          if (--this._eventsCount === 0)
+            this._events = Object.create(null);
+          else {
+            delete events[type];
+            if (events.removeListener)
+              this.emit('removeListener', type, list.listener || listener);
+          }
+        } else if (typeof list !== 'function') {
+          position = -1;
+
+          for (i = list.length - 1; i >= 0; i--) {
+            if (list[i] === listener || list[i].listener === listener) {
+              originalListener = list[i].listener;
+              position = i;
+              break;
+            }
+          }
+
+          if (position < 0)
+            return this;
+
+          if (position === 0)
+            list.shift();
+          else {
+            spliceOne(list, position);
+          }
+
+          if (list.length === 1)
+            events[type] = list[0];
+
+          if (events.removeListener !== undefined)
+            this.emit('removeListener', type, originalListener || listener);
+        }
+
+        return this;
+      };
+
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+  EventEmitter.prototype.removeAllListeners =
+      function removeAllListeners(type) {
+        var listeners, events, i;
+
+        events = this._events;
+        if (events === undefined)
+          return this;
+
+        // not listening for removeListener, no need to emit
+        if (events.removeListener === undefined) {
+          if (arguments.length === 0) {
+            this._events = Object.create(null);
+            this._eventsCount = 0;
+          } else if (events[type] !== undefined) {
+            if (--this._eventsCount === 0)
+              this._events = Object.create(null);
+            else
+              delete events[type];
+          }
+          return this;
+        }
+
+        // emit removeListener for all listeners on all events
+        if (arguments.length === 0) {
+          var keys = Object.keys(events);
+          var key;
+          for (i = 0; i < keys.length; ++i) {
+            key = keys[i];
+            if (key === 'removeListener') continue;
+            this.removeAllListeners(key);
+          }
+          this.removeAllListeners('removeListener');
+          this._events = Object.create(null);
+          this._eventsCount = 0;
+          return this;
+        }
+
+        listeners = events[type];
+
+        if (typeof listeners === 'function') {
+          this.removeListener(type, listeners);
+        } else if (listeners !== undefined) {
+          // LIFO order
+          for (i = listeners.length - 1; i >= 0; i--) {
+            this.removeListener(type, listeners[i]);
+          }
+        }
+
+        return this;
+      };
+
+  function _listeners(target, type, unwrap) {
+    var events = target._events;
+
+    if (events === undefined)
+      return [];
+
+    var evlistener = events[type];
+    if (evlistener === undefined)
+      return [];
+
+    if (typeof evlistener === 'function')
+      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+    return unwrap ?
+      unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+  }
+
+  EventEmitter.prototype.listeners = function listeners(type) {
+    return _listeners(this, type, true);
+  };
+
+  EventEmitter.prototype.rawListeners = function rawListeners(type) {
+    return _listeners(this, type, false);
+  };
+
+  EventEmitter.listenerCount = function(emitter, type) {
+    if (typeof emitter.listenerCount === 'function') {
+      return emitter.listenerCount(type);
+    } else {
+      return listenerCount.call(emitter, type);
+    }
+  };
+
+  EventEmitter.prototype.listenerCount = listenerCount;
+  function listenerCount(type) {
+    var events = this._events;
+
+    if (events !== undefined) {
+      var evlistener = events[type];
+
+      if (typeof evlistener === 'function') {
+        return 1;
+      } else if (evlistener !== undefined) {
+        return evlistener.length;
+      }
+    }
+
+    return 0;
+  }
+
+  EventEmitter.prototype.eventNames = function eventNames() {
+    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+  };
+
+  function arrayClone(arr, n) {
+    var copy = new Array(n);
+    for (var i = 0; i < n; ++i)
+      copy[i] = arr[i];
+    return copy;
+  }
+
+  function spliceOne(list, index) {
+    for (; index + 1 < list.length; index++)
+      list[index] = list[index + 1];
+    list.pop();
+  }
+
+  function unwrapListeners(arr) {
+    var ret = new Array(arr.length);
+    for (var i = 0; i < ret.length; ++i) {
+      ret[i] = arr[i].listener || arr[i];
+    }
+    return ret;
+  }
+
+  function once(emitter, name) {
+    return new Promise(function (resolve, reject) {
+      function errorListener(err) {
+        emitter.removeListener(name, resolver);
+        reject(err);
+      }
+
+      function resolver() {
+        if (typeof emitter.removeListener === 'function') {
+          emitter.removeListener('error', errorListener);
+        }
+        resolve([].slice.call(arguments));
+      }
+      eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+      if (name !== 'error') {
+        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+      }
+    });
+  }
+
+  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+    if (typeof emitter.on === 'function') {
+      eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+    }
+  }
+
+  function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+    if (typeof emitter.on === 'function') {
+      if (flags.once) {
+        emitter.once(name, listener);
+      } else {
+        emitter.on(name, listener);
+      }
+    } else if (typeof emitter.addEventListener === 'function') {
+      // EventTarget does not have `error` event semantics like Node
+      // EventEmitters, we do not listen for `error` events here.
+      emitter.addEventListener(name, function wrapListener(arg) {
+        // IE does not have builtin `{ once: true }` support so we
+        // have to do it manually.
+        if (flags.once) {
+          emitter.removeEventListener(name, wrapListener);
+        }
+        listener(arg);
+      });
+    } else {
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+    }
+  }
+
+  class ISignClientEvents extends events.exports {
+    constructor() {
+      super();
+    }
+  }
+  class ISignClient {
+    constructor(opts) {
+      this.opts = opts;
+      this.protocol = "wc";
+      this.version = 2;
+    }
+  }
+
+  class IEngineEvents extends events.exports.EventEmitter {
+    constructor() {
+      super();
+    }
+  }
+  class IEngine {
+    constructor(client) {
+      this.client = client;
+    }
+  }
+
+  exports.ICore = ICore;
+  exports.ICrypto = ICrypto;
+  exports.IEchoClient = IEchoClient;
+  exports.IEngine = IEngine;
+  exports.IEngineEvents = IEngineEvents;
+  exports.IExpirer = IExpirer;
+  exports.IJsonRpcHistory = IJsonRpcHistory;
+  exports.IKeyChain = IKeyChain;
+  exports.IMessageTracker = IMessageTracker;
+  exports.IPairing = IPairing;
+  exports.IPublisher = IPublisher;
+  exports.IRelayer = IRelayer;
+  exports.ISignClient = ISignClient;
+  exports.ISignClientEvents = ISignClientEvents;
+  exports.IStore = IStore;
+  exports.ISubscriber = ISubscriber;
+  exports.ISubscriberTopicMap = ISubscriberTopicMap;
+  exports.IVerify = IVerify;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
 //# sourceMappingURL=index.umd.js.map

package.json

 {
   "name": "@walletconnect/types",
   "description": "Typings for WalletConnect Protocol",
-  "version": "2.15.0-canary-lm.7",
+  "version": "2.15.0-canary-lm.8",
   "author": "WalletConnect, Inc. <walletconnect.com>",
@@ -6,0 +6,0 @@ "homepage": "https://github.com/walletconnect/walletconnect-monorepo/",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

325618

increased by4.67%

Lines of code

2088

increased by55.94%

Number of low quality alerts

1

decreased by-50%

No dependency changes