@subsquid/evm-typegen 4.0.1 → 4.1.0

package/lib/multicall.d.ts

@@ -1,216 +1,52 @@
-/**
- * TODO migrate multicall
-import * as ethers from 'ethers'
-import {ContractBase, Func} from './abi.support'
-
-
-const abi = new ethers.Interface([
-    {
-        type: 'function',
-        name: 'aggregate',
-        stateMutability: 'nonpayable',
-        inputs: [
-            {
-                name: 'calls',
-                type: 'tuple[]',
-                components: [
-                    {name: 'target', type: 'address'},
-                    {name: 'callData', type: 'bytes'},
-                ]
-            }
-        ],
-        outputs: [
-            {name: 'blockNumber', type: 'uint256'},
-            {name: 'returnData', type: 'bytes[]'},
-        ]
-    },
-    {
-        name: 'tryAggregate',
-        type: 'function',
-        stateMutability: 'nonpayable',
-        inputs: [
-            {name: 'requireSuccess', type: 'bool'},
-            {
-                name: 'calls',
-                type: 'tuple[]',
-                components: [
-                    {name: 'target', type: 'address'},
-                    {name: 'callData', type: 'bytes'},
-                ]
-            }
-        ],
-        outputs: [
-            {
-                name: 'returnData',
-                type: 'tuple[]',
-                components: [
-                    {name: 'success', type: 'bool'},
-                    {name: 'returnData', type: 'bytes'},
-                ]
-            },
-        ]
-    }
-])
-
-
-type AnyFunc = Func<any, {}, any>
-type Call = [address: string, bytes: string]
-
-
-const aggregate = new Func<[calls: Call[]], {}, {blockNumber: bigint, returnData: string[]}>(
-    abi, abi.getFunction('aggregate')!.selector
-)
-
-
-const try_aggregate = new Func<[requireSuccess: boolean, calls: Array<[target: string, callData: string]>], {}, Array<{success: boolean, returnData: string}>>(
-    abi, abi.getFunction('tryAggregate')!.selector
-)
-
-
+import * as p from '@subsquid/evm-codec';
+import { ContractBase, AbiFunction } from '@subsquid/evm-abi';
+import { Codec, Struct } from "@subsquid/evm-codec";
 export type MulticallResult<T> = {
-    success: true
-    value: T
+    success: true;
+    value: T;
 } | {
-    success: false
-    returnData?: string
-    value?: undefined
+    success: false;
+    returnData?: string;
+    value?: undefined;
+};
+type AnyFunc = AbiFunction<any, any>;
+type AggregateTuple<T extends AnyFunc = AnyFunc> = [func: T, address: string, args: T extends AbiFunction<infer U, any> ? U : never];
+export declare class Multicall extends ContractBase {
+    static aggregate: AbiFunction<{
+        readonly calls: p.Codec<{
+            readonly target: string;
+            readonly callData: string | Uint8Array;
+        }[], {
+            readonly target: string;
+            readonly callData: string;
+        }[]>;
+    }, {
+        readonly blockNumber: p.Codec<number | bigint, bigint>;
+        readonly returnData: p.Codec<(string | Uint8Array)[], string[]>;
+    }>;
+    static tryAggregate: AbiFunction<{
+        readonly requireSuccess: p.Codec<boolean, boolean>;
+        readonly calls: p.Codec<{
+            readonly target: string;
+            readonly callData: string | Uint8Array;
+        }[], {
+            readonly target: string;
+            readonly callData: string;
+        }[]>;
+    }, p.Codec<{
+        readonly success: boolean;
+        readonly returnData: string | Uint8Array;
+    }[], {
+        readonly success: boolean;
+        readonly returnData: string;
+    }[]>>;
+    aggregate<Args extends Struct, R extends Struct | Codec<any, any>>(func: AbiFunction<Args, R>, address: string, calls: Args[], paging?: number): Promise<R[]>;
+    aggregate<Args extends Struct, R extends Struct | Codec<any, any>>(func: AbiFunction<Args, R>, calls: [address: string, args: Args][], paging?: number): Promise<R[]>;
+    aggregate(calls: AggregateTuple[], paging?: number): Promise<any[]>;
+    tryAggregate<Args extends Struct, R extends Struct | Codec<any, any>>(func: AbiFunction<Args, R>, address: string, calls: Args[], paging?: number): Promise<MulticallResult<R>[]>;
+    tryAggregate<Args extends Struct, R extends Struct | Codec<any, any>>(func: AbiFunction<Args, R>, calls: [address: string, args: Args][], paging?: number): Promise<MulticallResult<R>[]>;
+    tryAggregate(calls: AggregateTuple[], paging?: number): Promise<MulticallResult<any>[]>;
+    private makeCalls;
 }
-
-
-export class Multicall extends ContractBase {
-    static aggregate = aggregate
-    static try_aggregate = try_aggregate
-
-    aggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        address: string,
-        calls: Args[],
-        paging?: number
-    ): Promise<R[]>
-
-    aggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        calls: [address: string, args: Args][],
-        paging?: number
-    ): Promise<R[]>
-
-    aggregate(
-        calls: [func: AnyFunc, address: string, args: any[]][],
-        paging?: number
-    ): Promise<any[]>
-
-    async aggregate(...args: any[]): Promise<any[]> {
-        let [calls, funcs, page] = this.makeCalls(args)
-        let size = calls.length
-        let results = new Array(size)
-        for (let [from, to] of splitIntoPages(size, page)) {
-            let {returnData} = await this.eth_call(aggregate, [calls.slice(from, to)])
-            for (let i = from; i < to; i++) {
-                let data = returnData[i - from]
-                results[i] = funcs[i].decodeResult(data)
-            }
-        }
-        return results
-    }
-
-    tryAggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        address: string,
-        calls: Args[],
-        paging?: number
-    ): Promise<MulticallResult<R>[]>
-
-    tryAggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        calls: [address: string, args: Args][],
-        paging?: number
-    ): Promise<MulticallResult<R>[]>
-
-    tryAggregate(
-        calls: [func: AnyFunc, address: string, args: any[]][],
-        paging?: number
-    ): Promise<MulticallResult<any>[]>
-
-    async tryAggregate(...args: any[]): Promise<any[]> {
-        let [calls, funcs, page] = this.makeCalls(args)
-        let size = calls.length
-        let results = new Array(size)
-        for (let [from, to] of splitIntoPages(size, page)) {
-            let response = await this.eth_call(try_aggregate, [false, calls.slice(from, to)])
-            for (let i = from; i < to; i++) {
-                let res = response[i - from]
-                if (res.success) {
-                    try {
-                        results[i] = {
-                            success: true,
-                            value: funcs[i].decodeResult(res.returnData)
-                        }
-                    } catch(err: any) {
-                        results[i] = {success: false, returnData: res.returnData}
-                    }
-                } else {
-                    results[i] = {success: false}
-                }
-            }
-        }
-        return results
-    }
-
-    private makeCalls(args: any[]): [calls: Call[], funcs: AnyFunc[], page: number] {
-        let page = typeof args[args.length-1] == 'number' ? args.pop()! : Number.MAX_SAFE_INTEGER
-        switch(args.length) {
-            case 1: {
-                let list: [func: AnyFunc, address: string, args: any[]][] = args[0]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
-                for (let i = 0; i < list.length; i++) {
-                    let [func, address, args] = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
-                }
-                return [calls, funcs, page]
-            }
-            case 2: {
-                let func: AnyFunc = args[0]
-                let list: [address: string, args: any[]][] = args[1]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
-                for (let i = 0; i < list.length; i++) {
-                    let [address, args] = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
-                }
-                return [calls, funcs, page]
-            }
-            case 3: {
-                let func: AnyFunc = args[0]
-                let address: string = args[1]
-                let list: any[][] = args[2]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
-                for (let i = 0; i < list.length; i++) {
-                    let args = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
-                }
-                return [calls, funcs, page]
-            }
-            default:
-                throw new Error('unexpected number of arguments')
-        }
-    }
-}
-
-
-function* splitIntoPages(size: number, page: number): Iterable<[from: number, to: number]> {
-    let from = 0
-    while (size) {
-        let step = Math.min(page, size)
-        let to = from + step
-        yield [from, to]
-        size -= step
-        from = to
-    }
-}
-*/
+export {};
 //# sourceMappingURL=multicall.d.ts.map

