@subsquid/evm-typegen 1.3.0 → 2.0.0

package/lib/util/types.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReturnType = exports.getStructType = exports.getTupleType = exports.getFullTupleType = exports.getType = void 0;
+// taken from: https://github.com/ethers-io/ethers.js/blob/948f77050dae884fe88932fd88af75560aac9d78/packages/cli/src.ts/typescript.ts#L10
+function getType(param) {
+    if (param.baseType === 'array') {
+        return 'Array<' + getType(param.arrayChildren) + '>';
+    }
+    if (param.baseType === 'tuple') {
+        return getFullTupleType(param.components);
+    }
+    if (param.type === 'address' || param.type === 'string') {
+        return 'string';
+    }
+    if (param.type === 'bool') {
+        return 'boolean';
+    }
+    let match = param.type.match(/^(u?int)([0-9]+)$/);
+    if (match) {
+        return parseInt(match[2]) < 53 ? 'number' : 'ethers.BigNumber';
+    }
+    if (param.type.substring(0, 5) === 'bytes') {
+        return 'string';
+    }
+    throw new Error('unknown type');
+}
+exports.getType = getType;
+function getFullTupleType(params) {
+    let tuple = getTupleType(params);
+    let struct = getStructType(params);
+    if (struct == '{}') {
+        return tuple;
+    }
+    else {
+        return `(${tuple} & ${struct})`;
+    }
+}
+exports.getFullTupleType = getFullTupleType;
+function getTupleType(params) {
+    return '[' + params.map(p => {
+        return p.name ? `${p.name}: ${getType(p)}` : getType(p);
+    }).join(', ') + ']';
+}
+exports.getTupleType = getTupleType;
+// https://github.com/ethers-io/ethers.js/blob/948f77050dae884fe88932fd88af75560aac9d78/packages/abi/src.ts/coders/tuple.ts#L29
+function getStructType(params) {
+    let array = [];
+    let counts = {};
+    for (let p of params) {
+        if (p.name && array[p.name] == null) {
+            counts[p.name] = (counts[p.name] || 0) + 1;
+        }
+    }
+    let fields = params.filter(p => counts[p.name] == 1);
+    return '{' + fields.map(f => `${f.name}: ${getType(f)}`).join(', ') + '}';
+}
+exports.getStructType = getStructType;
+function getReturnType(outputs) {
+    return outputs.length == 1 ? getType(outputs[0]) : getFullTupleType(outputs);
+}
+exports.getReturnType = getReturnType;
+//# sourceMappingURL=types.js.map

package/lib/util/types.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@subsquid/evm-typegen",
-  "version": "1.3.0",
+  "version": "2.0.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",
@@ -17,16 +17,22 @@
   },
   "dependencies": {
     "commander": "^9.3.0",
-    "@ethersproject/abi": "^5.6.4",
-    "@subsquid/util-internal-code-printer": "^0.0.2",
-    "@subsquid/util-internal": "^0.0.1"
+    "@ethersproject/abi": "^5.7.0",
+    "@ethersproject/address": "^5.7.0",
+    "@subsquid/logger": "^0.3.0",
+    "@subsquid/util-internal-code-printer": "^0.1.0",
+    "@subsquid/util-internal-commander": "^0.0.1",
+    "@subsquid/util-internal": "^1.0.0",
+    "node-fetch": "^2.6.7"
   },
   "devDependencies": {
     "@types/node": "^16.11.41",
+    "@types/node-fetch": "^2.6.2",
+    "ethers": "^5.7.2",
     "typescript": "~4.7.4"
   },
   "scripts": {
     "build": "rm -rf lib && tsc"
   },
