@sparkdotfi/abi-cli 0.0.1

package/README.md

@@ -0,0 +1,66 @@
+# @sparkdotfi/abi-cli
+
+CLI tool for automatically fetching and generating ABIs from blockchain contracts across multiple networks.
+
+## Installation
+
+```bash
+npm install @sparkdotfi/abi-cli
+```
+
+## Configuration
+
+Create `abi-cli.config.ts` in your project root:
+
+```typescript
+import { GlobalConfig } from '@sparkdotfi/abi-cli'
+import { getEnv } from '@sparkdotfi/common-nodejs/env'
+
+const env = getEnv()
+
+const config: GlobalConfig = {
+  out: 'out',
+  keys: {
+    alchemyApiKey: env.string('ALCHEMY_API_KEY'),
+    drpcApiKey: env.string('DRPC_API_KEY'),
+    etherscanApiKey: env.string('ETHERSCAN_API_KEY'),
+  },
+  contracts: {
+    USDC: {
+      mainnet: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+      base: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+      arbitrum: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+      optimism: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
+      unichain: '0x078D782b760474a361dDA0AF3839290b0EF57AD6',
+    },
+  },
+}
+
+export default config
+```
+
+## Usage
+
+```bash
+# Set environment variables 
+export ALCHEMY_API_KEY="your_key"
+export DRPC_API_KEY="your_key"
+export ETHERSCAN_API_KEY="your_key"
+
+# Run CLI
+npx @sparkdotfi/abi-cli
+
+# Or add `abi-cli` command to your package.json
+{
+  "scripts": {
+    "generate": "abi-cli"
+  }
+}
+```
+
+## Features
+
+- Fetches ABIs from multiple networks
+- Supports proxy contract resolution
+- Verifies ABI compatability between many networks
+- Generates TypeScript files

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,11 @@
+import { NodeContext, NodeRuntime } from '@effect/platform-node';
+import { Effect, Layer } from 'effect';
+import { configLayer } from './config/Config';
+import { abiFetcherLayer } from './fetch/AbiFetcher';
+import { blockchainClientRepositoryLayer } from './fetch/BlockchainClientRepository';
+import { main } from './main';
+import { progressBarLayer } from './services/ProgressBar';
+const blockchainClientRepository = Layer.provide(blockchainClientRepositoryLayer, configLayer);
+const abiFetcher = Layer.provide(abiFetcherLayer, [blockchainClientRepository, configLayer]);
+const mainDeps = Layer.mergeAll(configLayer, blockchainClientRepository, abiFetcher, NodeContext.layer, progressBarLayer);
+main.pipe(Effect.provide(mainDeps), Effect.withSpan('cli'), NodeRuntime.runMain);

package/dist/common.d.ts

@@ -0,0 +1,7 @@
+import { Hash256 } from '@sparkdotfi/common-universal';
+export interface DefaultError {
+    cause?: unknown;
+    message: string;
+}
+export declare function calcHash(data: string): Hash256;
+//# sourceMappingURL=common.d.ts.map

package/dist/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAA;AAGtD,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9C"}

package/dist/common.js

@@ -0,0 +1,5 @@
+import { Hash256 } from '@sparkdotfi/common-universal';
+import { keccak256, toHex } from 'viem';
+export function calcHash(data) {
+    return Hash256(keccak256(toHex(data)));
+}

package/dist/config/Config.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from 'effect';
+import { ParseError } from 'effect/ParseResult';
+import { DefaultError } from '../common';
+import { GlobalConfig } from './schema';
+declare const ConfigParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigParseError";
+} & Readonly<A>;
+export declare class ConfigParseError extends ConfigParseError_base<DefaultError> {
+}
+export interface CliConfigService {
+    readonly getConfig: () => Effect.Effect<GlobalConfig>;
+}
+declare const CliConfig_base: Context.TagClass<CliConfig, "CliConfig", CliConfigService>;
+export declare class CliConfig extends CliConfig_base {
+}
+export declare function configLayerFromConfig(cfg: GlobalConfig): Layer.Layer<CliConfig, ParseError>;
+export declare const configLayer: Layer.Layer<CliConfig, ConfigParseError | ParseError, never>;
+export {};
+//# sourceMappingURL=Config.d.ts.map

package/dist/config/Config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/config/Config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,YAAY,EAAgB,MAAM,UAAU,CAAA;;;;AAErD,qBAAa,gBAAiB,SAAQ,sBAAqC,YAAY,CAAC;CAAG;AAE3F,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAA;CACtD;;AASD,qBAAa,SAAU,SAAQ,cAAuD;CAAG;AAEzF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAE3F;AAED,eAAO,MAAM,WAAW,8DASmB,CAAA"}

package/dist/config/Config.js

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import { Context, Data, Effect, Layer, Schema } from 'effect';
+import { configSchema } from './schema';
+export class ConfigParseError extends Data.TaggedError('ConfigParseError') {
+}
+const make = (config) => Effect.gen(function* () {
+    return {
+        getConfig: () => Effect.succeed(config),
+    };
+}).pipe(Effect.withSpan('make'));
+export class CliConfig extends Context.Tag('CliConfig')() {
+}
+export function configLayerFromConfig(cfg) {
+    return Layer.effect(CliConfig, make(cfg));
+}
+export const configLayer = Layer.effect(CliConfig, Effect.gen(function* () {
+    const config = yield* loadRawConfigFromFile;
+    const decodedConfig = yield* Schema.decodeUnknownEither(configSchema)(config);
+    yield* Effect.logInfo('Config loaded');
+    return yield* make(decodedConfig);
+}).pipe(Effect.withSpan('configLayer')));
+const loadRawConfigFromFile = Effect.tryPromise({
+    try: async () => {
+        const rootDir = process.cwd();
+        const config = await import(path.join(rootDir, 'abi-cli.config.ts'));
+        return config.default;
+    },
+    catch: (error) => new ConfigParseError({
+        message: 'Failed to load config',
+        cause: error,
+    }),
+}).pipe(Effect.withSpan('loadRawConfigFromFile'));

