@snapshot-labs/snapshot.js 0.2.2 → 0.2.6

package/src/plugins/safeSnap/index.ts

@@ -43,7 +43,8 @@ const ModuleAbi = [
   'event ProposalQuestionCreated(bytes32 indexed questionId, string indexed proposalId)',
 
   // Read functions
-  'function executor() view returns (address)',
+  'function avatar() view returns (address)', // Reality Module
+  'function executor() view returns (address)', // Dao Module
   'function oracle() view returns (address)',
   'function questionCooldown() view returns (uint32)',
   'function buildQuestion(string proposalId, bytes32[] txHashes) view returns (string)',
@@ -179,12 +180,26 @@ const getModuleDetails = async (
   cooldown: number;
   minimumBond: number;
 }> => {
-  const moduleDetails = await multicall(network, provider, ModuleAbi, [
-    [moduleAddress, 'executor'],
-    [moduleAddress, 'oracle'],
-    [moduleAddress, 'questionCooldown'],
-    [moduleAddress, 'minimumBond']
-  ]);
+  let moduleDetails;
+  try {
+    // Assume module is Reality Module
+    moduleDetails = await multicall(network, provider, ModuleAbi, [
+      [moduleAddress, 'avatar'],
+      [moduleAddress, 'oracle'],
+      [moduleAddress, 'questionCooldown'],
+      [moduleAddress, 'minimumBond']
+    ]);
+  } catch (err) {
+    // The Reality Module doesn't have an avatar field, causing tx to fails.
+    // Assume module is Dao Module (old version)
+    moduleDetails = await multicall(network, provider, ModuleAbi, [
+      [moduleAddress, 'executor'],
+      [moduleAddress, 'oracle'],
+      [moduleAddress, 'questionCooldown'],
+      [moduleAddress, 'minimumBond']
+    ]);
+  }
+
   return {
     dao: moduleDetails[0][0],
     oracle: moduleDetails[1][0],

package/src/sign/eip1271.ts

@@ -49,8 +49,8 @@ export async function verifyOldVersion(
   return returnValue.toLowerCase() === magicValue.toLowerCase();
 }
 
-export async function verify(address, sig, hash) {
-  const provider = getProvider('1');
+export async function verify(address, sig, hash, network = '1') {
+  const provider = getProvider(network);
   if (await verifyDefault(address, sig, hash, provider)) return true;
   return await verifyOldVersion(address, sig, hash, provider);
 }

package/src/sign/index.ts

@@ -42,12 +42,12 @@ export default class Client {
   }
 
   async sign(web3: Web3Provider | Wallet, address: string, message, types) {
-    if (!message.from) message.from = address;
-    if (!message.timestamp) message.timestamp = ~~(Date.now() / 1e3);
-    const data: any = { domain, types, message };
     let signer;
     if (web3 instanceof Wallet) signer = web3;
     if (web3 instanceof Web3Provider) signer = web3.getSigner();
+    if (!message.from) message.from = address;
+    if (!message.timestamp) message.timestamp = ~~(Date.now() / 1e3);
+    const data: any = { domain, types, message };
     const sig = await signer._signTypedData(domain, data.types, message);
     console.log('Sign', { address, sig, data });
     return await this.send({ address, sig, data });
@@ -109,11 +109,15 @@ export default class Client {
     return await this.sign(web3, address, message, type);
   }
 
-  async follow(web3: Wallet, address: string, message: Follow) {
+  async follow(web3: Web3Provider | Wallet, address: string, message: Follow) {
     return await this.sign(web3, address, message, followTypes);
   }
 
-  async unfollow(web3: Wallet, address: string, message: Unfollow) {
+  async unfollow(
+    web3: Web3Provider | Wallet,
+    address: string,
+    message: Unfollow
+  ) {
     return await this.sign(web3, address, message, unfollowTypes);
   }
 

package/src/strategies/aave-governance-power/dist/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (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 };
+    }
+};
+exports.__esModule = true;
+exports.strategy = exports.about = exports.examples = exports.version = exports.author = void 0;
+var units_1 = require("@ethersproject/units");
+var utils_1 = require("../../utils");
+var examples_json_1 = require("./examples.json");
+exports.author = 'kartojal';
+exports.version = '0.1.0';
+exports.examples = examples_json_1["default"];
+exports.about = '';
+/**
+ * Aave Governance strategy to measure voting or
+ */
+var abi = [
+    {
+        inputs: [
+            { internalType: 'address', name: 'user', type: 'address' },
+            { internalType: 'uint256', name: 'blockNumber', type: 'uint256' }
+        ],
+        name: 'getPropositionPowerAt',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            { internalType: 'address', name: 'user', type: 'address' },
+            { internalType: 'uint256', name: 'blockNumber', type: 'uint256' }
+        ],
+        name: 'getVotingPowerAt',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function'
+    }
+];
+var powerTypesToMethod = {
+    vote: 'getVotingPowerAt',
+    proposition: 'getPropositionPowerAt'
+};
+function strategy(space, network, provider, addresses, options, snapshot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var blockTag, _a, response;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!(typeof snapshot === 'number')) return [3 /*break*/, 1];
+                    _a = snapshot;
+                    return [3 /*break*/, 3];
+                case 1: return [4 /*yield*/, provider.getBlockNumber(snapshot)];
+                case 2:
+                    _a = _b.sent();
+                    _b.label = 3;
+                case 3:
+                    blockTag = _a;
+                    // Early return 0 voting power if governanceStrategy or powerType is not correctly set
+                    if (!options.governanceStrategy || !powerTypesToMethod[options.powerType]) {
+                        return [2 /*return*/, Object.fromEntries(addresses.map(function (address) { return [address, '0']; }))];
+                    }
+                    return [4 /*yield*/, utils_1.multicall(network, provider, abi, addresses.map(function (address) { return [
+                            options.governanceStrategy,
+                            powerTypesToMethod[options.powerType],
+                            [address.toLowerCase(), blockTag]
+                        ]; }), { blockTag: blockTag })];
+                case 4:
+                    response = _b.sent();
+                    return [2 /*return*/, Object.fromEntries(response.map(function (value, i) { return [
+                            addresses[i],
+                            parseFloat(units_1.formatUnits(value.toString(), options.decimals))
+                        ]; }))];
+            }
+        });
+    });
+}
+exports.strategy = strategy;

