@snapshot-labs/snapshot.js 0.11.38 → 0.12.0-beta.1

package/dist/snapshot.cjs.js

@@ -13,6 +13,7 @@ var addErrors = require('ajv-errors');
 var set = require('lodash.set');
 var providers$1 = require('@ethersproject/providers');
 var bytes = require('@ethersproject/bytes');
+var starknet$1 = require('starknet');
 var wallet = require('@ethersproject/wallet');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -38,17 +39,6 @@ See the Apache Version 2.0 License for specific language governing permissions
 and limitations under the License.
 ***************************************************************************** */
 
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
 function __rest(s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -69,256 +59,205 @@ function __awaiter(thisArg, _arguments, P, generator) {
         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
 }
 
-var spaceTypes = {
-    Space: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'settings', type: 'string' }
-    ]
-};
-var proposalTypes = {
-    Proposal: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'type', type: 'string' },
-        { name: 'title', type: 'string' },
-        { name: 'body', type: 'string' },
-        { name: 'discussion', type: 'string' },
-        { name: 'choices', type: 'string[]' },
-        { name: 'start', type: 'uint64' },
-        { name: 'end', type: 'uint64' },
-        { name: 'snapshot', type: 'uint64' },
-        { name: 'plugins', type: 'string' },
-        { name: 'app', type: 'string' }
-    ]
-};
-var updateProposalTypes = {
-    UpdateProposal: [
-        { name: 'proposal', type: 'string' },
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'type', type: 'string' },
-        { name: 'title', type: 'string' },
-        { name: 'body', type: 'string' },
-        { name: 'discussion', type: 'string' },
-        { name: 'choices', type: 'string[]' },
-        { name: 'plugins', type: 'string' }
-    ]
-};
-var flagProposalTypes = {
-    FlagProposal: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'proposal', type: 'string' },
-        { name: 'timestamp', type: 'uint64' }
-    ]
-};
-var cancelProposalTypes = {
-    CancelProposal: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'string' }
-    ]
-};
-var cancelProposal2Types = {
-    CancelProposal: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'bytes32' }
-    ]
-};
-var voteTypes = {
-    Vote: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'string' },
-        { name: 'choice', type: 'uint32' },
-        { name: 'reason', type: 'string' },
-        { name: 'app', type: 'string' },
-        { name: 'metadata', type: 'string' }
-    ]
-};
-var voteArrayTypes = {
-    Vote: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'string' },
-        { name: 'choice', type: 'uint32[]' },
-        { name: 'reason', type: 'string' },
-        { name: 'app', type: 'string' },
-        { name: 'metadata', type: 'string' }
-    ]
-};
-var voteStringTypes = {
-    Vote: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'string' },
-        { name: 'choice', type: 'string' },
-        { name: 'reason', type: 'string' },
-        { name: 'app', type: 'string' },
-        { name: 'metadata', type: 'string' }
-    ]
-};
-var vote2Types = {
-    Vote: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'bytes32' },
-        { name: 'choice', type: 'uint32' },
-        { name: 'reason', type: 'string' },
-        { name: 'app', type: 'string' },
-        { name: 'metadata', type: 'string' }
-    ]
-};
-var voteArray2Types = {
-    Vote: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'bytes32' },
-        { name: 'choice', type: 'uint32[]' },
-        { name: 'reason', type: 'string' },
-        { name: 'app', type: 'string' },
-        { name: 'metadata', type: 'string' }
-    ]
-};
-var voteString2Types = {
-    Vote: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'proposal', type: 'bytes32' },
-        { name: 'choice', type: 'string' },
-        { name: 'reason', type: 'string' },
-        { name: 'app', type: 'string' },
-        { name: 'metadata', type: 'string' }
-    ]
-};
-var followTypes = {
-    Follow: [
-        { name: 'from', type: 'address' },
-        { name: 'network', type: 'string' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' }
-    ]
-};
-var unfollowTypes = {
-    Unfollow: [
-        { name: 'from', type: 'address' },
-        { name: 'network', type: 'string' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' }
-    ]
-};
-var subscribeTypes = {
-    Subscribe: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' }
-    ]
-};
-var unsubscribeTypes = {
-    Unsubscribe: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' }
-    ]
-};
-var profileTypes = {
-    Profile: [
-        { name: 'from', type: 'address' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'profile', type: 'string' }
-    ]
-};
-var statementTypes = {
-    Statement: [
-        { name: 'from', type: 'address' },
-        { name: 'timestamp', type: 'uint64' },
-        { name: 'space', type: 'string' },
-        { name: 'about', type: 'string' },
-        { name: 'statement', type: 'string' },
-        { name: 'discourse', type: 'string' },
-        { name: 'status', type: 'string' },
-        { name: 'network', type: 'string' }
-    ]
-};
-var aliasTypes = {
-    Alias: [
-        { name: 'from', type: 'address' },
-        { name: 'alias', type: 'address' },
-        { name: 'timestamp', type: 'uint64' }
-    ]
-};
-var deleteSpaceType = {
-    DeleteSpace: [
-        { name: 'from', type: 'address' },
-        { name: 'space', type: 'string' },
-        { name: 'timestamp', type: 'uint64' }
-    ]
+const spaceTypes = {
+    Space: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'settings', type: 'string' }
+    ]
+};
+const proposalTypes = {
+    Proposal: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'type', type: 'string' },
+        { name: 'title', type: 'string' },
+        { name: 'body', type: 'string' },
+        { name: 'discussion', type: 'string' },
+        { name: 'choices', type: 'string[]' },
+        { name: 'start', type: 'uint64' },
+        { name: 'end', type: 'uint64' },
+        { name: 'snapshot', type: 'uint64' },
+        { name: 'plugins', type: 'string' },
+        { name: 'app', type: 'string' }
+    ]
+};
+const updateProposalTypes = {
+    UpdateProposal: [
+        { name: 'proposal', type: 'string' },
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'type', type: 'string' },
+        { name: 'title', type: 'string' },
+        { name: 'body', type: 'string' },
+        { name: 'discussion', type: 'string' },
+        { name: 'choices', type: 'string[]' },
+        { name: 'plugins', type: 'string' }
+    ]
+};
+const flagProposalTypes = {
+    FlagProposal: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'proposal', type: 'string' },
+        { name: 'timestamp', type: 'uint64' }
+    ]
+};
+const cancelProposalTypes = {
+    CancelProposal: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'string' }
+    ]
+};
+const cancelProposal2Types = {
+    CancelProposal: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'bytes32' }
+    ]
+};
+const voteTypes = {
+    Vote: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'string' },
+        { name: 'choice', type: 'uint32' },
+        { name: 'reason', type: 'string' },
+        { name: 'app', type: 'string' },
+        { name: 'metadata', type: 'string' }
+    ]
+};
+const voteArrayTypes = {
+    Vote: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'string' },
+        { name: 'choice', type: 'uint32[]' },
+        { name: 'reason', type: 'string' },
+        { name: 'app', type: 'string' },
+        { name: 'metadata', type: 'string' }
+    ]
+};
+const voteStringTypes = {
+    Vote: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'string' },
+        { name: 'choice', type: 'string' },
+        { name: 'reason', type: 'string' },
+        { name: 'app', type: 'string' },
+        { name: 'metadata', type: 'string' }
+    ]
+};
+const vote2Types = {
+    Vote: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'bytes32' },
+        { name: 'choice', type: 'uint32' },
+        { name: 'reason', type: 'string' },
+        { name: 'app', type: 'string' },
+        { name: 'metadata', type: 'string' }
+    ]
+};
+const voteArray2Types = {
+    Vote: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'bytes32' },
+        { name: 'choice', type: 'uint32[]' },
+        { name: 'reason', type: 'string' },
+        { name: 'app', type: 'string' },
+        { name: 'metadata', type: 'string' }
+    ]
+};
+const voteString2Types = {
+    Vote: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'proposal', type: 'bytes32' },
+        { name: 'choice', type: 'string' },
+        { name: 'reason', type: 'string' },
+        { name: 'app', type: 'string' },
+        { name: 'metadata', type: 'string' }
+    ]
+};
+const followTypes = {
+    Follow: [
+        { name: 'from', type: 'address' },
+        { name: 'network', type: 'string' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' }
+    ]
+};
+const unfollowTypes = {
+    Unfollow: [
+        { name: 'from', type: 'address' },
+        { name: 'network', type: 'string' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' }
+    ]
+};
+const subscribeTypes = {
+    Subscribe: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' }
+    ]
+};
+const unsubscribeTypes = {
+    Unsubscribe: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' }
+    ]
+};
+const profileTypes = {
+    Profile: [
+        { name: 'from', type: 'address' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'profile', type: 'string' }
+    ]
+};
+const statementTypes = {
+    Statement: [
+        { name: 'from', type: 'address' },
+        { name: 'timestamp', type: 'uint64' },
+        { name: 'space', type: 'string' },
+        { name: 'about', type: 'string' },
+        { name: 'statement', type: 'string' },
+        { name: 'discourse', type: 'string' },
+        { name: 'status', type: 'string' },
+        { name: 'network', type: 'string' }
+    ]
+};
+const aliasTypes = {
+    Alias: [
+        { name: 'from', type: 'address' },
+        { name: 'alias', type: 'address' },
+        { name: 'timestamp', type: 'uint64' }
+    ]
+};
+const deleteSpaceType = {
+    DeleteSpace: [
+        { name: 'from', type: 'address' },
+        { name: 'space', type: 'string' },
+        { name: 'timestamp', type: 'uint64' }
+    ]
 };
 
 var livenet = {
@@ -339,255 +278,163 @@ var constants = {
 	local: local
 };
 
-var NAME = 'snapshot';
-var VERSION = '0.1.4';
-var domain = {
-    name: NAME,
-    version: VERSION
-    // chainId: 1
-};
-var Client = /** @class */ (function () {
-    function Client(address, options) {
-        if (address === void 0) { address = constants.livenet.sequencer; }
-        if (options === void 0) { options = {}; }
-        address = address.replace(constants.livenet.hub, constants.livenet.sequencer);
-        address = address.replace(constants.testnet.hub, constants.testnet.sequencer);
-        address = address.replace(constants.local.hub, constants.local.sequencer);
-        this.address = address;
-        this.options = options;
-    }
-    Client.prototype.sign = function (web3, address$1, message, types) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var signer, checksumAddress, domainData, _b, data, sig;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        signer = (web3 === null || web3 === void 0 ? void 0 : web3.getSigner) ? web3.getSigner() : web3;
-                        checksumAddress = address.getAddress(address$1);
-                        message.from = message.from ? address.getAddress(message.from) : checksumAddress;
-                        if (!message.timestamp)
-                            message.timestamp = parseInt((Date.now() / 1e3).toFixed());
-                        domainData = __assign({}, domain);
-                        if (!(typeof window !== 'undefined' && ((_a = window.ethereum) === null || _a === void 0 ? void 0 : _a.isTrust))) return [3 /*break*/, 2];
-                        _b = domainData;
-                        return [4 /*yield*/, signer.provider.getNetwork()];
-                    case 1:
-                        _b.chainId = (_c.sent()).chainId;
-                        _c.label = 2;
-                    case 2:
-                        data = { domain: domainData, types: types, message: message };
-                        return [4 /*yield*/, signer._signTypedData(domainData, data.types, message)];
-                    case 3:
-                        sig = _c.sent();
-                        return [4 /*yield*/, this.send({ address: checksumAddress, sig: sig, data: data })];
-                    case 4: return [2 /*return*/, _c.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.send = function (envelop) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address, init;
-            return __generator(this, function (_a) {
-                address = this.address;
-                if (envelop.sig === '0x' && this.options.relayerURL)
-                    address = this.options.relayerURL;
-                init = {
-                    method: 'POST',
-                    headers: {
-                        Accept: 'application/json',
-                        'Content-Type': 'application/json'
-                    },
-                    body: JSON.stringify(envelop)
-                };
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        fetch__default['default'](address, init)
-                            .then(function (res) {
-                            var _a;
-                            if (res.ok)
-                                return resolve(res.json());
-                            if ((_a = res.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('application/json'))
-                                return res.json().then(reject).catch(reject);
-                            throw res;
-                        })
-                            .catch(reject);
-                    })];
-            });
-        });
-    };
-    Client.prototype.space = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, spaceTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.proposal = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!message.discussion)
-                            message.discussion = '';
-                        if (!message.app)
-                            message.app = '';
-                        return [4 /*yield*/, this.sign(web3, address, message, proposalTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.updateProposal = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, updateProposalTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.flagProposal = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, flagProposalTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.cancelProposal = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            var type2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        type2 = message.proposal.startsWith('0x');
-                        return [4 /*yield*/, this.sign(web3, address, message, type2 ? cancelProposal2Types : cancelProposalTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.vote = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            var isShutter, type2, type;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        isShutter = (message === null || message === void 0 ? void 0 : message.privacy) === 'shutter';
-                        if (!message.reason)
-                            message.reason = '';
-                        if (!message.app)
-                            message.app = '';
-                        if (!message.metadata)
-                            message.metadata = '{}';
-                        type2 = message.proposal.startsWith('0x');
-                        type = type2 ? vote2Types : voteTypes;
-                        if (['approval', 'ranked-choice'].includes(message.type))
-                            type = type2 ? voteArray2Types : voteArrayTypes;
-                        if (!isShutter && ['quadratic', 'weighted'].includes(message.type)) {
-                            type = type2 ? voteString2Types : voteStringTypes;
-                            message.choice = JSON.stringify(message.choice);
-                        }
-                        if (isShutter)
-                            type = type2 ? voteString2Types : voteStringTypes;
-                        delete message.privacy;
-                        // @ts-ignore
-                        delete message.type;
-                        return [4 /*yield*/, this.sign(web3, address, message, type)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.follow = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, followTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.unfollow = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, unfollowTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.subscribe = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, subscribeTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.unsubscribe = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, unsubscribeTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.profile = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, profileTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.statement = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, statementTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.alias = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, aliasTypes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    Client.prototype.deleteSpace = function (web3, address, message) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(web3, address, message, deleteSpaceType)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    return Client;
-}());
+const NAME = 'snapshot';
+const VERSION = '0.1.4';
+const domain = {
+    name: NAME,
+    version: VERSION
+    // chainId: 1
+};
+class Client {
+    constructor(address = constants.livenet.sequencer, options = {}) {
+        address = address.replace(constants.livenet.hub, constants.livenet.sequencer);
+        address = address.replace(constants.testnet.hub, constants.testnet.sequencer);
+        address = address.replace(constants.local.hub, constants.local.sequencer);
+        this.address = address;
+        this.options = options;
+    }
+    sign(web3, address$1, message, types) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // @ts-ignore
+            const signer = (web3 === null || web3 === void 0 ? void 0 : web3.getSigner) ? web3.getSigner() : web3;
+            const checksumAddress = address.getAddress(address$1);
+            message.from = message.from ? address.getAddress(message.from) : checksumAddress;
+            if (!message.timestamp)
+                message.timestamp = parseInt((Date.now() / 1e3).toFixed());
+            const domainData = Object.assign({}, domain);
+            // @ts-ignore
+            if (typeof window !== 'undefined' && ((_a = window.ethereum) === null || _a === void 0 ? void 0 : _a.isTrust)) {
+                domainData.chainId = (yield signer.provider.getNetwork()).chainId;
+            }
+            const data = { domain: domainData, types, message };
+            const sig = yield signer._signTypedData(domainData, data.types, message);
+            return yield this.send({ address: checksumAddress, sig, data });
+        });
+    }
+    send(envelop) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let address = this.address;
+            if (envelop.sig === '0x' && this.options.relayerURL)
+                address = this.options.relayerURL;
+            const init = {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(envelop)
+            };
+            return new Promise((resolve, reject) => {
+                fetch__default['default'](address, init)
+                    .then((res) => {
+                    var _a;
+                    if (res.ok)
+                        return resolve(res.json());
+                    if ((_a = res.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('application/json'))
+                        return res.json().then(reject).catch(reject);
+                    throw res;
+                })
+                    .catch(reject);
+            });
+        });
+    }
+    space(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, spaceTypes);
+        });
+    }
+    proposal(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!message.discussion)
+                message.discussion = '';
+            if (!message.app)
+                message.app = '';
+            return yield this.sign(web3, address, message, proposalTypes);
+        });
+    }
+    updateProposal(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, updateProposalTypes);
+        });
+    }
+    flagProposal(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, flagProposalTypes);
+        });
+    }
+    cancelProposal(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type2 = message.proposal.startsWith('0x');
+            return yield this.sign(web3, address, message, type2 ? cancelProposal2Types : cancelProposalTypes);
+        });
+    }
+    vote(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isShutter = (message === null || message === void 0 ? void 0 : message.privacy) === 'shutter';
+            if (!message.reason)
+                message.reason = '';
+            if (!message.app)
+                message.app = '';
+            if (!message.metadata)
+                message.metadata = '{}';
+            const type2 = message.proposal.startsWith('0x');
+            let type = type2 ? vote2Types : voteTypes;
+            if (['approval', 'ranked-choice'].includes(message.type))
+                type = type2 ? voteArray2Types : voteArrayTypes;
+            if (!isShutter && ['quadratic', 'weighted'].includes(message.type)) {
+                type = type2 ? voteString2Types : voteStringTypes;
+                message.choice = JSON.stringify(message.choice);
+            }
+            if (isShutter)
+                type = type2 ? voteString2Types : voteStringTypes;
+            delete message.privacy;
+            // @ts-ignore
+            delete message.type;
+            return yield this.sign(web3, address, message, type);
+        });
+    }
+    follow(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, followTypes);
+        });
+    }
+    unfollow(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, unfollowTypes);
+        });
+    }
+    subscribe(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, subscribeTypes);
+        });
+    }
+    unsubscribe(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, unsubscribeTypes);
+        });
+    }
+    profile(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, profileTypes);
+        });
+    }
+    statement(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, statementTypes);
+        });
+    }
+    alias(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, aliasTypes);
+        });
+    }
+    deleteSpace(web3, address, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sign(web3, address, message, deleteSpaceType);
+        });
+    }
+}
 
 var $schema = "http://json-schema.org/draft-07/schema#";
 var $ref = "#/definitions/Space";