package/dist/config/schema.d.ts

@@ -0,0 +1,135 @@
+import { Schema } from 'effect';
+declare const addressesSchema: Schema.SchemaClass<{
+    readonly mainnet?: (`0x${string}` & {
+        readonly __TAG__: "CheckedAddress";
+    }) | undefined;
+    readonly base?: (`0x${string}` & {
+        readonly __TAG__: "CheckedAddress";
+    }) | undefined;
+    readonly gnosis?: (`0x${string}` & {
+        readonly __TAG__: "CheckedAddress";
+    }) | undefined;
+    readonly arbitrum?: (`0x${string}` & {
+        readonly __TAG__: "CheckedAddress";
+    }) | undefined;
+    readonly optimism?: (`0x${string}` & {
+        readonly __TAG__: "CheckedAddress";
+    }) | undefined;
+    readonly worldchain?: (`0x${string}` & {
+        readonly __TAG__: "CheckedAddress";
+    }) | undefined;
+    readonly unichain?: (`0x${string}` & {
+        readonly __TAG__: "CheckedAddress";
+    }) | undefined;
+}, {
+    readonly [x: string]: string | undefined;
+}, never>;
+export declare const configSchema: Schema.Struct<{
+    out: typeof Schema.String;
+    secrets: Schema.Struct<{
+        alchemyApiKey: typeof Schema.String;
+        drpcApiKey: typeof Schema.String;
+        etherscanApiKey: typeof Schema.String;
+    }>;
+    eoa: Schema.PropertySignature<":", {
+        readonly [x: string]: {
+            readonly mainnet?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly base?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly gnosis?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly arbitrum?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly optimism?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly worldchain?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly unichain?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+        };
+    }, never, "?:", {
+        readonly [x: string]: {
+            readonly [x: string]: string | undefined;
+        };
+    }, false, never>;
+    contracts: Schema.PropertySignature<":", {
+        readonly [x: string]: {
+            readonly mainnet?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly base?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly gnosis?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly arbitrum?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly optimism?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly worldchain?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+            readonly unichain?: (`0x${string}` & {
+                readonly __TAG__: "CheckedAddress";
+            }) | undefined;
+        };
+    }, never, "?:", {
+        readonly [x: string]: {
+            readonly [x: string]: string | undefined;
+        };
+    }, false, never>;
+    interfaces: Schema.PropertySignature<":", {
+        readonly [x: string]: {
+            readonly methods?: readonly string[] | undefined;
+            readonly events?: readonly string[] | undefined;
+            readonly addresses: {
+                readonly mainnet?: (`0x${string}` & {
+                    readonly __TAG__: "CheckedAddress";
+                }) | undefined;
+                readonly base?: (`0x${string}` & {
+                    readonly __TAG__: "CheckedAddress";
+                }) | undefined;
+                readonly gnosis?: (`0x${string}` & {
+                    readonly __TAG__: "CheckedAddress";
+                }) | undefined;
+                readonly arbitrum?: (`0x${string}` & {
+                    readonly __TAG__: "CheckedAddress";
+                }) | undefined;
+                readonly optimism?: (`0x${string}` & {
+                    readonly __TAG__: "CheckedAddress";
+                }) | undefined;
+                readonly worldchain?: (`0x${string}` & {
+                    readonly __TAG__: "CheckedAddress";
+                }) | undefined;
+                readonly unichain?: (`0x${string}` & {
+                    readonly __TAG__: "CheckedAddress";
+                }) | undefined;
+            };
+        };
+    }, never, "?:", {
+        readonly [x: string]: {
+            readonly addresses: {
+                readonly [x: string]: string | undefined;
+            };
+            readonly methods?: readonly string[] | undefined;
+            readonly events?: readonly string[] | undefined;
+        };
+    }, false, never>;
+}>;
+export type AbiCliConfig = Schema.Schema.Encoded<typeof configSchema>;
+export type GlobalConfig = Schema.Schema.Type<typeof configSchema>;
+export type AddressesConfig = Schema.Schema.Type<typeof addressesSchema>;
+export type InterfaceConfig = NonNullable<Schema.Schema.Type<typeof configSchema>['interfaces']>[number];
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAWvC,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;SAOpB,CAAA;AAgBD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBvB,CAAA;AAGF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,YAAY,CAAC,CAAA;AACrE,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAA;AAElE,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;AAExE,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/config/schema.js