package/lib/multicall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multicall.d.ts","sourceRoot":"","sources":["../src/multicall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsNE"}
+{"version":3,"file":"multicall.d.ts","sourceRoot":"","sources":["../src/multicall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,qBAAqB,CAAA;AACxC,OAAO,EAAM,YAAY,EAAE,WAAW,EAAC,MAAM,mBAAmB,CAAA;AAChE,OAAO,EAAC,KAAK,EAAE,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAclD,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;IAC/B,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,CAAC,CAAA;CACT,GAAG;IACF,OAAO,EAAE,KAAK,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,KAAK,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AACpC,KAAK,cAAc,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAA;AAGpI,qBAAa,SAAU,SAAQ,YAAY;IACzC,MAAM,CAAC,SAAS;;;;;;;;;;;OAAY;IAC5B,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;UAAe;IAElC,SAAS,CAAC,IAAI,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAC/D,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,EAC1B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,IAAI,EAAE,EACb,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,EAAE,CAAC;IAEf,SAAS,CAAC,IAAI,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAC/D,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EACtC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,EAAE,CAAC;IAEf,SAAS,CACP,KAAK,EAAE,cAAc,EAAE,EACvB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,EAAE,CAAC;IAgBjB,YAAY,CAAC,IAAI,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAClE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,EAC1B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,IAAI,EAAE,EACb,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;IAEhC,YAAY,CAAC,IAAI,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAClE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EACtC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;IAEhC,YAAY,CACV,KAAK,EAAE,cAAc,EAAE,EACvB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;IA8BlC,OAAO,CAAC,SAAS;CA2ClB"}

package/lib/multicall.js

@@ -1,217 +1,139 @@
 "use strict";
-/**
- * TODO migrate multicall
-import * as ethers from 'ethers'
-import {ContractBase, Func} from './abi.support'
-
-
-const abi = new ethers.Interface([
-    {
-        type: 'function',
-        name: 'aggregate',
-        stateMutability: 'nonpayable',
-        inputs: [
-            {
-                name: 'calls',
-                type: 'tuple[]',
-                components: [
-                    {name: 'target', type: 'address'},
-                    {name: 'callData', type: 'bytes'},
-                ]
-            }
-        ],
-        outputs: [
-            {name: 'blockNumber', type: 'uint256'},
-            {name: 'returnData', type: 'bytes[]'},
-        ]
-    },
-    {
-        name: 'tryAggregate',
-        type: 'function',
-        stateMutability: 'nonpayable',
-        inputs: [
-            {name: 'requireSuccess', type: 'bool'},
-            {
-                name: 'calls',
-                type: 'tuple[]',
-                components: [
-                    {name: 'target', type: 'address'},
-                    {name: 'callData', type: 'bytes'},
-                ]
-            }
-        ],
-        outputs: [
-            {
-                name: 'returnData',
-                type: 'tuple[]',
-                components: [
-                    {name: 'success', type: 'bool'},
-                    {name: 'returnData', type: 'bytes'},
-                ]
-            },
-        ]
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-])
-
-
-type AnyFunc = Func<any, {}, any>
-type Call = [address: string, bytes: string]
-
-
-const aggregate = new Func<[calls: Call[]], {}, {blockNumber: bigint, returnData: string[]}>(
-    abi, abi.getFunction('aggregate')!.selector
-)
-
-
-const try_aggregate = new Func<[requireSuccess: boolean, calls: Array<[target: string, callData: string]>], {}, Array<{success: boolean, returnData: string}>>(
-    abi, abi.getFunction('tryAggregate')!.selector
-)
-
-
-export type MulticallResult<T> = {
-    success: true
-    value: T
-} | {
-    success: false
-    returnData?: string
-    value?: undefined
-}
-
-
-export class Multicall extends ContractBase {
-    static aggregate = aggregate
-    static try_aggregate = try_aggregate
-
-    aggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        address: string,
-        calls: Args[],
-        paging?: number
-    ): Promise<R[]>
-
-    aggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        calls: [address: string, args: Args][],
-        paging?: number
-    ): Promise<R[]>
-
-    aggregate(
-        calls: [func: AnyFunc, address: string, args: any[]][],
-        paging?: number
-    ): Promise<any[]>
-
-    async aggregate(...args: any[]): Promise<any[]> {
-        let [calls, funcs, page] = this.makeCalls(args)
-        let size = calls.length
-        let results = new Array(size)
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Multicall = void 0;
+const p = __importStar(require("@subsquid/evm-codec"));
+const evm_abi_1 = require("@subsquid/evm-abi");
+const aggregate = (0, evm_abi_1.fun)('0x252dba42', {
+    calls: p.array(p.struct({
+        target: p.address,
+        callData: p.bytes
+    }))
+}, { blockNumber: p.uint256, returnData: p.array(p.bytes) });
+const tryAggregate = (0, evm_abi_1.fun)('0xbce38bd7', {
+    requireSuccess: p.bool,
+    calls: p.array(p.struct({ target: p.address, callData: p.bytes }))
+}, p.array(p.struct({ success: p.bool, returnData: p.bytes })));
+class Multicall extends evm_abi_1.ContractBase {
+    async aggregate(...args) {
+        let [calls, funcs, page] = this.makeCalls(args);
+        let size = calls.length;
+        let results = new Array(size);
         for (let [from, to] of splitIntoPages(size, page)) {
-            let {returnData} = await this.eth_call(aggregate, [calls.slice(from, to)])
+            let { returnData } = await this.eth_call(aggregate, { calls: calls.slice(from, to) });
             for (let i = from; i < to; i++) {
-                let data = returnData[i - from]
-                results[i] = funcs[i].decodeResult(data)
+                let data = returnData[i - from];
+                results[i] = funcs[i].decodeResult(data);
             }
         }
-        return results
+        return results;
     }
-
-    tryAggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        address: string,
-        calls: Args[],
-        paging?: number
-    ): Promise<MulticallResult<R>[]>
-
-    tryAggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        calls: [address: string, args: Args][],
-        paging?: number
-    ): Promise<MulticallResult<R>[]>
-
-    tryAggregate(
-        calls: [func: AnyFunc, address: string, args: any[]][],
-        paging?: number
-    ): Promise<MulticallResult<any>[]>
-
-    async tryAggregate(...args: any[]): Promise<any[]> {
-        let [calls, funcs, page] = this.makeCalls(args)
-        let size = calls.length
-        let results = new Array(size)
+    async tryAggregate(...args) {
+        let [calls, funcs, page] = this.makeCalls(args);
+        let size = calls.length;
+        let results = new Array(size);
         for (let [from, to] of splitIntoPages(size, page)) {
-            let response = await this.eth_call(try_aggregate, [false, calls.slice(from, to)])
+            let response = await this.eth_call(tryAggregate, {
+                requireSuccess: false,
+                calls: calls.slice(from, to)
+            });
             for (let i = from; i < to; i++) {
-                let res = response[i - from]
+                let res = response[i - from];
                 if (res.success) {
                     try {
                         results[i] = {
                             success: true,
                             value: funcs[i].decodeResult(res.returnData)
-                        }
-                    } catch(err: any) {
-                        results[i] = {success: false, returnData: res.returnData}
+                        };
                     }
-                } else {
-                    results[i] = {success: false}
+                    catch (err) {
+                        results[i] = { success: false, returnData: res.returnData };
+                    }
+                }
+                else {
+                    results[i] = { success: false };
                 }
             }
         }
-        return results
+        return results;
     }
-
-    private makeCalls(args: any[]): [calls: Call[], funcs: AnyFunc[], page: number] {
-        let page = typeof args[args.length-1] == 'number' ? args.pop()! : Number.MAX_SAFE_INTEGER
-        switch(args.length) {
+    makeCalls(args) {
+        let page = typeof args[args.length - 1] == 'number' ? args.pop() : Number.MAX_SAFE_INTEGER;
+        switch (args.length) {
             case 1: {
-                let list: [func: AnyFunc, address: string, args: any[]][] = args[0]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
+                let list = args[0];
+                let calls = new Array(list.length);
+                let funcs = new Array(list.length);
                 for (let i = 0; i < list.length; i++) {
-                    let [func, address, args] = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
+                    let [func, address, args] = list[i];
+                    calls[i] = { target: address, callData: func.encode(args) };
+                    funcs[i] = func;
                 }
-                return [calls, funcs, page]
+                return [calls, funcs, page];
             }
             case 2: {
-                let func: AnyFunc = args[0]
-                let list: [address: string, args: any[]][] = args[1]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
+                let func = args[0];
+                let list = args[1];
+                let calls = new Array(list.length);
+                let funcs = new Array(list.length);
                 for (let i = 0; i < list.length; i++) {
-                    let [address, args] = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
+                    let [address, args] = list[i];
+                    calls[i] = { target: address, callData: func.encode(args) };
+                    funcs[i] = func;
                 }
-                return [calls, funcs, page]
+                return [calls, funcs, page];
             }
             case 3: {
-                let func: AnyFunc = args[0]
-                let address: string = args[1]
-                let list: any[][] = args[2]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
+                let func = args[0];
+                let address = args[1];
+                let list = args[2];
+                let calls = new Array(list.length);
+                let funcs = new Array(list.length);
                 for (let i = 0; i < list.length; i++) {
-                    let args = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
+                    let args = list[i];
+                    calls[i] = { target: address, callData: func.encode(args) };
+                    funcs[i] = func;
                 }
-                return [calls, funcs, page]
+                return [calls, funcs, page];
             }
             default:
-                throw new Error('unexpected number of arguments')
+                throw new Error('unexpected number of arguments');
         }
     }
 }
-
-
-function* splitIntoPages(size: number, page: number): Iterable<[from: number, to: number]> {
-    let from = 0
+exports.Multicall = Multicall;
+Multicall.aggregate = aggregate;
+Multicall.tryAggregate = tryAggregate;
+function* splitIntoPages(size, page) {
+    let from = 0;
     while (size) {
-        let step = Math.min(page, size)
-        let to = from + step
-        yield [from, to]
-        size -= step
-        from = to
+        let step = Math.min(page, size);
+        let to = from + step;
+        yield [from, to];
+        size -= step;
+        from = to;
     }
 }
-*/
 //# sourceMappingURL=multicall.js.map

package/lib/multicall.js.map

@@ -1 +1 @@
-{"version":3,"file":"multicall.js","sourceRoot":"","sources":["../src/multicall.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsNE"}
+{"version":3,"file":"multicall.js","sourceRoot":"","sources":["../src/multicall.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subsquid/evm-typegen",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "CLI for generating typescript types and decode implementations for evm logs",
   "license": "GPL-3.0-or-later",
   "repository": "git@github.com:subsquid/squid.git",
@@ -21,8 +21,8 @@
     "@subsquid/util-internal": "^3.2.0",
     "@subsquid/util-internal-code-printer": "^1.2.2",
     "@subsquid/util-internal-commander": "^1.4.0",
-    "@subsquid/evm-codec": "^0.1.0",
-    "@subsquid/evm-abi": "^0.2.0",
+    "@subsquid/evm-codec": "^0.2.0",
+    "@subsquid/evm-abi": "^0.2.1",
     "commander": "^11.1.0"
   },
   "devDependencies": {

package/src/multicall.ts

@@ -1,215 +1,167 @@
-/**
- * TODO migrate multicall
-import * as ethers from 'ethers'
-import {ContractBase, Func} from './abi.support'
-
-
-const abi = new ethers.Interface([
-    {
-        type: 'function',
-        name: 'aggregate',
-        stateMutability: 'nonpayable',
-        inputs: [
-            {
-                name: 'calls',
-                type: 'tuple[]',
-                components: [
-                    {name: 'target', type: 'address'},
-                    {name: 'callData', type: 'bytes'},
-                ]
-            }
-        ],
-        outputs: [
-            {name: 'blockNumber', type: 'uint256'},
-            {name: 'returnData', type: 'bytes[]'},
-        ]
-    },
-    {
-        name: 'tryAggregate',
-        type: 'function',
-        stateMutability: 'nonpayable',
-        inputs: [
-            {name: 'requireSuccess', type: 'bool'},
-            {
-                name: 'calls',
-                type: 'tuple[]',
-                components: [
-                    {name: 'target', type: 'address'},
-                    {name: 'callData', type: 'bytes'},
-                ]
-            }
-        ],
-        outputs: [
-            {
-                name: 'returnData',
-                type: 'tuple[]',
-                components: [
-                    {name: 'success', type: 'bool'},
-                    {name: 'returnData', type: 'bytes'},
-                ]
-            },
-        ]
-    }
-])
-
-
-type AnyFunc = Func<any, {}, any>
-type Call = [address: string, bytes: string]
-
-
-const aggregate = new Func<[calls: Call[]], {}, {blockNumber: bigint, returnData: string[]}>(
-    abi, abi.getFunction('aggregate')!.selector
-)
-
-
-const try_aggregate = new Func<[requireSuccess: boolean, calls: Array<[target: string, callData: string]>], {}, Array<{success: boolean, returnData: string}>>(
-    abi, abi.getFunction('tryAggregate')!.selector
-)
-
+import * as p from '@subsquid/evm-codec'
+import {fun, ContractBase, AbiFunction} from '@subsquid/evm-abi'
+import {Codec, Struct} from "@subsquid/evm-codec";
+
+const aggregate = fun('0x252dba42', {
+  calls: p.array(p.struct({
+    target: p.address,
+    callData: p.bytes
+  }))
+}, {blockNumber: p.uint256, returnData: p.array(p.bytes)})
+
+const tryAggregate = fun('0xbce38bd7', {
+  requireSuccess: p.bool,
+  calls: p.array(p.struct({target: p.address, callData: p.bytes}))
+}, p.array(p.struct({success: p.bool, returnData: p.bytes})))
 
 export type MulticallResult<T> = {
-    success: true
-    value: T
+  success: true
+  value: T
 } | {
-    success: false
-    returnData?: string
-    value?: undefined
+  success: false
+  returnData?: string
+  value?: undefined
 }
 
+type AnyFunc = AbiFunction<any, any>
+type AggregateTuple<T extends AnyFunc = AnyFunc> = [func: T, address: string, args: T extends AbiFunction<infer U, any> ? U : never]
+type Call = {target: string, callData: string}
 
 export class Multicall extends ContractBase {
-    static aggregate = aggregate
-    static try_aggregate = try_aggregate
-
-    aggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        address: string,
-        calls: Args[],
-        paging?: number
-    ): Promise<R[]>
-
-    aggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        calls: [address: string, args: Args][],
-        paging?: number
-    ): Promise<R[]>
-
-    aggregate(
-        calls: [func: AnyFunc, address: string, args: any[]][],
-        paging?: number
-    ): Promise<any[]>
-
-    async aggregate(...args: any[]): Promise<any[]> {
-        let [calls, funcs, page] = this.makeCalls(args)
-        let size = calls.length
-        let results = new Array(size)
-        for (let [from, to] of splitIntoPages(size, page)) {
-            let {returnData} = await this.eth_call(aggregate, [calls.slice(from, to)])
-            for (let i = from; i < to; i++) {
-                let data = returnData[i - from]
-                results[i] = funcs[i].decodeResult(data)
-            }
-        }
-        return results
+  static aggregate = aggregate
+  static tryAggregate = tryAggregate
+
+  aggregate<Args extends Struct, R extends Struct | Codec<any, any>>(
+    func: AbiFunction<Args, R>,
+    address: string,
+    calls: Args[],
+    paging?: number
+  ): Promise<R[]>
+
+  aggregate<Args extends Struct, R extends Struct | Codec<any, any>>(
+    func: AbiFunction<Args, R>,
+    calls: [address: string, args: Args][],
+    paging?: number
+  ): Promise<R[]>
+
+  aggregate(
+    calls: AggregateTuple[],
+    paging?: number
+  ): Promise<any[]>
+
+  async aggregate(...args: any[]): Promise<any[]> {
+    let [calls, funcs, page] = this.makeCalls(args)
+    let size = calls.length
+    let results = new Array(size)
+    for (let [from, to] of splitIntoPages(size, page)) {
+      let {returnData} = await this.eth_call(aggregate, {calls: calls.slice(from, to)})
+      for (let i = from; i < to; i++) {
+        let data = returnData[i - from]
+        results[i] = funcs[i].decodeResult(data)
+      }
     }
-
-    tryAggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        address: string,
-        calls: Args[],
-        paging?: number
-    ): Promise<MulticallResult<R>[]>
-
-    tryAggregate<Args extends any[], R>(
-        func: Func<Args, {}, R>,
-        calls: [address: string, args: Args][],
-        paging?: number
-    ): Promise<MulticallResult<R>[]>
-
-    tryAggregate(
-        calls: [func: AnyFunc, address: string, args: any[]][],
-        paging?: number
-    ): Promise<MulticallResult<any>[]>
-
-    async tryAggregate(...args: any[]): Promise<any[]> {
-        let [calls, funcs, page] = this.makeCalls(args)
-        let size = calls.length
-        let results = new Array(size)
-        for (let [from, to] of splitIntoPages(size, page)) {
-            let response = await this.eth_call(try_aggregate, [false, calls.slice(from, to)])
-            for (let i = from; i < to; i++) {
-                let res = response[i - from]
-                if (res.success) {
-                    try {
-                        results[i] = {
-                            success: true,
-                            value: funcs[i].decodeResult(res.returnData)
-                        }
-                    } catch(err: any) {
-                        results[i] = {success: false, returnData: res.returnData}
-                    }
-                } else {
-                    results[i] = {success: false}
-                }
+    return results
+  }
+
+  tryAggregate<Args extends Struct, R extends Struct | Codec<any, any>>(
+    func: AbiFunction<Args, R>,
+    address: string,
+    calls: Args[],
+    paging?: number
+  ): Promise<MulticallResult<R>[]>
+
+  tryAggregate<Args extends Struct, R extends Struct | Codec<any, any>>(
+    func: AbiFunction<Args, R>,
+    calls: [address: string, args: Args][],
+    paging?: number
+  ): Promise<MulticallResult<R>[]>
+
+  tryAggregate(
+    calls: AggregateTuple[],
+    paging?: number
+  ): Promise<MulticallResult<any>[]>
+
+  async tryAggregate(...args: any[]): Promise<any[]> {
+    let [calls, funcs, page] = this.makeCalls(args)
+    let size = calls.length
+    let results = new Array(size)
+    for (let [from, to] of splitIntoPages(size, page)) {
+      let response = await this.eth_call(tryAggregate, {
+        requireSuccess: false,
+        calls: calls.slice(from, to)
+      })
+      for (let i = from; i < to; i++) {
+        let res = response[i - from]
+        if (res.success) {
+          try {
+            results[i] = {
+              success: true,
+              value: funcs[i].decodeResult(res.returnData)
             }
+          } catch (err: any) {
+            results[i] = {success: false, returnData: res.returnData}
+          }
+        } else {
+          results[i] = {success: false}
         }
-        return results
+      }
     }
-
-    private makeCalls(args: any[]): [calls: Call[], funcs: AnyFunc[], page: number] {
-        let page = typeof args[args.length-1] == 'number' ? args.pop()! : Number.MAX_SAFE_INTEGER
-        switch(args.length) {
-            case 1: {
-                let list: [func: AnyFunc, address: string, args: any[]][] = args[0]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
-                for (let i = 0; i < list.length; i++) {
-                    let [func, address, args] = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
-                }
-                return [calls, funcs, page]
-            }
-            case 2: {
-                let func: AnyFunc = args[0]
-                let list: [address: string, args: any[]][] = args[1]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
-                for (let i = 0; i < list.length; i++) {
-                    let [address, args] = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
-                }
-                return [calls, funcs, page]
-            }
-            case 3: {
-                let func: AnyFunc = args[0]
-                let address: string = args[1]
-                let list: any[][] = args[2]
-                let calls = new Array(list.length)
-                let funcs = new Array(list.length)
-                for (let i = 0; i < list.length; i++) {
-                    let args = list[i]
-                    calls[i] = [address, func.encode(args)]
-                    funcs[i] = func
-                }
-                return [calls, funcs, page]
-            }
-            default:
-                throw new Error('unexpected number of arguments')
+    return results
+  }
+
+  private makeCalls(args: any[]): [calls: Call[], funcs: AnyFunc[], page: number] {
+    let page = typeof args[args.length - 1] == 'number' ? args.pop()! : Number.MAX_SAFE_INTEGER
+    switch (args.length) {
+      case 1: {
+        let list: AggregateTuple[] = args[0]
+        let calls: Call[] = new Array(list.length)
+        let funcs = new Array(list.length)
+        for (let i = 0; i < list.length; i++) {
+          let [func, address, args] = list[i]
+          calls[i] = {target: address, callData: func.encode(args)}
+          funcs[i] = func
+        }
+        return [calls, funcs, page]
+      }
+      case 2: {
+        let func: AnyFunc = args[0]
+        let list: [address: string, args: any][] = args[1]
+        let calls: Call[] = new Array(list.length)
+        let funcs = new Array(list.length)
+        for (let i = 0; i < list.length; i++) {
+          let [address, args] = list[i]
+          calls[i] = {target: address, callData: func.encode(args)}
+          funcs[i] = func
         }
+        return [calls, funcs, page]
+      }
+      case 3: {
+        let func: AnyFunc = args[0]
+        let address: string = args[1]
+        let list: any = args[2]
+        let calls: Call[] = new Array(list.length)
+        let funcs = new Array(list.length)
+        for (let i = 0; i < list.length; i++) {
+          let args = list[i]
+          calls[i] = {target: address, callData: func.encode(args)}
+          funcs[i] = func
+        }
+        return [calls, funcs, page]
+      }
+      default:
+        throw new Error('unexpected number of arguments')
     }
+  }
 }
 
 
 function* splitIntoPages(size: number, page: number): Iterable<[from: number, to: number]> {
-    let from = 0
-    while (size) {
-        let step = Math.min(page, size)
-        let to = from + step
-        yield [from, to]
-        size -= step
-        from = to
-    }
+  let from = 0
+  while (size) {
+    let step = Math.min(page, size)
+    let to = from + step
+    yield [from, to]
+    size -= step
+    from = to
+  }
 }
-*/