@@ -1436,250 +1283,254 @@ var alias = {
 	definitions: definitions$7
 };
 
-var schemas = {
-    space: space.definitions.Space,
-    proposal: proposal.definitions.Proposal,
-    updateProposal: updateProposal.definitions.UpdateProposal,
-    vote: vote.definitions.Vote,
-    profile: profile.definitions.Profile,
-    statement: statement.definitions.Statement,
-    zodiac: zodiac.definitions.Zodiac,
-    alias: alias.definitions.Alias
+var schemas = {
+    space: space.definitions.Space,
+    proposal: proposal.definitions.Proposal,
+    updateProposal: updateProposal.definitions.UpdateProposal,
+    vote: vote.definitions.Vote,
+    profile: profile.definitions.Profile,
+    statement: statement.definitions.Statement,
+    zodiac: zodiac.definitions.Zodiac,
+    alias: alias.definitions.Alias
 };
 
-var Multicaller = /** @class */ (function () {
-    function Multicaller(network, provider, abi, options) {
-        this.options = {};
-        this.calls = [];
-        this.paths = [];
-        this.network = network;
-        this.provider = provider;
-        this.abi = abi;
-        this.options = options || {};
-    }
-    Multicaller.prototype.call = function (path, address, fn, params) {
-        this.calls.push([address, fn, params]);
-        this.paths.push(path);
-        return this;
-    };
-    Multicaller.prototype.execute = function (from) {
-        return __awaiter(this, void 0, void 0, function () {
-            var obj, result;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        obj = from || {};
-                        return [4 /*yield*/, multicall(this.network, this.provider, this.abi, this.calls, this.options)];
-                    case 1:
-                        result = _a.sent();
-                        result.forEach(function (r, i) { return set__default['default'](obj, _this.paths[i], r.length > 1 ? r : r[0]); });
-                        this.calls = [];
-                        this.paths = [];
-                        return [2 /*return*/, obj];
-                }
-            });
-        });
-    };
-    return Multicaller;
-}());
+class Multicaller {
+    constructor(network, provider, abi, options) {
+        this.options = {};
+        this.calls = [];
+        this.paths = [];
+        this.network = network;
+        this.provider = provider;
+        this.abi = abi;
+        this.options = options || {};
+    }
+    call(path, address, fn, params) {
+        this.calls.push([address, fn, params]);
+        this.paths.push(path);
+        return this;
+    }
+    execute(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const obj = from || {};
+            const result = yield multicall(this.network, this.provider, this.abi, this.calls, this.options);
+            result.forEach((r, i) => set__default['default'](obj, this.paths[i], r.length > 1 ? r : r[0]));
+            this.calls = [];
+            this.paths = [];
+            return obj;
+        });
+    }
+}
 
-var cache = {};
-var expirationTime = 0;
-function getSnapshots(network, snapshot, provider, networks, options) {
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var snapshots, cacheKey, cachedEntry, now, networkIn, block, query, url, data;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    snapshots = {};
-                    networks.forEach(function (n) { return (snapshots[n] = 'latest'); });
-                    if (snapshot === 'latest')
-                        return [2 /*return*/, snapshots];
-                    cacheKey = network + "-" + snapshot + "-" + networks.join('-');
-                    cachedEntry = cache[cacheKey];
-                    now = Date.now();
-                    if (cachedEntry && expirationTime > now) {
-                        return [2 /*return*/, cachedEntry];
-                    }
-                    // Reset cache every hour
-                    if (expirationTime < now) {
-                        cache = {};
-                        // Set expiration time to next hour
-                        expirationTime = now + 60 * 60 * 1000 - (now % (60 * 60 * 1000));
-                    }
-                    snapshots[network] = snapshot;
-                    networkIn = Object.keys(snapshots).filter(function (s) { return network !== s; });
-                    if (networkIn.length === 0)
-                        return [2 /*return*/, snapshots];
-                    return [4 /*yield*/, provider.getBlock(snapshot)];
-                case 1:
-                    block = _a.sent();
-                    query = {
-                        blocks: {
-                            __args: {
-                                where: {
-                                    ts: block.timestamp,
-                                    network_in: networkIn
-                                }
-                            },
-                            network: true,
-                            number: true
-                        }
-                    };
-                    url = options.blockFinderUrl || 'https://blockfinder.snapshot.org';
-                    return [4 /*yield*/, subgraphRequest(url, query)];
-                case 2:
-                    data = _a.sent();
-                    data.blocks.forEach(function (block) { return (snapshots[block.network] = block.number); });
-                    cache[cacheKey] = snapshots;
-                    return [2 /*return*/, snapshots];
-            }
-        });
-    });
+let cache = {};
+let expirationTime = 0;
+function getSnapshots(network_1, snapshot_1, provider_1, networks_1) {
+    return __awaiter(this, arguments, void 0, function* (network, snapshot, provider, networks, options = {}) {
+        // If snapshot is latest, return all latest
+        const snapshots = {};
+        networks.forEach((n) => (snapshots[n] = 'latest'));
+        if (snapshot === 'latest')
+            return snapshots;
+        // Check if cache is valid
+        const cacheKey = `${network}-${snapshot}-${networks.join('-')}`;
+        const cachedEntry = cache[cacheKey];
+        const now = Date.now();
+        if (cachedEntry && expirationTime > now) {
+            return cachedEntry;
+        }
+        // Reset cache every hour
+        if (expirationTime < now) {
+            cache = {};
+            // Set expiration time to next hour
+            expirationTime = now + 60 * 60 * 1000 - (now % (60 * 60 * 1000));
+        }
+        snapshots[network] = snapshot;
+        const networkIn = Object.keys(snapshots).filter((s) => network !== s);
+        if (networkIn.length === 0)
+            return snapshots;
+        const block = yield provider.getBlock(snapshot);
+        const query = {
+            blocks: {
+                __args: {
+                    where: {
+                        ts: block.timestamp,
+                        network_in: networkIn
+                    }
+                },
+                network: true,
+                number: true
+            }
+        };
+        const url = options.blockFinderUrl || 'https://blockfinder.snapshot.org';
+        const data = yield subgraphRequest(url, query);
+        data.blocks.forEach((block) => (snapshots[block.network] = block.number));
+        cache[cacheKey] = snapshots;
+        return snapshots;
+    });
 }
 
-var providers = {};
-function getProvider(network, _a) {
-    var _b = (_a === void 0 ? {} : _a).broviderUrl, broviderUrl = _b === void 0 ? 'https://rpc.snapshot.org' : _b;
-    var url = broviderUrl + "/" + network;
-    if (!providers[network])
-        providers[network] = new providers$1.StaticJsonRpcProvider({
-            url: url,
-            timeout: 25000,
-            allowGzip: true
-        }, Number(network));
-    return providers[network];
+const providers = {};
+const DEFAULT_BROVIDER_URL = 'https://rpc.snapshot.org';
+function getProvider(network, { broviderUrl = DEFAULT_BROVIDER_URL } = {}) {
+    const url = `${broviderUrl}/${network}`;
+    if (!providers[network])
+        providers[network] = new providers$1.StaticJsonRpcProvider({
+            url,
+            timeout: 25000,
+            allowGzip: true
+        }, Number(network));
+    return providers[network];
 }
 
-function signMessage(web3, msg, address) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    msg = bytes.hexlify(new Buffer(msg, 'utf8'));
-                    return [4 /*yield*/, web3.send('personal_sign', [msg, address])];
-                case 1: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
-function getBlockNumber(provider) {
-    return __awaiter(this, void 0, void 0, function () {
-        var blockNumber, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, provider.getBlockNumber()];
-                case 1:
-                    blockNumber = _a.sent();
-                    return [2 /*return*/, parseInt(blockNumber)];
-                case 2:
-                    e_1 = _a.sent();
-                    return [2 /*return*/, Promise.reject()];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+function signMessage(web3, msg, address) {
+    return __awaiter(this, void 0, void 0, function* () {
+        msg = bytes.hexlify(new Buffer(msg, 'utf8'));
+        return yield web3.send('personal_sign', [msg, address]);
+    });
+}
+function getBlockNumber(provider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const blockNumber = yield provider.getBlockNumber();
+            return parseInt(blockNumber);
+        }
+        catch (e) {
+            return Promise.reject();
+        }
+    });
 }
 