@@ -0,0 +1,48 @@
+import { CheckedAddress, allSparkDomains } from '@sparkdotfi/common-universal';
+import { Option, Schema } from 'effect';
+const CheckedAddressSchema = Schema.declare((input) => input === CheckedAddress(input));
+const StringToCheckedAddress = Schema.transform(Schema.String, CheckedAddressSchema, {
+    decode: (fromA) => CheckedAddress(fromA),
+    encode: (address) => address.toString(),
+});
+const addressesSchema = Schema.partial(Schema.Record({
+    key: Schema.String.pipe(Schema.filter(isSparkDomain)).annotations({ message: () => 'Must be valid spark domain' }),
+    value: StringToCheckedAddress.annotations({
+        message: () => 'Must be valid address',
+    }),
+}));
+const interfaceSchema = Schema.Record({
+    key: Schema.String,
+    value: Schema.Struct({
+        methods: Schema.optional(Schema.Array(Schema.String)),
+        events: Schema.optional(Schema.Array(Schema.String)),
+        addresses: addressesSchema,
+    }),
+});
+const contractsMapSchema = Schema.Record({
+    key: Schema.String,
+    value: addressesSchema,
+});
+export const configSchema = Schema.Struct({
+    out: Schema.String,
+    secrets: Schema.Struct({
+        alchemyApiKey: Schema.String,
+        drpcApiKey: Schema.String,
+        etherscanApiKey: Schema.String,
+    }),
+    eoa: Schema.optionalToRequired(contractsMapSchema, contractsMapSchema, {
+        decode: (o) => (Option.isNone(o) ? {} : o.value),
+        encode: (ti) => Option.some(ti),
+    }),
+    contracts: Schema.optionalToRequired(contractsMapSchema, contractsMapSchema, {
+        decode: (o) => (Option.isNone(o) ? {} : o.value),
+        encode: (ti) => Option.some(ti),
+    }),
+    interfaces: Schema.optionalToRequired(interfaceSchema, interfaceSchema, {
+        decode: (o) => (Option.isNone(o) ? {} : o.value),
+        encode: (ti) => Option.some(ti),
+    }),
+});
+function isSparkDomain(data) {
+    return allSparkDomains.includes(data);
+}

package/dist/fetch/AbiFetcher.d.ts

@@ -0,0 +1,29 @@
+import { CheckedAddress } from '@sparkdotfi/common-universal';
+import { Context, Effect, Layer } from 'effect';
+import { TimeoutException } from 'effect/Cause';
+import { DefaultError } from '../common';
+import { CliConfig } from '../config/Config';
+import { Abi, ContractIndex } from '../types';
+import { BlockchainClientNotFoundError, BlockchainClientRepository } from './BlockchainClientRepository';
+declare const AbiFetcher_base: Context.TagClass<AbiFetcher, "AbiFetcher", AbiFetcherService>;
+export declare class AbiFetcher extends AbiFetcher_base {
+}
+export interface AbiFetcherService {
+    readonly fetchAbi: (contract: ContractIndex) => Effect.Effect<Abi, AbiFetcherError | AbiNotFoundError | TimeoutException | BlockchainClientNotFoundError>;
+}
+declare const AbiNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AbiNotFoundError";
+} & Readonly<A>;
+export declare class AbiNotFoundError extends AbiNotFoundError_base<{
+    address: CheckedAddress;
+    chainId: number;
+}> {
+}
+declare const AbiFetcherError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AbiFetcherError";
+} & Readonly<A>;
+export declare class AbiFetcherError extends AbiFetcherError_base<DefaultError> {
+}
+export declare const abiFetcherLayer: Layer.Layer<AbiFetcher, never, CliConfig | BlockchainClientRepository>;
+export {};
+//# sourceMappingURL=AbiFetcher.d.ts.map

package/dist/fetch/AbiFetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbiFetcher.d.ts","sourceRoot":"","sources":["../../src/fetch/AbiFetcher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAmB,MAAM,8BAA8B,CAAA;AAC9E,OAAO,EAAE,OAAO,EAAkB,MAAM,EAAE,KAAK,EAAY,MAAM,QAAQ,CAAA;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;;AAExG,qBAAa,UAAW,SAAQ,eAA0D;CAAG;AAE7F,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,CACjB,QAAQ,EAAE,aAAa,KACpB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,6BAA6B,CAAC,CAAA;CAC/G;;;;AAED,qBAAa,gBAAiB,SAAQ,sBAAqC;IACzE,OAAO,EAAE,cAAc,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAC;CAAG;;;;AACL,qBAAa,eAAgB,SAAQ,qBAAoC,YAAY,CAAC;CAAG;AAyBzF,eAAO,MAAM,eAAe,wEAAiC,CAAA"}

package/dist/fetch/AbiFetcher.js

@@ -0,0 +1,63 @@
+import { whatsabi } from '@shazow/whatsabi';
+import { domainToChainId } from '@sparkdotfi/common-universal';
+import { Context, Data, Duration, Effect, Layer, Schedule } from 'effect';
+import { CliConfig } from '../config/Config';
+import { BlockchainClientRepository } from './BlockchainClientRepository';
+export class AbiFetcher extends Context.Tag('AbiFetcher')() {
+}
+export class AbiNotFoundError extends Data.TaggedError('AbiNotFoundError') {
+}
+export class AbiFetcherError extends Data.TaggedError('AbiFetcherError') {
+}
+const make = Effect.gen(function* () {
+    const blockchainClientRepository = yield* BlockchainClientRepository;
+    const config = yield* (yield* CliConfig).getConfig();
+    const fetchAbi = (contract) => Effect.gen(function* () {
+        const { address, domain } = contract;
+        const client = yield* blockchainClientRepository.getClientForDomain(domain);
+        return yield* whatsAbiFetchEffect({
+            address,
+            chainId: domainToChainId[domain],
+            etherscanApiKey: config.secrets.etherscanApiKey,
+            client,
+        });
+    });
+    return {
+        fetchAbi,
+    };
+});
+export const abiFetcherLayer = Layer.effect(AbiFetcher, make);
+const whatsAbiFetchEffect = (args) => {
+    const { chainId, etherscanApiKey, client, address } = args;
+    return Effect.tryPromise({
+        try: async () => {
+            const loader = new whatsabi.loaders.EtherscanV2ABILoader({
+                apiKey: etherscanApiKey,
+                chainId,
+            });
+            return await whatsabi.autoload(address, {
+                provider: client,
+                followProxies: true,
+                abiLoader: loader,
+                onError: (_name, err) => {
+                    // @todo this api is odd: will the promise reject on such error?
+                    throw err;
+                },
+            });
+        },
+        catch: (error) => {
+            return new AbiFetcherError({
+                cause: error,
+                message: 'WhatsABI failure',
+            });
+        },
+    }).pipe(Effect.timeout('10 seconds'), Effect.retry(Schedule.intersect(Schedule.exponential(Duration.millis(250), 1.5), Schedule.recurs(3))), Effect.andThen((data) => {
+        if (data.abi.length === 0) {
+            return Effect.fail(new AbiNotFoundError({ address, chainId }));
+        }
+        if (!data.abiLoadedFrom || !data.abiLoadedFrom.name.toLowerCase().includes('etherscan')) {
+            return Effect.fail(new AbiNotFoundError({ address, chainId }));
+        }
+        return Effect.succeed(data.abi);
+    }));
+};

