Feature/v3/export generic deploy

dist/types/hardhat.config.d.ts

@@ -1,5 +1,4 @@
 import '@chainlink/hardhat-chainlink';
-import '@nomicfoundation/hardhat-ethers';
 import '@typechain/hardhat';
 import 'hardhat-deploy';
 import 'hardhat-deploy-ethers';

dist/types/src/constants/conceroNetworks.d.ts

@@ -0,0 +1,8 @@
+import mainnetChains from '@concero/concero-networks/output/chains.mainnet.json';
+import testnetChains from '@concero/concero-networks/output/chains.testnet.json';
+import { type ConceroNetwork } from '../types';
+export type ConceroMainnetNetworkNames = (typeof mainnetChains)[keyof typeof mainnetChains]['name'];
+export type ConceroTestnetNetworkNames = (typeof testnetChains)[keyof typeof testnetChains]['name'];
+export declare const testnetNetworks: Record<string, ConceroNetwork>;
+export declare const mainnetNetworks: Record<string, ConceroNetwork>;
+export declare const conceroNetworks: Record<string, ConceroNetwork>;

dist/types/src/constants/deploymentVariables.d.ts

@@ -0,0 +1,14 @@
+import type { WaitForTransactionReceiptParameters } from "viem/actions/public/waitForTransactionReceipt";
+import { EnvPrefixes } from "../../types/deploymentVariables";
+import { ConceroNetwork } from "../../types/ConceroNetwork";
+declare enum ProxyEnum {
+    routerProxy = "routerProxy",
+    verifierProxy = "verifierProxy",
+    priceFeedProxy = "priceFeedProxy",
+    creValidatorLibProxy = "creValidatorLibProxy",
+    relayerLibProxy = "relayerLibProxy"
+}
+declare function getViemReceiptConfig(chain: ConceroNetwork): Partial<WaitForTransactionReceiptParameters>;
+declare const envPrefixes: EnvPrefixes;
+declare const ADMIN_ROLE = "0xdf8b4c520ffe197c5343c6f5aec59570151ef9a492f2c624fd45ddde6135ec42";
+export { ProxyEnum, envPrefixes, getViemReceiptConfig, ADMIN_ROLE, };

dist/types/src/deploy/GenericDeploy.d.ts

@@ -0,0 +1,19 @@
+import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { TransactionReceipt } from 'ethers';
+export interface ITxParams {
+    gasLimit: bigint;
+    libraries: Record<string, string>;
+}
+export interface IDeployResult {
+    address: string;
+    chainType: string;
+    chainName: string;
+    chainId: number;
+    receipt: TransactionReceipt;
+}
+export interface IGenericDeployParams {
+    hre: HardhatRuntimeEnvironment;
+    contractName: string;
+    txParams?: Partial<ITxParams>;
+}
+export declare const genericDeploy: ({ hre, contractName, txParams }: IGenericDeployParams, ...contractConstructorArgs: any[]) => Promise<IDeployResult>;

dist/types/src/index.d.ts

@@ -1,6 +1,7 @@
-import { config } from './constants/config';
-import { getNetworkEnvKey, getNetworkKey, networkTypes, type ConceroNetwork, type NetworkType } from './networks';
-import { TokenSender } from './tokens/TokenSender';
-import { hardhatDeployWrapper } from './deploy/hardhatDeployWrapper';
-export { ConceroNetwork, config, getNetworkEnvKey, getNetworkKey, networkTypes, TokenSender, hardhatDeployWrapper, };
-export type { NetworkType };
+export * from './types';
+export * from './utils';
+export * from './networks';
+export { config } from './constants/config';
+export { conceroNetworks, testnetNetworks, mainnetNetworks, type ConceroMainnetNetworkNames, type ConceroTestnetNetworkNames, } from './constants/conceroNetworks';
+export { genericDeploy, type IDeployResult, type IGenericDeployParams, type ITxParams } from './deploy/GenericDeploy';
+export { TokenSender } from './tokens/TokenSender';

dist/types/src/networks/index.d.ts

@@ -1,5 +1,2 @@
-import { getNetworkEnvKey, getNetworkKey } from './getNetworkEnvKey';
-import { networkTypes } from './networkTypes';
-import { type ConceroNetwork, type NetworkType } from './types';
-export { getNetworkEnvKey, getNetworkKey, networkTypes };
-export type { ConceroNetwork, NetworkType };
+export { getNetworkEnvKey, getNetworkKey } from './getNetworkEnvKey';
+export { networkTypes, type ConceroNetwork, type NetworkType } from '../types';

