diff --git a/packages/evm/artifacts/index.ts b/packages/evm/artifacts/index.ts
index 640b0ba21..1d3a05101 100644
--- a/packages/evm/artifacts/index.ts
+++ b/packages/evm/artifacts/index.ts
@@ -253,74 +253,6 @@ export function prepareERC1155Payload({
   );
 }
 
-export interface ERC1155TransferPayload {
-  tokenId: bigint;
-  amount: bigint;
-  asset: Address;
-  target: Address;
-}
-
-export function prepareERC1155Transfer({
-  tokenId,
-  amount,
-  asset,
-  target,
-}: ERC1155TransferPayload) {
-  return encodeAbiParameters(
-    parseAbiParameters([
-      'Transfer request',
-      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',
-    ]),
-    [
-      {
-        assetType: 2,
-        asset,
-        data: prepareERC1155Payload({ tokenId, amount }),
-        target,
-      },
-    ],
-  );
-}
-
-export interface FungiblePayload { amount: bigint }
-
-export function prepareFungiblePayload({ amount }: FungiblePayload) {
-  return encodeAbiParameters(
-    parseAbiParameters([
-      'FungiblePayload payload',
-      'struct FungiblePayload { uint256 amount; }',
-    ]),
-    [{ amount }],
-  );
-}
-
-export interface FungibleTransferPayload {
-  amount: bigint;
-  asset: Address;
-  target: Address;
-}
-
-export function prepareFungibleTransfer({
-  amount,
-  asset,
-  target,
-}: FungibleTransferPayload) {
-  return encodeAbiParameters(
-    parseAbiParameters([
-      'Transfer request',
-      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',
-    ]),
-    [
-      {
-        assetType: asset == zeroAddress ? 0 : 1,
-        asset,
-        data: prepareFungiblePayload({ amount }),
-        target,
-      },
-    ],
-  );
-}
-
 export interface PointsIncentivePayload {
   venue: Address;
   selector: Hex;
@@ -548,6 +480,10 @@ export const prepareClaimPayload = ({ target, data = zeroHash }: ClaimPayload) =
   )
 }
 
+/*
+* Transfer Payloads
+*/
+
 export enum AssetType {
   ETH,
   ERC20,
@@ -573,3 +509,70 @@ export const prepareTransferPayload =({ assetType, address, target, data }: Tran
   )
 }
 
+export interface ERC1155TransferPayload {
+  tokenId: bigint;
+  amount: bigint;
+  asset: Address;
+  target: Address;
+}
+
+export function prepareERC1155Transfer({
+  tokenId,
+  amount,
+  asset,
+  target,
+}: ERC1155TransferPayload) {
+  return encodeAbiParameters(
+    parseAbiParameters([
+      'Transfer request',
+      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',
+    ]),
+    [
+      {
+        assetType: AssetType.ERC1155,
+        asset,
+        data: prepareERC1155Payload({ tokenId, amount }),
+        target,
+      },
+    ],
+  );
+}
+
+export interface FungiblePayload { amount: bigint }
+
+export function prepareFungiblePayload({ amount }: FungiblePayload) {
+  return encodeAbiParameters(
+    parseAbiParameters([
+      'FungiblePayload payload',
+      'struct FungiblePayload { uint256 amount; }',
+    ]),
+    [{ amount }],
+  );
+}
+
+export interface FungibleTransferPayload {
+  amount: bigint;
+  asset: Address;
+  target: Address;
+}
+
+export function prepareFungibleTransfer({
+  amount,
+  asset,
+  target,
+}: FungibleTransferPayload) {
+  return encodeAbiParameters(
+    parseAbiParameters([
+      'Transfer request',
+      'struct Transfer { uint8 assetType; address asset; address target; bytes data; }',
+    ]),
+    [
+      {
+        assetType: asset == zeroAddress ? AssetType.ETH : AssetType.ERC20,
+        asset,
+        data: prepareFungiblePayload({ amount }),
+        target,
+      },
+    ],
+  );
+}
diff --git a/packages/sdk/src/Actions/ContractAction.ts b/packages/sdk/src/Actions/ContractAction.ts
index 085f70c9c..4219db835 100644
--- a/packages/sdk/src/Actions/ContractAction.ts
+++ b/packages/sdk/src/Actions/ContractAction.ts
@@ -19,7 +19,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { ContractActionPayload };
 