package/dist/fetch/BlockchainClientRepository.d.ts

@@ -0,0 +1,29 @@
+import { SparkDomain } from '@sparkdotfi/common-universal';
+import { Context, Effect, Layer } from 'effect';
+import { PublicClient } from 'viem';
+import { DefaultError } from '../common';
+import { CliConfig } from '../config/Config';
+declare const BlockchainClientNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BlockchainClientNotFoundError";
+} & Readonly<A>;
+export declare class BlockchainClientNotFoundError extends BlockchainClientNotFoundError_base<DefaultError> {
+}
+declare const BuildBlockchainRepositoryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BuildBlockchainRepositoryError";
+} & Readonly<A>;
+export declare class BuildBlockchainRepositoryError extends BuildBlockchainRepositoryError_base<DefaultError> {
+}
+export interface BlockchainClientRepositoryService {
+    readonly getClientForDomain: (domain: SparkDomain) => Effect.Effect<PublicClient, BlockchainClientNotFoundError, never>;
+}
+declare const BlockchainClientRepository_base: Context.TagClass<BlockchainClientRepository, "BlockchainClientRepository", BlockchainClientRepositoryService>;
+export declare class BlockchainClientRepository extends BlockchainClientRepository_base {
+}
+export declare const blockchainClientRepositoryLayer: Layer.Layer<BlockchainClientRepository, BuildBlockchainRepositoryError, CliConfig>;
+export declare function getRpcUrls({ domain, alchemyApiKey, drpcApiKey, }: {
+    domain: SparkDomain;
+    alchemyApiKey: string;
+    drpcApiKey: string;
+}): string[];
+export {};
+//# sourceMappingURL=BlockchainClientRepository.d.ts.map

package/dist/fetch/BlockchainClientRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockchainClientRepository.d.ts","sourceRoot":"","sources":["../../src/fetch/BlockchainClientRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EAKZ,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAe,YAAY,EAAgC,MAAM,MAAM,CAAA;AAC9E,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;;;;AAE5C,qBAAa,6BAA8B,SAAQ,mCAAkD,YAAY,CAAC;CAAG;;;;AACrH,qBAAa,8BAA+B,SAAQ,oCAAmD,YAAY,CAAC;CAAG;AAEvH,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,kBAAkB,EAAE,CAC3B,MAAM,EAAE,WAAW,KAChB,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,6BAA6B,EAAE,KAAK,CAAC,CAAA;CACvE;;AAmDD,qBAAa,0BAA2B,SAAQ,+BAG7C;CAAG;AAEN,eAAO,MAAM,+BAA+B,oFAAmD,CAAA;AAE/F,wBAAgB,UAAU,CAAC,EACzB,MAAM,EACN,aAAa,EACb,UAAU,GACX,EAAE;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CAE/E"}

package/dist/fetch/BlockchainClientRepository.js

@@ -0,0 +1,51 @@
+import { allSparkDomains, domainToChain, getAlchemyRpcUrl, getDrpcRpcUrl, } from '@sparkdotfi/common-universal';
+import { Context, Data, Effect, Layer } from 'effect';
+import { http, createPublicClient, fallback } from 'viem';
+import { CliConfig } from '../config/Config';
+export class BlockchainClientNotFoundError extends Data.TaggedError('BlockchainClientNotFoundError') {
+}
+export class BuildBlockchainRepositoryError extends Data.TaggedError('BuildBlockchainRepositoryError') {
+}
+const effect = Effect.gen(function* () {
+    const config = yield* (yield* CliConfig).getConfig();
+    const clients = yield* Effect.try({
+        try: () => {
+            return allSparkDomains.map((domain) => {
+                const chain = domainToChain[domain];
+                const rpcUrls = getRpcUrls({
+                    domain,
+                    alchemyApiKey: config.secrets.alchemyApiKey,
+                    drpcApiKey: config.secrets.drpcApiKey,
+                });
+                const transport = fallback(rpcUrls.map((rpcUrl) => http(rpcUrl)));
+                return createPublicClient({
+                    chain,
+                    transport,
+                });
+            });
+        },
+        catch: (error) => new BuildBlockchainRepositoryError({
+            cause: error,
+            message: 'Failed to build blockchain client repository',
+        }),
+    }).pipe(Effect.withSpan('buildBlockchainClientRepository'));
+    const getClientForDomain = (domain) => Effect.gen(function* () {
+        const client = clients.find((client) => client.chain?.id === domainToChain[domain].id);
+        if (!client) {
+            return yield* Effect.fail(new BlockchainClientNotFoundError({
+                cause: clients,
+                message: `Blockchain client not found for domain ${domain}`,
+            }));
+        }
+        return yield* Effect.succeed(client);
+    }).pipe(Effect.withSpan('getClientForDomain'));
+    return {
+        getClientForDomain,
+    };
+});
+export class BlockchainClientRepository extends Context.Tag('BlockchainClientRepository')() {
+}
+export const blockchainClientRepositoryLayer = Layer.effect(BlockchainClientRepository, effect);
+export function getRpcUrls({ domain, alchemyApiKey, drpcApiKey, }) {
+    return [getAlchemyRpcUrl({ domain, alchemyApiKey }), getDrpcRpcUrl({ domain, drpcApiKey })];
+}