-function verifyDefault(address, sig, hash, provider) {
-    return __awaiter(this, void 0, void 0, function () {
-        var returnValue, magicValue, abi, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    magicValue = '0x1626ba7e';
-                    abi = 'function isValidSignature(bytes32 _hash, bytes memory _signature) public view returns (bytes4 magicValue)';
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, call(provider, [abi], [address, 'isValidSignature', [bytes.arrayify(hash), sig]])];
-                case 2:
-                    returnValue = _a.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    // @ts-ignore
-                    if (e_1.message.startsWith('missing revert data in call exception')) {
-                        return [2 /*return*/, false];
-                    }
-                    throw e_1;
-                case 4: return [2 /*return*/, returnValue.toLowerCase() === magicValue.toLowerCase()];
-            }
-        });
-    });
-}
-function verifyOldVersion(address, sig, hash, provider) {
-    return __awaiter(this, void 0, void 0, function () {
-        var magicValue, abi, returnValue;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    magicValue = '0x20c13b0b';
-                    abi = 'function isValidSignature(bytes _hash, bytes memory _signature) public view returns (bytes4 magicValue)';
-                    return [4 /*yield*/, call(provider, [abi], [address, 'isValidSignature', [bytes.arrayify(hash), sig]])];
-                case 1:
-                    returnValue = _a.sent();
-                    return [2 /*return*/, returnValue.toLowerCase() === magicValue.toLowerCase()];
-            }
-        });
-    });
-}
-function verify(address, sig, hash, network, options) {
-    if (network === void 0) { network = '1'; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var provider;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    provider = getProvider(network, options);
-                    return [4 /*yield*/, verifyDefault(address, sig, hash, provider)];
-                case 1:
-                    if (_a.sent())
-                        return [2 /*return*/, true];
-                    return [4 /*yield*/, verifyOldVersion(address, sig, hash, provider)];
-                case 2: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
+const RPC_URLS = {
+    SN_MAIN: 'https://starknet-mainnet.public.blastapi.io',
+    SN_SEPOLIA: 'https://starknet-sepolia.public.blastapi.io'
+};
+const ABI = [
+    {
+        name: 'argent::account::interface::IDeprecatedArgentAccount',
+        type: 'interface',
+        items: [
+            {
+                name: 'isValidSignature',
+                type: 'function',
+                inputs: [
+                    {
+                        name: 'hash',
+                        type: 'core::felt252'
+                    },
+                    {
+                        name: 'signatures',
+                        type: 'core::array::Array::<core::felt252>'
+                    }
+                ],
+                outputs: [
+                    {
+                        type: 'core::felt252'
+                    }
+                ],
+                state_mutability: 'view'
+            }
+        ]
+    }
+];
+function getProvider$1(network, options) {
+    var _a;
+    if (!RPC_URLS[network])
+        throw new Error('Invalid network');
+    return new starknet$1.RpcProvider({
+        nodeUrl: (_a = options === null || options === void 0 ? void 0 : options.broviderUrl) !== null && _a !== void 0 ? _a : RPC_URLS[network]
+    });
+}
+function isStarknetMessage(data) {
+    return !!data.primaryType && !!data.types.StarkNetDomain;
+}
+function getHash(data, address) {
+    const { domain, types, primaryType, message } = data;
+    return starknet$1.typedData.getMessageHash({ types, primaryType, domain, message }, address);
+}
+function verify(address_1, sig_1, data_1) {
+    return __awaiter(this, arguments, void 0, function* (address, sig, data, network = 'SN_MAIN', options = {}) {
+        const contractAccount = new starknet$1.Contract(ABI, address, getProvider$1(network, options));
+        yield contractAccount.isValidSignature(getHash(data, address), [
+            sig[0],
+            sig[1]
+        ]);
+        return true;
+    });
 }
 
-function getHash(data) {
-    var domain = data.domain, types = data.types, message = data.message;
-    return hash._TypedDataEncoder.hash(domain, types, message);
-}
-function verify$1(address, sig, data, network, options) {
-    if (network === void 0) { network = '1'; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var domain, types, message, hash, recoverAddress;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    domain = data.domain, types = data.types, message = data.message;
-                    hash = getHash(data);
-                    // console.log('Hash', hash);
-                    // console.log('Address', address);
-                    try {
-                        recoverAddress = wallet.verifyTypedData(domain, types, message, sig);
-                        // console.log('Recover address', recoverAddress);
-                        if (address === recoverAddress)
-                            return [2 /*return*/, true];
-                    }
-                    catch (e) {
-                        // console.log('Could not recoverAddress:' + e.message);
-                    }
-                    return [4 /*yield*/, verify(address, sig, hash, network, options)];
-                case 1: 
-                // console.log('Check EIP1271 signature');
-                return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
+var starknet = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isStarknetMessage: isStarknetMessage,
+    getHash: getHash,
+    'default': verify
+});
+
+function isEqual(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+function getHash$1(data) {
+    const { domain, types, message } = data;
+    return hash._TypedDataEncoder.hash(domain, types, message);
+}
+function verify$1(address_1, sig_1, data_1) {
+    return __awaiter(this, arguments, void 0, function* (address, sig, data, network = '1', options = {}) {
+        const { domain, types, message } = data;
+        try {
+            const recoverAddress = wallet.verifyTypedData(domain, types, message, sig);
+            if (isEqual(address, recoverAddress))
+                return true;
+        }
+        catch (e) { }
+        const provider = getProvider(network, options);
+        const hash = getHash$1(data);
+        if (yield verifyDefault(address, sig, hash, provider))
+            return true;
+        return yield verifyOldVersion(address, sig, hash, provider);
+    });
+}
+function verifyDefault(address, sig, hash, provider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let returnValue;
+        const magicValue = '0x1626ba7e';
+        const abi = 'function isValidSignature(bytes32 _hash, bytes memory _signature) public view returns (bytes4 magicValue)';
+        try {
+            returnValue = yield call(provider, [abi], [address, 'isValidSignature', [bytes.arrayify(hash), sig]]);
+        }
+        catch (e) {
+            if (e.message.startsWith('missing revert data in call exception')) {
+                return false;
+            }
+            throw e;
+        }
+        return isEqual(returnValue, magicValue);
+    });
+}
+function verifyOldVersion(address, sig, hash, provider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const magicValue = '0x20c13b0b';
+        const abi = 'function isValidSignature(bytes _hash, bytes memory _signature) public view returns (bytes4 magicValue)';
+        const returnValue = yield call(provider, [abi], [address, 'isValidSignature', [bytes.arrayify(hash), sig]]);
+        return isEqual(returnValue, magicValue);
+    });
+}
+
+var evm = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getHash: getHash$1,
+    'default': verify$1
+});
+
+function getHash$2(data, address) {
+    const networkType = isStarknetMessage(data) ? starknet : evm;
+    return networkType.getHash(data, address);
+}
+function verify$2(address_1, sig_1, data_1) {
+    return __awaiter(this, arguments, void 0, function* (address, sig, data, network = '1', options = {}) {
+        if (!isStarknetAddress(address) && !isEvmAddress(address)) {
+            throw new Error('Invalid address');
+        }
+        const networkType = isStarknetMessage(data) ? starknet : evm;
+        return yield networkType.default(address, sig, data, network, options);
+    });
 }
 
 var gateways = [
@@ -3350,415 +3201,345 @@ var networks = {
 }
 };
 
-var SingleChoiceVoting = /** @class */ (function () {
-    function SingleChoiceVoting(proposal, votes, strategies, selected) {
-        this.proposal = proposal;
-        this.votes = votes;
-        this.strategies = strategies;
-        this.selected = selected;
-    }
-    SingleChoiceVoting.isValidChoice = function (voteChoice, proposalChoices) {
-        return (typeof voteChoice === 'number' &&
-            (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[voteChoice - 1]) !== undefined);
-    };
-    SingleChoiceVoting.prototype.getValidVotes = function () {
-        var _this = this;
-        return this.votes.filter(function (vote) {
-            return SingleChoiceVoting.isValidChoice(vote.choice, _this.proposal.choices);
-        });
-    };
-    SingleChoiceVoting.prototype.getScores = function () {
-        var _this = this;
-        return this.proposal.choices.map(function (choice, i) {
-            var votes = _this.getValidVotes().filter(function (vote) { return vote.choice === i + 1; });
-            var balanceSum = votes.reduce(function (a, b) { return a + b.balance; }, 0);
-            return balanceSum;
-        });
-    };
-    SingleChoiceVoting.prototype.getScoresByStrategy = function () {
-        var _this = this;
-        return this.proposal.choices.map(function (choice, i) {
-            var scores = _this.strategies.map(function (strategy, sI) {
-                var votes = _this.getValidVotes().filter(function (vote) { return vote.choice === i + 1; });
-                var scoreSum = votes.reduce(function (a, b) { return a + b.scores[sI]; }, 0);
-                return scoreSum;
-            });
-            return scores;
-        });
-    };
-    SingleChoiceVoting.prototype.getScoresTotal = function () {
-        return this.votes.reduce(function (a, b) { return a + b.balance; }, 0);
-    };
-    SingleChoiceVoting.prototype.getChoiceString = function () {
-        return this.proposal.choices[this.selected - 1];
-    };
-    return SingleChoiceVoting;
-}());
+class SingleChoiceVoting {
+    constructor(proposal, votes, strategies, selected) {
+        this.proposal = proposal;
+        this.votes = votes;
+        this.strategies = strategies;
+        this.selected = selected;
+    }
+    static isValidChoice(voteChoice, proposalChoices) {
+        return (typeof voteChoice === 'number' &&
+            (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[voteChoice - 1]) !== undefined);
+    }
+    getValidVotes() {
+        return this.votes.filter((vote) => SingleChoiceVoting.isValidChoice(vote.choice, this.proposal.choices));
+    }
+    getScores() {
+        return this.proposal.choices.map((choice, i) => {
+            const votes = this.getValidVotes().filter((vote) => vote.choice === i + 1);
+            const balanceSum = votes.reduce((a, b) => a + b.balance, 0);
+            return balanceSum;
+        });
+    }
+    getScoresByStrategy() {
+        return this.proposal.choices.map((choice, i) => {
+            const scores = this.strategies.map((strategy, sI) => {
+                const votes = this.getValidVotes().filter((vote) => vote.choice === i + 1);
+                const scoreSum = votes.reduce((a, b) => a + b.scores[sI], 0);
+                return scoreSum;
+            });
+            return scores;
+        });
+    }
+    getScoresTotal() {
+        return this.votes.reduce((a, b) => a + b.balance, 0);
+    }
+    getChoiceString() {
+        return this.proposal.choices[this.selected - 1];
+    }
+}
 
-var ApprovalVoting = /** @class */ (function () {
-    function ApprovalVoting(proposal, votes, strategies, selected) {
-        this.proposal = proposal;
-        this.votes = votes;
-        this.strategies = strategies;
-        this.selected = selected;
-    }
-    ApprovalVoting.isValidChoice = function (voteChoice, proposalChoices) {
-        return (Array.isArray(voteChoice) &&
-            // If voteChoice index is not in proposalChoices, return false
-            voteChoice.every(function (choice) { return (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[choice - 1]) !== undefined; }) &&
-            // If any voteChoice is duplicated, return false
-            voteChoice.length === new Set(voteChoice).size);
-    };
-    ApprovalVoting.prototype.getValidVotes = function () {
-        var _this = this;
-        return this.votes.filter(function (vote) {
-            return ApprovalVoting.isValidChoice(vote.choice, _this.proposal.choices);
-        });
-    };
-    ApprovalVoting.prototype.getScores = function () {
-        var _this = this;
-        return this.proposal.choices.map(function (choice, i) {
-            return _this.getValidVotes()
-                .filter(function (vote) { return vote.choice.includes(i + 1); })
-                .reduce(function (a, b) { return a + b.balance; }, 0);
-        });
-    };
-    ApprovalVoting.prototype.getScoresByStrategy = function () {
-        var _this = this;
-        return this.proposal.choices.map(function (choice, i) {
-            return _this.strategies.map(function (strategy, sI) {
-                return _this.getValidVotes()
-                    .filter(function (vote) { return vote.choice.includes(i + 1); })
-                    .reduce(function (a, b) { return a + b.scores[sI]; }, 0);
-            });
-        });
-    };
-    ApprovalVoting.prototype.getScoresTotal = function () {
-        return this.votes.reduce(function (a, b) { return a + b.balance; }, 0);
-    };
-    ApprovalVoting.prototype.getChoiceString = function () {
-        var _this = this;
-        if (!this.selected)
-            return '';
-        return this.proposal.choices
-            .filter(function (choice, i) { return _this.selected.includes(i + 1); })
-            .join(', ');
-    };
-    return ApprovalVoting;
-}());
+class ApprovalVoting {
+    constructor(proposal, votes, strategies, selected) {
+        this.proposal = proposal;
+        this.votes = votes;
+        this.strategies = strategies;
+        this.selected = selected;
+    }
+    static isValidChoice(voteChoice, proposalChoices) {
+        return (Array.isArray(voteChoice) &&
+            // If voteChoice index is not in proposalChoices, return false
+            voteChoice.every((choice) => (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[choice - 1]) !== undefined) &&
+            // If any voteChoice is duplicated, return false
+            voteChoice.length === new Set(voteChoice).size);
+    }
+    getValidVotes() {
+        return this.votes.filter((vote) => ApprovalVoting.isValidChoice(vote.choice, this.proposal.choices));
+    }
+    getScores() {
+        return this.proposal.choices.map((choice, i) => this.getValidVotes()
+            .filter((vote) => vote.choice.includes(i + 1))
+            .reduce((a, b) => a + b.balance, 0));
+    }
+    getScoresByStrategy() {
+        return this.proposal.choices.map((choice, i) => this.strategies.map((strategy, sI) => this.getValidVotes()
+            .filter((vote) => vote.choice.includes(i + 1))
+            .reduce((a, b) => a + b.scores[sI], 0)));
+    }
+    getScoresTotal() {
+        return this.votes.reduce((a, b) => a + b.balance, 0);
+    }
+    getChoiceString() {
+        if (!this.selected)
+            return '';
+        return this.proposal.choices
+            .filter((choice, i) => this.selected.includes(i + 1))
+            .join(', ');
+    }
+}
 