package/src/strategies/aavegotchi/dist/index.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (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 };
+    }
+};
+exports.__esModule = true;
+exports.strategy = exports.examples = exports.version = exports.author = void 0;
+var utils_1 = require("../../utils");
+var examples_json_1 = require("./examples.json");
+exports.author = 'vfatouros';
+exports.version = '0.1.0';
+exports.examples = examples_json_1["default"];
+var tokenAbi = [
+    {
+        constant: true,
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'account',
+                type: 'address'
+            }
+        ],
+        name: 'balanceOf',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: 'totalSupply',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                internalType: 'address',
+                name: '_account',
+                type: 'address'
+            }
+        ],
+        name: 'staked',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: 'ghst_',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'poolTokens_',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'ghstUsdcPoolToken_',
+                type: 'uint256'
+            }
+        ],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function'
+    }
+];
+function strategy(_space, network, provider, addresses, options, snapshot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var blockTag, res, ghstQuickTotalSupply, ghstQuickTokenBalanceInUni, ghstQuickTokensPerUni, ghstUsdcTotalSupply, ghstUsdcTokenBalanceInUni, ghstUsdcTokensPerUni, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    options.ghstWethAddress =
+                        options.ghstWethAddress || '0xccb9d2100037f1253e6c1682adf7dc9944498aff';
+                    blockTag = typeof snapshot === 'number' ? snapshot : 'latest';
+                    return [4 /*yield*/, utils_1.multicall(network, provider, tokenAbi, [
+                            [options.ghstQuickAddress, 'totalSupply', []],
+                            [options.tokenAddress, 'balanceOf', [options.ghstQuickAddress]],
+                            [options.ghstUsdcAddress, 'totalSupply', []],
+                            [options.tokenAddress, 'balanceOf', [options.ghstUsdcAddress]]
+                        ].concat(addresses.map(function (address) { return [
+                            options.stakingAddress,
+                            'staked',
+                            [address]
+                        ]; })), { blockTag: blockTag })];
+                case 1:
+                    res = _a.sent();
+                    ghstQuickTotalSupply = res[0];
+                    ghstQuickTokenBalanceInUni = res[1];
+                    ghstQuickTokensPerUni = ghstQuickTokenBalanceInUni /
+                        Math.pow(10, options.decimals) /
+                        (ghstQuickTotalSupply / 1e18);
+                    ghstUsdcTotalSupply = res[2];
+                    ghstUsdcTokenBalanceInUni = res[3];
+                    ghstUsdcTokensPerUni = ghstUsdcTokenBalanceInUni /
+                        Math.pow(10, options.decimals) /
+                        (ghstUsdcTotalSupply / 1e18);
+                    response = res.slice(4);
+                    return [2 /*return*/, Object.fromEntries(response.map(function (values, i) { return [
+                            addresses[i],
+                            values[0] / 1e18 + //ghst_
+                                (values[1] / Math.pow(10, options.decimals)) * ghstQuickTokensPerUni + //poolTokens_
+                                (values[2] / Math.pow(10, options.decimals)) * ghstUsdcTokensPerUni //ghstUsdcPoolToken_
+                        ]; }))];
+            }
+        });
+    });
+}
+exports.strategy = strategy;

package/src/strategies/aavegotchi-agip/dist/index.js