package/dist/fetch/fetchAbis.d.ts

@@ -0,0 +1,8 @@
+import { Effect } from 'effect';
+import { CliConfig } from '../config/Config';
+import { ProgressBar } from '../services/ProgressBar';
+import { AbiFetcher } from './AbiFetcher';
+export declare const fetchAbis: Effect.Effect<Partial<Record<"mainnet" | "base" | "gnosis" | "arbitrum" | "optimism" | "worldchain" | "unichain", Record<`0x${string}` & {
+    readonly __TAG__: "CheckedAddress";
+}, import("../types").ContractMetadata>>>, import("./BlockchainClientRepository").BlockchainClientNotFoundError | import("./AbiFetcher").AbiFetcherError | import("./AbiFetcher").AbiNotFoundError | import("effect/Cause").TimeoutException | import("../services/ProgressBar").ProgressBarError, CliConfig | AbiFetcher | ProgressBar>;
+//# sourceMappingURL=fetchAbis.d.ts.map

package/dist/fetch/fetchAbis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchAbis.d.ts","sourceRoot":"","sources":["../../src/fetch/fetchAbis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE5C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC,eAAO,MAAM,SAAS;;wUAoBwE,CAAA"}

package/dist/fetch/fetchAbis.js

@@ -0,0 +1,38 @@
+import { Effect } from 'effect';
+import { entries, uniqueBy } from 'remeda';
+import { CliConfig } from '../config/Config';
+import { ProgressBar } from '../services/ProgressBar';
+import { AbiFetcher } from './AbiFetcher';
+export const fetchAbis = Effect.gen(function* () {
+    const config = yield* (yield* CliConfig).getConfig();
+    const abiFetcher = yield* AbiFetcher;
+    const progressBar = yield* ProgressBar;
+    const contracts = getContractsToFetch(config);
+    yield* Effect.logInfo(`Fetching ${contracts.length} ABIs`);
+    yield* progressBar.create(contracts.length);
+    const effects = contracts.map((contract) => abiFetcher.fetchAbi(contract).pipe(Effect.map((abi) => ({ contract, abi })), Effect.tap(() => progressBar.increment)));
+    const downloadedAbis = yield* Effect.all(effects, { concurrency: 5 });
+    yield* progressBar.finish;
+    return getMetadataStore(downloadedAbis);
+}).pipe(Effect.withSpan('fetchAbis'));
+function getContractsToFetch(config) {
+    const contractsPart = entries(config.contracts).flatMap(([name, chainAddresses]) => {
+        return entries(chainAddresses).map(([domain, address]) => ({ domain, address, name }));
+    });
+    const interfacesPart = entries(config.interfaces || {}).flatMap(([name, interfaceConfig]) => {
+        return entries(interfaceConfig.addresses).map(([domain, address]) => ({ domain, address, name }));
+    });
+    return uniqueBy(contractsPart.concat(interfacesPart), (c) => `${c.domain}-${c.address}`);
+}
+// @todo this should be possible to replace with nested usage of remeda's groupBy
+function getMetadataStore(downloadedAbis) {
+    return downloadedAbis.reduce((acc, data) => {
+        const domain = data.contract.domain;
+        const address = data.contract.address;
+        if (!acc[domain]) {
+            acc[domain] = {};
+        }
+        acc[domain][address] = { abi: data.abi };
+        return acc;
+    }, {});
+}

package/dist/generate/dataProcessing.d.ts

@@ -0,0 +1,8 @@
+import { GlobalConfig } from '../config/schema';
+import { ContractMetadataStore, EoaEntity, PreprocessedEntity } from '../types';
+export declare function preprocess(store: ContractMetadataStore, config: GlobalConfig): {
+    contracts: PreprocessedEntity[];
+    eoas: EoaEntity[];
+    interfaces: never[];
+};
+//# sourceMappingURL=dataProcessing.d.ts.map

package/dist/generate/dataProcessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataProcessing.d.ts","sourceRoot":"","sources":["../../src/generate/dataProcessing.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAoB,qBAAqB,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAEjG,wBAAgB,UAAU,CAAC,KAAK,EAAE,qBAAqB,EAAE,MAAM,EAAE,YAAY;;;;EAkB5E"}

package/dist/generate/dataProcessing.js

@@ -0,0 +1,25 @@
+import { assert } from '@sparkdotfi/common-universal';
+import { entries, keys } from 'remeda';
+export function preprocess(store, config) {
+    const contractsData = entries(config.contracts).map(([name, addresses]) => {
+        const metadata = getMetadataFromStore(store, addresses);
+        return {
+            addresses,
+            name,
+            abi: metadata.abi,
+        };
+    });
+    const eoaData = entries(config.eoa || {}).map(([name, addresses]) => ({ name, addresses }));
+    return {
+        contracts: contractsData,
+        eoas: eoaData,
+        interfaces: [],
+    };
+}
+function getMetadataFromStore(store, addresses) {
+    const firstDomain = keys(addresses)[0];
+    assert(firstDomain !== undefined, 'Addresses are empty');
+    const firstAddress = addresses[firstDomain];
+    assert(firstAddress !== undefined);
+    return store[firstDomain][firstAddress];
+}

package/dist/generate/formatOutput.d.ts

@@ -0,0 +1,2 @@
+export declare function format(content: string): Promise<string>;
+//# sourceMappingURL=formatOutput.d.ts.map