@@ -28,46 +28,48 @@ export class ContractAction extends DeployableTarget<ContractActionPayload> {
   public override readonly base = ContractAction.base;
 
   public async chainId(
-    params: CallParams<typeof readContractActionChainId> = {},
+    params?: ReadParams<typeof contractActionAbi, 'chainId'>,
   ) {
     return readContractActionChainId(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async target(
-    params: CallParams<typeof readContractActionTarget> = {},
-  ) {
+  public async target(params?: ReadParams<typeof contractActionAbi, 'target'>) {
     return readContractActionTarget(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async selector(
-    params: CallParams<typeof readContractActionSelector> = {},
+    params?: ReadParams<typeof contractActionAbi, 'selector'>,
   ) {
     return readContractActionSelector(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async value(params: CallParams<typeof readContractActionValue> = {}) {
+  public async value(params?: ReadParams<typeof contractActionAbi, 'value'>) {
     return readContractActionValue(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async execute(
     data: Hex,
-    params: CallParams<typeof writeContractActionExecute> = {},
+    params?: WriteParams<typeof contractActionAbi, 'execute'>,
   ) {
     return this.awaitResult(
       this.executeRaw(data, params),
@@ -78,47 +80,51 @@ export class ContractAction extends DeployableTarget<ContractActionPayload> {
 
   public async executeRaw(
     data: Hex,
-    params: CallParams<typeof writeContractActionExecute> = {},
+    params?: WriteParams<typeof contractActionAbi, 'execute'>,
   ) {
     return writeContractActionExecute(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [data],
     });
   }
 
   public async prepare(
     data: Hex,
-    params: CallParams<typeof readContractActionPrepare> = {},
+    params?: ReadParams<typeof contractActionAbi, 'prepare'>,
   ) {
     return readContractActionPrepare(this._config, {
       address: this.assertValidAddress(),
       args: [data],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readContractActionSupportsInterface> = {},
+    params?: ReadParams<typeof contractActionAbi, 'supportsInterface'>,
   ) {
     return readContractActionSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readContractActionGetComponentInterface> = {},
+    params?: ReadParams<typeof contractActionAbi, 'getComponentInterface'>,
   ) {
     return readContractActionGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/Actions/ERC721MintAction.ts b/packages/sdk/src/Actions/ERC721MintAction.ts
index d67e0eaba..17d46ade6 100644
--- a/packages/sdk/src/Actions/ERC721MintAction.ts
+++ b/packages/sdk/src/Actions/ERC721MintAction.ts
@@ -16,7 +16,7 @@ import type {
   DeployableOptions,
   GenericDeployableParams,
 } from '../Deployable/Deployable';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 import { ContractAction } from './ContractAction';
 
 export type { ERC721MintActionPayload };
@@ -27,7 +27,7 @@ export class ERC721MintAction extends ContractAction {
 
   public override async execute(
     data: Hex,
-    params: CallParams<typeof writeErc721MintActionExecute> = {},
+    params?: WriteParams<typeof erc721MintActionAbi, 'execute'>,
   ) {
     return this.awaitResult(
       this.executeRaw(data, params),
@@ -38,31 +38,33 @@ export class ERC721MintAction extends ContractAction {
 
   public override async executeRaw(
     data: Hex,
-    params: CallParams<typeof writeErc721MintActionExecute> = {},
+    params?: WriteParams<typeof erc721MintActionAbi, 'execute'>,
   ) {
     return writeErc721MintActionExecute(this._config, {
       address: this.assertValidAddress(),
       args: [data],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public override async prepare(
     data: Hex,
-    params: CallParams<typeof readErc721MintActionPrepare> = {},
+    params?: ReadParams<typeof erc721MintActionAbi, 'prepare'>,
   ) {
     return readErc721MintActionPrepare(this._config, {
       address: this.assertValidAddress(),
       args: [data],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async validate(
     data: Hex,
-    params: CallParams<typeof writeErc721MintActionValidate> = {},
+    params?: WriteParams<typeof erc721MintActionAbi, 'validate'>,
   ) {
     return this.awaitResult(
       this.validateRaw(data, params),
@@ -73,35 +75,38 @@ export class ERC721MintAction extends ContractAction {
 
   public async validateRaw(
     data: Hex,
-    params: CallParams<typeof writeErc721MintActionValidate> = {},
+    params?: WriteParams<typeof erc721MintActionAbi, 'validate'>,
   ) {
     return writeErc721MintActionValidate(this._config, {
       address: this.assertValidAddress(),
       args: [data],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public override async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readErc721MintActionSupportsInterface> = {},
+    params?: ReadParams<typeof erc721MintActionAbi, 'supportsInterface'>,
   ) {
     return readErc721MintActionSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public override async getComponentInterface(
-    params: CallParams<typeof readErc721MintActionGetComponentInterface> = {},
+    params?: ReadParams<typeof erc721MintActionAbi, 'getComponentInterface'>,
   ) {
     return readErc721MintActionGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/AllowLists/SimpleAllowList.ts b/packages/sdk/src/AllowLists/SimpleAllowList.ts
index b7d4c6cf3..068f75798 100644
--- a/packages/sdk/src/AllowLists/SimpleAllowList.ts
+++ b/packages/sdk/src/AllowLists/SimpleAllowList.ts
@@ -17,7 +17,7 @@ import type {
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
-import type { CallParams } from '../utils';
+import type { ReadParams } from '../utils';
 
 export type { SimpleAllowListPayload };
 
@@ -27,20 +27,21 @@ export class SimpleAllowList extends DeployableTarget<SimpleAllowListPayload> {
 
   public async isAllowed(
     address: Address,
-    params: CallParams<typeof readSimpleAllowListIsAllowed> = {},
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
   ): Promise<boolean> {
     return await readSimpleAllowListIsAllowed(this._config, {
       address: this.assertValidAddress(),
       args: [address, zeroHash],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async setAllowed(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSimpleAllowListSetAllowed> = {},
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
   ) {
     return this.awaitResult(
       this.setAllowedRaw(addresses, allowed, params),
@@ -52,34 +53,37 @@ export class SimpleAllowList extends DeployableTarget<SimpleAllowListPayload> {
   public async setAllowedRaw(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSimpleAllowListSetAllowed> = {},
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
   ) {
     return await writeSimpleAllowListSetAllowed(this._config, {
       address: this.assertValidAddress(),
       args: [addresses, allowed],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readSimpleAllowListSupportsInterface> = {},
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
   ) {
     return readSimpleAllowListSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readSimpleAllowListGetComponentInterface> = {},
+    params?: ReadParams<typeof simpleAllowListAbi, 'setAllowed'>,
   ) {
     return readSimpleAllowListGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/AllowLists/SimpleDenyList.ts b/packages/sdk/src/AllowLists/SimpleDenyList.ts
index 3adcfd9c9..d7c4ed35d 100644
--- a/packages/sdk/src/AllowLists/SimpleDenyList.ts
+++ b/packages/sdk/src/AllowLists/SimpleDenyList.ts
@@ -17,7 +17,7 @@ import type {
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { SimpleDenyListPayload };
 
@@ -27,58 +27,62 @@ export class SimpleDenyList extends DeployableTarget<SimpleDenyListPayload> {
 
   public async isAllowed(
     address: Address,
-    params: CallParams<typeof readSimpleDenyListIsAllowed> = {},
+    params?: ReadParams<typeof simpleDenyListAbi, 'isAllowed'>,
   ): Promise<boolean> {
     return await readSimpleDenyListIsAllowed(this._config, {
       address: this.assertValidAddress(),
       args: [address, zeroHash],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async setAllowed(
+  public async setDenied(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSimpleDenyListSetDenied> = {},
+    params?: WriteParams<typeof simpleDenyListAbi, 'setDenied'>,
   ) {
     return this.awaitResult(
-      this.setAllowedRaw(addresses, allowed, params),
+      this.setDeniedRaw(addresses, allowed, params),
       simpleDenyListAbi,
       simulateSimpleDenyListSetDenied,
     );
   }
 
-  public async setAllowedRaw(
+  public async setDeniedRaw(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSimpleDenyListSetDenied> = {},
+    params?: WriteParams<typeof simpleDenyListAbi, 'setDenied'>,
   ) {
     return await writeSimpleDenyListSetDenied(this._config, {
       address: this.assertValidAddress(),
       args: [addresses, allowed],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readSimpleDenyListSupportsInterface> = {},
+    params?: ReadParams<typeof simpleDenyListAbi, 'supportsInterface'>,
   ) {
     return readSimpleDenyListSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readSimpleDenyListGetComponentInterface> = {},
+    params?: ReadParams<typeof simpleDenyListAbi, 'getComponentInterface'>,
   ) {
     return readSimpleDenyListGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/BoostCore.ts b/packages/sdk/src/BoostCore.ts
index 8d19a26d5..69b6af0c2 100644
--- a/packages/sdk/src/BoostCore.ts
+++ b/packages/sdk/src/BoostCore.ts
@@ -86,7 +86,7 @@ import {
   DeployableUnknownOwnerProvidedError,
   NoContractAddressUponReceiptError,
 } from './errors';
-import type { CallParams } from './utils';
+import type { ReadParams, WriteParams } from './utils';
 
 export const BOOST_CORE_ADDRESS: Address = import.meta.env
   .VITE_BOOST_CORE_ADDRESS;
@@ -340,7 +340,7 @@ export class BoostCore extends Deployable<[Address, Address]> {
     incentiveId: bigint,
     address: Address,
     data: Hex,
-    params: CallParams<typeof writeBoostCoreClaimIncentive> = {},
+    params?: WriteParams<typeof boostCoreAbi, 'claimIncentive'>,
   ) {
     return this.awaitResult(
       this.claimIncentiveRaw(boostId, incentiveId, address, data, params),
@@ -354,31 +354,33 @@ export class BoostCore extends Deployable<[Address, Address]> {
     incentiveId: bigint,
     address: Address,
     data: Hex,
-    params: CallParams<typeof writeBoostCoreClaimIncentive> = {},
+    params?: WriteParams<typeof boostCoreAbi, 'claimIncentive'>,
   ) {
     return writeBoostCoreClaimIncentive(this._config, {
       address: this.assertValidAddress(),
       args: [boostId, incentiveId, address, data],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async readBoost(
     id: bigint,
-    params: CallParams<typeof readBoostCoreGetBoost> = {},
+    params?: ReadParams<typeof boostCoreAbi, 'getBoost'>,
   ) {
     return readBoostCoreGetBoost(this._config, {
       address: this.assertValidAddress(),
       args: [id],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async getBoost(
     _id: string | bigint,
-    params: CallParams<typeof readBoostCoreGetBoost> = {},
+    params?: ReadParams<typeof boostCoreAbi, 'getBoost'>,
   ) {
     let id: bigint;
     if (typeof _id === 'string') {
@@ -422,19 +424,20 @@ export class BoostCore extends Deployable<[Address, Address]> {
   }
 
   public async getBoostCount(
-    params: CallParams<typeof readBoostCoreGetBoostCount> = {},
+    params?: ReadParams<typeof boostCoreAbi, 'getBoostCount'>,
   ) {
     return readBoostCoreGetBoostCount(this._config, {
       address: this.assertValidAddress(),
       args: [],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async setProcolFeeReceiver(
     address: Address,
-    params: CallParams<typeof writeBoostCoreSetProtocolFeeReceiver> = {},
+    params?: WriteParams<typeof boostCoreAbi, 'setProtocolFeeReceiver'>,
   ) {
     return this.awaitResult(
       this.setProcolFeeReceiverRaw(address, params),
@@ -445,19 +448,20 @@ export class BoostCore extends Deployable<[Address, Address]> {
 
   public async setProcolFeeReceiverRaw(
     address: Address,
-    params: CallParams<typeof writeBoostCoreSetClaimFee> = {},
+    params?: WriteParams<typeof boostCoreAbi, 'setProtocolFeeReceiver'>,
   ) {
     return writeBoostCoreSetProtocolFeeReceiver(this._config, {
       address: this.assertValidAddress(),
       args: [address],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async setClaimFee(
     claimFee: bigint,
-    params: CallParams<typeof writeBoostCoreSetClaimFee> = {},
+    params?: WriteParams<typeof boostCoreAbi, 'setClaimFee'>,
   ) {
     return this.awaitResult(
       this.setClaimFeeRaw(claimFee, params),
@@ -468,13 +472,14 @@ export class BoostCore extends Deployable<[Address, Address]> {
 
   public async setClaimFeeRaw(
     claimFee: bigint,
-    params: CallParams<typeof writeBoostCoreSetClaimFee> = {},
+    params?: WriteParams<typeof boostCoreAbi, 'setClaimFee'>,
   ) {
     return writeBoostCoreSetClaimFee(this._config, {
       address: this.assertValidAddress(),
       args: [claimFee],
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
diff --git a/packages/sdk/src/Budgets/SimpleBudget.ts b/packages/sdk/src/Budgets/SimpleBudget.ts
index 3f87b9ef0..a4a463ee8 100644
--- a/packages/sdk/src/Budgets/SimpleBudget.ts
+++ b/packages/sdk/src/Budgets/SimpleBudget.ts
@@ -1,6 +1,10 @@
 import {
+  type ERC1155TransferPayload,
+  type FungibleTransferPayload,
   type SimpleBudgetPayload,
   type TransferPayload,
+  prepareERC1155Transfer,
+  prepareFungibleTransfer,
   prepareSimpleBudgetPayload,
   prepareTransferPayload,
   readSimpleBudgetAvailable,
@@ -10,7 +14,7 @@ import {
   readSimpleBudgetSupportsInterface,
   readSimpleBudgetTotal,
   readVestingBudgetStart,
-  simpleAllowListAbi,
+  simpleBudgetAbi,
   simulateSimpleBudgetAllocate,
   simulateSimpleBudgetDisburse,
   simulateSimpleBudgetDisburseBatch,
@@ -24,102 +28,124 @@ import {
 } from '@boostxyz/evm';
 import { bytecode } from '@boostxyz/evm/artifacts/contracts/budgets/SimpleBudget.sol/SimpleBudget.json';
 import { getAccount } from '@wagmi/core';
+import type { CreateWriteContractParameters } from '@wagmi/core/codegen';
 import { type Address, type Hex, zeroAddress } from 'viem';
-import {
-  Deployable,
-  type DeployableOptions,
-  type GenericDeployableParams,
+import { writeContract } from 'viem/actions';
+import type {
+  DeployableOptions,
+  GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import { DeployableUnknownOwnerProvidedError } from '../errors';
-import type { CallParams } from '../utils';
+import {
+  DeployableUnknownOwnerProvidedError,
+  UnknownTransferPayloadSupplied,
+} from '../errors';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { SimpleBudgetPayload };
 
+export function isFungibleTransfer(
+  transfer: FungibleTransferPayload | ERC1155TransferPayload,
+): transfer is FungibleTransferPayload {
+  return (transfer as ERC1155TransferPayload).tokenId === undefined;
+}
+
+export function isERC1155TransferPayload(
+  transfer: FungibleTransferPayload | ERC1155TransferPayload,
+): transfer is ERC1155TransferPayload {
+  return (transfer as ERC1155TransferPayload).tokenId !== undefined;
+}
+
+export function prepareTransfer(
+  transfer: FungibleTransferPayload | ERC1155TransferPayload,
+) {
+  if (isFungibleTransfer(transfer)) {
+    return prepareFungibleTransfer(transfer);
+  } else if (isERC1155TransferPayload(transfer)) {
+    return prepareERC1155Transfer(transfer);
+  } else throw new UnknownTransferPayloadSupplied(transfer);
+}
+
 export class SimpleBudget extends DeployableTarget<SimpleBudgetPayload> {
   public static base = import.meta.env.VITE_SIMPLE_BUDGET_BASE;
   public override readonly base = SimpleBudget.base;
 
-  public start(params: CallParams<typeof readVestingBudgetStart> = {}) {
-    return readVestingBudgetStart(this._config, {
-      address: this.assertValidAddress(),
-      ...params,
-    });
-  }
-
   public async allocate(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeSimpleBudgetAllocate> = {},
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'allocate'>,
   ) {
     return this.awaitResult(
       this.allocateRaw(transfer, params),
-      simpleAllowListAbi,
+      simpleBudgetAbi,
       simulateSimpleBudgetAllocate,
     );
   }
 
   public allocateRaw(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeSimpleBudgetAllocate> = {},
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'allocate'>,
   ) {
     return writeSimpleBudgetAllocate(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareTransferPayload(transfer)],
-      ...params,
+      args: [prepareTransfer(transfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reclaim(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeSimpleBudgetReclaim> = {},
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'reclaim'>,
   ) {
     return this.awaitResult(
       this.reclaimRaw(transfer, params),
-      simpleAllowListAbi,
+      simpleBudgetAbi,
       simulateSimpleBudgetReclaim,
     );
   }
 
   public reclaimRaw(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeSimpleBudgetReclaim> = {},
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'reclaim'>,
   ) {
     return writeSimpleBudgetReclaim(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareTransferPayload(transfer)],
-      ...params,
+      args: [prepareTransfer(transfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async disburse(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeSimpleBudgetDisburse> = {},
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburse'>,
   ) {
     return this.awaitResult(
       this.disburseRaw(transfer, params),
-      simpleAllowListAbi,
+      simpleBudgetAbi,
       simulateSimpleBudgetDisburse,
     );
   }
 
   public disburseRaw(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeSimpleBudgetDisburse> = {},
+    transfer: FungibleTransferPayload | ERC1155TransferPayload,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburse'>,
   ) {
     return writeSimpleBudgetDisburse(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareTransferPayload(transfer)],
-      ...params,
+      args: [prepareTransfer(transfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async disburseBatch(
-    transfers: TransferPayload[],
-    params: CallParams<typeof writeSimpleBudgetDisburseBatch> = {},
+    transfers: Array<FungibleTransferPayload | ERC1155TransferPayload>,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburseBatch'>,
   ) {
     return this.awaitResult(
       this.disburseBatchRaw(transfers, params),
-      simpleAllowListAbi,
+      simpleBudgetAbi,
       simulateSimpleBudgetDisburseBatch,
     );
   }
@@ -127,24 +153,25 @@ export class SimpleBudget extends DeployableTarget<SimpleBudgetPayload> {
   // use prepareFungibleTransfer or prepareERC1155Transfer
   // TODO use data structure
   public disburseBatchRaw(
-    transfers: TransferPayload[],
-    params: CallParams<typeof writeSimpleBudgetDisburseBatch> = {},
+    transfers: Array<FungibleTransferPayload | ERC1155TransferPayload>,
+    params?: WriteParams<typeof simpleBudgetAbi, 'disburseBatch'>,
   ) {
     return writeSimpleBudgetDisburseBatch(this._config, {
       address: this.assertValidAddress(),
-      args: [transfers.map(prepareTransferPayload)],
-      ...params,
+      args: [transfers.map(prepareTransfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async setAuthorized(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSimpleBudgetSetAuthorized> = {},
+    params?: WriteParams<typeof simpleBudgetAbi, 'setAuthorized'>,
   ) {
     return this.awaitResult(
       this.setAuthorizedRaw(addresses, allowed, params),
-      simpleAllowListAbi,
+      simpleBudgetAbi,
       simulateSimpleBudgetSetAuthorized,
     );
   }
@@ -152,81 +179,88 @@ export class SimpleBudget extends DeployableTarget<SimpleBudgetPayload> {
   public async setAuthorizedRaw(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSimpleBudgetSetAuthorized> = {},
+    params?: WriteParams<typeof simpleBudgetAbi, 'setAuthorized'>,
   ) {
     return await writeSimpleBudgetSetAuthorized(this._config, {
       address: this.assertValidAddress(),
       args: [addresses, allowed],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public isAuthorized(
     account: Address,
-    params: CallParams<typeof readSimpleBudgetIsAuthorized> = {},
+    params?: ReadParams<typeof simpleBudgetAbi, 'isAuthorized'>,
   ) {
     return readSimpleBudgetIsAuthorized(this._config, {
       address: this.assertValidAddress(),
       args: [account],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public total(
     asset: Address,
     tokenId: bigint | undefined,
-    params: CallParams<typeof readSimpleBudgetTotal> = {},
+    params?: ReadParams<typeof simpleBudgetAbi, 'total'>,
   ) {
     return readSimpleBudgetTotal(this._config, {
       address: this.assertValidAddress(),
       args: tokenId ? [asset, tokenId] : [asset],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public available(
     asset: Address,
     tokenId: bigint | undefined,
-    params: CallParams<typeof readSimpleBudgetAvailable> = {},
+    params?: ReadParams<typeof simpleBudgetAbi, 'available'>,
   ) {
     return readSimpleBudgetAvailable(this._config, {
       address: this.assertValidAddress(),
       args: tokenId ? [asset, tokenId] : [asset],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public distributed(
     asset: Address,
     tokenId: bigint | undefined,
-    params: CallParams<typeof readSimpleBudgetDistributed> = {},
+    params?: ReadParams<typeof simpleBudgetAbi, 'distributed'>,
   ) {
     return readSimpleBudgetDistributed(this._config, {
       address: this.assertValidAddress(),
       args: tokenId ? [asset, tokenId] : [asset],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readSimpleBudgetSupportsInterface> = {},
+    params?: ReadParams<typeof simpleBudgetAbi, 'supportsInterface'>,
   ) {
     return readSimpleBudgetSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readSimpleBudgetGetComponentInterface> = {},
+    params?: ReadParams<typeof simpleBudgetAbi, 'getComponentInterface'>,
   ) {
     return readSimpleBudgetGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
@@ -252,7 +286,7 @@ export class SimpleBudget extends DeployableTarget<SimpleBudgetPayload> {
       }
     }
     return {
-      abi: simpleAllowListAbi,
+      abi: simpleBudgetAbi,
       bytecode: bytecode as Hex,
       args: [prepareSimpleBudgetPayload(payload)],
       ...this.optionallyAttachAccount(options.account),
diff --git a/packages/sdk/src/Budgets/VestingBudget.ts b/packages/sdk/src/Budgets/VestingBudget.ts
index cbd651ce6..8f7afbeca 100644
--- a/packages/sdk/src/Budgets/VestingBudget.ts
+++ b/packages/sdk/src/Budgets/VestingBudget.ts
@@ -1,7 +1,7 @@
 import {
-  type TransferPayload,
+  type FungibleTransferPayload,
   type VestingBudgetPayload,
-  prepareTransferPayload,
+  prepareFungibleTransfer,
   prepareVestingBudgetPayload,
   readVestingBudgetAvailable,
   readVestingBudgetCliff,
@@ -34,7 +34,7 @@ import type {
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
 import { DeployableUnknownOwnerProvidedError } from '../errors';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { VestingBudgetPayload };
 
@@ -42,33 +42,36 @@ export class VestingBudget extends DeployableTarget<VestingBudgetPayload> {
   public static base = import.meta.env.VITE_VESTING_BUDGET_BASE;
   public override readonly base = VestingBudget.base;
 
-  public start(params: CallParams<typeof readVestingBudgetStart> = {}) {
+  public start(params?: ReadParams<typeof vestingBudgetAbi, 'start'>) {
     return readVestingBudgetStart(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public duration(params: CallParams<typeof readVestingBudgetDuration> = {}) {
+  public duration(params?: ReadParams<typeof vestingBudgetAbi, 'duration'>) {
     return readVestingBudgetDuration(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public cliff(params: CallParams<typeof readVestingBudgetCliff> = {}) {
+  public cliff(params?: ReadParams<typeof vestingBudgetAbi, 'cliff'>) {
     return readVestingBudgetCliff(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async allocate(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeVestingBudgetAllocate> = {},
+    transfer: FungibleTransferPayload,
+    params?: WriteParams<typeof vestingBudgetAbi, 'allocate'>,
   ) {
     return this.awaitResult(
       this.allocateRaw(transfer, params),
@@ -78,19 +81,20 @@ export class VestingBudget extends DeployableTarget<VestingBudgetPayload> {
   }
 
   public allocateRaw(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeVestingBudgetAllocate> = {},
+    transfer: FungibleTransferPayload,
+    params?: WriteParams<typeof vestingBudgetAbi, 'allocate'>,
   ) {
     return writeVestingBudgetAllocate(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareTransferPayload(transfer)],
-      ...params,
+      args: [prepareFungibleTransfer(transfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reclaim(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeVestingBudgetReclaim> = {},
+    transfer: FungibleTransferPayload,
+    params?: WriteParams<typeof vestingBudgetAbi, 'reclaim'>,
   ) {
     return this.awaitResult(
       this.reclaimRaw(transfer, params),
@@ -100,19 +104,20 @@ export class VestingBudget extends DeployableTarget<VestingBudgetPayload> {
   }
 
   public reclaimRaw(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeVestingBudgetReclaim> = {},
+    transfer: FungibleTransferPayload,
+    params?: WriteParams<typeof vestingBudgetAbi, 'reclaim'>,
   ) {
     return writeVestingBudgetReclaim(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareTransferPayload(transfer)],
-      ...params,
+      args: [prepareFungibleTransfer(transfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async disburse(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeVestingBudgetDisburse> = {},
+    transfer: FungibleTransferPayload,
+    params?: WriteParams<typeof vestingBudgetAbi, 'disburse'>,
   ) {
     return this.awaitResult(
       this.disburseRaw(transfer, params),
@@ -122,19 +127,20 @@ export class VestingBudget extends DeployableTarget<VestingBudgetPayload> {
   }
 
   public disburseRaw(
-    transfer: TransferPayload,
-    params: CallParams<typeof writeVestingBudgetDisburse> = {},
+    transfer: FungibleTransferPayload,
+    params?: WriteParams<typeof vestingBudgetAbi, 'disburse'>,
   ) {
     return writeVestingBudgetDisburse(this._config, {
       address: this.assertValidAddress(),
-      args: [prepareTransferPayload(transfer)],
-      ...params,
+      args: [prepareFungibleTransfer(transfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async disburseBatch(
-    transfers: TransferPayload[],
-    params: CallParams<typeof writeVestingBudgetDisburseBatch> = {},
+    transfers: FungibleTransferPayload[],
+    params?: WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>,
   ) {
     return this.awaitResult(
       this.disburseBatchRaw(transfers, params),
@@ -144,20 +150,21 @@ export class VestingBudget extends DeployableTarget<VestingBudgetPayload> {
   }
 
   public disburseBatchRaw(
-    transfers: TransferPayload[],
-    params: CallParams<typeof writeVestingBudgetDisburseBatch> = {},
+    transfers: FungibleTransferPayload[],
+    params?: WriteParams<typeof vestingBudgetAbi, 'disburseBatch'>,
   ) {
     return writeVestingBudgetDisburseBatch(this._config, {
       address: this.assertValidAddress(),
-      args: [transfers.map(prepareTransferPayload)],
-      ...params,
+      args: [transfers.map(prepareFungibleTransfer)],
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async setAuthorized(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeVestingBudgetSetAuthorized> = {},
+    params?: WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>,
   ) {
     return this.awaitResult(
       this.setAuthorizedRaw(addresses, allowed, params),
@@ -169,86 +176,94 @@ export class VestingBudget extends DeployableTarget<VestingBudgetPayload> {
   public async setAuthorizedRaw(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeVestingBudgetSetAuthorized> = {},
+    params?: WriteParams<typeof vestingBudgetAbi, 'setAuthorized'>,
   ) {
     return await writeVestingBudgetSetAuthorized(this._config, {
       address: this.assertValidAddress(),
       args: [addresses, allowed],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public isAuthorized(
     account: Address,
-    params: CallParams<typeof readVestingBudgetIsAuthorized> = {},
+    params?: ReadParams<typeof vestingBudgetAbi, 'isAuthorized'>,
   ) {
     return readVestingBudgetIsAuthorized(this._config, {
       address: this.assertValidAddress(),
       args: [account],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public end(params: CallParams<typeof readVestingBudgetEnd> = {}) {
+  public end(params?: ReadParams<typeof vestingBudgetAbi, 'end'>) {
     return readVestingBudgetEnd(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public total(
     asset: Address,
-    params: CallParams<typeof readVestingBudgetTotal> = {},
+    params?: ReadParams<typeof vestingBudgetAbi, 'total'>,
   ) {
     return readVestingBudgetTotal(this._config, {
       address: this.assertValidAddress(),
       args: [asset],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public available(
     asset: Address,
-    params: CallParams<typeof readVestingBudgetAvailable> = {},
+    params?: ReadParams<typeof vestingBudgetAbi, 'available'>,
   ) {
     return readVestingBudgetAvailable(this._config, {
       address: this.assertValidAddress(),
       args: [asset],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public distributed(
     asset: Address,
-    params: CallParams<typeof readVestingBudgetDistributed> = {},
+    params?: ReadParams<typeof vestingBudgetAbi, 'distributed'>,
   ) {
     return readVestingBudgetDistributed(this._config, {
       address: this.assertValidAddress(),
       args: [asset],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readVestingBudgetSupportsInterface> = {},
+    params?: ReadParams<typeof vestingBudgetAbi, 'supportsInterface'>,
   ) {
     return readVestingBudgetSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readVestingBudgetGetComponentInterface> = {},
+    params?: ReadParams<typeof vestingBudgetAbi, 'getComponentInterface'>,
   ) {
     return readVestingBudgetGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/Deployable/Contract.ts b/packages/sdk/src/Deployable/Contract.ts
index b042614ca..b8706606b 100644
--- a/packages/sdk/src/Deployable/Contract.ts
+++ b/packages/sdk/src/Deployable/Contract.ts
@@ -46,7 +46,7 @@ export class Contract {
     hashPromise: Promise<Hash>,
     abi: abi,
     fn: CreateSimulateContractReturnType<abi, undefined, functionName>,
-    waitParams: Omit<WaitForTransactionReceiptParameters, 'hash'> = {},
+    waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,
   ) {
     return awaitResult(this._config, hashPromise, abi, fn, waitParams);
   }
diff --git a/packages/sdk/src/Deployable/Deployable.ts b/packages/sdk/src/Deployable/Deployable.ts
index 75eb7436a..722fff93f 100644
--- a/packages/sdk/src/Deployable/Deployable.ts
+++ b/packages/sdk/src/Deployable/Deployable.ts
@@ -57,7 +57,7 @@ export class Deployable<Payload = unknown> extends Contract {
   public async deploy(
     _payload?: Payload,
     _options?: DeployableOptions,
-    waitParams: Omit<WaitForTransactionReceiptParameters, 'hash'> = {},
+    waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,
   ): Promise<Address> {
     const config = _options?.config || this._config;
     const address = await getDeployedContractAddress(
diff --git a/packages/sdk/src/Incentives/AllowListIncentive.ts b/packages/sdk/src/Incentives/AllowListIncentive.ts
index aca075b10..8c689a9f0 100644
--- a/packages/sdk/src/Incentives/AllowListIncentive.ts
+++ b/packages/sdk/src/Incentives/AllowListIncentive.ts
@@ -23,7 +23,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { AllowListIncentivePayload };
 
@@ -32,42 +32,46 @@ export class AllowListIncentive extends DeployableTarget<AllowListIncentivePaylo
   public override readonly base = AllowListIncentive.base;
 
   public async claims(
-    params: CallParams<typeof readAllowListIncentiveClaims> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'claims'>,
   ) {
     return readAllowListIncentiveClaims(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reward(
-    params: CallParams<typeof readAllowListIncentiveReward> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'reward'>,
   ) {
     return readAllowListIncentiveReward(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claimed(
     address: Address,
-    params: CallParams<typeof readAllowListIncentiveClaimed> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'claimed'>,
   ) {
     return readAllowListIncentiveClaimed(this._config, {
       address: this.assertValidAddress(),
       args: [address],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async allowList(
-    params: CallParams<typeof readAllowListIncentiveAllowList> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'allowList'>,
   ): Promise<SimpleAllowList> {
     const address = await readAllowListIncentiveAllowList(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
     return new SimpleAllowList(
       { config: this._config, account: this._account },
@@ -76,17 +80,18 @@ export class AllowListIncentive extends DeployableTarget<AllowListIncentivePaylo
   }
 
   public async limit(
-    params: CallParams<typeof readAllowListIncentiveLimit> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'limit'>,
   ) {
     return readAllowListIncentiveLimit(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claim(
     payload: ClaimPayload,
-    params: CallParams<typeof writeAllowListIncentiveClaim> = {},
+    params?: WriteParams<typeof allowListIncentiveAbi, 'claim'>,
   ) {
     return this.awaitResult(
       this.claimRaw(payload, params),
@@ -97,46 +102,50 @@ export class AllowListIncentive extends DeployableTarget<AllowListIncentivePaylo
 
   public async claimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writeAllowListIncentiveClaim> = {},
+    params?: WriteParams<typeof allowListIncentiveAbi, 'claim'>,
   ) {
     return writeAllowListIncentiveClaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   // use prepareClaimPayload?
   public async isClaimable(
     payload: ClaimPayload,
-    params: CallParams<typeof readAllowListIncentiveIsClaimable> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'isClaimable'>,
   ) {
     return readAllowListIncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readAllowListIncentiveSupportsInterface> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'supportsInterface'>,
   ) {
     return readAllowListIncentiveSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readAllowListIncentiveGetComponentInterface> = {},
+    params?: ReadParams<typeof allowListIncentiveAbi, 'getComponentInterface'>,
   ) {
     return readAllowListIncentiveGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/Incentives/CGDAIncentive.ts b/packages/sdk/src/Incentives/CGDAIncentive.ts
index 53f411281..df5f8770c 100644
--- a/packages/sdk/src/Incentives/CGDAIncentive.ts
+++ b/packages/sdk/src/Incentives/CGDAIncentive.ts
@@ -27,7 +27,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { CGDAIncentivePayload };
 
@@ -35,47 +35,52 @@ export class CGDAIncentive extends DeployableTarget<CGDAIncentivePayload> {
   public static base = import.meta.env.VITE_CGDA_INCENTIVE_BASE;
   public override readonly base = CGDAIncentive.base;
 
-  public async claims(params: CallParams<typeof readCgdaIncentiveClaims> = {}) {
+  public async claims(params?: ReadParams<typeof cgdaIncentiveAbi, 'claims'>) {
     return readCgdaIncentiveClaims(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async reward(params: CallParams<typeof readCgdaIncentiveReward> = {}) {
+  public async reward(params?: ReadParams<typeof cgdaIncentiveAbi, 'reward'>) {
     return readCgdaIncentiveReward(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claimed(
     address: Address,
-    params: CallParams<typeof readCgdaIncentiveClaimed> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'claimed'>,
   ) {
     return readCgdaIncentiveClaimed(this._config, {
       address: this.assertValidAddress(),
       args: [address],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async asset(params: CallParams<typeof readCgdaIncentiveAsset> = {}) {
+  public async asset(params?: ReadParams<typeof cgdaIncentiveAbi, 'asset'>) {
     return readCgdaIncentiveAsset(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async cgdaParams(
-    params: CallParams<typeof readCgdaIncentiveCgdaParams> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'cgdaParams'>,
   ): Promise<CGDAParameters> {
     const [rewardDecay, rewardBoost, lastClaimTime, currentReward] =
       await readCgdaIncentiveCgdaParams(this._config, {
         address: this.assertValidAddress(),
-        ...params,
+        // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+        ...(params as any),
       });
     return {
       rewardDecay,
@@ -86,17 +91,18 @@ export class CGDAIncentive extends DeployableTarget<CGDAIncentivePayload> {
   }
 
   public async totalBudget(
-    params: CallParams<typeof readCgdaIncentiveTotalBudget> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'totalBudget'>,
   ) {
     return readCgdaIncentiveTotalBudget(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claim(
     payload: ClaimPayload,
-    params: CallParams<typeof writeCgdaIncentiveClaim> = {},
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'claim'>,
   ) {
     return this.awaitResult(
       this.claimRaw(payload, params),
@@ -107,18 +113,19 @@ export class CGDAIncentive extends DeployableTarget<CGDAIncentivePayload> {
 
   public async claimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writeCgdaIncentiveClaim> = {},
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'claim'>,
   ) {
     return writeCgdaIncentiveClaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reclaim(
     payload: ClaimPayload,
-    params: CallParams<typeof writeCgdaIncentiveReclaim> = {},
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'reclaim'>,
   ) {
     return this.awaitResult(
       this.reclaimRaw(payload, params),
@@ -129,65 +136,71 @@ export class CGDAIncentive extends DeployableTarget<CGDAIncentivePayload> {
 
   public async reclaimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writeCgdaIncentiveReclaim> = {},
+    params?: WriteParams<typeof cgdaIncentiveAbi, 'reclaim'>,
   ) {
     return writeCgdaIncentiveReclaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async isClaimable(
     payload: ClaimPayload,
-    params: CallParams<typeof readCgdaIncentiveIsClaimable> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'isClaimable'>,
   ) {
     return readCgdaIncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async preflight(
     data: CGDAIncentivePayload,
-    params: CallParams<typeof readCgdaIncentiveIsClaimable> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'preflight'>,
   ) {
     return readCgdaIncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
       args: [prepareCGDAIncentivePayload(data)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async currentReward(
-    params: CallParams<typeof readCgdaIncentiveCurrentReward> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'currentReward'>,
   ) {
     return readCgdaIncentiveCurrentReward(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readCgdaIncentiveSupportsInterface> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'supportsInterface'>,
   ) {
     return readCgdaIncentiveSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readCgdaIncentiveGetComponentInterface> = {},
+    params?: ReadParams<typeof cgdaIncentiveAbi, 'getComponentInterface'>,
   ) {
     return readCgdaIncentiveGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/Incentives/ERC1155Incentive.ts b/packages/sdk/src/Incentives/ERC1155Incentive.ts
index 62e514398..5e9b41410 100644
--- a/packages/sdk/src/Incentives/ERC1155Incentive.ts
+++ b/packages/sdk/src/Incentives/ERC1155Incentive.ts
@@ -30,7 +30,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { ERC1155IncentivePayload, ERC1155StrategyType };
 
@@ -39,84 +39,88 @@ export class ERC1155Incentive extends DeployableTarget<ERC1155IncentivePayload>
   public override readonly base = ERC1155Incentive.base;
 
   public async claims(
-    params: CallParams<typeof readErc1155IncentiveClaims> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'claims'>,
   ) {
     return readErc1155IncentiveClaims(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reward(
-    params: CallParams<typeof readErc1155IncentiveReward> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'reward'>,
   ) {
     return readErc1155IncentiveReward(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claimed(
     address: Address,
-    params: CallParams<typeof readErc1155IncentiveClaimed> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'claimed'>,
   ) {
     return readErc1155IncentiveClaimed(this._config, {
       address: this.assertValidAddress(),
       args: [address],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async asset(
-    params: CallParams<typeof readErc1155IncentiveAsset> = {},
-  ) {
+  public async asset(params?: ReadParams<typeof erc1155IncentiveAbi, 'asset'>) {
     return readErc1155IncentiveAsset(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async strategy(
-    params: CallParams<typeof readErc1155IncentiveStrategy> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'strategy'>,
   ): Promise<StrategyType> {
     return readErc1155IncentiveStrategy(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     }) as Promise<StrategyType>;
   }
 
-  public async limit(
-    params: CallParams<typeof readErc1155IncentiveLimit> = {},
-  ) {
+  public async limit(params?: ReadParams<typeof erc1155IncentiveAbi, 'limit'>) {
     return readErc1155IncentiveLimit(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async tokenId(
-    params: CallParams<typeof readErc1155IncentiveTokenId> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'tokenId'>,
   ) {
     return readErc1155IncentiveTokenId(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async extraData(
-    params: CallParams<typeof readErc1155IncentiveExtraData> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'extraData'>,
   ) {
     return readErc1155IncentiveExtraData(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claim(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc1155IncentiveClaim> = {},
+    params?: WriteParams<typeof erc1155IncentiveAbi, 'claim'>,
   ) {
     return this.awaitResult(
       this.claimRaw(payload, params),
@@ -127,18 +131,19 @@ export class ERC1155Incentive extends DeployableTarget<ERC1155IncentivePayload>
 
   public async claimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc1155IncentiveClaim> = {},
+    params?: WriteParams<typeof erc1155IncentiveAbi, 'claim'>,
   ) {
     return writeErc1155IncentiveClaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reclaim(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc1155IncentiveReclaim> = {},
+    params?: WriteParams<typeof erc1155IncentiveAbi, 'reclaim'>,
   ) {
     return this.awaitResult(
       this.reclaimRaw(payload, params),
@@ -149,55 +154,60 @@ export class ERC1155Incentive extends DeployableTarget<ERC1155IncentivePayload>
 
   public async reclaimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc1155IncentiveReclaim> = {},
+    params?: WriteParams<typeof erc1155IncentiveAbi, 'reclaim'>,
   ) {
     return writeErc1155IncentiveReclaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async isClaimable(
     payload: ClaimPayload,
-    params: CallParams<typeof readErc1155IncentiveIsClaimable> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'isClaimable'>,
   ) {
     return readErc1155IncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async preflight(
     data: ERC1155IncentivePayload,
-    params: CallParams<typeof readErc1155IncentivePreflight> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'preflight'>,
   ) {
     return readErc1155IncentivePreflight(this._config, {
       address: this.assertValidAddress(),
       args: [prepareERC1155IncentivePayload(data)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readErc1155SupportsInterface> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'supportsInterface'>,
   ) {
     return readErc1155SupportsInterface(this._config, {
       address: this.assertValidAddress(),
       args: [interfaceId],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readErc1155IncentiveGetComponentInterface> = {},
+    params?: ReadParams<typeof erc1155IncentiveAbi, 'getComponentInterface'>,
   ) {
     return readErc1155IncentiveGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/Incentives/ERC20Incentive.ts b/packages/sdk/src/Incentives/ERC20Incentive.ts
index 1ef201f44..37795f8f0 100644
--- a/packages/sdk/src/Incentives/ERC20Incentive.ts
+++ b/packages/sdk/src/Incentives/ERC20Incentive.ts
@@ -30,7 +30,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { ERC20IncentivePayload };
 
@@ -38,73 +38,76 @@ export class ERC20Incentive extends DeployableTarget<ERC20IncentivePayload> {
   public static base = import.meta.env.VITE_ERC20_INCENTIVE_BASE;
   public override readonly base = ERC20Incentive.base;
 
-  public async claims(
-    params: CallParams<typeof readErc20IncentiveClaims> = {},
-  ) {
+  public async claims(params?: ReadParams<typeof erc20IncentiveAbi, 'claims'>) {
     return readErc20IncentiveClaims(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claimed(
     address: Address,
-    params: CallParams<typeof readErc20IncentiveClaimed> = {},
+    params?: ReadParams<typeof erc20IncentiveAbi, 'claimed'>,
   ) {
     return readErc20IncentiveClaimed(this._config, {
       address: this.assertValidAddress(),
       args: [address],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async asset(params: CallParams<typeof readErc20IncentiveAsset> = {}) {
+  public async asset(params?: ReadParams<typeof erc20IncentiveAbi, 'asset'>) {
     return readErc20IncentiveAsset(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async strategy(
-    params: CallParams<typeof readErc20IncentiveStrategy> = {},
+    params?: ReadParams<typeof erc20IncentiveAbi, 'strategy'>,
   ): Promise<StrategyType> {
     return readErc20IncentiveStrategy(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     }) as Promise<StrategyType>;
   }
 
-  public async reward(
-    params: CallParams<typeof readErc20IncentiveReward> = {},
-  ) {
+  public async reward(params?: ReadParams<typeof erc20IncentiveAbi, 'reward'>) {
     return readErc20IncentiveReward(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async limit(params: CallParams<typeof readErc20IncentiveLimit> = {}) {
+  public async limit(params?: ReadParams<typeof erc20IncentiveAbi, 'limit'>) {
     return readErc20IncentiveLimit(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async entries(
     i: bigint,
-    params: CallParams<typeof readErc20IncentiveEntries> = {},
+    params?: ReadParams<typeof erc20IncentiveAbi, 'entries'>,
   ) {
     return readErc20IncentiveEntries(this._config, {
       address: this.assertValidAddress(),
       args: [i],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claim(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc20IncentiveClaim> = {},
+    params?: WriteParams<typeof erc20IncentiveAbi, 'claim'>,
   ) {
     return this.awaitResult(
       this.claimRaw(payload, params),
@@ -115,18 +118,19 @@ export class ERC20Incentive extends DeployableTarget<ERC20IncentivePayload> {
 
   public async claimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc20IncentiveClaim> = {},
+    params?: WriteParams<typeof erc20IncentiveAbi, 'claim'>,
   ) {
     return writeErc20IncentiveClaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reclaim(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc20IncentiveReclaim> = {},
+    params?: WriteParams<typeof erc20IncentiveAbi, 'reclaim'>,
   ) {
     return this.awaitResult(
       this.reclaimRaw(payload, params),
@@ -137,39 +141,42 @@ export class ERC20Incentive extends DeployableTarget<ERC20IncentivePayload> {
 
   public async reclaimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writeErc20IncentiveReclaim> = {},
+    params?: WriteParams<typeof erc20IncentiveAbi, 'reclaim'>,
   ) {
     return writeErc20IncentiveReclaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async isClaimable(
     payload: ClaimPayload,
-    params: CallParams<typeof readErc20IncentiveIsClaimable> = {},
+    params?: ReadParams<typeof erc20IncentiveAbi, 'isClaimable'>,
   ) {
     return readErc20IncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async preflight(
     data: ERC20IncentivePayload,
-    params: CallParams<typeof readErc20IncentivePreflight> = {},
+    params?: ReadParams<typeof erc20IncentiveAbi, 'preflight'>,
   ) {
     return readErc20IncentivePreflight(this._config, {
       address: this.assertValidAddress(),
       args: [prepareERC20IncentivePayload(data)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async drawRaffle(
-    params: CallParams<typeof writeErc20IncentiveDrawRaffle> = {},
+    params?: WriteParams<typeof erc20IncentiveAbi, 'drawRaffle'>,
   ) {
     return this.awaitResult(
       this.drawRaffleRaw(params),
@@ -179,33 +186,36 @@ export class ERC20Incentive extends DeployableTarget<ERC20IncentivePayload> {
   }
 
   public async drawRaffleRaw(
-    params: CallParams<typeof writeErc20IncentiveDrawRaffle> = {},
+    params?: WriteParams<typeof erc20IncentiveAbi, 'drawRaffle'>,
   ) {
     return writeErc20IncentiveDrawRaffle(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readErc20IncentiveSupportsInterface> = {},
+    params?: ReadParams<typeof erc20IncentiveAbi, 'supportsInterface'>,
   ) {
     return readErc20IncentiveSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [interfaceId],
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readErc20IncentiveGetComponentInterface> = {},
+    params?: ReadParams<typeof erc20IncentiveAbi, 'getComponentInterface'>,
   ) {
     return readErc20IncentiveGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/Incentives/PointsIncentive.ts b/packages/sdk/src/Incentives/PointsIncentive.ts
index a26790187..06f78877c 100644
--- a/packages/sdk/src/Incentives/PointsIncentive.ts
+++ b/packages/sdk/src/Incentives/PointsIncentive.ts
@@ -24,7 +24,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { PointsIncentivePayload };
 
@@ -33,72 +33,79 @@ export class PointsIncentive extends DeployableTarget<PointsIncentivePayload> {
   public override readonly base = PointsIncentive.base;
 
   public async claims(
-    params: CallParams<typeof readPointsIncentiveClaims> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'claims'>,
   ) {
     return readPointsIncentiveClaims(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async currentReward(
-    params: CallParams<typeof readPointsIncentiveCurrentReward> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'currentReward'>,
   ) {
     return readPointsIncentiveCurrentReward(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async reward(
-    params: CallParams<typeof readPointsIncentiveReward> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'reward'>,
   ) {
     return readPointsIncentiveReward(this._config, {
       address: this.assertValidAddress(),
       args: [],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claimed(
     address: Address,
-    params: CallParams<typeof readPointsIncentiveClaimed> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'claimed'>,
   ) {
     return readPointsIncentiveClaimed(this._config, {
       address: this.assertValidAddress(),
       args: [address],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async venue(params: CallParams<typeof readPointsIncentiveVenue> = {}) {
+  public async venue(params?: ReadParams<typeof pointsIncentiveAbi, 'venue'>) {
     return readPointsIncentiveVenue(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  public async limit(params: CallParams<typeof readPointsIncentiveLimit> = {}) {
+  public async limit(params?: ReadParams<typeof pointsIncentiveAbi, 'limit'>) {
     return readPointsIncentiveLimit(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async selector(
-    params: CallParams<typeof readPointsIncentiveSelector> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'selector'>,
   ) {
     return readPointsIncentiveSelector(this._config, {
       address: this.assertValidAddress(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async claim(
     payload: ClaimPayload,
-    params: CallParams<typeof writePointsIncentiveClaim> = {},
+    params?: WriteParams<typeof pointsIncentiveAbi, 'claim'>,
   ) {
     return this.awaitResult(
       this.claimRaw(payload, params),
@@ -109,45 +116,48 @@ export class PointsIncentive extends DeployableTarget<PointsIncentivePayload> {
 
   public async claimRaw(
     payload: ClaimPayload,
-    params: CallParams<typeof writePointsIncentiveClaim> = {},
+    params?: WriteParams<typeof pointsIncentiveAbi, 'claim'>,
   ) {
     return writePointsIncentiveClaim(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
-  //prepareClaimPayload
   public async isClaimable(
     payload: ClaimPayload,
-    params: CallParams<typeof readPointsIncentiveIsClaimable> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'isClaimable'>,
   ) {
     return readPointsIncentiveIsClaimable(this._config, {
       address: this.assertValidAddress(),
       args: [prepareClaimPayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async supportsInterface(
     interfaceId: Hex,
-    params: CallParams<typeof readPointsIncentiveSupportsInterface> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'supportsInterface'>,
   ) {
     return readPointsIncentiveSupportsInterface(this._config, {
       address: this.assertValidAddress(),
       args: [interfaceId],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async getComponentInterface(
-    params: CallParams<typeof readPointsIncentiveGetComponentInterface> = {},
+    params?: ReadParams<typeof pointsIncentiveAbi, 'getComponentInterface'>,
   ) {
     return readPointsIncentiveGetComponentInterface(this._config, {
       address: this.assertValidAddress(),
       ...this.optionallyAttachAccount(),
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
       args: [],
     });
   }
diff --git a/packages/sdk/src/Validators/SignerValidator.ts b/packages/sdk/src/Validators/SignerValidator.ts
index 501d52633..93b21d00f 100644
--- a/packages/sdk/src/Validators/SignerValidator.ts
+++ b/packages/sdk/src/Validators/SignerValidator.ts
@@ -17,7 +17,7 @@ import type {
   GenericDeployableParams,
 } from '../Deployable/Deployable';
 import { DeployableTarget } from '../Deployable/DeployableTarget';
-import type { CallParams } from '../utils';
+import type { ReadParams, WriteParams } from '../utils';
 
 export type { SignerValidatorPayload };
 
@@ -27,18 +27,19 @@ export class SignerValidator extends DeployableTarget<SignerValidatorPayload> {
 
   public async signers(
     address: Address,
-    params: CallParams<typeof readSignerValidatorSigners> = {},
+    params?: ReadParams<typeof signerValidatorAbi, 'signers'>,
   ) {
     return readSignerValidatorSigners(this._config, {
       address: this.assertValidAddress(),
       args: [address],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async validate(
     payload: SignerValidatorValidatePayload,
-    params: CallParams<typeof writeSignerValidatorValidate> = {},
+    params?: WriteParams<typeof signerValidatorAbi, 'validate'>,
   ) {
     return this.awaitResult(
       this.validateRaw(payload, params),
@@ -49,19 +50,20 @@ export class SignerValidator extends DeployableTarget<SignerValidatorPayload> {
 
   public async validateRaw(
     payload: SignerValidatorValidatePayload,
-    params: CallParams<typeof writeSignerValidatorValidate> = {},
+    params?: ReadParams<typeof signerValidatorAbi, 'validate'>,
   ) {
     return writeSignerValidatorValidate(this._config, {
       address: this.assertValidAddress(),
       args: [prepareSignerValidatorValidatePayload(payload)],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
   public async setAuthorized(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSignerValidatorSetAuthorized> = {},
+    params?: WriteParams<typeof signerValidatorAbi, 'setAuthorized'>,
   ) {
     return this.awaitResult(
       this.setAuthorizedRaw(addresses, allowed, params),
@@ -73,12 +75,13 @@ export class SignerValidator extends DeployableTarget<SignerValidatorPayload> {
   public async setAuthorizedRaw(
     addresses: Address[],
     allowed: boolean[],
-    params: CallParams<typeof writeSignerValidatorSetAuthorized> = {},
+    params?: WriteParams<typeof signerValidatorAbi, 'setAuthorized'>,
   ) {
     return await writeSignerValidatorSetAuthorized(this._config, {
       address: this.assertValidAddress(),
       args: [addresses, allowed],
-      ...params,
+      // biome-ignore lint/suspicious/noExplicitAny: Accept any shape of valid wagmi/viem parameters, wagmi does the same thing internally
+      ...(params as any),
     });
   }
 
diff --git a/packages/sdk/src/errors.ts b/packages/sdk/src/errors.ts
index cb7999327..4a9070924 100644
--- a/packages/sdk/src/errors.ts
+++ b/packages/sdk/src/errors.ts
@@ -61,7 +61,9 @@ export class DeployableMissingPayloadError extends Error {
 export class NoContractAddressUponReceiptError extends Error {
   public readonly receipt: WaitForTransactionReceiptReturnType;
   constructor(receipt: WaitForTransactionReceiptReturnType) {
-    super(`Expected a contract address to exist on receipt.`);
+    super(`Expected a contract address to exist on receipt.`, {
+      cause: receipt,
+    });
     this.receipt = receipt;
   }
 }
@@ -71,8 +73,19 @@ export class InvalidComponentInterfaceError extends Error {
   public readonly received: Hex = zeroHash;
 
   constructor(expected: Hex[], received: Hex) {
-    super(`Address provided is not `);
+    super(`Address provided is not `, { cause: { expected, received } });
     this.expected = expected;
     this.received = received;
   }
 }
+
+export class UnknownTransferPayloadSupplied extends Error {
+  received: unknown;
+  constructor(received: unknown) {
+    super(
+      `Did not provide a valid FungibleTransferPayload or ERC1155 transfer payload.`,
+      { cause: received },
+    );
+    this.received = received;
+  }
+}
diff --git a/packages/sdk/src/utils.ts b/packages/sdk/src/utils.ts
index c450e31a1..5e22f3497 100644
--- a/packages/sdk/src/utils.ts
+++ b/packages/sdk/src/utils.ts
@@ -15,18 +15,33 @@ import {
   type ContractFunctionArgs,
   decodeFunctionData,
 } from 'viem';
+import type { WriteContractParameters } from 'viem/actions';
 import { NoContractAddressUponReceiptError } from './errors';
 
-// biome-ignore lint/suspicious/noExplicitAny: <explanation>
-export type CallParams<T extends (_c: any, params: any) => any> = Omit<
-  Parameters<T>[1],
-  'address' | 'args'
+export type WriteParams<
+  abi extends Abi,
+  functionName extends ContractFunctionName<abi>,
+> = Partial<
+  Omit<
+    WriteContractParameters<abi, functionName>,
+    'address' | 'args' | 'functionName' | 'abi'
+  >
+>;
+
+export type ReadParams<
+  abi extends Abi,
+  functionName extends ContractFunctionName<abi>,
+> = Partial<
+  Omit<
+    WriteContractParameters<abi, functionName>,
+    'address' | 'args' | 'functionName' | 'abi'
+  >
 >;
 
 export async function getDeployedContractAddress(
   config: Config,
   hash: Promise<Hash>,
-  waitParams: Omit<WaitForTransactionReceiptParameters, 'hash'> = {},
+  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,
 ) {
   const receipt = await waitForTransactionReceipt(config, {
     ...waitParams,
@@ -49,7 +64,7 @@ export async function awaitResult<
     undefined,
     functionName
   >,
-  waitParams: Omit<WaitForTransactionReceiptParameters, 'hash'> = {},
+  waitParams?: Omit<WaitForTransactionReceiptParameters, 'hash'>,
 ) {
   const hash = await hashPromise;
   const receipt = await waitForTransactionReceipt(config, {