dist/types/src/types/ConceroNetwork.d.ts

@@ -0,0 +1,41 @@
+import { Chain } from 'viem';
+export type NetworkType = 'mainnet' | 'testnet' | 'localhost';
+export type ConceroNetworkNames = string;
+export type ConceroNetwork = {
+    chainId: number;
+    name: string;
+    type: NetworkType;
+    chainSelector: bigint;
+    accounts?: string[];
+    viemChain: Chain;
+    confirmations: number;
+    url: string;
+    rpcUrls: string[];
+    saveDeployments?: boolean;
+    trezorDerivationPaths?: number[][];
+    trezorInsecureDerivation?: boolean;
+};
+export interface ChainDefinition {
+    id: number;
+    name: string;
+    rpcUrls: string[];
+    blockExplorer?: {
+        name: string;
+        url: string;
+    };
+    isTestnet: boolean;
+}
+export type ConceroLocalNetwork = ConceroNetwork & {
+    saveDeployments?: boolean;
+    forking?: {
+        url: string;
+        enabled: boolean;
+        blockNumber?: number;
+    };
+};
+export type ConceroHardhatNetwork = Omit<ConceroLocalNetwork, 'accounts'> & {
+    accounts: Array<{
+        privateKey: string;
+        balance: string;
+    }>;
+};

dist/types/src/types/index.d.ts

@@ -0,0 +1,2 @@
+export { type NetworkType, type ConceroNetwork, type ConceroNetworkNames, type ChainDefinition, type ConceroLocalNetwork, type ConceroHardhatNetwork, } from './ConceroNetwork';
+export { networkTypes } from './networkTypes';

dist/types/src/types/networkTypes.d.ts

@@ -0,0 +1,2 @@
+import { type NetworkType } from './ConceroNetwork';
+export declare const networkTypes: Record<NetworkType, NetworkType>;

dist/types/src/utils/compileContracts.d.ts

@@ -0,0 +1,9 @@
+interface HardhatCompileParams {
+    concurrency?: number;
+    force?: boolean;
+    noSizeContracts?: boolean;
+    noTypechain?: boolean;
+    quiet?: boolean;
+}
+export declare function compileContracts({ quiet, force }: HardhatCompileParams): void;
+export {};

dist/types/src/utils/createDotEnvLoader.d.ts

@@ -0,0 +1,6 @@
+export interface DotEnvLoaderConfig {
+    baseFiles: string[];
+    stageFiles?: string[];
+    deploymentFiles?: string[];
+}
+export declare function createDotEnvLoader(config: DotEnvLoaderConfig): (basePath?: string) => void;

dist/types/src/utils/createEnvUpdater.d.ts

@@ -0,0 +1,8 @@
+export interface EnvUpdaterConfig<TPrefixes extends Record<string, string>> {
+    prefixes: TPrefixes;
+    basePath: string;
+}
+export declare function createEnvUpdater<TPrefixes extends Record<string, string>, TEnvFileName extends string>(config: EnvUpdaterConfig<TPrefixes>): {
+    updateEnvVariable: (key: string, newValue: string, envFileName: TEnvFileName) => void;
+    updateEnvAddress: (prefix: keyof TPrefixes, newValue: string, envFileName: TEnvFileName, networkPostfix?: string) => void;
+};

dist/types/src/utils/createViemChain.d.ts

@@ -0,0 +1,3 @@
+import { defineChain } from 'viem';
+import { type ChainDefinition } from '../types';
+export declare function createViemChain(chainDefinition: ChainDefinition): ReturnType<typeof defineChain>;

dist/types/src/utils/createWalletGetter.d.ts

@@ -0,0 +1,13 @@
+import { type NetworkType } from '../types';
+export interface BaseAccountTypePrefixes extends Record<string, string> {
+    proxyDeployer: 'PROXY_DEPLOYER';
+    deployer: 'DEPLOYER';
+}
+export declare const baseAccountTypePrefixes: BaseAccountTypePrefixes;
+export interface WalletGetterConfig<TPrefixes extends Record<string, string>> {
+    accountTypePrefixes: TPrefixes;
+}
+export declare function createWalletGetter<TPrefixes extends Record<string, string>>(config: WalletGetterConfig<TPrefixes>): {
+    getWallet: (chainType: NetworkType, accountType: keyof TPrefixes, walletType: "privateKey" | "address") => string | undefined;
+};
+export declare const getWallet: (chainType: NetworkType, accountType: keyof BaseAccountTypePrefixes, walletType: "privateKey" | "address") => string | undefined;

