@rocketh/deploy 0.10.9 → 0.10.11

package/dist/index.d.ts

@@ -0,0 +1,325 @@
+import { DeploymentConstruction, Deployment } from 'rocketh';
+import { Chain, ContractFunctionName, ContractFunctionArgs, DecodeFunctionResultReturnType, WriteContractParameters, ReadContractParameters, Address } from 'viem';
+
+interface Register {
+}
+type ResolvedRegister = {
+    /**
+     * TypeScript type to use for `address` values
+     * @default `0x${string}`
+     */
+    addressType: Register extends {
+        addressType: infer type;
+    } ? type : Register extends {
+        AddressType: infer type;
+    } ? type : DefaultRegister['addressType'];
+    /**
+     * TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48`
+     * @default bigint
+     */
+    bigIntType: Register extends {
+        bigIntType: infer type;
+    } ? type : Register extends {
+        BigIntType: infer type;
+    } ? type : DefaultRegister['bigIntType'];
+    /**
+     * TypeScript type to use for `bytes` values
+     * @default { inputs: `0x${string}`; outputs: `0x${string}`; }
+     */
+    bytesType: Register extends {
+        bytesType: infer type extends {
+            inputs: unknown;
+            outputs: unknown;
+        };
+    } ? type : Register extends {
+        BytesType: infer type extends {
+            inputs: unknown;
+            outputs: unknown;
+        };
+    } ? type : DefaultRegister['bytesType'];
+    /**
+     * TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48`
+     * @default number
+     */
+    intType: Register extends {
+        intType: infer type;
+    } ? type : Register extends {
+        IntType: infer type;
+    } ? type : DefaultRegister['intType'];
+    /**
+     * Maximum depth for nested array types (e.g. string[][])
+     *
+     * Note: You probably only want to set this to a specific number if parsed types are returning as `unknown`
+     * and you want to figure out why. If you set this, you should probably also reduce `FixedArrayMaxLength`.
+     *
+     * @default false
+     */
+    arrayMaxDepth: Register extends {
+        arrayMaxDepth: infer type extends number | false;
+    } ? type : Register extends {
+        ArrayMaxDepth: infer type extends number | false;
+    } ? type : DefaultRegister['arrayMaxDepth'];
+    /**
+     * Lower bound for fixed array length
+     * @default 1
+     */
+    fixedArrayMinLength: Register extends {
+        fixedArrayMinLength: infer type extends number;
+    } ? type : Register extends {
+        FixedArrayMinLength: infer type extends number;
+    } ? type : DefaultRegister['fixedArrayMinLength'];
+    /**
+     * Upper bound for fixed array length
+     * @default 99
+     */
+    fixedArrayMaxLength: Register extends {
+        fixedArrayMaxLength: infer type extends number;
+    } ? type : Register extends {
+        FixedArrayMaxLength: infer type extends number;
+    } ? type : DefaultRegister['fixedArrayMaxLength'];
+    /**
+     * When set, validates {@link AbiParameter}'s `type` against {@link AbiType}
+     *
+     * Note: You probably only want to set this to `true` if parsed types are returning as `unknown`
+     * and you want to figure out why.
+     *
+     * @default false
+     */
+    strictAbiType: Register extends {
+        strictAbiType: infer type extends boolean;
+    } ? type : Register extends {
+        StrictAbiType: infer type extends boolean;
+    } ? type : DefaultRegister['strictAbiType'];
+    /** @deprecated Use `addressType` instead */
+    AddressType: ResolvedRegister['addressType'];
+    /** @deprecated Use `addressType` instead */
+    BigIntType: ResolvedRegister['bigIntType'];
+    /** @deprecated Use `bytesType` instead */
+    BytesType: ResolvedRegister['bytesType'];
+    /** @deprecated Use `intType` instead */
+    IntType: ResolvedRegister['intType'];
+    /** @deprecated Use `arrayMaxDepth` instead */
+    ArrayMaxDepth: ResolvedRegister['arrayMaxDepth'];
+    /** @deprecated Use `fixedArrayMinLength` instead */
+    FixedArrayMinLength: ResolvedRegister['fixedArrayMinLength'];
+    /** @deprecated Use `fixedArrayMaxLength` instead */
+    FixedArrayMaxLength: ResolvedRegister['fixedArrayMaxLength'];
+    /** @deprecated Use `strictAbiType` instead */
+    StrictAbiType: ResolvedRegister['strictAbiType'];
+};
+type DefaultRegister = {
+    /** Maximum depth for nested array types (e.g. string[][]) */
+    arrayMaxDepth: false;
+    /** Lower bound for fixed array length */
+    fixedArrayMinLength: 1;
+    /** Upper bound for fixed array length */
+    fixedArrayMaxLength: 99;
+    /** TypeScript type to use for `address` values */
+    addressType: `0x${string}`;
+    /** TypeScript type to use for `bytes` values */
+    bytesType: {
+        /** TypeScript type to use for `bytes` input values */
+        inputs: `0x${string}`;
+        /** TypeScript type to use for `bytes` output values */
+        outputs: `0x${string}`;
+    };
+    /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48` */
+    bigIntType: bigint;
+    /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48` */
+    intType: number;
+    /** When set, validates {@link AbiParameter}'s `type` against {@link AbiType} */
+    strictAbiType: false;
+    /** @deprecated Use `arrayMaxDepth` instead */
+    ArrayMaxDepth: DefaultRegister['arrayMaxDepth'];
+    /** @deprecated Use `fixedArrayMinLength` instead */
+    FixedArrayMinLength: DefaultRegister['fixedArrayMinLength'];
+    /** @deprecated Use `fixedArrayMaxLength` instead */
+    FixedArrayMaxLength: DefaultRegister['fixedArrayMaxLength'];
+    /** @deprecated Use `addressType` instead */
+    AddressType: DefaultRegister['addressType'];
+    /** @deprecated Use `bytesType` instead */
+    BytesType: {
+        inputs: DefaultRegister['bytesType']['inputs'];
+        outputs: DefaultRegister['bytesType']['outputs'];
+    };
+    /** @deprecated Use `bigIntType` instead */
+    BigIntType: DefaultRegister['bigIntType'];
+    /** @deprecated Use `intType` instead */
+    IntType: DefaultRegister['intType'];
+    /** @deprecated Use `strictAbiType` instead */
+    StrictAbiType: DefaultRegister['strictAbiType'];
+};
+
+/**
+ * Combines members of an intersection into a readable type.
+ *
+ * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+ * @example
+ * type Result = Pretty<{ a: string } | { b: string } | { c: number, d: bigint }>
+ * //   ^? type Result = { a: string; b: string; c: number; d: bigint }
+ */
+type Pretty<type> = {
+    [key in keyof type]: type[key];
+} & unknown;
+/**
+ * Creates range between two positive numbers using [tail recursion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#tail-recursion-elimination-on-conditional-types).
+ *
+ * @param start - Number to start range
+ * @param stop - Number to end range
+ * @returns Array with inclusive range from {@link start} to {@link stop}
+ *
+ * @example
+ * type Result = Range<1, 3>
+ * //   ^? type Result = [1, 2, 3]
+ */
+type Range<start extends number, stop extends number, result extends number[] = [], padding extends 0[] = [], current extends number = [...padding, ...result]['length'] & number> = current extends stop ? current extends start ? [current] : result extends [] ? [] : [...result, current] : current extends start ? Range<start, stop, [current], padding> : result extends [] ? Range<start, stop, [], [...padding, 0]> : Range<start, stop, [...result, current], padding>;
+
+type MBytes = '' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32;
+type MBits = '' | 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 | 128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 | 192 | 200 | 208 | 216 | 224 | 232 | 240 | 248 | 256;
+type SolidityAddress = 'address';
+type SolidityBool = 'bool';
+type SolidityBytes = `bytes${MBytes}`;
+type SolidityFunction = 'function';
+type SolidityString = 'string';
+type SolidityTuple = 'tuple';
+type SolidityInt = `${'u' | ''}int${MBits}`;
+type SolidityFixedArrayRange = Range<ResolvedRegister['fixedArrayMinLength'], ResolvedRegister['fixedArrayMaxLength']>[number];
+/**
+ * Recursively build arrays up to maximum depth
+ * or use a more broad type when maximum depth is switched "off"
+ */
+type _BuildArrayTypes<T extends string, Depth extends readonly number[] = []> = ResolvedRegister['arrayMaxDepth'] extends false ? `${T}[${string}]` : Depth['length'] extends ResolvedRegister['arrayMaxDepth'] ? T : T extends `${any}[${SolidityFixedArrayRange | ''}]` ? _BuildArrayTypes<T | `${T}[${SolidityFixedArrayRange | ''}]`, [
+    ...Depth,
+    1
+]> : _BuildArrayTypes<`${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]>;
+type SolidityArrayWithoutTuple = _BuildArrayTypes<SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString>;
+type SolidityArrayWithTuple = _BuildArrayTypes<SolidityTuple>;
+type SolidityArray = SolidityArrayWithoutTuple | SolidityArrayWithTuple;
+type AbiType = SolidityArray | SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString | SolidityTuple;
+type ResolvedAbiType = ResolvedRegister['strictAbiType'] extends true ? AbiType : string;
+type AbiInternalType = ResolvedAbiType | `address ${string}` | `contract ${string}` | `enum ${string}` | `struct ${string}`;
+type AbiParameter = Pretty<{
+    type: ResolvedAbiType;
+    name?: string | undefined;
+    /** Representation used by Solidity compiler */
+    internalType?: AbiInternalType | undefined;
+} & ({
+    type: Exclude<ResolvedAbiType, SolidityTuple | SolidityArrayWithTuple>;
+} | {
+    type: SolidityTuple | SolidityArrayWithTuple;
+    components: readonly AbiParameter[];
+})>;
+type AbiEventParameter = AbiParameter & {
+    indexed?: boolean | undefined;
+};
+/**
+ * State mutability for {@link AbiFunction}
+ *
+ * @see https://docs.soliditylang.org/en/latest/contracts.html#state-mutability
+ */
+type AbiStateMutability = 'pure' | 'view' | 'nonpayable' | 'payable';
+/** ABI ["function"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
+type AbiFunction = {
+    type: 'function';
+    /**
+     * @deprecated use `pure` or `view` from {@link AbiStateMutability} instead
+     * @see https://github.com/ethereum/solidity/issues/992
+     */
+    constant?: boolean | undefined;
+    /**
+     * @deprecated Vyper used to provide gas estimates
+     * @see https://github.com/vyperlang/vyper/issues/2151
+     */
+    gas?: number | undefined;
+    inputs: readonly AbiParameter[];
+    name: string;
+    outputs: readonly AbiParameter[];
+    /**
+     * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
+     * @see https://github.com/ethereum/solidity/issues/992
+     */
+    payable?: boolean | undefined;
+    stateMutability: AbiStateMutability;
+};
+/** ABI ["constructor"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
+type AbiConstructor = {
+    type: 'constructor';
+    inputs: readonly AbiParameter[];
+    /**
+     * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
+     * @see https://github.com/ethereum/solidity/issues/992
+     */
+    payable?: boolean | undefined;
+    stateMutability: Extract<AbiStateMutability, 'payable' | 'nonpayable'>;
+};
+/** ABI ["fallback"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
+type AbiFallback = {
+    type: 'fallback';
+    inputs?: readonly [] | undefined;
+    /**
+     * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
+     * @see https://github.com/ethereum/solidity/issues/992
+     */
+    payable?: boolean | undefined;
+    stateMutability: Extract<AbiStateMutability, 'payable' | 'nonpayable'>;
+};
+/** ABI ["receive"](https://docs.soliditylang.org/en/latest/contracts.html#receive-ether-function) type */
+type AbiReceive = {
+    type: 'receive';
+    stateMutability: Extract<AbiStateMutability, 'payable'>;
+};
+/** ABI ["event"](https://docs.soliditylang.org/en/latest/abi-spec.html#events) type */
+type AbiEvent = {
+    type: 'event';
+    anonymous?: boolean | undefined;
+    inputs: readonly AbiEventParameter[];
+    name: string;
+};
+/** ABI ["error"](https://docs.soliditylang.org/en/latest/abi-spec.html#errors) type */
+type AbiError = {
+    type: 'error';
+    inputs: readonly AbiParameter[];
+    name: string;
+};
+/**
+ * Contract [ABI Specification](https://docs.soliditylang.org/en/latest/abi-spec.html#json)
+ */
+type Abi = readonly (AbiConstructor | AbiError | AbiEvent | AbiFallback | AbiFunction | AbiReceive)[];
+
+type EIP1193DATA = `0x${string}`;
+
+declare module 'rocketh' {
+    interface Environment {
+        deploy: DeployFunction;
+        execute: ExecuteFunction;
+        read: ReadFunction;
+        executeByName: ExecuteFunctionByName;
+        readByName: ReadFunctionByName;
+    }
+}
+type DeployFunction = <TAbi extends Abi, TChain extends Chain = Chain>(name: string, args: DeploymentConstruction<TAbi>, options?: DeployOptions) => Promise<Deployment<TAbi> & {
+    updated: boolean;
+}>;
+type ExecuteFunction = <TAbi extends Abi, TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName> = ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>>(deployment: Deployment<TAbi>, args: ExecutionArgs<TAbi, TFunctionName, TArgs>) => Promise<EIP1193DATA>;
+type ExecuteFunctionByName = <TAbi extends Abi, TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName> = ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>>(name: string, args: ExecutionArgs<TAbi, TFunctionName, TArgs>) => Promise<EIP1193DATA>;
+type ReadFunction = <TAbi extends Abi, TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>, TArgs extends ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName> = ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>>(deployment: Deployment<TAbi>, args: ReadingArgs<TAbi, TFunctionName, TArgs>) => Promise<DecodeFunctionResultReturnType<TAbi, TFunctionName>>;
+type ReadFunctionByName = <TAbi extends Abi, TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>, TArgs extends ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName> = ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>>(name: string, args: ReadingArgs<TAbi, TFunctionName, TArgs>) => Promise<DecodeFunctionResultReturnType<TAbi, TFunctionName>>;
+type ExecutionArgs<TAbi extends Abi, TFunctionName extends ContractFunctionName<TAbi, 'nonpayable' | 'payable'>, TArgs extends ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName> = ContractFunctionArgs<TAbi, 'nonpayable' | 'payable', TFunctionName>> = Omit<WriteContractParameters<TAbi, TFunctionName, TArgs>, 'address' | 'abi' | 'account' | 'nonce' | 'chain'> & {
+    account: string;
+};
+type ReadingArgs<TAbi extends Abi, TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>, TArgs extends ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName> = ContractFunctionArgs<TAbi, 'pure' | 'view', TFunctionName>> = Omit<ReadContractParameters<TAbi, TFunctionName, TArgs>, 'address' | 'abi' | 'account' | 'nonce'> & {
+    account?: string;
+};
+type DeployOptions = {
+    linkedData?: any;
+    deterministic?: boolean | `0x${string}`;
+    libraries?: {
+        [name: string]: Address;
+    };
+} & ({
+    skipIfAlreadyDeployed?: boolean;
+} | {
+    alwaysOverride?: boolean;
+});
+
+export type { DeployFunction, DeployOptions, ExecuteFunction, ExecuteFunctionByName, ExecutionArgs, ReadFunction, ReadFunctionByName, ReadingArgs };

package/dist/index.mjs

@@ -0,0 +1,349 @@
+import { extendEnvironment } from 'rocketh';
+import { encodeFunctionData, decodeFunctionResult, encodeDeployData, keccak256, encodePacked } from 'viem';
+import { logs } from 'named-logs';
+
+const logger = logs("rocketh-deploy");
+async function broadcastTransaction(env, signer, params) {
+  if (signer.type === "wallet" || signer.type === "remote") {
+    return signer.signer.request({
+      method: "eth_sendTransaction",
+      params
+    });
+  } else {
+    const rawTx = await signer.signer.request({
+      method: "eth_signTransaction",
+      params
+    });
+    return env.network.provider.request({
+      method: "eth_sendRawTransaction",
+      params: [rawTx]
+    });
+  }
+}
+function linkRawLibrary(bytecode, libraryName, libraryAddress) {
+  const address = libraryAddress.replace("0x", "");
+  let encodedLibraryName;
+  if (libraryName.startsWith("$") && libraryName.endsWith("$")) {
+    encodedLibraryName = libraryName.slice(1, libraryName.length - 1);
+  } else {
+    encodedLibraryName = keccak256(encodePacked(["string"], [libraryName])).slice(2, 36);
+  }
+  const pattern = new RegExp(`_+\\$${encodedLibraryName}\\$_+`, "g");
+  if (!pattern.exec(bytecode)) {
+    throw new Error(`Can't link '${libraryName}' (${encodedLibraryName}) in 
+----
+ ${bytecode}
+----
+`);
+  }
+  return bytecode.replace(pattern, address);
+}
+function linkRawLibraries(bytecode, libraries) {
+  for (const libName of Object.keys(libraries)) {
+    const libAddress = libraries[libName];
+    bytecode = linkRawLibrary(bytecode, libName, libAddress);
+  }
+  return bytecode;
+}
+function linkLibraries(artifact, libraries) {
+  let bytecode = artifact.bytecode;
+  if (libraries) {
+    if (artifact.linkReferences) {
+      for (const [fileName, fileReferences] of Object.entries(artifact.linkReferences)) {
+        for (const [libName, fixups] of Object.entries(fileReferences)) {
+          const addr = libraries[libName];
+          if (addr === void 0) {
+            continue;
+          }
+          for (const fixup of fixups) {
+            bytecode = bytecode.substring(0, 2 + fixup.start * 2) + addr.substring(2) + bytecode.substring(2 + (fixup.start + fixup.length) * 2);
+          }
+        }
+      }
+    } else {
+      bytecode = linkRawLibraries(bytecode, libraries);
+    }
+  }
+  return bytecode;
+}
+extendEnvironment((env) => {
+  async function execute(deployment, args) {
+    const { account, ...viemArgs } = args;
+    let address;
+    if (account.startsWith("0x")) {
+      address = account;
+    } else {
+      if (env.namedAccounts) {
+        address = env.namedAccounts[account];
+        if (!address) {
+          throw new Error(`no address for ${account}`);
+        }
+      } else {
+        throw new Error(`no accounts setup, cannot get address for ${account}`);
+      }
+    }
+    const artifactToUse = deployment;
+    const abi = artifactToUse.abi;
+    const calldata = encodeFunctionData({
+      abi,
+      functionName: viemArgs.functionName,
+      args: viemArgs.args
+    });
+    const signer = env.addressSigners[address];
+    const txParam = {
+      to: deployment.address,
+      type: "0x2",
+      from: address,
+      chainId: `0x${env.network.chain.id.toString(16)}`,
+      data: calldata,
+      gas: viemArgs.gas && `0x${viemArgs.gas.toString(16)}`,
+      // gasPrice: viemArgs.gasPrice && `0x${viemArgs.gasPrice.toString(16)}` as `0x${string}`,
+      maxFeePerGas: viemArgs.maxFeePerGas && `0x${viemArgs.maxFeePerGas.toString(16)}`,
+      maxPriorityFeePerGas: viemArgs.maxPriorityFeePerGas && `0x${viemArgs.maxPriorityFeePerGas.toString(16)}`
+      // nonce: viemArgs.nonce && (`0x${viemArgs.nonce.toString(16)}` as `0x${string}`),
+    };
+    if (viemArgs.value) {
+      txParam.value = `0x${viemArgs.value?.toString(16)}`;
+    }
+    let txHash;
+    if (signer.type === "wallet" || signer.type === "remote") {
+      txHash = await signer.signer.request({
+        method: "eth_sendTransaction",
+        params: [txParam]
+      });
+    } else {
+      const rawTx = await signer.signer.request({
+        method: "eth_signTransaction",
+        params: [txParam]
+      });
+      txHash = await env.network.provider.request({
+        method: "eth_sendRawTransaction",
+        params: [rawTx]
+      });
+    }
+    const pendingExecution = {
+      type: "execution",
+      transaction: { hash: txHash, origin: address }
+      // description, // TODO
+      // TODO we should have the nonce, except for wallet like metamask where it is not usre you get the nonce you start with
+    };
+    await env.savePendingExecution(pendingExecution);
+    return txHash;
+  }
+  async function executeByName(name, args) {
+    const deployment = env.getOrNull(name);
+    if (!deployment) {
+      throw new Error(`no deployment named ${name}`);
+    }
+    return execute(deployment, args);
+  }
+  async function read(deployment, args) {
+    const { account, ...viemArgs } = args;
+    let address;
+    if (account) {
+      if (account.startsWith("0x")) {
+        address = account;
+      } else {
+        if (env.namedAccounts) {
+          address = env.namedAccounts[account];
+          if (!address) {
+            throw new Error(`no address for ${account}`);
+          }
+        } else {
+          throw new Error(`no accounts setup, cannot get address for ${account}`);
+        }
+      }
+    }
+    const artifactToUse = deployment;
+    const abi = artifactToUse.abi;
+    const calldata = encodeFunctionData({
+      abi,
+      functionName: viemArgs.functionName,
+      args: viemArgs.args
+    });
+    const result = await env.network.provider.request({
+      method: "eth_call",
+      params: [
+        {
+          to: deployment.address,
+          type: "0x2",
+          from: address,
+          chainId: `0x${env.network.chain.id.toString(16)}`,
+          data: calldata
+          // value: `0x${viemArgs.value?.toString(16)}` as `0x${string}`,
+        }
+      ]
+    });
+    const parsed = decodeFunctionResult({
+      abi,
+      functionName: viemArgs.functionName,
+      data: result,
+      args: viemArgs.args
+    });
+    return parsed;
+  }
+  async function readByName(name, args) {
+    const deployment = env.getOrNull(name);
+    if (!deployment) {
+      throw new Error(`no deployment named ${name}`);
+    }
+    return read(deployment, args);
+  }
+  async function deploy(name, args, options) {
+    const skipIfAlreadyDeployed = options && "skipIfAlreadyDeployed" in options && options.skipIfAlreadyDeployed;
+    const allwaysOverride = options && "allwaysOverride" in options && options.allwaysOverride;
+    if (allwaysOverride && skipIfAlreadyDeployed) {
+      throw new Error(`conflicting options: "allwaysOverride" and "skipIfAlreadyDeployed"`);
+    }
+    const existingDeployment = env.getOrNull(name);
+    if (existingDeployment && skipIfAlreadyDeployed) {
+      logger.info(`deployment for ${name} at ${existingDeployment.address}, skipIfAlreadyDeployed: true => we skip`);
+      return { ...existingDeployment, updated: false };
+    }
+    const { account, artifact, ...viemArgs } = args;
+    let address;
+    if (account.startsWith("0x")) {
+      address = account;
+    } else {
+      if (env.namedAccounts) {
+        address = env.namedAccounts[account];
+        if (!address) {
+          throw new Error(`no address for ${account}`);
+        }
+      } else {
+        throw new Error(`no accounts setup, cannot get address for ${account}`);
+      }
+    }
+    const artifactToUse = typeof artifact === "string" ? env.artifacts[artifact] : artifact;
+    const bytecode = linkLibraries(artifactToUse, options?.libraries);
+    const abi = artifactToUse.abi;
+    const argsToUse = {
+      ...viemArgs,
+      account,
+      abi,
+      bytecode
+    };
+    const calldata = encodeDeployData(argsToUse);
+    const argsData = `0x${calldata.replace(bytecode, "")}`;
+    if (existingDeployment) {
+      logger.info(`existing deployment for ${name} at ${existingDeployment.address}`);
+    }
+    if (existingDeployment && !allwaysOverride) {
+      const previousBytecode = existingDeployment.bytecode;
+      const previousArgsData = existingDeployment.argsData;
+      const last2Bytes = previousBytecode.slice(-4);
+      const cborLength = parseInt(last2Bytes, 16);
+      const previousBytecodeWithoutCBOR = previousBytecode.slice(0, -cborLength * 2);
+      const newBytecodeWithoutCBOR = bytecode.slice(0, -cborLength * 2);
+      if (previousBytecodeWithoutCBOR === newBytecodeWithoutCBOR && previousArgsData === argsData) {
+        return { ...existingDeployment, updated: false };
+      }
+    }
+    const partialDeployment = {
+      ...artifactToUse,
+      argsData,
+      linkedData: options?.linkedData
+    };
+    const signer = env.addressSigners[address];
+    const chainId = `0x${env.network.chain.id.toString(16)}`;
+    const maxFeePerGas = viemArgs.maxFeePerGas && `0x${viemArgs.maxFeePerGas.toString(16)}`;
+    const maxPriorityFeePerGas = viemArgs.maxPriorityFeePerGas && `0x${viemArgs.maxPriorityFeePerGas.toString(16)}`;
+    const params = [
+      {
+        type: "0x2",
+        from: address,
+        chainId,
+        data: calldata,
+        gas: viemArgs.gas && `0x${viemArgs.gas.toString(16)}`,
+        maxFeePerGas,
+        maxPriorityFeePerGas
+        // gasPrice: viemArgs.gasPrice && `0x${viemArgs.gasPrice.toString(16)}` as `0x${string}`,
+        // value: `0x${viemArgs.value?.toString(16)}` as `0x${string}`,
+        // nonce: viemArgs.nonce && (`0x${viemArgs.nonce.toString(16)}` as `0x${string}`),
+      }
+    ];
+    let expectedAddress = void 0;
+    if (options?.deterministic) {
+      const deterministicFactoryAddress = `0x4e59b44847b379578588920ca78fbf26c0b4956c`;
+      const deterministicFactoryDeployerAddress = `0x3fab184622dc19b6109349b94811493bf2a45362`;
+      const factoryDeploymentData = `0xf8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222`;
+      const code = await env.network.provider.request({
+        method: "eth_getCode",
+        params: [deterministicFactoryAddress, "latest"]
+      });
+      if (code === "0x") {
+        const balanceHexString = await env.network.provider.request({
+          method: "eth_getBalance",
+          params: [deterministicFactoryDeployerAddress, "latest"]
+        });
+        const balance = BigInt(balanceHexString);
+        if (balance < 10000000000000000n) {
+          const need = 10000000000000000n - balance;
+          const balanceToSend = `0x${need.toString(16)}`;
+          const txHash3 = await broadcastTransaction(env, signer, [
+            {
+              type: "0x2",
+              chainId,
+              from: address,
+              to: deterministicFactoryDeployerAddress,
+              value: balanceToSend,
+              gas: `0x${BigInt(21e3).toString(16)}`,
+              maxFeePerGas,
+              maxPriorityFeePerGas
+            }
+          ]);
+          await env.savePendingExecution({
+            type: "execution",
+            // TODO different type ?
+            transaction: { hash: txHash3, origin: address }
+          });
+        }
+        const txHash2 = await env.network.provider.request({
+          method: "eth_sendRawTransaction",
+          params: [factoryDeploymentData]
+        });
+        await env.savePendingExecution({
+          type: "execution",
+          // TODO different type ?
+          transaction: { hash: txHash2, origin: address }
+        });
+      }
+      const salt = typeof options.deterministic === "string" ? `0x${options.deterministic.slice(2).padStart(64, "0")}` : "0x0000000000000000000000000000000000000000000000000000000000000000";
+      const bytecode2 = params[0].data || "0x";
+      expectedAddress = "0x" + keccak256(`0xff${deterministicFactoryAddress.slice(2)}${salt.slice(2)}${keccak256(bytecode2).slice(2)}`).slice(
+        -40
+      );
+      const codeAlreadyDeployed = await env.network.provider.request({
+        method: "eth_getCode",
+        params: [expectedAddress, "latest"]
+      });
+      if (codeAlreadyDeployed !== "0x") {
+        env.showMessage(`contract was already deterministically deployed at ${expectedAddress}`);
+        const deployment2 = await env.save(name, {
+          address: expectedAddress,
+          ...partialDeployment
+        });
+        return { ...deployment2, updated: true };
+      }
+      params[0].data = salt + (bytecode2.slice(2) || "");
+      params[0].to = deterministicFactoryAddress;
+    }
+    const txHash = await broadcastTransaction(env, signer, params);
+    const pendingDeployment = {
+      type: "deployment",
+      expectedAddress,
+      partialDeployment,
+      transaction: { hash: txHash, origin: address },
+      name
+      // TODO we should have the nonce, except for wallet like metamask where it is not usre you get the nonce you start with
+    };
+    const deployment = await env.savePendingDeployment(pendingDeployment);
+    return { ...deployment, updated: true };
+  }
+  env.deploy = deploy;
+  env.execute = execute;
+  env.executeByName = executeByName;
+  env.read = read;
+  env.readByName = readByName;
+  return env;
+});