-function calcPercentageOfSum(part, wholeArray) {
-    var whole = wholeArray.reduce(function (a, b) { return a + b; }, 0);
-    var percent = part / whole;
-    return isNaN(percent) ? 0 : percent;
-}
-function calcSqrt(percentageWeight, votingPower) {
-    return Math.sqrt(percentageWeight * votingPower);
-}
-function calcSquare(num) {
-    return num * num;
-}
-function calcReducedQuadraticScores(percentages, scoresTotal) {
-    // Reduce each quadratic score so that the sum of quadratic scores matches
-    // the total scores.
-    // This is done to unsure that features like quorum still work as expected.
-    return percentages.map(function (p) { return scoresTotal * p; });
-}
-var QuadraticVoting = /** @class */ (function () {
-    function QuadraticVoting(proposal, votes, strategies, selected) {
-        this.proposal = proposal;
-        this.votes = votes;
-        this.strategies = strategies;
-        this.selected = selected;
-    }
-    QuadraticVoting.isValidChoice = function (voteChoice, proposalChoices) {
-        return (typeof voteChoice === 'object' &&
-            !Array.isArray(voteChoice) &&
-            voteChoice !== null &&
-            // If voteChoice object keys are not in choices, return false
-            Object.keys(voteChoice).every(function (key) { return (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[Number(key) - 1]) !== undefined; }) &&
-            // If voteChoice object is empty, return false
-            Object.keys(voteChoice).length > 0 &&
-            // If voteChoice object values have a negative number, return false
-            Object.values(voteChoice).every(function (value) { return typeof value === 'number' && value >= 0; }) &&
-            // If voteChoice doesn't have any positive value, return false
-            Object.values(voteChoice).some(function (value) { return typeof value === 'number' && value > 0; }));
-    };
-    QuadraticVoting.prototype.getValidVotes = function () {
-        var _this = this;
-        return this.votes.filter(function (vote) {
-            return QuadraticVoting.isValidChoice(vote.choice, _this.proposal.choices);
-        });
-    };
-    QuadraticVoting.prototype.getScores = function () {
-        var validVotes = this.getValidVotes();
-        var scoresTotal = this.getValidVotes().reduce(function (a, b) { return a + b.balance; }, 0);
-        var quadraticScores = this.proposal.choices.map(function (_, i) {
-            var votingPowerSqrt = validVotes
-                .map(function (vote) {
-                var choiceWeightPercent = calcPercentageOfSum(vote.choice[i + 1], Object.values(vote.choice));
-                return calcSqrt(choiceWeightPercent, vote.balance);
-            })
-                .reduce(function (a, b) { return a + b; }, 0);
-            return calcSquare(votingPowerSqrt);
-        });
-        var percentagesOfScores = quadraticScores.map(function (_, i) {
-            return calcPercentageOfSum(quadraticScores[i], quadraticScores);
-        });
-        return calcReducedQuadraticScores(percentagesOfScores, scoresTotal);
-    };
-    QuadraticVoting.prototype.getScoresByStrategy = function () {
-        var _this = this;
-        var validVotes = this.getValidVotes();
-        var scoresTotal = this.getValidVotes().reduce(function (a, b) { return a + b.balance; }, 0);
-        var quadraticScoresByStrategy = this.proposal.choices
-            .map(function (_, i) {
-            return _this.strategies.map(function (_, sI) {
-                return validVotes
-                    .map(function (vote) {
-                    var choiceWeightPercentByStrategy = calcPercentageOfSum(vote.choice[i + 1], Object.values(vote.choice));
-                    return calcSqrt(choiceWeightPercentByStrategy, vote.scores[sI]);
-                })
-                    .reduce(function (a, b) { return a + b; }, 0);
-            });
-        })
-            .map(function (arr) { return arr.map(function (num) { return [calcSquare(num)]; }); });
-        var reducedQuadraticScores = quadraticScoresByStrategy.map(function (_, i) {
-            var percentagesOfScores = _this.strategies.map(function (_, sI) {
-                return calcPercentageOfSum(quadraticScoresByStrategy[i][sI][0], quadraticScoresByStrategy.flat(2));
-            });
-            return calcReducedQuadraticScores(percentagesOfScores, scoresTotal);
-        });
-        return reducedQuadraticScores;
-    };
-    QuadraticVoting.prototype.getScoresTotal = function () {
-        return this.votes.reduce(function (a, b) { return a + b.balance; }, 0);
-    };
-    QuadraticVoting.prototype.getChoiceString = function () {
-        var _this = this;
-        return this.proposal.choices
-            .map(function (choice, i) {
-            if (_this.selected[i + 1]) {
-                var percent = calcPercentageOfSum(_this.selected[i + 1], Object.values(_this.selected));
-                return Math.round(percent * 1000) / 10 + "% for " + choice;
-            }
-        })
-            .filter(function (el) { return el != null; })
-            .join(', ');
-    };
-    return QuadraticVoting;
-}());
+function calcPercentageOfSum(part, wholeArray) {
+    const whole = wholeArray.reduce((a, b) => a + b, 0);
+    const percent = part / whole;
+    return isNaN(percent) ? 0 : percent;
+}
+function calcSqrt(percentageWeight, votingPower) {
+    return Math.sqrt(percentageWeight * votingPower);
+}
+function calcSquare(num) {
+    return num * num;
+}
+function calcReducedQuadraticScores(percentages, scoresTotal) {
+    // Reduce each quadratic score so that the sum of quadratic scores matches
+    // the total scores.
+    // This is done to unsure that features like quorum still work as expected.
+    return percentages.map((p) => scoresTotal * p);
+}
+class QuadraticVoting {
+    constructor(proposal, votes, strategies, selected) {
+        this.proposal = proposal;
+        this.votes = votes;
+        this.strategies = strategies;
+        this.selected = selected;
+    }
+    static isValidChoice(voteChoice, proposalChoices) {
+        return (typeof voteChoice === 'object' &&
+            !Array.isArray(voteChoice) &&
+            voteChoice !== null &&
+            // If voteChoice object keys are not in choices, return false
+            Object.keys(voteChoice).every((key) => (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[Number(key) - 1]) !== undefined) &&
+            // If voteChoice object is empty, return false
+            Object.keys(voteChoice).length > 0 &&
+            // If voteChoice object values have a negative number, return false
+            Object.values(voteChoice).every((value) => typeof value === 'number' && value >= 0) &&
+            // If voteChoice doesn't have any positive value, return false
+            Object.values(voteChoice).some((value) => typeof value === 'number' && value > 0));
+    }
+    getValidVotes() {
+        return this.votes.filter((vote) => QuadraticVoting.isValidChoice(vote.choice, this.proposal.choices));
+    }
+    getScores() {
+        const validVotes = this.getValidVotes();
+        const scoresTotal = this.getValidVotes().reduce((a, b) => a + b.balance, 0);
+        const quadraticScores = this.proposal.choices.map((_, i) => {
+            const votingPowerSqrt = validVotes
+                .map((vote) => {
+                const choiceWeightPercent = calcPercentageOfSum(vote.choice[i + 1], Object.values(vote.choice));
+                return calcSqrt(choiceWeightPercent, vote.balance);
+            })
+                .reduce((a, b) => a + b, 0);
+            return calcSquare(votingPowerSqrt);
+        });
+        const percentagesOfScores = quadraticScores.map((_, i) => calcPercentageOfSum(quadraticScores[i], quadraticScores));
+        return calcReducedQuadraticScores(percentagesOfScores, scoresTotal);
+    }
+    getScoresByStrategy() {
+        const validVotes = this.getValidVotes();
+        const scoresTotal = this.getValidVotes().reduce((a, b) => a + b.balance, 0);
+        const quadraticScoresByStrategy = this.proposal.choices
+            .map((_, i) => this.strategies.map((_, sI) => validVotes
+            .map((vote) => {
+            const choiceWeightPercentByStrategy = calcPercentageOfSum(vote.choice[i + 1], Object.values(vote.choice));
+            return calcSqrt(choiceWeightPercentByStrategy, vote.scores[sI]);
+        })
+            .reduce((a, b) => a + b, 0)))
+            .map((arr) => arr.map((num) => [calcSquare(num)]));
+        const reducedQuadraticScores = quadraticScoresByStrategy.map((_, i) => {
+            const percentagesOfScores = this.strategies.map((_, sI) => calcPercentageOfSum(quadraticScoresByStrategy[i][sI][0], quadraticScoresByStrategy.flat(2)));
+            return calcReducedQuadraticScores(percentagesOfScores, scoresTotal);
+        });
+        return reducedQuadraticScores;
+    }
+    getScoresTotal() {
+        return this.votes.reduce((a, b) => a + b.balance, 0);
+    }
+    getChoiceString() {
+        return this.proposal.choices
+            .map((choice, i) => {
+            if (this.selected[i + 1]) {
+                const percent = calcPercentageOfSum(this.selected[i + 1], Object.values(this.selected));
+                return `${Math.round(percent * 1000) / 10}% for ${choice}`;
+            }
+        })
+            .filter((el) => el != null)
+            .join(', ');
+    }
+}
 
-function irv(ballots, rounds) {
-    var candidates = __spread(new Set(ballots.map(function (vote) { return vote[0]; }).flat()));
-    var votes = Object.entries(ballots.reduce(function (votes, _a, i, src) {
-        var _b = __read(_a, 1), v = _b[0];
-        var balance = src[i][1];
-        votes[v[0]][0] += balance;
-        var score = src[i][2];
-        if (score.length > 1) {
-            votes[v[0]][1] = score.map(function (s, sI) { return s + votes[v[0]][1][sI] || s; });
-        }
-        else
-            votes[v[0]][1] = [
-                votes[v[0]][1].concat(score).reduce(function (a, b) { return a + b; }, 0)
-            ];
-        return votes;
-    }, Object.assign.apply(Object, __spread([{}], candidates.map(function (c) {
-        var _a;
-        return (_a = {}, _a[c] = [0, []], _a);
-    })))));
-    var votesWithoutScore = votes.map(function (vote) { return [vote[0], vote[1][0]]; });
-    /* eslint-disable @typescript-eslint/no-unused-vars */
-    var _a = __read(votesWithoutScore.reduce(function (_a, _b) {
-        var _c = __read(_a, 2), n = _c[0], m = _c[1];
-        var _d = __read(_b, 2), v = _d[0], c = _d[1];
-        return (c > m ? [v, c] : [n, m]);
-    }, ['?', -Infinity]), 2), topCand = _a[0], topCount = _a[1];
-    var _b = __read(votesWithoutScore.reduce(function (_a, _b) {
-        var _c = __read(_a, 2), n = _c[0], m = _c[1];
-        var _d = __read(_b, 2), v = _d[0], c = _d[1];
-        return (c < m ? [v, c] : [n, m]);
-    }, ['?', Infinity]), 2), bottomCand = _b[0], bottomCount = _b[1];
-    /* eslint-enable @typescript-eslint/no-unused-vars */
-    var sortedByHighest = votes.sort(function (a, b) { return b[1][0] - a[1][0]; });
-    var totalPowerOfVotes = ballots
-        .map(function (bal) { return bal[1]; })
-        .reduce(function (a, b) { return a + b; }, 0);
-    rounds.push({
-        round: rounds.length + 1,
-        sortedByHighest: sortedByHighest
-    });
-    return topCount > totalPowerOfVotes / 2 ||
-        sortedByHighest.length < 3
-        ? rounds
-        : irv(ballots
-            .map(function (ballot) { return [
-            ballot[0].filter(function (c) { return c != bottomCand; }),
-            ballot[1],
-            ballot[2]
-        ]; })
-            .filter(function (ballot) { return ballot[0].length > 0; }), rounds);
-}
-function getFinalRound(votes) {
-    var rounds = irv(votes.map(function (vote) { return [vote.choice, vote.balance, vote.scores]; }), []);
-    var finalRound = rounds[rounds.length - 1];
-    return finalRound.sortedByHighest;
-}
-function getScoresMethod(votes, proposal) {
-    var finalRound = getFinalRound(votes);
-    return proposal.choices.map(function (choice, i) {
-        return finalRound
-            .filter(function (res) { return Number(res[0]) === i + 1; })
-            .reduce(function (a, b) { return a + b[1][0]; }, 0);
-    });
-}
-var RankedChoiceVoting = /** @class */ (function () {
-    function RankedChoiceVoting(proposal, votes, strategies, selected) {
-        this.proposal = proposal;
-        this.votes = votes;
-        this.strategies = strategies;
-        this.selected = selected;
-    }
-    RankedChoiceVoting.isValidChoice = function (voteChoice, proposalChoices) {
-        return (Array.isArray(voteChoice) &&
-            // If voteChoice index is not in choices, return false
-            voteChoice.every(function (voteChoice) { return (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[voteChoice - 1]) !== undefined; }) &&
-            // If any voteChoice is duplicated, return false
-            voteChoice.length === new Set(voteChoice).size &&
-            // If voteChoice is empty, return false
-            voteChoice.length > 0 &&
-            // If not all proposalChoices are selected, return false
-            // TODO: We should add support for pacial bailout in the future
-            voteChoice.length === proposalChoices.length);
-    };
-    RankedChoiceVoting.prototype.getValidVotes = function () {
-        var _this = this;
-        return this.votes.filter(function (vote) {
-            return RankedChoiceVoting.isValidChoice(vote.choice, _this.proposal.choices);
-        });
-    };
-    RankedChoiceVoting.prototype.getScores = function () {
-        return getScoresMethod(this.getValidVotes(), this.proposal);
-    };
-    RankedChoiceVoting.prototype.getScoresByStrategy = function () {
-        var _this = this;
-        var finalRound = getFinalRound(this.getValidVotes());
-        return this.proposal.choices.map(function (choice, i) {
-            return _this.strategies.map(function (strategy, sI) {
-                return finalRound
-                    .filter(function (res) { return Number(res[0]) === i + 1; })
-                    .reduce(function (a, b) { return a + b[1][1][sI]; }, 0);
-            });
-        });
-    };
-    RankedChoiceVoting.prototype.getScoresTotal = function () {
-        return this.votes.reduce(function (a, b) { return a + b.balance; }, 0);
-    };
-    RankedChoiceVoting.prototype.getChoiceString = function () {
-        var _this = this;
-        return this.selected
-            .map(function (choice) {
-            if (_this.proposal.choices[choice - 1])
-                return _this.proposal.choices[choice - 1];
-        })
-            .map(function (el, i) { return "(" + getNumberWithOrdinal(i + 1) + ") " + el; })
-            .join(', ');
-    };
-    return RankedChoiceVoting;
-}());
+function irv(ballots, rounds) {
+    const candidates = [
+        ...new Set(ballots.map((vote) => vote[0]).flat())
+    ];
+    const votes = Object.entries(ballots.reduce((votes, [v], i, src) => {
+        const balance = src[i][1];
+        votes[v[0]][0] += balance;
+        const score = src[i][2];
+        if (score.length > 1) {
+            votes[v[0]][1] = score.map((s, sI) => s + votes[v[0]][1][sI] || s);
+        }
+        else
+            votes[v[0]][1] = [
+                votes[v[0]][1].concat(score).reduce((a, b) => a + b, 0)
+            ];
+        return votes;
+    }, Object.assign({}, ...candidates.map((c) => ({ [c]: [0, []] })))));
+    const votesWithoutScore = votes.map((vote) => [vote[0], vote[1][0]]);
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    const [topCand, topCount] = votesWithoutScore.reduce(([n, m], [v, c]) => (c > m ? [v, c] : [n, m]), ['?', -Infinity]);
+    const [bottomCand, bottomCount] = votesWithoutScore.reduce(([n, m], [v, c]) => (c < m ? [v, c] : [n, m]), ['?', Infinity]);
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    const sortedByHighest = votes.sort((a, b) => b[1][0] - a[1][0]);
+    const totalPowerOfVotes = ballots
+        .map((bal) => bal[1])
+        .reduce((a, b) => a + b, 0);
+    rounds.push({
+        round: rounds.length + 1,
+        sortedByHighest
+    });
+    return topCount > totalPowerOfVotes / 2 ||
+        sortedByHighest.length < 3
+        ? rounds
+        : irv(ballots
+            .map((ballot) => [
+            ballot[0].filter((c) => c != bottomCand),
+            ballot[1],
+            ballot[2]
+        ])
+            .filter((ballot) => ballot[0].length > 0), rounds);
+}
+function getFinalRound(votes) {
+    const rounds = irv(votes.map((vote) => [vote.choice, vote.balance, vote.scores]), []);
+    const finalRound = rounds[rounds.length - 1];
+    return finalRound.sortedByHighest;
+}
+function getScoresMethod(votes, proposal) {
+    const finalRound = getFinalRound(votes);
+    return proposal.choices.map((choice, i) => finalRound
+        .filter((res) => Number(res[0]) === i + 1)
+        .reduce((a, b) => a + b[1][0], 0));
+}
+class RankedChoiceVoting {
+    constructor(proposal, votes, strategies, selected) {
+        this.proposal = proposal;
+        this.votes = votes;
+        this.strategies = strategies;
+        this.selected = selected;
+    }
+    static isValidChoice(voteChoice, proposalChoices) {
+        return (Array.isArray(voteChoice) &&
+            // If voteChoice index is not in choices, return false
+            voteChoice.every((voteChoice) => (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[voteChoice - 1]) !== undefined) &&
+            // If any voteChoice is duplicated, return false
+            voteChoice.length === new Set(voteChoice).size &&
+            // If voteChoice is empty, return false
+            voteChoice.length > 0 &&
+            // If not all proposalChoices are selected, return false
+            // TODO: We should add support for pacial bailout in the future
+            voteChoice.length === proposalChoices.length);
+    }
+    getValidVotes() {
+        return this.votes.filter((vote) => RankedChoiceVoting.isValidChoice(vote.choice, this.proposal.choices));
+    }
+    getScores() {
+        return getScoresMethod(this.getValidVotes(), this.proposal);
+    }
+    getScoresByStrategy() {
+        const finalRound = getFinalRound(this.getValidVotes());
+        return this.proposal.choices.map((choice, i) => this.strategies.map((strategy, sI) => {
+            return finalRound
+                .filter((res) => Number(res[0]) === i + 1)
+                .reduce((a, b) => a + b[1][1][sI], 0);
+        }));
+    }
+    getScoresTotal() {
+        return this.votes.reduce((a, b) => a + b.balance, 0);
+    }
+    getChoiceString() {
+        return this.selected
+            .map((choice) => {
+            if (this.proposal.choices[choice - 1])
+                return this.proposal.choices[choice - 1];
+        })
+            .map((el, i) => `(${getNumberWithOrdinal(i + 1)}) ${el}`)
+            .join(', ');
+    }
+}
 