dist/types/src/utils/ethersSignerCallContract.d.ts

@@ -0,0 +1,3 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { Address } from "viem";
+export declare const ethersSignerCallContract: (hre: HardhatRuntimeEnvironment, contract: Address, abi: any[], functionName: string, ...functionArgs: any[]) => Promise<`0x${string}`>;

dist/types/src/utils/extractProxyAdminAddress.d.ts

@@ -0,0 +1,2 @@
+import { ethers } from 'ethers';
+export declare function extractProxyAdminAddress(receipt: ethers.TransactionReceipt | null): string;

dist/types/src/utils/formatting.d.ts

@@ -0,0 +1,3 @@
+import { type Address } from "viem";
+export declare function shorten(address: Address): string;
+export declare function formatGas(gasAmountWei: bigint): string;

dist/types/src/utils/getActualGasData.d.ts

@@ -0,0 +1,8 @@
+import { PublicClient } from 'viem';
+type GasData = {
+    gasPrice?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+};
+export declare function getActualGasData(publicClient: PublicClient): Promise<GasData>;
+export {};

dist/types/src/utils/getEnvVar.d.ts

@@ -0,0 +1,8 @@
+import { Address } from 'viem';
+export declare function getEnvVar(key: string, defaultValue?: string): string;
+export interface EnvAddressConfig<TPrefixes extends Record<string, string>> {
+    prefixes: TPrefixes;
+}
+export declare function createEnvAddressGetter<TPrefixes extends Record<string, string>>(config: EnvAddressConfig<TPrefixes>): {
+    getEnvAddress: (prefix: keyof TPrefixes, networkName?: string) => [Address, string];
+};

dist/types/src/utils/getGasParameters.d.ts