@@ -0,0 +1,168 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (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 };
+    }
+};
+exports.__esModule = true;
+exports.strategy = exports.examples = exports.version = exports.author = void 0;
+var units_1 = require("@ethersproject/units");
+var multicaller_1 = require("../../utils/multicaller");
+var utils_1 = require("../../utils");
+var examples_json_1 = require("./examples.json");
+exports.author = 'candoizo';
+exports.version = '0.1.0';
+exports.examples = examples_json_1["default"];
+var AAVEGOTCHI_SUBGRAPH_URL = {
+    137: 'https://api.thegraph.com/subgraphs/name/aavegotchi/aavegotchi-core-matic'
+};
+var tokenAbi = [
+    {
+        inputs: [{ internalType: 'address', name: '_account', type: 'address' }],
+        name: 'itemBalances',
+        outputs: [
+            {
+                components: [
+                    { internalType: 'uint256', name: 'itemId', type: 'uint256' },
+                    { internalType: 'uint256', name: 'balance', type: 'uint256' }
+                ],
+                internalType: 'struct ItemsFacet.ItemIdIO[]',
+                name: 'bals_',
+                type: 'tuple[]'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    }
+];
+var itemPriceParams = {
+    itemTypes: {
+        __args: {
+            first: 1000
+        },
+        svgId: true,
+        ghstPrice: true
+    }
+};
+function strategy(_space, network, provider, addresses, options, snapshot) {
+    return __awaiter(this, void 0, void 0, function () {
+        var blockTag, multi, multiRes, walletQueryParams, result, prices, walletScores;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    blockTag = typeof snapshot === 'number' ? snapshot : 'latest';
+                    multi = new multicaller_1["default"](network, provider, tokenAbi, { blockTag: blockTag });
+                    addresses.map(function (addr) {
+                        return multi.call(options.tokenAddress + "." + addr.toLowerCase(), options.tokenAddress, 'itemBalances', [addr]);
+                    });
+                    return [4 /*yield*/, multi.execute()];
+                case 1:
+                    multiRes = _a.sent();
+                    walletQueryParams = {
+                        users: {
+                            __args: {
+                                where: {
+                                    id_in: addresses.map(function (addr) { return addr.toLowerCase(); })
+                                },
+                                first: 1000
+                            },
+                            id: true,
+                            gotchisOwned: {
+                                baseRarityScore: true,
+                                equippedWearables: true
+                            }
+                        }
+                    };
+                    return [4 /*yield*/, utils_1.subgraphRequest(AAVEGOTCHI_SUBGRAPH_URL[network], __assign(__assign({}, itemPriceParams), walletQueryParams))];
+                case 2:
+                    result = _a.sent();
+                    prices = {};
+                    result.itemTypes.map(function (itemInfo) {
+                        var itemValue = parseFloat(units_1.formatUnits(itemInfo.ghstPrice, 18));
+                        if (itemValue > 0)
+                            prices[parseInt(itemInfo.svgId)] = itemValue;
+                    });
+                    walletScores = {};
+                    result.users.map(function (addrInfo) {
+                        var id = addrInfo.id, gotchisOwned = addrInfo.gotchisOwned;
+                        var gotchisBrsEquipValue = 0;
+                        if (gotchisOwned.length > 0)
+                            gotchisOwned.map(function (gotchi) {
+                                var brs = parseInt(gotchi.baseRarityScore);
+                                gotchisBrsEquipValue += brs;
+                                gotchi.equippedWearables
+                                    .filter(function (itemId) { return itemId != 0; })
+                                    .map(function (itemId) {
+                                    var shopCost = prices[itemId];
+                                    if (isNaN(shopCost))
+                                        shopCost = 0;
+                                    gotchisBrsEquipValue += shopCost;
+                                });
+                            });
+                        var ownerItemValue = 0;
+                        var ownerItemInfo = multiRes[options.tokenAddress][id];
+                        if (ownerItemInfo.length > 0)
+                            ownerItemInfo.map(function (itemInfo) {
+                                var amountOwned = parseInt(itemInfo.balance.toString());
+                                var itemId = parseInt(itemInfo.itemId.toString());
+                                var pricetag = parseFloat(prices[itemId]);
+                                var cost = pricetag * amountOwned;
+                                if (isNaN(cost))
+                                    cost = 0;
+                                ownerItemValue += cost;
+                            });
+                        var addr = addresses.find(function (addrOption) { return addrOption.toLowerCase() === id; });
+                        walletScores[addr] = ownerItemValue + gotchisBrsEquipValue;
+                    });
+                    addresses.map(function (addr) {
+                        if (!walletScores[addr])
+                            walletScores[addr] = 0;
+                    });
+                    return [2 /*return*/, walletScores];
+            }
+        });
+    });
+}
+exports.strategy = strategy;