package/dist/generate/formatOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatOutput.d.ts","sourceRoot":"","sources":["../../src/generate/formatOutput.ts"],"names":[],"mappings":"AAKA,wBAAsB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAe7D"}

package/dist/generate/formatOutput.js

@@ -0,0 +1,19 @@
+import prettier from 'prettier';
+// This code is basically copied from wagmi-cli. Any idea how to improve it?
+// Theoretically, we could not do it at all and rely on repo configured linting.
+// In practice e.g. when I hit ctrl+s in not formatted file - I had a huge lag.
+export async function format(content) {
+    const config = await prettier.resolveConfig(process.cwd());
+    return prettier.format(content, {
+        arrowParens: 'always',
+        endOfLine: 'lf',
+        parser: 'typescript',
+        printWidth: 120,
+        semi: false,
+        singleQuote: true,
+        tabWidth: 2,
+        trailingComma: 'all',
+        ...config,
+        plugins: [],
+    });
+}

package/dist/generate/generate.d.ts

@@ -0,0 +1,11 @@
+import { FileSystem } from '@effect/platform';
+import { Effect } from 'effect';
+import { AddressesConfig, GlobalConfig } from '../config/schema';
+import { ContractMetadataStore, PreprocessedContractsData } from '../types';
+export declare const generate: (metadataStore: ContractMetadataStore, config: GlobalConfig) => Effect.Effect<void, import("effect/Cause").UnknownException | import("@effect/platform/Error").PlatformError, FileSystem.FileSystem>;
+/**
+ * @internal
+ */
+export declare function generateModule(data: PreprocessedContractsData): Promise<string>;
+export declare function getOrderedAddresses(data: AddressesConfig): AddressesConfig;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/generate/generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAO,qBAAqB,EAAa,yBAAyB,EAAsB,MAAM,UAAU,CAAA;AAI/G,eAAO,MAAM,QAAQ,kBAAmB,qBAAqB,UAAU,YAAY,yIAWL,CAAA;AAE9E;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM/E;AAiBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAE1E"}

package/dist/generate/generate.js

@@ -0,0 +1,56 @@
+import { FileSystem } from '@effect/platform';
+import { Effect } from 'effect';
+import { entries, fromEntries } from 'remeda';
+import { preprocess } from './dataProcessing';
+import { format } from './formatOutput';
+export const generate = (metadataStore, config) => Effect.gen(function* () {
+    yield* Effect.logInfo('Validating ...');
+    const fs = yield* FileSystem.FileSystem;
+    const data = preprocess(metadataStore, config);
+    yield* Effect.logInfo('Writing ...');
+    const module = yield* Effect.tryPromise(() => generateModule(data));
+    yield* fs.writeFileString(config.out, module);
+}).pipe(Effect.withSpan('generate'));
+/**
+ * @internal
+ */
+export function generateModule(data) {
+    const sections = data.eoas.map(eoaSection).concat(data.contracts.map(contractSection));
+    const source = sections.join('\n');
+    return format(source);
+}
+function eoaSection(data) {
+    return `
+  ${header(data.name, 'EOA')}
+  ${addressesSection(data.name, data.addresses, 'EOA')}
+  `;
+}
+function contractSection(data) {
+    return `
+  ${header(data.name, 'Contract')}
+  ${abiSection(data.name, data.abi)}
+  ${addressesSection(data.name, data.addresses, 'Contract')}
+  `;
+}
+export function getOrderedAddresses(data) {
+    return fromEntries(entries(data).sort(([a], [b]) => a.localeCompare(b)));
+}
+function header(name, type) {
+    return `
+  //////////////////////////////////////////////////////////////////
+  // ${name} ${type}
+  //////////////////////////////////////////////////////////////////
+  `;
+}
+function addressesSection(name, data, type) {
+    const sortedData = getOrderedAddresses(data);
+    const stringified = JSON.stringify(sortedData, null, 2);
+    return wrapWithConstDeclaration(`${name}${type}Address`, stringified);
+}
+function abiSection(name, data) {
+    const stringified = JSON.stringify(data);
+    return wrapWithConstDeclaration(`${name}Abi`, stringified);
+}
+function wrapWithConstDeclaration(name, content) {
+    return `export const ${name} = ${content} as const\n`;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { AbiCliConfig } from './config/schema';
+declare function defineConfig(config: AbiCliConfig): AbiCliConfig;
+export type { AbiCliConfig };
+export { defineConfig };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,iBAAS,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAExD;AAED,YAAY,EAAE,YAAY,EAAE,CAAA;AAC5B,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+function defineConfig(config) {
+    return config;
+}
+export { defineConfig };

package/dist/main.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from 'effect';
+import { CliConfig } from './config/Config';
+export declare const main: Effect.Effect<void, import("./fetch/BlockchainClientRepository").BlockchainClientNotFoundError | import("./fetch/AbiFetcher").AbiFetcherError | import("./fetch/AbiFetcher").AbiNotFoundError | import("effect/Cause").TimeoutException | import("effect/Cause").UnknownException | import("./services/ProgressBar").ProgressBarError | import("@effect/platform/Error").PlatformError | import("./verify/verify").ValidationError, CliConfig | import("./fetch/AbiFetcher").AbiFetcher | import("./services/ProgressBar").ProgressBar | import("@effect/platform/FileSystem").FileSystem>;
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAK3C,eAAO,MAAM,IAAI,4jBAOe,CAAA"}

package/dist/main.js

@@ -0,0 +1,11 @@
+import { Effect } from 'effect';
+import { CliConfig } from './config/Config';
+import { fetchAbis } from './fetch/fetchAbis';
+import { generate } from './generate/generate';
+import { verify } from './verify/verify';
+export const main = Effect.gen(function* () {
+    const config = yield* (yield* CliConfig).getConfig();
+    const metadataStore = yield* fetchAbis;
+    yield* verify(metadataStore, config);
+    yield* generate(metadataStore, config);
+}).pipe(Effect.withSpan('main'));

package/dist/services/ProgressBar.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from 'effect';
+import { DefaultError } from '../common';
+declare const ProgressBarError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProgressBarError";
+} & Readonly<A>;
+export declare class ProgressBarError extends ProgressBarError_base<DefaultError> {
+}
+export interface ProgressBarService {
+    readonly create: (total: number) => Effect.Effect<void, ProgressBarError, never>;
+    readonly increment: Effect.Effect<void, ProgressBarError, never>;
+    readonly finish: Effect.Effect<void, ProgressBarError, never>;
+}
+declare const ProgressBar_base: Context.TagClass<ProgressBar, "ProgressBar", ProgressBarService>;
+export declare class ProgressBar extends ProgressBar_base {
+}
+export declare const progressBarLayer: Layer.Layer<ProgressBar, never, never>;
+export declare const progressBarMockLayer: Layer.Layer<ProgressBar, never, never>;
+export {};
+//# sourceMappingURL=ProgressBar.d.ts.map

