@subsquid/evm-typegen 4.5.1 → 5.0.0

package/src/typegen.ts

@@ -1,254 +1,303 @@
-import { Logger } from '@subsquid/logger'
-import { def } from '@subsquid/util-internal'
-import { keccak256 } from '@subsquid/evm-abi'
-import { getType } from './util/types'
-import type { Abi, AbiEvent, AbiFunction, AbiParameter } from 'abitype'
-import { FileOutput, OutDir } from '@subsquid/util-internal-code-printer'
+import type {Logger} from '@subsquid/logger'
+import {FileOutput, type OutDir} from '@subsquid/util-internal-code-printer'
+import type {Abi} from 'abitype'
+import * as fs from 'node:fs'
+import {type ContractDef, type DocDef, type EventDef, type FieldDef, type FunctionDef, type NatSpec, type TypeDef, describe} from './description'
+
+type Import = {name: string; alias?: string; type?: boolean}
 
 export class Typegen {
-  private out: FileOutput
-
-  constructor(
-    dest: OutDir,
-    private abi: Abi,
-    basename: string,
-    private log: Logger,
-  ) {
-    this.out = dest.file(basename + '.ts')
-  }
-
-  async generate() {
-    this.out.line(`import * as p from '@subsquid/evm-codec'`)
-    this.out.line(
-      `import { event, fun, viewFun, indexed, ContractBase } from '@subsquid/evm-abi'`,
-    )
-    this.out.line(
-      `import type { EventParams as EParams, FunctionArguments, FunctionReturn } from '@subsquid/evm-abi'`,
-    )
-
-    this.generateEvents()
-    this.generateFunctions()
-    this.generateContract()
-    this.generateEventTypes()
-    this.generateFunctionTypes()
-
-    await this.out.write()
-    this.log.info(`saved ${this.out.file}`)
-  }
-
-  private generateEvents() {
-    let events = this.getEvents()
-    if (events.length == 0) {
-      return
-    }
-    this.out.line()
-    this.out.block(`export const events =`, () => {
-      for (let e of events) {
-        this.out.line(
-          `${this.getPropName(e)}: event("${this.topic0(e)}", "${this.signature(e)}", {${this.toTypes(
-            e.inputs,
-          )}}),`,
-        )
-      }
-    })
-  }
-
-  private topic0(e: AbiEvent): string {
-    return `0x${keccak256(this.signature(e)).toString('hex')}`
-  }
-
-  private toTypes(inputs: readonly AbiParameter[]): string {
-    return inputs.map((input, idx) => getType(input, idx)).join(', ')
-  }
-
-  private generateFunctions() {
-    let functions = this.getFunctions()
-    if (functions.length == 0) {
-      return
+    private dest: OutDir
+    private contract: ContractDef
+    private modules = new Set<'events' | 'functions'>()
+
+    constructor(
+        dest: OutDir,
+        abi: Abi,
+        basename: string,
+        private log: Logger,
+        natspec?: NatSpec,
+    ) {
+        // Earlier versions of typegen emitted a single `${basename}.ts` file
+        // alongside the output dir. The current layout is a directory
+        // (`${basename}/index.ts` etc.). When TypeScript resolves
+        // `import './abi/foo'` it prefers `foo.ts` over `foo/index.ts`, so
+        // a stale legacy file would silently shadow the freshly generated
+        // module — builds keep passing against the old contents. Detect and
+        // remove the legacy file before we lay down the new directory.
+        const legacy = dest.path(`${basename}.ts`)
+        if (fs.existsSync(legacy) && fs.statSync(legacy).isFile()) {
+            log.warn(`removing stale ${legacy} from a previous typegen layout`)
+            fs.unlinkSync(legacy)
+        }
+        this.dest = dest.child(basename)
+        this.contract = describe(abi, natspec)
     }
-    this.out.line()
-    this.out.block(`export const functions =`, () => {
-      for (let f of functions) {
-        let returnType = ''
-        if (f.outputs?.length === 1) {
-          returnType = getType({ ...f.outputs[0], name: undefined })
+
+    async generate(): Promise<void> {
+        if (this.contract.events.length > 0) {
+            this.generateEvents()
+            this.modules.add('events')
         }
-        if (f.outputs?.length > 1) {
-          returnType = `{${this.toTypes(f.outputs)}}`
+        if (this.contract.functions.length > 0) {
+            this.generateFunctions()
+            this.modules.add('functions')
         }
-        const funType = f.stateMutability === 'view' || f.stateMutability === 'pure' ? 'viewFun' : 'fun'
-        this.out.line(
-          `${this.getPropName(f)}: ${funType}("${this.functionSelector(
-            f,
-          )}", "${this.signature(f)}", {${this.toTypes(f.inputs)}}, ${returnType}),`,
-        )
-      }
-    })
-  }
-
-  private functionSelector(f: AbiFunction): string {
-    const sighash = this.signature(f)
-    return `0x${keccak256(sighash).slice(0, 4).toString('hex')}`
-  }
-
-  private generateContract() {
-    this.out.line()
-    this.out.block(`export class Contract extends ContractBase`, () => {
-      let functions = this.getFunctions()
-      for (let f of functions) {
-        if ((f.stateMutability === 'pure' || f.stateMutability === 'view') &&
-          f.outputs?.length
-        ) {
-          this.out.line()
-          let argNames = f.inputs.map((a, idx) => a.name || `_${idx}`)
-          const ref = this.getPropNameGetter(f)
-          const [argsType] = this.toFunctionTypes(f)
-          let args = f.inputs
-            .map(
-              (a, idx) =>
-                `${argNames[idx]}: ${argsType}["${argNames[idx]}"]`,
-            )
-            .join(', ')
-          this.out.block(`${this.getPropName(f)}(${args})`, () => {
-            this.out.line(
-              `return this.eth_call(functions${ref}, {${argNames.join(', ')}})`,
-            )
-          })
+        this.generateContract()
+        this.writeIndex()
+    }
+
+    private generateEvents(): void {
+        const out = new TypeModuleOutput(this.dest.path('events.ts'))
+        out.import('support', 'event')
+        out.import('support', 'EventParams', 'EParams', true)
+
+        for (let i = 0; i < this.contract.events.length; i++) {
+            if (i > 0) out.line()
+            out.printEvent(this.contract.events[i])
         }
-      }
-    })
-  }
 
-  private canonicalType(param: AbiParameter): string {
-    if (!param.type.startsWith('tuple')) {
-      return param.type
+        out.write()
+        this.log.info(`saved ${out.file}`)
     }
-    const arrayBrackets = param.type.slice(5)
-    return `(${(param as any).components.map((param: AbiParameter) =>
-      this.canonicalType(param),
-    )})${arrayBrackets}`
-  }
-
-  private signature(item: AbiEvent | AbiFunction): string {
-    return `${item.name}(${item.inputs
-      .map((param) => this.canonicalType(param))
-      .join(',')})`
-  }
-
-  private getPropName(item: AbiEvent | AbiFunction): string {
-    if (this.getOverloads(item) == 1) {
-      return item.name
-    } else if (item.type === 'function') {
-      return `'${this.signature(item)}'`
-    } else {
-      return `'${item.name}(${item.inputs
-      .map((param) => this.canonicalType(param) + (param.indexed ? ` indexed` : ``))
-      .join(',')})'`
+
+    private generateFunctions(): void {
+        const out = new TypeModuleOutput(this.dest.path('functions.ts'))
+        out.import('support', 'FunctionArguments', undefined, true)
+        out.import('support', 'FunctionReturn', undefined, true)
+
+        for (let i = 0; i < this.contract.functions.length; i++) {
+            if (i > 0) out.line()
+            out.printFunction(this.contract.functions[i])
+        }
+
+        out.write()
+        this.log.info(`saved ${out.file}`)
     }
-  }
 
-  private getPropNameGetter(item: AbiEvent | AbiFunction): string {
-    if (this.getOverloads(item) == 1) {
-      return '.' + item.name
-    } else{
-      return `[${this.getPropName(item)}]`
+    private generateContract(): void {
+        const viewFns = this.contract.functions.filter((f) => f.outputs.length > 0)
+
+        const out = new TypeModuleOutput(this.dest.path('contract.ts'))
+        out.import('support', 'ContractBase')
+
+        for (const f of viewFns) {
+            out.importFrom('./functions.js', {name: f.key})
+            if (f.inputs.length > 0) {
+                out.importFrom('./functions.js', {name: f.paramsTypeName, type: true})
+            }
+        }
+
+        out.line('export class Contract extends ContractBase {')
+        out.indentation(() => {
+            for (let i = 0; i < viewFns.length; i++) {
+                const f = viewFns[i]
+                if (i > 0) out.line()
+                const argNames = f.inputs.map((a) => a.name)
+                const argList = f.inputs
+                    .map((a) => `${a.name}: ${f.paramsTypeName}[${JSON.stringify(a.name)}]`)
+                    .join(', ')
+                out.line(`${f.key}(${argList}) {`)
+                out.indentation(() => {
+                    const argsObj = argNames.length === 0 ? '{}' : `{${argNames.join(', ')}}`
+                    out.line(`return this.eth_call(${f.key}, ${argsObj})`)
+                })
+                out.line('}')
+            }
+        })
+        out.line('}')
+
+        out.write()
+        this.log.info(`saved ${out.file}`)
     }
-  }
 
-  private getOverloads(item: AbiEvent | AbiFunction): number {
-    if (item.type === 'event') {
-      return this.eventOverloads()[item.name]
-    } else {
-      return this.functionOverloads()[item.name]
+    private writeIndex(): void {
+        const out = new FileOutput(this.dest.path('index.ts'))
+        for (const m of this.modules) {
+            out.line(`export * as ${m} from './${m}.js'`)
+        }
+        out.line()
+        out.line(`export { Contract } from './contract.js'`)
+        out.write()
+        this.log.info(`saved ${out.file}`)
     }
-  }
+}
+
+const EVM_CODEC_MODULE = '@subsquid/evm-codec'
+const SUPPORT_MODULE = '../abi.support.js'
 
-  private capitalize(s: string): string {
-    return s.charAt(0).toUpperCase() + s.slice(1)
-  }
+const BUCKETS = {
+    evmCodec: EVM_CODEC_MODULE,
+    support: SUPPORT_MODULE,
+} as const
 
-  private getOverloadIndex(item: AbiEvent | AbiFunction): number {
-    const abi = [...this.getEvents(), ...this.getFunctions()]
-    const overloads = abi.filter((x) => x.name === item.name)
-    return overloads.findIndex((x) => x === item)
-  }
+class TypeModuleOutput extends FileOutput {
+    // Seeded so evm-codec + abi.support always appear first in the output.
+    private imports = new Map<string, Import[]>([
+        [EVM_CODEC_MODULE, []],
+        [SUPPORT_MODULE, []],
+    ])
 
-  private toEventType(e: AbiEvent): string {
-    if (this.getOverloads(e) === 1) {
-      return `${this.capitalize(e.name)}EventArgs`
+    constructor(file: string) {
+        super(file)
+        this.lazy(() => {
+            let printed = 0
+            for (const [from, imps] of this.imports) {
+                printed += this.printImports(from, imps)
+            }
+            if (printed > 0) this.line()
+        })
     }
-    const index = this.getOverloadIndex(e)
-    return `${this.capitalize(e.name)}EventArgs_${index}`
-  }
-
-  private generateEventTypes() {
-    const events = this.getEvents()
-    if (events.length == 0) {
-      return
+
+    import(bucket: keyof typeof BUCKETS, name: string, alias?: string, type = false): void {
+        this.importFrom(BUCKETS[bucket], {name, alias, type})
     }
-    this.out.line()
-    this.out.line(`/// Event types`)
-    for (let e of events) {
-      const propName = this.getPropNameGetter(e)
-      this.out.line(
-        `export type ${this.toEventType(e)} = EParams<typeof events${propName}>`,
-      )
+
+    importFrom(from: string, imp: Import): void {
+        let list = this.imports.get(from)
+        if (!list) {
+            list = []
+            this.imports.set(from, list)
+        }
+        list.push(imp)
     }
-  }
 
-  private toFunctionTypes(f: AbiFunction): [string, string] {
-    if (this.getOverloads(f) === 1) {
-      return [`${this.capitalize(f.name)}Params`, `${this.capitalize(f.name)}Return`]
+    private printImports(from: string, imports: Import[]): number {
+        if (imports.length === 0) return 0
+        const seen = new Set<string>()
+        const values: Import[] = []
+        const types: Import[] = []
+        for (const imp of imports) {
+            const key = `${imp.type ? 't' : 'v'}:${imp.name}:${imp.alias || ''}`
+            if (seen.has(key)) continue
+            seen.add(key)
+            ;(imp.type ? types : values).push(imp)
+        }
+        const fmt = (list: Import[]) =>
+            list
+                .map((i) => (i.alias ? `${i.name} as ${i.alias}` : i.name))
+                .sort()
+                .join(', ')
+        if (values.length > 0) this.line(`import { ${fmt(values)} } from '${from}'`)
+        if (types.length > 0) this.line(`import type { ${fmt(types)} } from '${from}'`)
+        return (values.length > 0 ? 1 : 0) + (types.length > 0 ? 1 : 0)
     }
-    const index = this.getOverloadIndex(f)
-    return [`${this.capitalize(f.name)}Params_${index}`, `${this.capitalize(f.name)}Return_${index}`]
-  }
-
-  private generateFunctionTypes() {
-    let functions = this.getFunctions()
-    if (functions.length == 0) {
-      return
+
+    printDoc(signature: string, docs: DocDef | undefined): void {
+        const docLines: string[] = []
+        if (docs?.notice) docLines.push(docs.notice)
+        if (docs?.dev) docLines.push(`@dev ${docs.dev}`)
+        if (docLines.length === 0) {
+            this.line(`/** ${signature} */`)
+        } else {
+            this.line('/**')
+            this.line(` * ${signature}`)
+            this.line(' *')
+            for (const l of docLines) this.line(` * ${l}`)
+            this.line(' */')
+        }
     }
-    this.out.line()
-    this.out.line(`/// Function types`)
-    for (let f of functions) {
-      const propName = this.getPropNameGetter(f)
-      const [args, ret] = this.toFunctionTypes(f)
-      this.out.line(
-        `export type ${args} = FunctionArguments<typeof functions${propName}>`,
-      )
-      this.out.line(
-        `export type ${ret} = FunctionReturn<typeof functions${propName}>`,
-      )
-      this.out.line()
+
+    printEvent(e: EventDef): void {
+        this.printDoc(e.signature, e.docs)
+        if (e.inputs.length === 0) {
+            this.line(`export const ${e.key} = event('${e.topic}', {})`)
+        } else {
+            this.line(`export const ${e.key} = event('${e.topic}', {`)
+            this.indentation(() => {
+                for (const f of e.inputs) this.printFieldDsl(f, ',')
+            })
+            this.line('})')
+        }
+        this.line(`export type ${e.typeName} = EParams<typeof ${e.key}>`)
     }
-  }
 
-  @def
-  private functionOverloads(): Record<string, number> {
-    let overloads: Record<string, number> = {}
-    for (let item of this.getFunctions()) {
-      overloads[item.name] = (overloads[item.name] || 0) + 1
+    printFunction(f: FunctionDef): void {
+        this.import('support', 'func')
+
+        this.printDoc(f.signature, f.docs)
+        const prefix = `export const ${f.key} = func('${f.selector}', `
+        const hasInputs = f.inputs.length > 0
+        const hasOutputs = f.outputs.length > 0
+        const singleReturn = f.outputs.length === 1
+
+        if (!hasInputs && !hasOutputs) {
+            this.line(`${prefix}{})`)
+        } else if (!hasInputs && singleReturn) {
+            this.printTypeDsl(`${prefix}{}, `, f.outputs[0].type, ')')
+        } else if (!hasInputs) {
+            this.import('evmCodec', 'struct')
+            this.line(`${prefix}{}, struct({`)
+            this.indentation(() => {
+                for (const o of f.outputs) this.printFieldDsl(o, ',')
+            })
+            this.line('}))')
+        } else {
+            this.line(`${prefix}{`)
+            this.indentation(() => {
+                for (const inp of f.inputs) this.printFieldDsl(inp, ',')
+            })
+            if (!hasOutputs) {
+                this.line('})')
+            } else if (singleReturn) {
+                this.printTypeDsl('}, ', f.outputs[0].type, ')')
+            } else {
+                this.import('evmCodec', 'struct')
+                this.line('}, struct({')
+                this.indentation(() => {
+                    for (const o of f.outputs) this.printFieldDsl(o, ',')
+                })
+                this.line('}))')
+            }
+        }
+
+        this.line(`export type ${f.paramsTypeName} = FunctionArguments<typeof ${f.key}>`)
+        this.line(`export type ${f.returnTypeName} = FunctionReturn<typeof ${f.key}>`)
     }
-    return overloads
-  }
-
-  @def
-  private eventOverloads(): Record<string, number> {
-    let overloads: Record<string, number> = {}
-    for (let item of this.getEvents()) {
-      overloads[item.name] = (overloads[item.name] || 0) + 1
+
+    private printFieldDsl(f: FieldDef, end: string): void {
+        if (f.doc) this.line(`/** ${f.doc} */`)
+        const start = `${propKey(f.name)}: `
+        if (f.indexed) {
+            this.import('support', 'indexed')
+            this.printTypeDsl(`${start}indexed(`, f.type, `)${end}`)
+            return
+        }
+        this.printTypeDsl(start, f.type, end)
     }
-    return overloads
-  }
-
-  @def
-  private getFunctions(): AbiFunction[] {
-    return this.abi.filter((f) => f.type === 'function') as AbiFunction[]
-  }
-
-  @def
-  private getEvents(): AbiEvent[] {
-    return this.abi.filter((f) => f.type === 'event') as AbiEvent[]
-  }
+
+    private printTypeDsl(start: string, type: TypeDef, end: string): void {
+        switch (type.kind) {
+            case 'primitive':
+                this.import('evmCodec', type.name)
+                this.line(start + type.name + end)
+                return
+            case 'array':
+                this.import('evmCodec', 'array')
+                this.printTypeDsl(`${start}array(`, type.item, `)${end}`)
+                return
+            case 'fixedArray':
+                this.import('evmCodec', 'fixedSizeArray')
+                this.printTypeDsl(`${start}fixedSizeArray(`, type.item, `, ${type.size})${end}`)
+                return
+            case 'tuple': {
+                this.import('evmCodec', 'struct')
+                if (type.fields.length === 0) {
+                    this.line(`${start}struct({})${end}`)
+                    return
+                }
+                this.line(`${start}struct({`)
+                this.indentation(() => {
+                    for (const f of type.fields) this.printFieldDsl(f, ',')
+                })
+                this.line(`})${end}`)
+                return
+            }
+        }
+    }
+}
+
+function propKey(name: string): string {
+    if (/^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name)) return name
+    return JSON.stringify(name)
 }

package/lib/util/types.d.ts

@@ -1,3 +0,0 @@
-import type { AbiEventParameter } from 'abitype';
-export declare function getType(param: AbiEventParameter, index?: number): string;
-//# sourceMappingURL=types.d.ts.map

package/lib/util/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/util/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAkBhD,wBAAgB,OAAO,CAAC,KAAK,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAmCxE"}

package/lib/util/types.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getType = getType;
-function isStaticArray(param) {
-    return param.type.match(/\[\d+]$/);
-}
-function isDynamicArray(param) {
-    return param.type.endsWith('[]');
-}
-function elementsCount(param) {
-    return Number(param.type.match(/\[(\d+)]$/)?.[1] ?? 0);
-}
-function arrayChildType(param) {
-    return param.type.replace(/\[\d*]$/, '');
-}
-function getType(param, index) {
-    const { name, ...namelessParam } = param;
-    if (name) {
-        return `"${name}": ${getType(namelessParam)}`;
-    }
-    if (index !== undefined) {
-        return `"_${index}": ${getType(namelessParam)}`;
-    }
-    const { indexed, ...indexlessParam } = param;
-    if (indexed) {
-        return `indexed(${getType(indexlessParam)})`;
-    }
-    if (isStaticArray(param)) {
-        const elements = elementsCount(param);
-        return `p.fixedSizeArray(${getType({
-            ...param,
-            type: arrayChildType(param),
-        })}, ${elements})`;
-    }
-    if (isDynamicArray(param)) {
-        return `p.array(${getType({
-            ...param,
-            type: arrayChildType(param),
-        })})`;
-    }
-    if (param.type === 'tuple') {
-        return `p.struct({${param.components.map((type, idx) => getType(type, idx)).join(', ')}})`;
-    }
-    return `p.${param.type}`;
-}
-//# sourceMappingURL=types.js.map

package/lib/util/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/util/types.ts"],"names":[],"mappings":";;AAkBA,0BAmCC;AAnDD,SAAS,aAAa,CAAC,KAAwB;IAC7C,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;AACpC,CAAC;AAED,SAAS,cAAc,CAAC,KAAwB;IAC9C,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;AAClC,CAAC;AAED,SAAS,aAAa,CAAC,KAAwB;IAC7C,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;AACxD,CAAC;AAED,SAAS,cAAc,CAAC,KAAwB;IAC9C,OAAO,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAA;AAC1C,CAAC;AAED,SAAgB,OAAO,CAAC,KAAwB,EAAE,KAAc;IAC9D,MAAM,EAAE,IAAI,EAAE,GAAG,aAAa,EAAE,GAAG,KAAK,CAAA;IAExC,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,IAAI,IAAI,MAAM,OAAO,CAAC,aAAoB,CAAC,EAAE,CAAA;IACtD,CAAC;IAED,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC,aAAa,CAAC,EAAE,CAAA;IACjD,CAAC;IAED,MAAM,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,GAAG,KAAK,CAAA;IAC5C,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,WAAW,OAAO,CAAC,cAAqB,CAAC,GAAG,CAAA;IACrD,CAAC;IACD,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,CAAC,CAAA;QACrC,OAAO,oBAAoB,OAAO,CAAC;YACjC,GAAG,KAAK;YACR,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC;SAC5B,CAAC,KAAK,QAAQ,GAAG,CAAA;IACpB,CAAC;IAED,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,WAAW,OAAO,CAAC;YACxB,GAAG,KAAK;YACR,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC;SAC5B,CAAC,GAAG,CAAA;IACP,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC3B,OAAO,aAAc,KAAa,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,IAAuB,EAAE,GAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAA;IAChI,CAAC;IAED,OAAO,KAAK,KAAK,CAAC,IAAI,EAAE,CAAA;AAC1B,CAAC"}

package/src/util/types.ts

@@ -1,54 +0,0 @@
-import type { AbiEventParameter } from 'abitype'
-
-function isStaticArray(param: AbiEventParameter) {
-  return param.type.match(/\[\d+]$/)
-}
-
-function isDynamicArray(param: AbiEventParameter) {
-  return param.type.endsWith('[]')
-}
-
-function elementsCount(param: AbiEventParameter) {
-  return Number(param.type.match(/\[(\d+)]$/)?.[1] ?? 0)
-}
-
-function arrayChildType(param: AbiEventParameter) {
-  return param.type.replace(/\[\d*]$/, '')
-}
-
-export function getType(param: AbiEventParameter, index?: number): string {
-  const { name, ...namelessParam } = param
-
-  if (name) {
-    return `"${name}": ${getType(namelessParam as any)}`
-  }
-
-  if (index !== undefined) {
-    return `"_${index}": ${getType(namelessParam)}`
-  }
-
-  const { indexed, ...indexlessParam } = param
-  if (indexed) {
-    return `indexed(${getType(indexlessParam as any)})`
-  }
-  if (isStaticArray(param)) {
-    const elements = elementsCount(param)
-    return `p.fixedSizeArray(${getType({
-      ...param,
-      type: arrayChildType(param),
-    })}, ${elements})`
-  }
-
-  if (isDynamicArray(param)) {
-    return `p.array(${getType({
-      ...param,
-      type: arrayChildType(param),
-    })})`
-  }
-
-  if (param.type === 'tuple') {
-    return `p.struct({${(param as any).components.map((type: AbiEventParameter, idx: number) => getType(type, idx)).join(', ')}})`
-  }
-
-  return `p.${param.type}`
-}