-function percentageOfTotal(i, values, total) {
-    var reducedTotal = total.reduce(function (a, b) { return a + b; }, 0);
-    var percent = (values[i] / reducedTotal) * 100;
-    return isNaN(percent) ? 0 : percent;
-}
-function weightedPower(i, choice, balance) {
-    return ((percentageOfTotal(i + 1, choice, Object.values(choice)) / 100) * balance);
-}
-var WeightedVoting = /** @class */ (function () {
-    function WeightedVoting(proposal, votes, strategies, selected) {
-        this.proposal = proposal;
-        this.votes = votes;
-        this.strategies = strategies;
-        this.selected = selected;
-    }
-    WeightedVoting.isValidChoice = function (voteChoice, proposalChoices) {
-        return (typeof voteChoice === 'object' &&
-            !Array.isArray(voteChoice) &&
-            voteChoice !== null &&
-            // If voteChoice object keys are not in choices, return false
-            Object.keys(voteChoice).every(function (key) { return (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[Number(key) - 1]) !== undefined; }) &&
-            // If voteChoice object is empty, return false
-            Object.keys(voteChoice).length > 0 &&
-            // If voteChoice object values have a negative number, return false
-            Object.values(voteChoice).every(function (value) { return typeof value === 'number' && value >= 0; }) &&
-            // If voteChoice doesn't have any positive value, return false
-            Object.values(voteChoice).some(function (value) { return typeof value === 'number' && value > 0; }));
-    };
-    WeightedVoting.prototype.getValidVotes = function () {
-        var _this = this;
-        return this.votes.filter(function (vote) {
-            return WeightedVoting.isValidChoice(vote.choice, _this.proposal.choices);
-        });
-    };
-    WeightedVoting.prototype.getScores = function () {
-        var _this = this;
-        var results = this.proposal.choices.map(function (choice, i) {
-            return _this.getValidVotes()
-                .map(function (vote) { return weightedPower(i, vote.choice, vote.balance); })
-                .reduce(function (a, b) { return a + b; }, 0);
-        });
-        var validScoresTotal = this.getValidVotes().reduce(function (a, b) { return a + b.balance; }, 0);
-        return results
-            .map(function (res, i) { return percentageOfTotal(i, results, results); })
-            .map(function (p) { return (validScoresTotal / 100) * p; });
-    };
-    WeightedVoting.prototype.getScoresByStrategy = function () {
-        var _this = this;
-        var results = this.proposal.choices
-            .map(function (choice, i) {
-            return _this.strategies.map(function (strategy, sI) {
-                return _this.getValidVotes()
-                    .map(function (vote) { return weightedPower(i, vote.choice, vote.scores[sI]); })
-                    .reduce(function (a, b) { return a + b; }, 0);
-            });
-        })
-            .map(function (arr) { return arr.map(function (pwr) { return [pwr]; }); });
-        var validScoresTotal = this.getValidVotes().reduce(function (a, b) { return a + b.balance; }, 0);
-        return results.map(function (res, i) {
-            return _this.strategies
-                .map(function (strategy, sI) {
-                return percentageOfTotal(0, results[i][sI], results.flat(2));
-            })
-                .map(function (p) { return [(validScoresTotal / 100) * p]; })
-                .flat();
-        });
-    };
-    WeightedVoting.prototype.getScoresTotal = function () {
-        return this.votes.reduce(function (a, b) { return a + b.balance; }, 0);
-    };
-    WeightedVoting.prototype.getChoiceString = function () {
-        var _this = this;
-        return this.proposal.choices
-            .map(function (choice, i) {
-            if (_this.selected[i + 1]) {
-                return Math.round(percentageOfTotal(i + 1, _this.selected, Object.values(_this.selected)) * 10) / 10 + "% for " + choice;
-            }
-        })
-            .filter(function (el) { return el != null; })
-            .join(', ');
-    };
-    return WeightedVoting;
-}());
+function percentageOfTotal(i, values, total) {
+    const reducedTotal = total.reduce((a, b) => a + b, 0);
+    const percent = (values[i] / reducedTotal) * 100;
+    return isNaN(percent) ? 0 : percent;
+}
+function weightedPower(i, choice, balance) {
+    return ((percentageOfTotal(i + 1, choice, Object.values(choice)) / 100) * balance);
+}
+class WeightedVoting {
+    constructor(proposal, votes, strategies, selected) {
+        this.proposal = proposal;
+        this.votes = votes;
+        this.strategies = strategies;
+        this.selected = selected;
+    }
+    static isValidChoice(voteChoice, proposalChoices) {
+        return (typeof voteChoice === 'object' &&
+            !Array.isArray(voteChoice) &&
+            voteChoice !== null &&
+            // If voteChoice object keys are not in choices, return false
+            Object.keys(voteChoice).every((key) => (proposalChoices === null || proposalChoices === void 0 ? void 0 : proposalChoices[Number(key) - 1]) !== undefined) &&
+            // If voteChoice object is empty, return false
+            Object.keys(voteChoice).length > 0 &&
+            // If voteChoice object values have a negative number, return false
+            Object.values(voteChoice).every((value) => typeof value === 'number' && value >= 0) &&
+            // If voteChoice doesn't have any positive value, return false
+            Object.values(voteChoice).some((value) => typeof value === 'number' && value > 0));
+    }
+    getValidVotes() {
+        return this.votes.filter((vote) => WeightedVoting.isValidChoice(vote.choice, this.proposal.choices));
+    }
+    getScores() {
+        const results = this.proposal.choices.map((choice, i) => this.getValidVotes()
+            .map((vote) => weightedPower(i, vote.choice, vote.balance))
+            .reduce((a, b) => a + b, 0));
+        const validScoresTotal = this.getValidVotes().reduce((a, b) => a + b.balance, 0);
+        return results
+            .map((res, i) => percentageOfTotal(i, results, results))
+            .map((p) => (validScoresTotal / 100) * p);
+    }
+    getScoresByStrategy() {
+        const results = this.proposal.choices
+            .map((choice, i) => this.strategies.map((strategy, sI) => this.getValidVotes()
+            .map((vote) => weightedPower(i, vote.choice, vote.scores[sI]))
+            .reduce((a, b) => a + b, 0)))
+            .map((arr) => arr.map((pwr) => [pwr]));
+        const validScoresTotal = this.getValidVotes().reduce((a, b) => a + b.balance, 0);
+        return results.map((res, i) => this.strategies
+            .map((strategy, sI) => percentageOfTotal(0, results[i][sI], results.flat(2)))
+            .map((p) => [(validScoresTotal / 100) * p])
+            .flat());
+    }
+    getScoresTotal() {
+        return this.votes.reduce((a, b) => a + b.balance, 0);
+    }
+    getChoiceString() {
+        return this.proposal.choices
+            .map((choice, i) => {
+            if (this.selected[i + 1]) {
+                return `${Math.round(percentageOfTotal(i + 1, this.selected, Object.values(this.selected)) * 10) / 10}% for ${choice}`;
+            }
+        })
+            .filter((el) => el != null)
+            .join(', ');
+    }
+}
 
-var voting = {
-    'single-choice': SingleChoiceVoting,
-    approval: ApprovalVoting,
-    quadratic: QuadraticVoting,
-    'ranked-choice': RankedChoiceVoting,
-    weighted: WeightedVoting,
-    basic: SingleChoiceVoting
+var voting = {
+    'single-choice': SingleChoiceVoting,
+    approval: ApprovalVoting,
+    quadratic: QuadraticVoting,
+    'ranked-choice': RankedChoiceVoting,
+    weighted: WeightedVoting,
+    basic: SingleChoiceVoting
 };
 
 var delegationSubgraphs = {
@@ -3772,771 +3553,633 @@ var delegationSubgraphs = {
 	"11155111": "https://subgrapher.snapshot.org/delegation/11155111"
 };
 
-var SNAPSHOT_SUBGRAPH_URL = delegationSubgraphs;
-var PAGE_SIZE = 1000;
-function getDelegatesBySpace(network, space, snapshot, options) {
-    if (snapshot === void 0) { snapshot = 'latest'; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var subgraphUrl, pivot, result, spaceIn, newResults;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    subgraphUrl = options.subgraphUrl || SNAPSHOT_SUBGRAPH_URL[network];
-                    if (!subgraphUrl) {
-                        return [2 /*return*/, Promise.reject("Delegation subgraph not available for network " + network)];
-                    }
-                    pivot = 0;
-                    result = new Map();
-                    spaceIn = buildSpaceIn(space);
-                    _a.label = 1;
-                case 1:
-                    return [4 /*yield*/, fetchData({
-                            url: subgraphUrl,
-                            spaces: spaceIn,
-                            pivot: pivot,
-                            snapshot: snapshot
-                        })];
-                case 2:
-                    newResults = _a.sent();
-                    if (checkAllDuplicates(newResults)) {
-                        throw new Error('Unable to paginate delegation');
-                    }
-                    newResults.forEach(function (delegation) {
-                        concatUniqueDelegation(result, delegation);
-                        pivot = delegation.timestamp;
-                    });
-                    if (newResults.length < PAGE_SIZE)
-                        return [3 /*break*/, 3];
-                    return [3 /*break*/, 1];
-                case 3: return [2 /*return*/, __spread(result.values())];
-            }
-        });
-    });
-}
-function checkAllDuplicates(delegations) {
-    return (delegations.length === PAGE_SIZE &&
-        delegations[0].timestamp === delegations[delegations.length - 1].timestamp);
-}
-function delegationKey(delegation) {
-    return delegation.delegator + "-" + delegation.delegate + "-" + delegation.space;
-}
-function concatUniqueDelegation(result, delegation) {
-    var key = delegationKey(delegation);
-    if (!result.has(key)) {
-        result.set(key, delegation);
-    }
-}
-function buildSpaceIn(space) {
-    var spaces = ['', space];
-    if (space.includes('.eth'))
-        spaces.push(space.replace('.eth', ''));
-    return spaces;
-}
-function fetchData(_a) {
-    var url = _a.url, spaces = _a.spaces, pivot = _a.pivot, snapshot = _a.snapshot;
-    return __awaiter(this, void 0, void 0, function () {
-        var params;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    params = {
-                        delegations: {
-                            __args: {
-                                where: {
-                                    space_in: spaces,
-                                    timestamp_gte: pivot
-                                },
-                                first: PAGE_SIZE,
-                                skip: 0,
-                                orderBy: 'timestamp',
-                                orderDirection: 'asc'
-                            },
-                            delegator: true,
-                            space: true,
-                            delegate: true,
-                            timestamp: true
-                        }
-                    };
-                    if (snapshot !== 'latest') {
-                        params.delegations.__args.block = { number: snapshot };
-                    }
-                    return [4 /*yield*/, subgraphRequest(url, params)];
-                case 1: return [2 /*return*/, (_b.sent()).delegations || []];
-            }
-        });
-    });
+const SNAPSHOT_SUBGRAPH_URL = delegationSubgraphs;
+const PAGE_SIZE = 1000;
+function getDelegatesBySpace(network_1, space_1) {
+    return __awaiter(this, arguments, void 0, function* (network, space, snapshot = 'latest', options = {}) {
+        const subgraphUrl = options.subgraphUrl || SNAPSHOT_SUBGRAPH_URL[network];
+        if (!subgraphUrl) {
+            return Promise.reject(`Delegation subgraph not available for network ${network}`);
+        }
+        let pivot = 0;
+        const result = new Map();
+        const spaceIn = buildSpaceIn(space);
+        while (true) {
+            const newResults = yield fetchData({
+                url: subgraphUrl,
+                spaces: spaceIn,
+                pivot,
+                snapshot
+            });
+            if (checkAllDuplicates(newResults)) {
+                throw new Error('Unable to paginate delegation');
+            }
+            newResults.forEach((delegation) => {
+                concatUniqueDelegation(result, delegation);
+                pivot = delegation.timestamp;
+            });
+            if (newResults.length < PAGE_SIZE)
+                break;
+        }
+        return [...result.values()];
+    });
+}
+function checkAllDuplicates(delegations) {
+    return (delegations.length === PAGE_SIZE &&
+        delegations[0].timestamp === delegations[delegations.length - 1].timestamp);
+}
+function delegationKey(delegation) {
+    return `${delegation.delegator}-${delegation.delegate}-${delegation.space}`;
+}
+function concatUniqueDelegation(result, delegation) {
+    const key = delegationKey(delegation);
+    if (!result.has(key)) {
+        result.set(key, delegation);
+    }
+}
+function buildSpaceIn(space) {
+    const spaces = ['', space];
+    if (space.includes('.eth'))
+        spaces.push(space.replace('.eth', ''));
+    return spaces;
+}
+function fetchData(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ url, spaces, pivot, snapshot }) {
+        const params = {
+            delegations: {
+                __args: {
+                    where: {
+                        space_in: spaces,
+                        timestamp_gte: pivot
+                    },
+                    first: PAGE_SIZE,
+                    skip: 0,
+                    orderBy: 'timestamp',
+                    orderDirection: 'asc'
+                },
+                delegator: true,
+                space: true,
+                delegate: true,
+                timestamp: true
+            }
+        };
+        if (snapshot !== 'latest') {
+            params.delegations.__args.block = { number: snapshot };
+        }
+        return (yield subgraphRequest(url, params)).delegations || [];
+    });
 }
 