@@ -0,0 +1,14 @@
+import { ConceroNetwork } from "../types/ConceroNetwork";
+interface GasParameters {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+/**
+ * Gets optimized gas parameters for priority transaction processing
+ * @param chain - The network configuration
+ * @param priorityMultiplier - Multiplier for maxPriorityFeePerGas (default: 2)
+ * @param maxFeeMultiplier - Multiplier for maxFeePerGas buffer (default: 2)
+ * @returns GasParameters object containing maxFeePerGas and maxPriorityFeePerGas
+ */
+export declare function getGasParameters(chain: ConceroNetwork, priorityMultiplier?: number, maxFeeMultiplier?: number): Promise<GasParameters>;
+export {};

dist/types/src/utils/getTrezorDeployEnabled.d.ts

@@ -0,0 +1 @@
+export declare const getTrezorDeployEnabled: () => boolean;

dist/types/src/utils/getViemClients.d.ts

@@ -0,0 +1,59 @@
+import { Chain, type TestClient, type PublicClient, type WalletClient } from "viem";
+import { type PrivateKeyAccount } from "viem/accounts";
+import { type ConceroNetwork, type NetworkType } from "../types";
+import { type BaseAccountTypePrefixes } from "../utils";
+declare function getClients(viemChain: Chain, url: string | undefined, account?: PrivateKeyAccount): {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+    account: PrivateKeyAccount;
+};
+export type ExtendedTestClient = TestClient & WalletClient & PublicClient;
+declare function getTestClient(account: PrivateKeyAccount): ExtendedTestClient;
+declare function getFallbackClients(chain: ConceroNetwork, account?: PrivateKeyAccount): {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+    account: PrivateKeyAccount;
+};
+declare function getViemAccount(chainType: NetworkType, accountType: keyof BaseAccountTypePrefixes): {
+    address: import("viem").Address;
+    nonceManager?: import("viem").NonceManager | undefined;
+    sign: (parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<import("viem").Hex>;
+    signAuthorization: (parameters: import("viem/_types/types/authorization").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>;
+    signMessage: ({ message }: {
+        message: import("viem").SignableMessage;
+    }) => Promise<import("viem").Hex>;
+    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<import("viem").IsNarrowable<import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>>, import("viem").Hex> extends true ? import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>> : import("viem").Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+    publicKey: import("viem").Hex;
+    source: "privateKey";
+    type: "local";
+};
+export interface ViemAccountGetterConfig<TPrefixes extends Record<string, string>> {
+    accountTypePrefixes: TPrefixes;
+    getWallet: (chainType: NetworkType, accountType: keyof TPrefixes, walletType: 'privateKey' | 'address') => string | undefined;
+}
+export declare function createViemAccountGetter<TPrefixes extends Record<string, string>>(config: ViemAccountGetterConfig<TPrefixes>): {
+    getViemAccount: (chainType: NetworkType, accountType: keyof TPrefixes) => {
+        address: import("viem").Address;
+        nonceManager?: import("viem").NonceManager | undefined;
+        sign: (parameters: {
+            hash: import("viem").Hash;
+        }) => Promise<import("viem").Hex>;
+        signAuthorization: (parameters: import("viem/_types/types/authorization").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>;
+        signMessage: ({ message }: {
+            message: import("viem").SignableMessage;
+        }) => Promise<import("viem").Hex>;
+        signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+            serializer?: serializer | undefined;
+        } | undefined) => Promise<import("viem").IsNarrowable<import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>>, import("viem").Hex> extends true ? import("viem").TransactionSerialized<import("viem").GetTransactionType<transaction>> : import("viem").Hex>;
+        signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<import("viem").Hex>;
+        publicKey: import("viem").Hex;
+        source: "privateKey";
+        type: "local";
+    };
+};
+export { getClients, getFallbackClients, getTestClient, getViemAccount };

dist/types/src/utils/getWallet.d.ts

@@ -0,0 +1 @@
+export { getWallet, createWalletGetter, baseAccountTypePrefixes, type BaseAccountTypePrefixes, type WalletGetterConfig } from './createWalletGetter';

dist/types/src/utils/index.d.ts

@@ -0,0 +1,14 @@
+export { createViemChain } from './createViemChain';
+export { getEnvVar, createEnvAddressGetter } from './getEnvVar';
+export { getTrezorDeployEnabled } from './getTrezorDeployEnabled';
+export { getWallet, createWalletGetter, baseAccountTypePrefixes, type BaseAccountTypePrefixes, type WalletGetterConfig } from './getWallet';
+export { err, log, warn } from './log';
+export { shorten, formatGas } from './formatting';
+export { ethersSignerCallContract } from './ethersSignerCallContract';
+export { compileContracts } from './compileContracts';
+export { localhostViemChain } from './localhostViemChain';
+export { extractProxyAdminAddress } from './extractProxyAdminAddress';
+export { createEnvUpdater, type EnvUpdaterConfig } from './createEnvUpdater';
+export { getActualGasData } from './getActualGasData';
+export { getGasParameters } from './getGasParameters';
+export { getClients, getFallbackClients, getTestClient, getViemAccount, createViemAccountGetter, type ExtendedTestClient, type ViemAccountGetterConfig, } from './getViemClients';

dist/types/src/utils/loadEnvFiles.d.ts

@@ -0,0 +1,6 @@
+export interface DotEnvLoaderConfig {
+    baseFiles: string[];
+    stageFiles?: string[];
+    deploymentFiles?: string[];
+}
+export declare function createDotEnvLoader(config: DotEnvLoaderConfig): (basePath?: string) => void;

dist/types/src/utils/localhostViemChain.d.ts

@@ -0,0 +1,82 @@
+export declare const localhostViemChain: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        universalSignatureVerifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    id: number;
+    name: "localhost";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "eth";
+        readonly symbol: "eth";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly [string];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+};
+export declare const hardhatViemChain: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        universalSignatureVerifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    id: number;
+    name: "hardhat";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "eth";
+        readonly symbol: "eth";
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly [string];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+};

dist/types/src/utils/log.d.ts

@@ -0,0 +1,4 @@
+export declare function log(message: any, functionName: string, networkName?: string): void;
+export declare function warn(message: any, functionName: string): void;
+export declare function err(message: any, functionName: string, networkName?: string): void;
+export default log;

dist/types/src/utils/updateEnvVariable.d.ts

@@ -0,0 +1,6 @@
+import { ConceroNetworkNames } from "../../types/ConceroNetwork";
+import { EnvFileName, EnvPrefixes } from "../../types/deploymentVariables";
+export type ContractPrefix = keyof EnvPrefixes;
+export declare function updateEnvVariable(key: string, newValue: string, envFileName: EnvFileName): void;
+export declare function updateEnvAddress(prefix: ContractPrefix, newValue: string, envFileName: EnvFileName, networkPostfix?: ConceroNetworkNames | string): void;
+export default updateEnvVariable;