-  "readme": "# @subsquid/evm-typegen\n\nThis package provides `squid-evm-typegen(1)` command \nwhich can generate TypeScript definitions for evm logs\nto be used within [substrate-processor](../substrate-processor) mapping handlers.\n"
+  "readme": "# @subsquid/evm-typegen\n\nGenerates TypeScript facades for EVM transactions, logs and `eth_call` queries. \n\nThe generated facade classes are assumed to be used by [squids](https://docs.Subsquid.io/overview) indexing EVM data. \nThe generated classes depend on [ethers](https://www.npmjs.com/package/ethers).\n\n## Usage\n\n```\nnpm i -g @subsquid/evm-typegen\n```\n\n```\nArguments:\n  output-dir             output directory for generated definitions\n  abi                    ABI file\n\nOptions:\n  --multicall            generate facade for MakerDAO multicall contract\n  --etherscan-api <url>  etherscan API to fetch contract ABI by a known address\n  --clean                delete output directory before run\n  -h, --help             display help for command\n\nABI file can be specified in three ways:\n\n1. as a plain JSON file:\n\nsquid-evm-typegen src/abi erc20.json\n\n2. as a contract address (to fetch ABI from etherscan)\n\nsquid-evm-typegen src/abi 0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413\n\n3. as an arbitrary http url\n\nsquid-evm-typegen src/abi https://example.com/erc721.json\n\nIn all cases typegen will use ABI's basename as a basename of generated files.\nYou can overwrite basename of generated files using fragment (#) suffix.\n\nsquid-evm-typegen src/abi 0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413#contract \n```\n"
 }

package/src/abi.support.ts

@@ -0,0 +1,115 @@
+import * as ethers from 'ethers'
+
+
+export interface LogRecord {
+    topics: string[]
+    data: string
+}
+
+
+export class LogEvent<Args> {
+    private fragment: ethers.utils.EventFragment
+
+    constructor(private abi: ethers.utils.Interface, public readonly topic: string) {
+        this.fragment = abi.getEvent(topic)
+    }
+
+    decode(rec: LogRecord): Args {
+        return this.abi.decodeEventLog(this.fragment, rec.data, rec.topics) as any as Args
+    }
+}
+
+
+export class Func<Args extends any[], FieldArgs, Result> {
+    private fragment: ethers.utils.FunctionFragment
+
+    constructor(private abi: ethers.utils.Interface, public readonly sighash: string) {
+        this.fragment = abi.getFunction(sighash)
+    }
+
+    decode(input: ethers.utils.BytesLike): Args & FieldArgs {
+        return this.abi.decodeFunctionData(this.fragment, input) as any as Args & FieldArgs
+    }
+
+    encode(args: Args): string {
+        return this.abi.encodeFunctionData(this.fragment, args)
+    }
+
+    decodeResult(output: ethers.utils.BytesLike): Result {
+        const decoded = this.abi.decodeFunctionResult(this.fragment, output)
+        return decoded.length > 1 ? decoded : decoded[0]
+    }
+
+    tryDecodeResult(output: ethers.utils.BytesLike): Result | undefined {
+        try {
+            return this.decodeResult(output)
+        } catch(err: any) {
+            return undefined
+        }
+    }
+}
+
+
+export function isFunctionResultDecodingError(val: unknown): val is Error & {data: string} {
+    if (!(val instanceof Error)) return false
+    let err = val as any
+    return err.code == 'CALL_EXCEPTION'
+        && typeof err.data == 'string'
+        && !err.errorArgs
+        && !err.errorName
+}
+
+
+export interface ChainContext  {
+    _chain: Chain
+}
+
+
+export interface BlockContext  {
+    _chain: Chain
+    block: Block
+}
+
+
+export interface Block  {
+    height: number
+}
+
+
+export interface Chain  {
+    client:  {
+        call: <T=any>(method: string, params?: unknown[]) => Promise<T>
+    }
+}
+
+
+export class ContractBase {
+    private readonly _chain: Chain
+    private readonly blockHeight: number
+    readonly address: string
+
+    constructor(ctx: BlockContext, address: string)
+    constructor(ctx: ChainContext, block: Block, address: string)
+    constructor(ctx: BlockContext, blockOrAddress: Block | string, address?: string) {
+        this._chain = ctx._chain
+        if (typeof blockOrAddress === 'string')  {
+            this.blockHeight = ctx.block.height
+            this.address = ethers.utils.getAddress(blockOrAddress)
+        } else  {
+            if (address == null) {
+                throw new Error('missing contract address')
+            }
+            this.blockHeight = blockOrAddress.height
+            this.address = ethers.utils.getAddress(address)
+        }
+    }
+
+    async eth_call<Args extends any[], FieldArgs, Result>(func: Func<Args, FieldArgs, Result>, args: Args): Promise<Result> {
+        let data = func.encode(args)
+        let result = await this._chain.client.call('eth_call', [
+            {to: this.address, data},
+            '0x'+this.blockHeight.toString(16)
+        ])
+        return func.decodeResult(result)
+    }
+}