-var ENS_RESOLVER_ABI = [
-    'function text(bytes32 node, string calldata key) external view returns (string memory)'
-];
-var EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000';
-var scoreApiHeaders = {
-    Accept: 'application/json',
-    'Content-Type': 'application/json'
-};
-var DEFAULT_SCORE_API_URL = 'https://score.snapshot.org';
-function formatScoreAPIUrl(url, options) {
-    if (url === void 0) { url = DEFAULT_SCORE_API_URL; }
-    if (options === void 0) { options = {
-        path: ''
-    }; }
-    var scoreURL = new URL(url);
-    if (options.path)
-        scoreURL.pathname = options.path;
-    var apiKey = scoreURL.searchParams.get('apiKey');
-    var headers = __assign({}, scoreApiHeaders);
-    if (apiKey) {
-        scoreURL.searchParams.delete('apiKey');
-        headers = __assign(__assign({}, scoreApiHeaders), { 'X-API-KEY': apiKey });
-    }
-    return {
-        url: scoreURL.toString(),
-        headers: headers
-    };
-}
-function parseScoreAPIResponse(res) {
-    return __awaiter(this, void 0, void 0, function () {
-        var data;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, res.text()];
-                case 1:
-                    data = _a.sent();
-                    try {
-                        data = JSON.parse(data);
-                    }
-                    catch (e) {
-                        return [2 /*return*/, Promise.reject({
-                                code: res.status || 500,
-                                message: 'Failed to parse response from score API',
-                                data: data
-                            })];
-                    }
-                    if (data.error)
-                        return [2 /*return*/, Promise.reject(data.error)];
-                    return [2 /*return*/, data];
-            }
-        });
-    });
-}
-var ajv = new Ajv__default['default']({
-    allErrors: true,
-    allowUnionTypes: true,
-    $data: true,
-    passContext: true
-});
-// @ts-ignore
-addFormats__default['default'](ajv);
-addErrors__default['default'](ajv);
-ajv.addFormat('address', {
-    validate: function (value) {
-        try {
-            return address.isAddress(value);
-        }
-        catch (err) {
-            return false;
-        }
-    }
-});
-ajv.addFormat('evmOrStarknetAddress', {
-    validate: function (value) {
-        try {
-            return address.isAddress(value) || /^0x[0-9a-fA-F]{62,64}$/.test(value);
-        }
-        catch (err) {
-            return false;
-        }
-    }
-});
-ajv.addFormat('long', {
-    validate: function () { return true; }
-});
-ajv.addFormat('ethValue', {
-    validate: function (value) {
-        if (!value.match(/^([0-9]|[1-9][0-9]+)(\.[0-9]+)?$/))
-            return false;
-        try {
-            units.parseUnits(value, 18);
-            return true;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-});
-var networksIds = Object.keys(networks);
-var mainnetNetworkIds = Object.keys(networks).filter(function (id) { return !networks[id].testnet; });
-ajv.addKeyword({
-    keyword: 'snapshotNetwork',
-    validate: function (schema, data) {
-        // @ts-ignore
-        var snapshotEnv = this.snapshotEnv || 'default';
-        if (snapshotEnv === 'mainnet')
-            return mainnetNetworkIds.includes(data);
-        return networksIds.includes(data);
-    },
-    error: {
-        message: 'network not allowed'
-    }
-});
-ajv.addKeyword({
-    keyword: 'maxLengthWithSpaceType',
-    validate: function validate(schema, data) {
-        // @ts-ignore
-        var spaceType = this.spaceType || 'default';
-        var isValid = data.length <= schema[spaceType];
-        if (!isValid) {
-            // @ts-ignore
-            validate.errors = [
-                {
-                    keyword: 'maxLengthWithSpaceType',
-                    message: "must NOT have more than " + schema[spaceType] + " characters",
-                    params: { limit: schema[spaceType] }
-                }
-            ];
-        }
-        return isValid;
-    },
-    errors: true
-});
-ajv.addKeyword({
-    keyword: 'maxItemsWithSpaceType',
-    validate: function validate(schema, data) {
-        // @ts-ignore
-        var spaceType = this.spaceType || 'default';
-        var isValid = data.length <= schema[spaceType];
-        if (!isValid) {
-            // @ts-ignore
-            validate.errors = [
-                {
-                    keyword: 'maxItemsWithSpaceType',
-                    message: "must NOT have more than " + schema[spaceType] + " items",
-                    params: { limit: schema[spaceType] }
-                }
-            ];
-        }
-        return isValid;
-    },
-    errors: true
-});
-// Custom URL format to allow empty string values
-// https://github.com/snapshot-labs/snapshot.js/pull/541/files
-ajv.addFormat('customUrl', {
-    type: 'string',
-    validate: function (str) {
-        if (!str.length)
-            return true;
-        return (str.startsWith('http://') ||
-            str.startsWith('https://') ||
-            str.startsWith('ipfs://') ||
-            str.startsWith('ipns://') ||
-            str.startsWith('snapshot://'));
-    }
-});
-function call(provider, abi, call, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var contract, params, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    contract = new contracts.Contract(call[0], abi, provider);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    params = call[2] || [];
-                    return [4 /*yield*/, contract[call[1]].apply(contract, __spread(params, [options || {}]))];
-                case 2: return [2 /*return*/, _a.sent()];
-                case 3:
-                    e_1 = _a.sent();
-                    return [2 /*return*/, Promise.reject(e_1)];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
-}
-function multicall(network, provider, abi$1, calls, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var multicallAbi, multicallAddress, multi, itf, max_1, pages, promises_1, results, e_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    multicallAbi = [
-                        'function aggregate(tuple(address target, bytes callData)[] calls) view returns (uint256 blockNumber, bytes[] returnData)'
-                    ];
-                    multicallAddress = (options === null || options === void 0 ? void 0 : options.multicallAddress) || networks[network].multicall;
-                    multi = new contracts.Contract(multicallAddress, multicallAbi, provider);
-                    itf = new abi.Interface(abi$1);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    max_1 = (options === null || options === void 0 ? void 0 : options.limit) || 500;
-                    if (options === null || options === void 0 ? void 0 : options.limit)
-                        delete options.limit;
-                    pages = Math.ceil(calls.length / max_1);
-                    promises_1 = [];
-                    Array.from(Array(pages)).forEach(function (x, i) {
-                        var callsInPage = calls.slice(max_1 * i, max_1 * (i + 1));
-                        promises_1.push(multi.aggregate(callsInPage.map(function (call) { return [
-                            call[0].toLowerCase(),
-                            itf.encodeFunctionData(call[1], call[2])
-                        ]; }), options || {}));
-                    });
-                    return [4 /*yield*/, Promise.all(promises_1)];
-                case 2:
-                    results = _a.sent();
-                    results = results.reduce(function (prev, _a) {
-                        var _b = __read(_a, 2), res = _b[1];
-                        return prev.concat(res);
-                    }, []);
-                    return [2 /*return*/, results.map(function (call, i) {
-                            return itf.decodeFunctionResult(calls[i][1], call);
-                        })];
-                case 3:
-                    e_2 = _a.sent();
-                    return [2 /*return*/, Promise.reject(e_2)];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
-}
-function subgraphRequest(url, query, options) {
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var res, responseData, data;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, fetch__default['default'](url, {
-                        method: 'POST',
-                        headers: __assign({ Accept: 'application/json', 'Content-Type': 'application/json' }, options === null || options === void 0 ? void 0 : options.headers),
-                        body: JSON.stringify({ query: jsonToGraphqlQuery.jsonToGraphQLQuery({ query: query }) })
-                    })];
-                case 1:
-                    res = _a.sent();
-                    return [4 /*yield*/, res.text()];
-                case 2:
-                    responseData = _a.sent();
-                    try {
-                        responseData = JSON.parse(responseData);
-                    }
-                    catch (e) {
-                        throw new Error("Errors found in subgraphRequest: URL: " + url + ", Status: " + res.status + ", Response: " + responseData.substring(0, 400));
-                    }
-                    if (responseData.errors) {
-                        throw new Error("Errors found in subgraphRequest: URL: " + url + ", Status: " + res.status + ",  Response: " + JSON.stringify(responseData.errors).substring(0, 400));
-                    }
-                    data = responseData.data;
-                    return [2 /*return*/, data || {}];
-            }
-        });
-    });
-}
-function getUrl(uri, gateway) {
-    if (gateway === void 0) { gateway = gateways[0]; }
-    var ipfsGateway = "https://" + gateway;
-    if (!uri)
-        return null;
-    if (!uri.startsWith('ipfs://') &&
-        !uri.startsWith('ipns://') &&
-        !uri.startsWith('https://') &&
-        !uri.startsWith('http://'))
-        return ipfsGateway + "/ipfs/" + uri;
-    var uriScheme = uri.split('://')[0];
-    if (uriScheme === 'ipfs')
-        return uri.replace('ipfs://', ipfsGateway + "/ipfs/");
-    if (uriScheme === 'ipns')
-        return uri.replace('ipns://', ipfsGateway + "/ipns/");
-    return uri;
-}
-function getJSON(uri, options) {
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var url;
-        return __generator(this, function (_a) {
-            url = getUrl(uri, options.gateways);
-            return [2 /*return*/, fetch__default['default'](url).then(function (res) { return res.json(); })];
-        });
-    });
-}
-function ipfsGet(gateway, ipfsHash, protocolType) {
-    if (protocolType === void 0) { protocolType = 'ipfs'; }
-    return __awaiter(this, void 0, void 0, function () {
-        var url;
-        return __generator(this, function (_a) {
-            url = "https://" + gateway + "/" + protocolType + "/" + ipfsHash;
-            return [2 /*return*/, fetch__default['default'](url).then(function (res) { return res.json(); })];
-        });
-    });
-}
-function sendTransaction(web3, contractAddress, abi, action, params, overrides) {
-    if (overrides === void 0) { overrides = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var signer, contract, contractWithSigner;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    signer = web3.getSigner();
-                    contract = new contracts.Contract(contractAddress, abi, web3);
-                    contractWithSigner = contract.connect(signer);
-                    return [4 /*yield*/, contractWithSigner[action].apply(contractWithSigner, __spread(params, [overrides]))];
-                case 1: 
-                // overrides.gasLimit = 12e6;
-                return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
-function getScores(space, strategies, network, addresses, snapshot, scoreApiUrl, options) {
-    if (snapshot === void 0) { snapshot = 'latest'; }
-    if (scoreApiUrl === void 0) { scoreApiUrl = DEFAULT_SCORE_API_URL; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var invalidAddress, invalidStrategy, urlObject, _a, url, headers, params, res, response, e_3;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!Array.isArray(addresses)) {
-                        return [2 /*return*/, inputError('addresses should be an array of addresses')];
-                    }
-                    if (addresses.length === 0) {
-                        return [2 /*return*/, inputError('addresses can not be empty')];
-                    }
-                    invalidAddress = addresses.find(function (address) { return !isValidAddress(address); });
-                    if (invalidAddress) {
-                        return [2 /*return*/, inputError("Invalid address: " + invalidAddress)];
-                    }
-                    if (!isValidNetwork(network)) {
-                        return [2 /*return*/, inputError("Invalid network: " + network)];
-                    }
-                    invalidStrategy = strategies.find(function (strategy) { return strategy.network && !isValidNetwork(strategy.network); });
-                    if (invalidStrategy) {
-                        return [2 /*return*/, inputError("Invalid network (" + invalidStrategy.network + ") in strategy " + invalidStrategy.name)];
-                    }
-                    if (!isValidSnapshot(snapshot, network)) {
-                        return [2 /*return*/, inputError("Snapshot (" + snapshot + ") must be 'latest' or greater than network start block (" + networks[network].start + ")")];
-                    }
-                    urlObject = new URL(scoreApiUrl);
-                    urlObject.pathname = '/api/scores';
-                    _a = formatScoreAPIUrl(scoreApiUrl, {
-                        path: '/api/scores'
-                    }), url = _a.url, headers = _a.headers;
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 5]);
-                    params = {
-                        space: space,
-                        network: network,
-                        snapshot: snapshot,
-                        strategies: strategies,
-                        addresses: addresses
-                    };
-                    return [4 /*yield*/, fetch__default['default'](url, {
-                            method: 'POST',
-                            headers: headers,
-                            body: JSON.stringify({ params: params })
-                        })];
-                case 2:
-                    res = _b.sent();
-                    return [4 /*yield*/, parseScoreAPIResponse(res)];
-                case 3:
-                    response = _b.sent();
-                    return [2 /*return*/, options.returnValue === 'all'
-                            ? response.result
-                            : response.result[options.returnValue || 'scores']];
-                case 4:
-                    e_3 = _b.sent();
-                    if (e_3.errno) {
-                        return [2 /*return*/, Promise.reject({ code: e_3.errno, message: e_3.toString(), data: '' })];
-                    }
-                    return [2 /*return*/, Promise.reject(e_3)];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
-}
-function getVp(address, network, strategies, snapshot, space, delegation, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, url, headers, invalidStrategy, init, res, response, e_4;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _a = formatScoreAPIUrl(options === null || options === void 0 ? void 0 : options.url), url = _a.url, headers = _a.headers;
-                    if (!isValidAddress(address)) {
-                        return [2 /*return*/, inputError("Invalid voter address: " + address)];
-                    }
-                    if (!isValidNetwork(network)) {
-                        return [2 /*return*/, inputError("Invalid network: " + network)];
-                    }
-                    invalidStrategy = strategies.find(function (strategy) { return strategy.network && !isValidNetwork(strategy.network); });
-                    if (invalidStrategy) {
-                        return [2 /*return*/, inputError("Invalid network (" + invalidStrategy.network + ") in strategy " + invalidStrategy.name)];
-                    }
-                    if (!isValidSnapshot(snapshot, network)) {
-                        return [2 /*return*/, inputError("Snapshot (" + snapshot + ") must be 'latest' or greater than network start block (" + networks[network].start + ")")];
-                    }
-                    init = {
-                        method: 'POST',
-                        headers: headers,
-                        body: JSON.stringify({
-                            jsonrpc: '2.0',
-                            method: 'get_vp',
-                            params: {
-                                address: address,
-                                network: network,
-                                strategies: strategies,
-                                snapshot: snapshot,
-                                space: space,
-                                delegation: delegation
-                            }
-                        })
-                    };
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, fetch__default['default'](url, init)];
-                case 2:
-                    res = _b.sent();
-                    return [4 /*yield*/, parseScoreAPIResponse(res)];
-                case 3:
-                    response = _b.sent();
-                    return [2 /*return*/, response.result];
-                case 4:
-                    e_4 = _b.sent();
-                    if (e_4.errno) {
-                        return [2 /*return*/, Promise.reject({ code: e_4.errno, message: e_4.toString(), data: '' })];
-                    }
-                    return [2 /*return*/, Promise.reject(e_4)];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
-}
-function validate(validation, author, space, network, snapshot, params, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, url, headers, init, res, response, e_5;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!isValidAddress(author)) {
-                        return [2 /*return*/, inputError("Invalid author: " + author)];
-                    }
-                    if (!isValidNetwork(network)) {
-                        return [2 /*return*/, inputError("Invalid network: " + network)];
-                    }
-                    if (!isValidSnapshot(snapshot, network)) {
-                        return [2 /*return*/, inputError("Snapshot (" + snapshot + ") must be 'latest' or greater than network start block (" + networks[network].start + ")")];
-                    }
-                    if (!options)
-                        options = {};
-                    _a = formatScoreAPIUrl(options.url), url = _a.url, headers = _a.headers;
-                    init = {
-                        method: 'POST',
-                        headers: headers,
-                        body: JSON.stringify({
-                            jsonrpc: '2.0',
-                            method: 'validate',
-                            params: {
-                                validation: validation,
-                                author: author,
-                                space: space,
-                                network: network,
-                                snapshot: snapshot,
-                                params: params
-                            }
-                        })
-                    };
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, fetch__default['default'](url, init)];
-                case 2:
-                    res = _b.sent();
-                    return [4 /*yield*/, parseScoreAPIResponse(res)];
-                case 3:
-                    response = _b.sent();
-                    return [2 /*return*/, response.result];
-                case 4:
-                    e_5 = _b.sent();
-                    if (e_5.errno) {
-                        return [2 /*return*/, Promise.reject({ code: e_5.errno, message: e_5.toString(), data: '' })];
-                    }
-                    return [2 /*return*/, Promise.reject(e_5)];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
-}
-function validateSchema(schema, data, options) {
-    if (options === void 0) { options = {
-        snapshotEnv: 'default',
-        spaceType: 'default'
-    }; }
-    var ajvValidate = ajv.compile(schema);
-    var valid = ajvValidate.call(options, data);
-    return valid ? valid : ajvValidate.errors;
-}
-function getEnsTextRecord(ens, record, network, options) {
-    if (network === void 0) { network = '1'; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var ensResolversOpt, broviderUrl, multicallOptions, ensResolvers, ensHash, provider, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    ensResolversOpt = options.ensResolvers, broviderUrl = options.broviderUrl, multicallOptions = __rest(options, ["ensResolvers", "broviderUrl"]);
-                    ensResolvers = ensResolversOpt ||
-                        networks[network].ensResolvers ||
-                        networks['1'].ensResolvers;
-                    ensHash = hash.namehash(hash.ensNormalize(ens));
-                    provider = getProvider(network, { broviderUrl: broviderUrl });
-                    return [4 /*yield*/, multicall(network, provider, ENS_RESOLVER_ABI, ensResolvers.map(function (address) { return [address, 'text', [ensHash, record]]; }), multicallOptions)];
-                case 1:
-                    result = _a.sent();
-                    return [2 /*return*/, result.flat().find(function (r) { return r; }) || ''];
-            }
-        });
-    });
-}
-function getSpaceUri(id, network, options) {
-    if (network === void 0) { network = '1'; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var e_6;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, getEnsTextRecord(id, 'snapshot', network, options)];
-                case 1: return [2 /*return*/, _a.sent()];
-                case 2:
-                    e_6 = _a.sent();
-                    console.log(e_6);
-                    return [2 /*return*/, null];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-}
-function getEnsOwner(ens, network, options) {
-    if (network === void 0) { network = '1'; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var registryAddress, provider, ensRegistry, ensNameWrapper, ensHash, owner, ensNameWrapperContract;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    registryAddress = '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e';
-                    provider = getProvider(network, options);
-                    ensRegistry = new contracts.Contract(registryAddress, ['function owner(bytes32) view returns (address)'], provider);
-                    ensNameWrapper = options.ensNameWrapper || networks[network].ensNameWrapper;
-                    ensHash = hash.namehash(hash.ensNormalize(ens));
-                    return [4 /*yield*/, ensRegistry.owner(ensHash)];
-                case 1:
-                    owner = _a.sent();
-                    if (!(owner === ensNameWrapper)) return [3 /*break*/, 3];
-                    ensNameWrapperContract = new contracts.Contract(ensNameWrapper, ['function ownerOf(uint256) view returns (address)'], provider);
-                    return [4 /*yield*/, ensNameWrapperContract.ownerOf(ensHash)];
-                case 2:
-                    owner = _a.sent();
-                    _a.label = 3;
-                case 3: return [2 /*return*/, owner];
-            }
-        });
-    });
-}
-function getSpaceController(id, network, options) {
-    if (network === void 0) { network = '1'; }
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        var spaceUri, isUriAddress, uriParts, position, address$1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getSpaceUri(id, network, options)];
-                case 1:
-                    spaceUri = _a.sent();
-                    if (spaceUri) {
-                        isUriAddress = address.isAddress(spaceUri);
-                        if (isUriAddress)
-                            return [2 /*return*/, spaceUri];
-                        uriParts = spaceUri.split('/');
-                        position = uriParts.includes('testnet') ? 5 : 4;
-                        address$1 = uriParts[position];
-                        isUriAddress = address.isAddress(address$1);
-                        if (isUriAddress)
-                            return [2 /*return*/, address$1];
-                    }
-                    return [4 /*yield*/, getEnsOwner(id, network, options)];
-                case 2: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
-function clone(item) {
-    return JSON.parse(JSON.stringify(item));
-}
-function sleep(time) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, new Promise(function (resolve) {
-                    setTimeout(resolve, time);
-                })];
-        });
-    });
-}
-function getNumberWithOrdinal(n) {
-    var s = ['th', 'st', 'nd', 'rd'], v = n % 100;
-    return n + (s[(v - 20) % 10] || s[v] || s[0]);
-}
-function isValidNetwork(network) {
-    return !!networks[network];
-}
-function isValidAddress(address$1) {
-    return address.isAddress(address$1) && address$1 !== EMPTY_ADDRESS;
-}
-function isValidSnapshot(snapshot, network) {
-    return (snapshot === 'latest' ||
-        (typeof snapshot === 'number' && snapshot >= networks[network].start));
-}
-function inputError(message) {
-    return Promise.reject(new Error(message));
-}
-var utils = {
-    call: call,
-    multicall: multicall,
-    subgraphRequest: subgraphRequest,
-    ipfsGet: ipfsGet,
-    getUrl: getUrl,
-    getJSON: getJSON,
-    sendTransaction: sendTransaction,
-    getScores: getScores,
-    getVp: getVp,
-    validateSchema: validateSchema,
-    getEnsTextRecord: getEnsTextRecord,
-    getSpaceUri: getSpaceUri,
-    getEnsOwner: getEnsOwner,
-    getSpaceController: getSpaceController,
-    getDelegatesBySpace: getDelegatesBySpace,
-    clone: clone,
-    sleep: sleep,
-    getNumberWithOrdinal: getNumberWithOrdinal,
-    voting: voting,
-    getProvider: getProvider,
-    signMessage: signMessage,
-    getBlockNumber: getBlockNumber,
-    Multicaller: Multicaller,
-    getSnapshots: getSnapshots,
-    getHash: getHash,
-    verify: verify$1,
-    validate: validate,
-    SNAPSHOT_SUBGRAPH_URL: SNAPSHOT_SUBGRAPH_URL
+const ENS_RESOLVER_ABI = [
+    'function text(bytes32 node, string calldata key) external view returns (string memory)'
+];
+const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000';
+const scoreApiHeaders = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json'
+};
+const DEFAULT_SCORE_API_URL = 'https://score.snapshot.org';
+function formatScoreAPIUrl(url = DEFAULT_SCORE_API_URL, options = {
+    path: ''
+}) {
+    const scoreURL = new URL(url);
+    if (options.path)
+        scoreURL.pathname = options.path;
+    const apiKey = scoreURL.searchParams.get('apiKey');
+    let headers = Object.assign({}, scoreApiHeaders);
+    if (apiKey) {
+        scoreURL.searchParams.delete('apiKey');
+        headers = Object.assign(Object.assign({}, scoreApiHeaders), { 'X-API-KEY': apiKey });
+    }
+    return {
+        url: scoreURL.toString(),
+        headers
+    };
+}
+function parseScoreAPIResponse(res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let data = yield res.text();
+        try {
+            data = JSON.parse(data);
+        }
+        catch (e) {
+            return Promise.reject({
+                code: res.status || 500,
+                message: 'Failed to parse response from score API',
+                data
+            });
+        }
+        if (data.error)
+            return Promise.reject(data.error);
+        return data;
+    });
+}
+const ajv = new Ajv__default['default']({
+    allErrors: true,
+    allowUnionTypes: true,
+    $data: true,
+    passContext: true
+});
+// @ts-ignore
+addFormats__default['default'](ajv);
+addErrors__default['default'](ajv);
+ajv.addFormat('address', {
+    validate: (value) => {
+        try {
+            return address.isAddress(value);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+});
+ajv.addFormat('starknetAddress', {
+    validate: (value) => {
+        try {
+            return isStarknetAddress(value);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+});
+ajv.addFormat('long', {
+    validate: () => true
+});
+ajv.addFormat('ethValue', {
+    validate: (value) => {
+        if (!value.match(/^([0-9]|[1-9][0-9]+)(\.[0-9]+)?$/))
+            return false;
+        try {
+            units.parseUnits(value, 18);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+});
+const networksIds = Object.keys(networks);
+const mainnetNetworkIds = Object.keys(networks).filter((id) => !networks[id].testnet);
+ajv.addKeyword({
+    keyword: 'snapshotNetwork',
+    validate: function (schema, data) {
+        // @ts-ignore
+        const snapshotEnv = this.snapshotEnv || 'default';
+        if (snapshotEnv === 'mainnet')
+            return mainnetNetworkIds.includes(data);
+        return networksIds.includes(data);
+    },
+    error: {
+        message: 'network not allowed'
+    }
+});
+ajv.addKeyword({
+    keyword: 'maxLengthWithSpaceType',
+    validate: function validate(schema, data) {
+        // @ts-ignore
+        const spaceType = this.spaceType || 'default';
+        const isValid = data.length <= schema[spaceType];
+        if (!isValid) {
+            // @ts-ignore
+            validate.errors = [
+                {
+                    keyword: 'maxLengthWithSpaceType',
+                    message: `must NOT have more than ${schema[spaceType]} characters`,
+                    params: { limit: schema[spaceType] }
+                }
+            ];
+        }
+        return isValid;
+    },
+    errors: true
+});
+ajv.addKeyword({
+    keyword: 'maxItemsWithSpaceType',
+    validate: function validate(schema, data) {
+        // @ts-ignore
+        const spaceType = this.spaceType || 'default';
+        const isValid = data.length <= schema[spaceType];
+        if (!isValid) {
+            // @ts-ignore
+            validate.errors = [
+                {
+                    keyword: 'maxItemsWithSpaceType',
+                    message: `must NOT have more than ${schema[spaceType]} items`,
+                    params: { limit: schema[spaceType] }
+                }
+            ];
+        }
+        return isValid;
+    },
+    errors: true
+});
+// Custom URL format to allow empty string values
+// https://github.com/snapshot-labs/snapshot.js/pull/541/files
+ajv.addFormat('customUrl', {
+    type: 'string',
+    validate: (str) => {
+        if (!str.length)
+            return true;
+        return (str.startsWith('http://') ||
+            str.startsWith('https://') ||
+            str.startsWith('ipfs://') ||
+            str.startsWith('ipns://') ||
+            str.startsWith('snapshot://'));
+    }
+});
+function call(provider, abi, call, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contract = new contracts.Contract(call[0], abi, provider);
+        try {
+            const params = call[2] || [];
+            return yield contract[call[1]](...params, options || {});
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+}
+function multicall(network, provider, abi$1, calls, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const multicallAbi = [
+            'function aggregate(tuple(address target, bytes callData)[] calls) view returns (uint256 blockNumber, bytes[] returnData)'
+        ];
+        const multicallAddress = (options === null || options === void 0 ? void 0 : options.multicallAddress) || networks[network].multicall;
+        const multi = new contracts.Contract(multicallAddress, multicallAbi, provider);
+        const itf = new abi.Interface(abi$1);
+        try {
+            const max = (options === null || options === void 0 ? void 0 : options.limit) || 500;
+            if (options === null || options === void 0 ? void 0 : options.limit)
+                delete options.limit;
+            const pages = Math.ceil(calls.length / max);
+            const promises = [];
+            Array.from(Array(pages)).forEach((x, i) => {
+                const callsInPage = calls.slice(max * i, max * (i + 1));
+                promises.push(multi.aggregate(callsInPage.map((call) => [
+                    call[0].toLowerCase(),
+                    itf.encodeFunctionData(call[1], call[2])
+                ]), options || {}));
+            });
+            let results = yield Promise.all(promises);
+            results = results.reduce((prev, [, res]) => prev.concat(res), []);
+            return results.map((call, i) => itf.decodeFunctionResult(calls[i][1], call));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    });
+}
+function subgraphRequest(url_1, query_1) {
+    return __awaiter(this, arguments, void 0, function* (url, query, options = {}) {
+        const res = yield fetch__default['default'](url, {
+            method: 'POST',
+            headers: Object.assign({ Accept: 'application/json', 'Content-Type': 'application/json' }, options === null || options === void 0 ? void 0 : options.headers),
+            body: JSON.stringify({ query: jsonToGraphqlQuery.jsonToGraphQLQuery({ query }) })
+        });
+        let responseData = yield res.text();
+        try {
+            responseData = JSON.parse(responseData);
+        }
+        catch (e) {
+            throw new Error(`Errors found in subgraphRequest: URL: ${url}, Status: ${res.status}, Response: ${responseData.substring(0, 400)}`);
+        }
+        if (responseData.errors) {
+            throw new Error(`Errors found in subgraphRequest: URL: ${url}, Status: ${res.status},  Response: ${JSON.stringify(responseData.errors).substring(0, 400)}`);
+        }
+        const { data } = responseData;
+        return data || {};
+    });
+}
+function getUrl(uri, gateway = gateways[0]) {
+    const ipfsGateway = `https://${gateway}`;
+    if (!uri)
+        return null;
+    if (!uri.startsWith('ipfs://') &&
+        !uri.startsWith('ipns://') &&
+        !uri.startsWith('https://') &&
+        !uri.startsWith('http://'))
+        return `${ipfsGateway}/ipfs/${uri}`;
+    const uriScheme = uri.split('://')[0];
+    if (uriScheme === 'ipfs')
+        return uri.replace('ipfs://', `${ipfsGateway}/ipfs/`);
+    if (uriScheme === 'ipns')
+        return uri.replace('ipns://', `${ipfsGateway}/ipns/`);
+    return uri;
+}
+function getJSON(uri_1) {
+    return __awaiter(this, arguments, void 0, function* (uri, options = {}) {
+        const url = getUrl(uri, options.gateways);
+        return fetch__default['default'](url).then((res) => res.json());
+    });
+}
+function ipfsGet(gateway_1, ipfsHash_1) {
+    return __awaiter(this, arguments, void 0, function* (gateway, ipfsHash, protocolType = 'ipfs') {
+        const url = `https://${gateway}/${protocolType}/${ipfsHash}`;
+        return fetch__default['default'](url).then((res) => res.json());
+    });
+}
+function sendTransaction(web3_1, contractAddress_1, abi_1, action_1, params_1) {
+    return __awaiter(this, arguments, void 0, function* (web3, contractAddress, abi, action, params, overrides = {}) {
+        const signer = web3.getSigner();
+        const contract = new contracts.Contract(contractAddress, abi, web3);
+        const contractWithSigner = contract.connect(signer);
+        // overrides.gasLimit = 12e6;
+        return yield contractWithSigner[action](...params, overrides);
+    });
+}
+function getScores(space_1, strategies_1, network_1, addresses_1) {
+    return __awaiter(this, arguments, void 0, function* (space, strategies, network, addresses, snapshot = 'latest', scoreApiUrl = DEFAULT_SCORE_API_URL, options = {}) {
+        if (!Array.isArray(addresses)) {
+            return inputError('addresses should be an array of addresses');
+        }
+        if (addresses.length === 0) {
+            return inputError('addresses can not be empty');
+        }
+        const invalidAddress = addresses.find((address) => !isValidAddress(address));
+        if (invalidAddress) {
+            return inputError(`Invalid address: ${invalidAddress}`);
+        }
+        if (!isValidNetwork(network)) {
+            return inputError(`Invalid network: ${network}`);
+        }
+        const invalidStrategy = strategies.find((strategy) => strategy.network && !isValidNetwork(strategy.network));
+        if (invalidStrategy) {
+            return inputError(`Invalid network (${invalidStrategy.network}) in strategy ${invalidStrategy.name}`);
+        }
+        if (!isValidSnapshot(snapshot, network)) {
+            return inputError(`Snapshot (${snapshot}) must be 'latest' or greater than network start block (${networks[network].start})`);
+        }
+        const urlObject = new URL(scoreApiUrl);
+        urlObject.pathname = '/api/scores';
+        const { url, headers } = formatScoreAPIUrl(scoreApiUrl, {
+            path: '/api/scores'
+        });
+        try {
+            const params = {
+                space,
+                network,
+                snapshot,
+                strategies,
+                addresses
+            };
+            const res = yield fetch__default['default'](url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ params })
+            });
+            const response = yield parseScoreAPIResponse(res);
+            return options.returnValue === 'all'
+                ? response.result
+                : response.result[options.returnValue || 'scores'];
+        }
+        catch (e) {
+            if (e.errno) {
+                return Promise.reject({ code: e.errno, message: e.toString(), data: '' });
+            }
+            return Promise.reject(e);
+        }
+    });
+}
+function getVp(address, network, strategies, snapshot, space, delegation, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { url, headers } = formatScoreAPIUrl(options === null || options === void 0 ? void 0 : options.url);
+        if (!isValidAddress(address)) {
+            return inputError(`Invalid voter address: ${address}`);
+        }
+        if (!isValidNetwork(network)) {
+            return inputError(`Invalid network: ${network}`);
+        }
+        const invalidStrategy = strategies.find((strategy) => strategy.network && !isValidNetwork(strategy.network));
+        if (invalidStrategy) {
+            return inputError(`Invalid network (${invalidStrategy.network}) in strategy ${invalidStrategy.name}`);
+        }
+        if (!isValidSnapshot(snapshot, network)) {
+            return inputError(`Snapshot (${snapshot}) must be 'latest' or greater than network start block (${networks[network].start})`);
+        }
+        const init = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'get_vp',
+                params: {
+                    address,
+                    network,
+                    strategies,
+                    snapshot,
+                    space,
+                    delegation
+                }
+            })
+        };
+        try {
+            const res = yield fetch__default['default'](url, init);
+            const response = yield parseScoreAPIResponse(res);
+            return response.result;
+        }
+        catch (e) {
+            if (e.errno) {
+                return Promise.reject({ code: e.errno, message: e.toString(), data: '' });
+            }
+            return Promise.reject(e);
+        }
+    });
+}
+function validate(validation, author, space, network, snapshot, params, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!isValidAddress(author)) {
+            return inputError(`Invalid author: ${author}`);
+        }
+        if (!isValidNetwork(network)) {
+            return inputError(`Invalid network: ${network}`);
+        }
+        if (!isValidSnapshot(snapshot, network)) {
+            return inputError(`Snapshot (${snapshot}) must be 'latest' or greater than network start block (${networks[network].start})`);
+        }
+        if (!options)
+            options = {};
+        const { url, headers } = formatScoreAPIUrl(options.url);
+        const init = {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'validate',
+                params: {
+                    validation,
+                    author,
+                    space,
+                    network,
+                    snapshot,
+                    params
+                }
+            })
+        };
+        try {
+            const res = yield fetch__default['default'](url, init);
+            const response = yield parseScoreAPIResponse(res);
+            return response.result;
+        }
+        catch (e) {
+            if (e.errno) {
+                return Promise.reject({ code: e.errno, message: e.toString(), data: '' });
+            }
+            return Promise.reject(e);
+        }
+    });
+}
+function validateSchema(schema, data, options = {
+    snapshotEnv: 'default',
+    spaceType: 'default'
+}) {
+    const ajvValidate = ajv.compile(schema);
+    const valid = ajvValidate.call(options, data);
+    return valid ? valid : ajvValidate.errors;
+}
+function getEnsTextRecord(ens_1, record_1) {
+    return __awaiter(this, arguments, void 0, function* (ens, record, network = '1', options = {}) {
+        const { ensResolvers: ensResolversOpt, broviderUrl } = options, multicallOptions = __rest(options, ["ensResolvers", "broviderUrl"]);
+        const ensResolvers = ensResolversOpt ||
+            networks[network].ensResolvers ||
+            networks['1'].ensResolvers;
+        const ensHash = hash.namehash(hash.ensNormalize(ens));
+        const provider = getProvider(network, { broviderUrl });
+        const result = yield multicall(network, provider, ENS_RESOLVER_ABI, ensResolvers.map((address) => [address, 'text', [ensHash, record]]), multicallOptions);
+        return result.flat().find((r) => r) || '';
+    });
+}
+function getSpaceUri(id_1) {
+    return __awaiter(this, arguments, void 0, function* (id, network = '1', options = {}) {
+        try {
+            return yield getEnsTextRecord(id, 'snapshot', network, options);
+        }
+        catch (e) {
+            console.log(e);
+            return null;
+        }
+    });
+}
+function getEnsOwner(ens_1) {
+    return __awaiter(this, arguments, void 0, function* (ens, network = '1', options = {}) {
+        const registryAddress = '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e';
+        const provider = getProvider(network, options);
+        const ensRegistry = new contracts.Contract(registryAddress, ['function owner(bytes32) view returns (address)'], provider);
+        const ensNameWrapper = options.ensNameWrapper || networks[network].ensNameWrapper;
+        const ensHash = hash.namehash(hash.ensNormalize(ens));
+        let owner = yield ensRegistry.owner(ensHash);
+        // If owner is the ENSNameWrapper contract, resolve the owner of the name
+        if (owner === ensNameWrapper) {
+            const ensNameWrapperContract = new contracts.Contract(ensNameWrapper, ['function ownerOf(uint256) view returns (address)'], provider);
+            owner = yield ensNameWrapperContract.ownerOf(ensHash);
+        }
+        return owner;
+    });
+}
+function getSpaceController(id_1) {
+    return __awaiter(this, arguments, void 0, function* (id, network = '1', options = {}) {
+        const spaceUri = yield getSpaceUri(id, network, options);
+        if (spaceUri) {
+            let isUriAddress = address.isAddress(spaceUri);
+            if (isUriAddress)
+                return spaceUri;
+            const uriParts = spaceUri.split('/');
+            const position = uriParts.includes('testnet') ? 5 : 4;
+            const address$1 = uriParts[position];
+            isUriAddress = address.isAddress(address$1);
+            if (isUriAddress)
+                return address$1;
+        }
+        return yield getEnsOwner(id, network, options);
+    });
+}
+function clone(item) {
+    return JSON.parse(JSON.stringify(item));
+}
+function sleep(time) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            setTimeout(resolve, time);
+        });
+    });
+}
+function getNumberWithOrdinal(n) {
+    const s = ['th', 'st', 'nd', 'rd'], v = n % 100;
+    return n + (s[(v - 20) % 10] || s[v] || s[0]);
+}
+function isValidNetwork(network) {
+    return !!networks[network];
+}
+function isValidAddress(address$1) {
+    return address.isAddress(address$1) && address$1 !== EMPTY_ADDRESS;
+}
+function isValidSnapshot(snapshot, network) {
+    return (snapshot === 'latest' ||
+        (typeof snapshot === 'number' && snapshot >= networks[network].start));
+}
+function isStarknetAddress(address) {
+    if (!address)
+        return false;
+    try {
+        starknet$1.validateAndParseAddress(address);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function isEvmAddress(address$1) {
+    return address.isAddress(address$1);
+}
+function getFormattedAddress(address$1, format = ['evm', 'starknet']) {
+    if (format.includes('evm') && address.isAddress(address$1))
+        return address.getAddress(address$1);
+    if (format.includes('starknet') && isStarknetAddress(address$1))
+        return starknet$1.validateAndParseAddress(address$1);
+    throw new Error(`Invalid address: ${address$1}`);
+}
+function inputError(message) {
+    return Promise.reject(new Error(message));
+}
+var utils = {
+    call,
+    multicall,
+    subgraphRequest,
+    ipfsGet,
+    getUrl,
+    getJSON,
+    sendTransaction,
+    getScores,
+    getVp,
+    validateSchema,
+    getEnsTextRecord,
+    getSpaceUri,
+    getEnsOwner,
+    getSpaceController,
+    getDelegatesBySpace,
+    clone,
+    sleep,
+    getNumberWithOrdinal,
+    voting,
+    getProvider,
+    signMessage,
+    getBlockNumber,
+    Multicaller,
+    getSnapshots,
+    getHash: getHash$2,
+    verify: verify$2,
+    validate,
+    isStarknetAddress,
+    isEvmAddress,
+    getFormattedAddress,
+    SNAPSHOT_SUBGRAPH_URL
 };
 
-var index = {
-    Client: Client,
-    Client712: Client,
-    schemas: schemas,
-    utils: utils
+var index = {
+    Client: Client,
+    Client712: Client,
+    schemas,
+    utils
 };
 
 module.exports = index;