@snapshot-labs/snapshot.js 0.13.1 → 0.14.0

package/dist/src/index.d.ts

@@ -93,7 +93,6 @@ declare const _default: {
                     snapshotNetwork: boolean;
                     title: string;
                     minLength: number;
-                    maxLength: number;
                 };
                 symbol: {
                     type: string;
@@ -136,7 +135,6 @@ declare const _default: {
                             };
                             network: {
                                 type: string;
-                                maxLength: number;
                                 title: string;
                                 snapshotNetwork: boolean;
                             };
@@ -291,14 +289,7 @@ declare const _default: {
                             type: string;
                             title: string;
                             description: string;
-                            anyOf: ({
-                                snapshotNetwork: boolean;
-                                starknetNetwork?: undefined;
-                            } | {
-                                starknetNetwork: boolean;
-                                snapshotNetwork?: undefined;
-                            })[];
-                            errorMessage: string;
+                            snapshotNetwork: boolean;
                         };
                         delegationApi: {
                             type: string;
@@ -399,14 +390,7 @@ declare const _default: {
                             network: {
                                 type: string;
                                 title: string;
-                                anyOf: ({
-                                    snapshotNetwork: boolean;
-                                    starknetNetwork?: undefined;
-                                } | {
-                                    starknetNetwork: boolean;
-                                    snapshotNetwork?: undefined;
-                                })[];
-                                errorMessage: string;
+                                snapshotNetwork: boolean;
                             };
                         };
                         required: string[];
@@ -827,7 +811,7 @@ declare const _default: {
     };
     utils: {
         call: typeof import("./utils").call;
-        multicall: typeof import("./utils").multicall;
+        multicall: typeof import("./multicall").multicall;
         subgraphRequest: typeof import("./utils").subgraphRequest;
         ipfsGet: typeof import("./utils").ipfsGet;
         getUrl: typeof import("./utils").getUrl;
@@ -856,7 +840,7 @@ declare const _default: {
         getProvider: typeof import("./utils/provider").default;
         signMessage: typeof import("./utils/web3").signMessage;
         getBlockNumber: typeof import("./utils/web3").getBlockNumber;
-        Multicaller: typeof import("./utils/multicaller").default;
+        Multicaller: typeof import("./multicall").Multicaller;
         getSnapshots: typeof import("./utils/blockfinder").getSnapshots;
         getHash: typeof import("./verify").getHash;
         verify: typeof import("./verify").verify;

package/dist/src/multicall/evm.d.ts

@@ -0,0 +1,4 @@
+import { Fragment, FunctionFragment, JsonFragment } from '@ethersproject/abi';
+import { Signer } from '@ethersproject/abstract-signer';
+import { Provider } from '@ethersproject/providers';
+export default function multicall(address: string, provider: Signer | Provider, abi: string | (Fragment | JsonFragment | string)[], calls: [string, FunctionFragment | string, any[]][], limit: number, options?: {}): Promise<any>;

package/dist/src/multicall/index.d.ts

@@ -0,0 +1,3 @@
+import Multicaller from './multicaller';
+declare function multicall(network: string, provider: any, abi: any[], calls: any[], options?: Record<string, any>): Promise<any>;
+export { multicall, Multicaller };

package/dist/src/multicall/multicaller.d.ts

@@ -0,0 +1,15 @@
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { RpcProvider } from 'starknet';
+type Path = string | number | number[] | string[];
+export default class Multicaller {
+    network: string;
+    provider: StaticJsonRpcProvider | RpcProvider;
+    abi: any[];
+    options: any;
+    calls: any[];
+    paths: Path[];
+    constructor(network: string, provider: StaticJsonRpcProvider | RpcProvider, abi: any[], options?: any);
+    call(path: Path, address: string, fn: string, params?: any[]): Multicaller;
+    execute(from?: any): Promise<any>;
+}
+export {};

package/dist/src/multicall/starknet.d.ts

@@ -0,0 +1,2 @@
+import { RpcProvider } from 'starknet';
+export default function multicall(address: string, provider: RpcProvider, abi: any[], calls: any[], limit: number, options?: Record<string, any>): Promise<any[][]>;

package/dist/src/schemas/index.d.ts

@@ -89,7 +89,6 @@ declare const _default: {
                 snapshotNetwork: boolean;
                 title: string;
                 minLength: number;
-                maxLength: number;
             };
             symbol: {
                 type: string;
@@ -132,7 +131,6 @@ declare const _default: {
                         };
                         network: {
                             type: string;
-                            maxLength: number;
                             title: string;
                             snapshotNetwork: boolean;
                         };
@@ -287,14 +285,7 @@ declare const _default: {
                         type: string;
                         title: string;
                         description: string;
-                        anyOf: ({
-                            snapshotNetwork: boolean;
-                            starknetNetwork?: undefined;
-                        } | {
-                            starknetNetwork: boolean;
-                            snapshotNetwork?: undefined;
-                        })[];
-                        errorMessage: string;
+                        snapshotNetwork: boolean;
                     };
                     delegationApi: {
                         type: string;
@@ -395,14 +386,7 @@ declare const _default: {
                         network: {
                             type: string;
                             title: string;
-                            anyOf: ({
-                                snapshotNetwork: boolean;
-                                starknetNetwork?: undefined;
-                            } | {
-                                starknetNetwork: boolean;
-                                snapshotNetwork?: undefined;
-                            })[];
-                            errorMessage: string;
+                            snapshotNetwork: boolean;
                         };
                     };
                     required: string[];

package/dist/src/utils/provider.d.ts

@@ -1,6 +1,5 @@
-export type ProviderOptions = {
-    broviderUrl?: string;
-    timeout?: number;
-};
-export default function getProvider(network: any, { broviderUrl, timeout }?: ProviderOptions): any;
-export declare function getBatchedProvider(network: any, { broviderUrl, timeout }?: ProviderOptions): any;
+export interface ProviderOptions {
+    readonly broviderUrl?: string;
+    readonly timeout?: number;
+}
+export default function getProvider(network: string | number, options?: ProviderOptions): any;

package/dist/src/utils.d.ts

@@ -1,9 +1,9 @@
-import Multicaller from './utils/multicaller';
 import { getSnapshots } from './utils/blockfinder';
 import getProvider from './utils/provider';
 import { signMessage, getBlockNumber } from './utils/web3';
 import { getHash, verify } from './verify';
 import getDelegatesBySpace, { SNAPSHOT_SUBGRAPH_URL } from './utils/delegation';
+import { multicall, Multicaller } from './multicall';
 interface Options {
     url?: string;
     headers?: any;
@@ -14,7 +14,6 @@ interface Strategy {
     params: any;
 }
 export declare function call(provider: any, abi: any[], call: any[], options?: any): Promise<any>;
-export declare function multicall(network: string, provider: any, abi: any[], calls: any[], options?: any): Promise<any>;
 export declare function subgraphRequest(url: string, query: any, options?: any): Promise<any>;
 export declare function getUrl(uri: any, gateway?: string): any;
 export declare function getJSON(uri: any, options?: any): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapshot-labs/snapshot.js",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "repository": "snapshot-labs/snapshot.js",
   "license": "MIT",
   "main": "dist/snapshot.cjs.js",

package/src/multicall/evm.ts

@@ -0,0 +1,48 @@
+import {
+  Fragment,
+  FunctionFragment,
+  Interface,
+  JsonFragment
+} from '@ethersproject/abi';
+import { Signer } from '@ethersproject/abstract-signer';
+import { Contract } from '@ethersproject/contracts';
+import { Provider } from '@ethersproject/providers';
+
+const multicallAbi = [
+  'function aggregate(tuple(address target, bytes callData)[] calls) view returns (uint256 blockNumber, bytes[] returnData)'
+];
+
+export default async function multicall(
+  address: string,
+  provider: Signer | Provider,
+  abi: string | (Fragment | JsonFragment | string)[],
+  calls: [string, FunctionFragment | string, any[]][],
+  limit: number,
+  options = {}
+): Promise<any> {
+  const multi = new Contract(address, multicallAbi, provider);
+  const itf = new Interface(abi);
+  try {
+    const pages = Math.ceil(calls.length / limit);
+    const promises: any = [];
+    Array.from(Array(pages)).forEach((x, i) => {
+      const callsInPage = calls.slice(limit * i, limit * (i + 1));
+      promises.push(
+        multi.aggregate(
+          callsInPage.map((call) => [
+            call[0].toLowerCase(),
+            itf.encodeFunctionData(call[1], call[2])
+          ]),
+          options
+        )
+      );
+    });
+    let results: any[] = await Promise.all(promises);
+    results = results.reduce((prev: any, [, res]: any) => prev.concat(res), []);
+    return results.map((call, i) =>
+      itf.decodeFunctionResult(calls[i][1], call)
+    );
+  } catch (e: any) {
+    return Promise.reject(e);
+  }
+}

package/src/multicall/index.ts

@@ -0,0 +1,52 @@
+import { constants } from 'starknet';
+import multicallEvm from './evm';
+import multicallStarknet from './starknet';
+import Multicaller from './multicaller';
+import networks from '../networks.json';
+
+type NetworkId = keyof typeof networks;
+
+const STARKNET_CHAIN_IDS: NetworkId[] = [
+  constants.StarknetChainId.SN_MAIN,
+  constants.StarknetChainId.SN_SEPOLIA
+] as const;
+
+const MULTICALLS_FN = {
+  evm: multicallEvm,
+  starknet: multicallStarknet
+} as const;
+
+async function multicall(
+  network: string,
+  provider,
+  abi: any[],
+  calls: any[],
+  options: Record<string, any> = {}
+) {
+  const address = options?.multicallAddress || networks[network].multicall;
+
+  if (!address) {
+    throw new Error('missing multicall address');
+  }
+
+  const multicallOptions = { ...options };
+  const limit = multicallOptions?.limit || 500;
+
+  delete multicallOptions.limit;
+  delete multicallOptions.multicallAddress;
+
+  const protocol = STARKNET_CHAIN_IDS.includes(network as NetworkId)
+    ? 'starknet'
+    : 'evm';
+
+  return MULTICALLS_FN[protocol](
+    address,
+    provider,
+    abi,
+    calls,
+    limit,
+    multicallOptions
+  );
+}
+
+export { multicall, Multicaller };

package/src/{utils → multicall}/multicaller.ts

@@ -1,28 +1,31 @@
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import set from 'lodash.set';
-import { multicall } from '../utils';
+import { RpcProvider } from 'starknet';
+import { multicall } from './';
+
+type Path = string | number | number[] | string[];
 
 export default class Multicaller {
   public network: string;
-  public provider: StaticJsonRpcProvider;
+  public provider: StaticJsonRpcProvider | RpcProvider;
   public abi: any[];
   public options: any = {};
   public calls: any[] = [];
-  public paths: any[] = [];
+  public paths: Path[] = [];
 
   constructor(
     network: string,
-    provider: StaticJsonRpcProvider,
+    provider: StaticJsonRpcProvider | RpcProvider,
     abi: any[],
-    options?
+    options: any = {}
   ) {
     this.network = network;
     this.provider = provider;
     this.abi = abi;
-    this.options = options || {};
+    this.options = options;
   }
 
-  call(path, address, fn, params?): Multicaller {
+  call(path: Path, address: string, fn: string, params?: any[]): Multicaller {
     this.calls.push([address, fn, params]);
     this.paths.push(path);
     return this;
@@ -37,7 +40,9 @@ export default class Multicaller {
       this.calls,
       this.options
     );
-    result.forEach((r, i) => set(obj, this.paths[i], r.length > 1 ? r : r[0]));
+    result.forEach((r: any, i: number) =>
+      set(obj, this.paths[i], r.length > 1 ? r : r[0])
+    );
     this.calls = [];
     this.paths = [];
     return obj;

package/src/multicall/starknet.ts

@@ -0,0 +1,154 @@
+import { num, RpcProvider, shortString, transaction, uint256 } from 'starknet';
+
+/**
+ * Parses the raw result from a Starknet function call based on its ABI.
+ * It handles different types like felt252, u8, u256, etc., and decodes them accordingly.
+ * @param rawResult - The raw result from the Starknet function call.
+ * @param functionAbi - The ABI of the function that was called.
+ * @returns The parsed result in a more usable format.
+ */
+function parseStarknetResult(rawResult: string[], functionAbi: any): any {
+  if (
+    !functionAbi ||
+    !functionAbi.outputs ||
+    !Array.isArray(rawResult) ||
+    rawResult.length === 0
+  ) {
+    return rawResult;
+  }
+
+  const output = functionAbi.outputs[0];
+  const rawValue = rawResult[0];
+
+  try {
+    switch (output.type) {
+      case 'core::felt252':
+        // Try to decode as shortString (for name, symbol)
+        try {
+          return shortString.decodeShortString(rawValue);
+        } catch {
+          // If shortString decode fails, return as hex
+          return rawValue;
+        }
+
+      // Unsigned integers
+      case 'core::integer::u8':
+      case 'core::integer::u16':
+      case 'core::integer::u32':
+      case 'core::integer::u64':
+        return parseInt(rawValue, 16);
+
+      case 'core::integer::u128':
+      case 'core::integer::usize':
+        return BigInt(rawValue).toString();
+
+      case 'core::integer::u256':
+        return uint256.uint256ToBN({
+          low: rawValue,
+          high: rawResult[1] || '0x0'
+        });
+
+      // Signed integers
+      case 'core::integer::i8':
+      case 'core::integer::i16':
+      case 'core::integer::i32':
+      case 'core::integer::i64':
+        return parseInt(rawValue, 16);
+
+      case 'core::integer::i128':
+        return BigInt(rawValue).toString();
+
+      // Boolean type
+      case 'core::bool':
+        return rawValue === '0x1' || rawValue === '0x01';
+
+      // Address types
+      case 'core::starknet::contract_address::ContractAddress':
+      case 'core::starknet::class_hash::ClassHash':
+      case 'core::starknet::storage_access::StorageAddress':
+        return rawValue;
+
+      // Byte array
+      case 'core::bytes_31::bytes31':
+        return rawValue;
+
+      default:
+        // Return raw value for unknown types
+        return rawValue;
+    }
+  } catch {
+    // Fallback to raw result if parsing fails
+    return rawResult;
+  }
+}
+
+/**
+ * Partitions the responses from a Starknet multicall into individual call results.
+ * Each response starts with its length, followed by the actual response data.
+ * @param responses - The array of responses from the Starknet multicall.
+ * @returns An array of arrays, where each inner array contains the response data for a single call.
+ */
+const partitionResponses = (responses: string[]): string[][] => {
+  if (responses.length === 0) {
+    return [];
+  }
+
+  const [responseLength, ...restResponses] = responses;
+  const responseLengthInt = Number(num.toBigInt(responseLength));
+  const response = restResponses.slice(0, responseLengthInt);
+  const remainingResponses = restResponses.slice(responseLengthInt);
+
+  return [response, ...partitionResponses(remainingResponses)];
+};
+
+export default async function multicall(
+  address: string,
+  provider: RpcProvider,
+  abi: any[],
+  calls: any[],
+  limit: number,
+  options: Record<string, any> = {}
+) {
+  const callData = calls.map((call) => {
+    return {
+      contractAddress: call[0],
+      entrypoint: call[1],
+      calldata: call[2] || []
+    };
+  });
+
+  // Chunk calls into batches based on limit
+  const chunks: any[][] = [];
+  for (let i = 0; i < callData.length; i += limit) {
+    chunks.push(callData.slice(i, i + limit));
+  }
+
+  // Process each chunk
+  const paginatedResults = await Promise.all(
+    chunks.map((chunk) =>
+      provider.callContract(
+        {
+          contractAddress: address,
+          entrypoint: 'aggregate',
+          calldata: transaction.fromCallsToExecuteCalldata(chunk)
+        },
+        options.blockTag ?? 'latest'
+      )
+    )
+  );
+
+  const callResults = paginatedResults
+    .map((callContractResult) => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const [_blockNumber, _totalLength, ...results] = callContractResult;
+      return partitionResponses(results);
+    })
+    .flat();
+
+  return callResults.map((result, index) => {
+    const [, functionName] = calls[index];
+    const functionAbi = abi.find((item) => item.name === functionName);
+
+    return [parseStarknetResult(result, functionAbi)];
+  });
+}

package/src/networks.json

@@ -1970,5 +1970,34 @@
     },
     "start": 7521509,
     "logo": "ipfs://QmNnGPr1CNvj12SSGzKARtUHv9FyEfE5nES73U4vBWQSJL"
+  },
+  "0x534e5f4d41494e": {
+    "key": "sn",
+    "name": "Starknet",
+    "shortName": "Starknet",
+    "chainId": "0x534e5f4d41494e",
+    "network": "mainnet",
+    "multicall": "0x05754af3760f3356da99aea5c3ec39ccac7783d925a19666ebbeca58ff0087f4",
+    "explorer": {
+      "url": "https://starkscan.co"
+    },
+    "rpc": [],
+    "start": 8446,
+    "logo": "ipfs://bafkreihbjafyh7eud7r6e5743esaamifcttsvbspfwcrfoc5ykodjdi67m"
+  },
+  "0x534e5f5345504f4c4941": {
+    "key": "sn-sep",
+    "name": "Starknet Testnet",
+    "shortName": "testnet",
+    "chainId": "0x534e5f5345504f4c4941",
+    "network": "testnet",
+    "testnet": true,
+    "multicall": "0x05754af3760f3356da99aea5c3ec39ccac7783d925a19666ebbeca58ff0087f4",
+    "explorer": {
+      "url": "https://sepolia.starkscan.co"
+    },
+    "rpc": [],
+    "start": 7,
+    "logo": "ipfs://bafkreihbjafyh7eud7r6e5743esaamifcttsvbspfwcrfoc5ykodjdi67m"
   }
-}
+}

package/src/schemas/space.json

@@ -91,8 +91,7 @@
           "type": "string",
           "snapshotNetwork": true,
           "title": "network",
-          "minLength": 1,
-          "maxLength": 32
+          "minLength": 1
         },
         "symbol": {
           "type": "string",
@@ -135,7 +134,6 @@
               },
               "network": {
                 "type": "string",
-                "maxLength": 12,
                 "title": "network",
                 "snapshotNetwork": true
               },
@@ -291,11 +289,7 @@
               "type": "string",
               "title": "Delegation network",
               "description": "The network of your delegation contract",
-              "anyOf": [
-                { "snapshotNetwork": true },
-                { "starknetNetwork": true }
-              ],
-              "errorMessage": "Must be a valid network"
+              "snapshotNetwork": true
             },
             "delegationApi": {
               "type": "string",
@@ -417,11 +411,7 @@
               "network": {
                 "type": "string",
                 "title": "Network",
-                "anyOf": [
-                { "snapshotNetwork": true },
-                { "starknetNetwork": true }
-              ],
-              "errorMessage": "Must be a valid network"
+                "snapshotNetwork": true
               }
             },
             "required": ["name", "address", "network"],