package/dist/services/ProgressBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressBar.d.ts","sourceRoot":"","sources":["../../src/services/ProgressBar.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAQ,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;;;;AAExC,qBAAa,gBAAiB,SAAQ,sBAAqC,YAAY,CAAC;CAAG;AAE3F,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAA;IAChF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAA;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,CAAC,CAAA;CAC9D;;AA4BD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG;AAEjG,eAAO,MAAM,gBAAgB,wCAAoC,CAAA;AASjE,eAAO,MAAM,oBAAoB,wCAAwC,CAAA"}

package/dist/services/ProgressBar.js

@@ -0,0 +1,35 @@
+import cliProgress from 'cli-progress';
+import { Context, Data, Effect, Layer } from 'effect';
+export class ProgressBarError extends Data.TaggedError('ProgressBarError') {
+}
+const effect = Effect.gen(function* () {
+    const bar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
+    const create = (total) => Effect.try({
+        try: () => bar.start(total, 0),
+        catch: (error) => new ProgressBarError({ message: 'Failed to create progress bar', cause: error }),
+    }).pipe(Effect.withSpan('create'));
+    const increment = Effect.try({
+        try: () => bar.increment(),
+        catch: (error) => new ProgressBarError({ message: 'Failed to update progress bar', cause: error }),
+    }).pipe(Effect.withSpan('increment'));
+    const finish = Effect.try({
+        try: () => bar.stop(),
+        catch: (error) => new ProgressBarError({ message: 'Failed to stop progress bar', cause: error }),
+    }).pipe(Effect.withSpan('finish'));
+    return {
+        create,
+        increment,
+        finish,
+    };
+});
+export class ProgressBar extends Context.Tag('ProgressBar')() {
+}
+export const progressBarLayer = Layer.effect(ProgressBar, effect);
+const mockEffect = Effect.gen(function* () {
+    return {
+        create: () => Effect.succeed(undefined),
+        finish: Effect.succeed(undefined),
+        increment: Effect.succeed(undefined),
+    };
+});
+export const progressBarMockLayer = Layer.effect(ProgressBar, mockEffect);

package/dist/test/loadModuleFromString.d.ts

@@ -0,0 +1,2 @@
+export declare function loadModuleFromString(source: string): Promise<unknown>;
+//# sourceMappingURL=loadModuleFromString.d.ts.map

package/dist/test/loadModuleFromString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadModuleFromString.d.ts","sourceRoot":"","sources":["../../src/test/loadModuleFromString.ts"],"names":[],"mappings":"AAEA,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAe3E"}

package/dist/test/loadModuleFromString.js

@@ -0,0 +1,14 @@
+import * as ts from 'typescript';
+export async function loadModuleFromString(source) {
+    const jsSource = ts.transpileModule(source, {
+        compilerOptions: {
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2020,
+        },
+    }).outputText;
+    const base64 = Buffer.from(jsSource).toString('base64');
+    const url = `data:text/javascript;base64,${base64}`;
+    const module = await import(url);
+    // removes custom prototype from the module object
+    return { ...module };
+}

package/dist/test/mockConfig.d.ts

@@ -0,0 +1,5 @@
+import { GlobalConfig } from '../config/schema';
+export declare function getMockConfig<T extends Partial<GlobalConfig>>(config: T): typeof basicMockConfig & T;
+declare const basicMockConfig: GlobalConfig;
+export {};
+//# sourceMappingURL=mockConfig.d.ts.map

package/dist/test/mockConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockConfig.d.ts","sourceRoot":"","sources":["../../src/test/mockConfig.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C,wBAAgB,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,eAAe,GAAG,CAAC,CAEpG;AAED,QAAA,MAAM,eAAe,EAAE,YAUb,CAAA"}

package/dist/test/mockConfig.js