package/src/main.ts

@@ -1,34 +1,194 @@
-import {program} from "commander"
-import path from "path"
-import process from "process"
-import {Typegen} from "./typegen"
-
-export function run(): void {
-    program.description(`
-Generates TypeScript definitions for evm log events
-for use within substrate-processor mapping handlers.
+import {Interface} from '@ethersproject/abi'
+import {isAddress} from '@ethersproject/address'
+import {createLogger} from '@subsquid/logger'
+import {runProgram, wait} from '@subsquid/util-internal'
+import {OutDir} from '@subsquid/util-internal-code-printer'
+import * as validator from '@subsquid/util-internal-commander'
+import {InvalidArgumentError, program} from 'commander'
+import * as fs from 'fs'
+import path from 'path'
+import {Typegen} from './typegen'
+import {GET} from './util/fetch'
+
+
+const LOG = createLogger('sqd:evm-typegen')
+
+
+runProgram(async function() {
+    program
+        .description(`
+Generates TypeScript facades for EVM transactions, logs and eth_call queries.
+
+The generated facades are assumed to be used by "squids" indexing EVM data.
     `.trim())
-        .requiredOption('--abi <path>', 'path to a JSON abi file')
-        .requiredOption('--output <path>', 'path for output typescript file');
+        .name('squid-evm-typegen')
+        .argument('<output-dir>', 'output directory for generated definitions')
+        .argument('[abi...]', 'ABI file', specArgument)
+        .option('--multicall', 'generate facade for MakerDAO multicall contract')
+        .option(
+            '--etherscan-api <url>',
+            'etherscan API to fetch contract ABI by a known address',
+            validator.Url(['http:', 'https:'])
+        )
+        .option('--clean', 'delete output directory before run')
+        .addHelpText('afterAll', `
+ABI file can be specified in three ways:
+
+1. as a plain JSON file:
+
+squid-evm-typegen src/abi erc20.json
+
+2. as a contract address (to fetch ABI from etherscan)
+
+squid-evm-typegen src/abi 0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413
+
+3. as an arbitrary http url
+
+squid-evm-typegen src/abi https://example.com/erc721.json
+
+In all cases typegen will use ABI's basename as a basename of generated files.
+You can overwrite basename of generated files using fragment (#) suffix.
+
+squid-evm-typegen src/abi 0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413#contract   
+        `)
+
+    program.parse()
+
+    let opts = program.opts() as {
+        clean?: boolean,
+        multicall?: boolean,
+        etherscanApi?: string
+    }
+    let dest = new OutDir(program.processedArgs[0])
+    let specs = program.processedArgs[1] as Spec[]
+
+    if (opts.clean && dest.exists()) {
+        LOG.info(`deleting ${dest.path()}`)
+        dest.del()
+    }
+
+    if (specs.length == 0 && !opts.multicall) {
+        LOG.warn('no ABI files given, nothing to generate')
+        return
+    }
+
+    dest.add('abi.support.ts', [__dirname, '../src/abi.support.ts'])
+    LOG.info(`saved ${dest.path('abi.support.ts')}`)
+
+    if (opts.multicall) {
+        dest.add('multicall.ts', [__dirname, '../src/multicall.ts'])
+        LOG.info(`saved ${dest.path('multicall.ts')}`)
+    }
 
-    program.parse();
+    for (let spec of specs) {
+        LOG.info(`processing ${spec.src}`)
+        let abi_json = await read(spec, opts)
+        let abi = new Interface(abi_json)
+        new Typegen(dest, abi, spec.name, LOG).generate()
+    }
+}, err => LOG.fatal(err))
 
-    const options = program.opts();
-    const inputPath = options.abi;
-    const outputPath = options.output;
 
-    if (path.parse(inputPath).ext !== ".json") {
-        throw new Error("invalid abi file extension");
+async function read(spec: Spec, options?: {etherscanApi?: string}): Promise<any> {
+    if (spec.kind == 'address') {
+        return fetchFromEtherscan(spec.src, options?.etherscanApi)
+    }
+    let abi: any
+    if (spec.kind == 'url') {
+        abi = await GET(spec.src)
+    } else {
+        abi = JSON.parse(fs.readFileSync(spec.src, 'utf-8'))
     }
+    if (Array.isArray(abi)) {
+        return abi
+    } else if (Array.isArray(abi?.abi)) {
+        return abi.abi
+    } else {
+        throw new Error('Unrecognized ABI format')
+    }
+}
+
+
+async function fetchFromEtherscan(address: string, api?: string): Promise<any> {
+    api = api || 'https://api.etherscan.io/'
+    let url = new URL('api?module=contract&action=getabi', api)
+    url.searchParams.set('address', address)
+    let response: {status: string, result: string}
+    let attempts = 2
+    while (true) {
+        response = await GET(url.toString())
+        if (response.status == '0' && response.result.includes('rate limit') && --attempts) {
+            LOG.warn('faced rate limit error while trying to fetch contract ABI. Trying again in 2 seconds.')
+            await wait(2000)
+        } else {
+            break
+        }
+    }
+    if (response.status == '1') {
+        return JSON.parse(response.result)
+    } else {
+        throw new Error(`Failed to fetch contract ABI from ${api}: ${response.result}`)
+    }
+}
+
 
-    if (path.parse(outputPath).ext !== ".ts") {
-        throw new Error("invalid output file extension");
+interface Spec {
+    kind: 'address' | 'url' | 'file'
+    src: string
+    name: string
+}
+
+
+function specArgument(value: string, prev: Spec[]): Spec[] {
+    let spec = parseSpec(value)
+    prev.push(spec)
+    return prev
+}
+
+
+function parseSpec(spec: string): Spec {
+    let [src, fragment] = splitFragment(spec)
+    if (src.startsWith('0x')) {
+        if (!isAddress(src)) throw new InvalidArgumentError('Invalid contract address')
+        return {
+            kind: 'address',
+            src,
+            name: fragment || src
+        }
+    } else if (src.includes('://')) {
+        let u = new URL(
+            validator.Url(['http:', 'https:'])(src)
+        )
+        return {
+            kind: 'url',
+            src,
+            name: fragment || basename(u.pathname)
+        }
+    } else {
+        return {
+            kind: 'file',
+            src,
+            name: fragment || basename(src)
+        }
     }
+}
+
 
-    try {
-        new Typegen(inputPath, outputPath).generate();
-    } catch (err: any) {
-        console.error(`evm-typegen error: ${err.toString()}`);
-        process.exit(1);
+function splitFragment(spec: string): [string, string] {
+    let parts = spec.split('#')
+    if (parts.length > 1) {
+        let fragment = parts.pop()!
+        return [parts.join('#'), fragment]
+    } else {
+        return [spec, '']
     }
 }
+
+
+function basename(file: string): string {
+    let name = path.parse(file).name
+    if (name) return name
+    throw new InvalidArgumentError(
+        `Can't derive target basename for output files. Use url fragment to specify it, e.g. #erc20`
+    )
+}

package/src/multicall.ts

@@ -0,0 +1,212 @@
+import * as ethers from 'ethers'
+import {ContractBase, Func} from './abi.support'
+
+
+const abi = new ethers.utils.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: ethers.BigNumber, returnData: string[]}>(
+    abi, abi.getSighash('aggregate')
+)
+
+
+const try_aggregate = new Func<[requireSuccess: boolean, calls: Array<[target: string, callData: string]>], {}, Array<{success: boolean, returnData: string}>>(
+    abi, abi.getSighash('tryAggregate')
+)
+
+
+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)
+        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
+    }
+}