@@ -0,0 +1,15 @@
+import { mergeDeep } from 'remeda';
+export function getMockConfig(config) {
+    return mergeDeep(basicMockConfig, config);
+}
+const basicMockConfig = {
+    out: '/out',
+    secrets: {
+        alchemyApiKey: 'alchemy-api-key',
+        drpcApiKey: 'drpc-api-key',
+        etherscanApiKey: 'etherscan-api-key',
+    },
+    contracts: {},
+    eoa: {},
+    interfaces: {},
+};

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+import { whatsabi } from '@shazow/whatsabi';
+import { CheckedAddress, SparkDomain } from '@sparkdotfi/common-universal';
+import { AddressesConfig } from './config/schema';
+export type Abi = whatsabi.abi.ABI;
+export interface ContractIndex {
+    address: CheckedAddress;
+    domain: SparkDomain;
+}
+export interface ContractMetadata {
+    abi: Abi;
+}
+export type ContractMetadataStore = Partial<Record<SparkDomain, Record<CheckedAddress, ContractMetadata>>>;
+export interface PreprocessedEntity {
+    name: string;
+    abi: Abi;
+    addresses: AddressesConfig;
+}
+export interface EoaEntity {
+    name: string;
+    addresses: AddressesConfig;
+}
+export interface PreprocessedContractsData {
+    contracts: PreprocessedEntity[];
+    interfaces: PreprocessedEntity[];
+    eoas: EoaEntity[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEjD,MAAM,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAA;AAElC,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,cAAc,CAAA;IACvB,MAAM,EAAE,WAAW,CAAA;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,GAAG,CAAA;CACT;AAED,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAA;AAE1G,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,GAAG,CAAA;IACR,SAAS,EAAE,eAAe,CAAA;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,eAAe,CAAA;CAC3B;AACD,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,kBAAkB,EAAE,CAAA;IAC/B,UAAU,EAAE,kBAAkB,EAAE,CAAA;IAChC,IAAI,EAAE,SAAS,EAAE,CAAA;CAClB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/verify/verify.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+import { GlobalConfig } from '../config/schema';
+import { ContractMetadataStore } from '../types';
+export declare const verify: (store: ContractMetadataStore, config: GlobalConfig) => Effect.Effect<void, ValidationError, never>;
+declare const ValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ValidationError";
+} & Readonly<A>;
+export declare class ValidationError extends ValidationError_base<{
+    message: string;
+}> {
+}
+export {};
+//# sourceMappingURL=verify.d.ts.map

package/dist/verify/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/verify/verify.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,MAAM,EAAE,MAAM,QAAQ,CAAA;AAErC,OAAO,EAAmB,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,MAAM,UAAW,qBAAqB,UAAU,YAAY,gDAIrE,CAAA;;;;AAwCJ,qBAAa,eAAgB,SAAQ,qBAAoC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;CAAG"}

package/dist/verify/verify.js

@@ -0,0 +1,35 @@
+import { assert } from '@sparkdotfi/common-universal';
+import { Data, Effect } from 'effect';
+import { entries } from 'remeda';
+export const verify = (store, config) => Effect.gen(function* () {
+    yield* hasAddresses(config);
+    yield* hasMatchingAbis(config, store);
+});
+const hasAddresses = (config) => Effect.gen(function* () {
+    const contracts = Object.entries(config.contracts);
+    const emptyAddresses = contracts.filter(([_name, addresses]) => {
+        return Object.keys(addresses).length === 0;
+    });
+    if (emptyAddresses.length > 0) {
+        return yield* Effect.fail(new ValidationError({ message: `Found empty addresses definitions: ${emptyAddresses.map((e) => e[0])}` }));
+    }
+}).pipe(Effect.withSpan('hasAddresses'));
+const hasMatchingAbis = (config, store) => Effect.gen(function* () {
+    const contracts = Object.entries(config.contracts);
+    const result = contracts.filter(([_name, addresses]) => {
+        return !validateAbisAreTheSame(addresses, store);
+    });
+    if (result.length > 0) {
+        return yield* Effect.fail(new ValidationError({ message: `Found not matching abis: ${result.map((e) => e[0])}` }));
+    }
+}).pipe(Effect.withSpan('hasMatchingAbis'));
+const validateAbisAreTheSame = (addresses, store) => {
+    const abis = entries(addresses).map(([domain, address]) => {
+        return store[domain][address];
+    });
+    assert(abis.length > 0, 'abis cant be empty');
+    const masterAbi = JSON.stringify(abis[0]);
+    return abis.every((a) => JSON.stringify(a) === masterAbi);
+};
+export class ValidationError extends Data.TaggedError('ValidationError') {
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@sparkdotfi/abi-cli",
+  "version": "0.0.1",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "type": "module",
+  "bin": {
+    "abi-cli": "./dist/cli.js"
+  },
+  "module": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts"
+    }
+  },
+  "files": ["dist"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sparkdotfi/spark-app.git",
+    "directory": "packages/abi-cli"
+  },
+  "scripts": {
+    "lint": "eslint src",
+    "verify": "concurrently --names \"LINT,TYPECHECK\" -c \"bgMagenta.bold,bgBlue.bold\" \"pnpm run lint\" \"pnpm run test --silent\" \"pnpm run typecheck\"",
+    "fix": "cd ../../ && pnpm run check:fix && cd - && pnpm run verify",
+    "typecheck": "tsc --noEmit",
+    "test": "mocha \"src/**/*.test.ts\"",
+    "cli": "tsx ./src/cli.ts",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm run clean && pnpm run build",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "devDependencies": {
+    "@sparkdotfi/common-nodejs": "workspace:^",
+    "@sparkdotfi/common-universal": "workspace:^",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.15.6",
+    "earl": "^1.3.0",
+    "mocha": "^10.8.2",
+    "@types/mocha": "^10.0.10",
+    "typescript": "*"
+  },
+  "dependencies": {
+    "@effect/platform": "^0.90.0",
+    "@effect/platform-node": "^0.94.0",
+    "@shazow/whatsabi": "^0.22.2",
+    "@types/cli-progress": "^3.11.6",
+    "cli-progress": "^3.12.0",
+    "effect": "^3.17.4",
+    "prettier": "^3.6.2",
+    "remeda": "^2.20.2",
+    "viem": "^2.33.2"
+  }
+}