diff --git a/examples/web/index.html b/examples/web/index.html
index accefa71..0e08277c 100644
--- a/examples/web/index.html
+++ b/examples/web/index.html
@@ -23,7 +23,7 @@
     </script>
 
     <script type="module" defer>
-      import { ArIO } from 'https://unpkg.com/@ar.io/sdk@1.0.0';
+      import { ArIO } from '../../bundles/web.bundle.min.js';
 
       const arIO = ArIO.init();
 
diff --git a/package.json b/package.json
index 52c371db..df9c0937 100644
--- a/package.json
+++ b/package.json
@@ -73,7 +73,7 @@
     "prepare": "husky install",
     "example:mjs": "yarn build:esm && node examples/node/index.mjs",
     "example:cjs": "yarn build:cjs && node examples/node/index.cjs",
-    "example:web": "yarn build:web && cp -r bundles/* examples/web && http-server --port 8080 --host -o examples/web"
+    "example:web": "yarn build:web && http-server --port 8080 --host -o examples/web"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.1.2",
diff --git a/src/common.ts b/src/common.ts
index 84068ed1..a2f58e8e 100644
--- a/src/common.ts
+++ b/src/common.ts
@@ -44,13 +44,18 @@ export type TransactionId = string;
 
 // TODO: append this with other configuration options (e.g. local vs. remote evaluation)
 export type ContractSigner = ArweaveSigner | ArconnectSigner;
-export type WithSigner = { signer: ContractSigner }; // TODO: optionally allow JWK in place of signer
-export type ContractConfiguration =
+export type WithSigner<T = NonNullable<unknown>> = {
+  signer: ContractSigner;
+} & T; // TODO: optionally allow JWK in place of signer
+export type OptionalSigner<T = NonNullable<unknown>> = {
+  signer?: ContractSigner;
+} & T;
+export type ContractConfiguration<T = NonNullable<unknown>> =
   | {
-      contract?: WarpContract<unknown> | RemoteContract<unknown>;
+      contract?: WarpContract<T> | RemoteContract<T>;
     }
   | {
-      contractTxId: string;
+      contractTxId?: string;
     };
 
 export type EvaluationOptions = {
@@ -63,13 +68,15 @@ export type EvaluationParameters<T = NonNullable<unknown>> = {
   evaluationOptions?: EvaluationOptions | Record<string, never> | undefined;
 } & T;
 
-export type WriteParameters<Input> = {
+export type ReadParameters<Input> = {
   functionName: string;
-  inputs: Input;
-  dryWrite?: boolean;
-  // TODO: add syncState and abortSignal options
+  inputs?: Input;
 };
 
+export type WriteParameters<Input> = WithSigner<
+  Required<ReadParameters<Input>>
+>;
+
 export interface BaseContract<T> {
   getState(params: EvaluationParameters): Promise<T>;
 }
@@ -79,10 +86,7 @@ export interface ReadContract {
     functionName,
     inputs,
     evaluationOptions,
-  }: EvaluationParameters<{
-    functionName: string;
-    inputs?: Input;
-  }>): Promise<State>;
+  }: EvaluationParameters<ReadParameters<Input>>): Promise<State>;
 }
 
 export interface WriteContract {
@@ -95,15 +99,6 @@ export interface WriteContract {
   >): Promise<WriteInteractionResult>;
 }
 
-export interface SmartWeaveContract<T> {
-  getContractState(params: EvaluationParameters): Promise<T>;
-  readInteraction<I, K>({
-    functionName,
-    inputs,
-    evaluationOptions,
-  }: EvaluationParameters<{ functionName: string; inputs?: I }>): Promise<K>;
-}
-
 // TODO: extend with additional methods
 export interface ArIOReadContract extends BaseContract<ArIOState> {
   getGateway({
@@ -139,9 +134,9 @@ export interface ArIOReadContract extends BaseContract<ArIOState> {
   getEpoch({
     blockHeight,
     evaluationOptions,
-  }: {
+  }: EvaluationParameters<{
     blockHeight: number;
-  } & EvaluationParameters): Promise<EpochDistributionData>;
+  }>): Promise<EpochDistributionData>;
   getCurrentEpoch({
     evaluationOptions,
   }: EvaluationParameters): Promise<EpochDistributionData>;
diff --git a/src/common/ant.ts b/src/common/ant.ts
index 4b22dd1d..96902067 100644
--- a/src/common/ant.ts
+++ b/src/common/ant.ts
@@ -23,6 +23,7 @@ import {
   ContractSigner,
   EvaluationOptions,
   EvaluationParameters,
+  OptionalSigner,
   WithSigner,
   WriteInteractionResult,
 } from '../types.js';
@@ -47,15 +48,18 @@ export class ANT {
    * ANT.createContract({ contractTxId: 'myContractTxId' });
    * ```
    */
-  static createContract(config: ContractConfiguration): WarpContract<ANTState> {
+  static createWriteableContract(
+    config: Required<ContractConfiguration<ANTState>>,
+  ): WarpContract<ANTState> {
     if (isContractConfiguration<ANTState>(config)) {
-      if (config.contract instanceof WarpContract) {
-        return config.contract;
-      }
+      return config.contract instanceof WarpContract
+        ? config.contract
+        : new WarpContract<ANTState>(config.contract.configuration());
     } else if (isContractTxIdConfiguration(config)) {
       return new WarpContract<ANTState>({ contractTxId: config.contractTxId });
+    } else {
+      throw new InvalidContractConfigurationError();
     }
-    throw new InvalidContractConfigurationError();
   }
 
   /**
@@ -82,23 +86,20 @@ export class ANT {
    * const readable = ANT.init({ contract: myContract });
    * ```
    */
-  static init(
-    config: ContractConfiguration &
-      WithSigner &
-      ({ contract: WarpContract<ANTState> } | { contractTxId: string }),
-  ): ANTWritable;
-  static init(
-    config?: ContractConfiguration &
-      ({ contract?: RemoteContract<ANTState> } | { contractTxId: string }),
-  ): ANTReadable;
-  static init(
-    config: ContractConfiguration & {
-      signer?: ContractSigner;
-    } = {},
-  ) {
-    if (config?.signer) {
-      const signer = config.signer;
-      const contract = this.createContract(config);
+  static init(config: Required<ContractConfiguration<ANTState>>): ANTReadable;
+  static init({
+    signer,
+    ...config
+  }: WithSigner<
+    // must be a WarpContract to get a ArIOWriteable
+    { contract: WarpContract<ANTState> } | { contractTxId: string }
+  >): ANTWritable;
+  static init({
+    signer,
+    ...config
+  }: OptionalSigner<Required<ContractConfiguration<ANTState>>>) {
+    if (signer) {
+      const contract = this.createWriteableContract(config);
       return new ANTWritable({ signer, contract });
     } else {
       return new ANTReadable(config);
@@ -109,13 +110,15 @@ export class ANT {
 export class ANTReadable implements ANTReadContract {
   protected contract: RemoteContract<ANTState> | WarpContract<ANTState>;
 
-  constructor(config: ContractConfiguration) {
+  constructor(config: Required<ContractConfiguration<ANTState>>) {
     if (isContractConfiguration<ANTState>(config)) {
       this.contract = config.contract;
     } else if (isContractTxIdConfiguration(config)) {
       this.contract = new RemoteContract<ANTState>({
         contractTxId: config.contractTxId,
       });
+    } else {
+      throw new InvalidContractConfigurationError();
     }
   }
 
@@ -325,7 +328,7 @@ export class ANTReadable implements ANTReadContract {
     evaluationOptions,
   }: EvaluationParameters<{ address: string }>): Promise<number> {
     const balances = await this.getBalances({ evaluationOptions });
-    return balances[address];
+    return balances[address] || 0;
   }
 }
 
@@ -334,11 +337,24 @@ export class ANTWritable extends ANTReadable {
   private signer: ContractSigner;
 
   constructor({
-    contract,
     signer,
-  }: { contract: WarpContract<ANTState> } & WithSigner) {
-    super({ contract });
-    this.signer = signer;
+    ...config
+  }: WithSigner<
+    { contract: WarpContract<ANTState> } | { contractTxId: string }
+  >) {
+    if (isContractConfiguration<ANTState>(config)) {
+      super({ contract: config.contract });
+      this.signer = signer;
+    } else if (isContractTxIdConfiguration(config)) {
+      super({
+        contract: new WarpContract<ANTState>({
+          contractTxId: config.contractTxId,
+        }),
+      });
+      this.signer = signer;
+    } else {
+      throw new InvalidContractConfigurationError();
+    }
   }
 
   /**
diff --git a/src/common/ar-io.ts b/src/common/ar-io.ts
index e329f142..b6d4e9c3 100644
--- a/src/common/ar-io.ts
+++ b/src/common/ar-io.ts
@@ -31,6 +31,7 @@ import {
   Gateway,
   JoinNetworkParams,
   Observations,
+  OptionalSigner,
   RegistrationType,
   TransactionId,
   UpdateGatewaySettingsParams,
@@ -60,60 +61,80 @@ export class ArIO {
    * ArIO.createContract({ contractTxId: 'myContractTxId' });
    * ```
    */
-  static createContract(
-    config: ContractConfiguration,
+  static createWriteableContract(
+    config?: ContractConfiguration<ArIOState>,
   ): WarpContract<ArIOState> {
-    if (isContractConfiguration<ArIOState>(config)) {
-      if (config.contract instanceof WarpContract) {
-        return config.contract;
-      }
+    if (!config || Object.keys(config).length === 0) {
+      return new WarpContract<ArIOState>({
+        contractTxId: ARNS_TESTNET_REGISTRY_TX,
+      });
+    } else if (isContractConfiguration<ArIOState>(config)) {
+      return config.contract instanceof WarpContract
+        ? config.contract
+        : new WarpContract<ArIOState>(config.contract.configuration());
     } else if (isContractTxIdConfiguration(config)) {
       return new WarpContract<ArIOState>({ contractTxId: config.contractTxId });
+    } else {
+      throw new InvalidContractConfigurationError();
     }
-    throw new InvalidContractConfigurationError();
   }
 
   /**
    * Initializes an ArIO instance.
    *
-   * There are two overloads for this function:
-   * 1. When a signer is provided in the configuration, it returns an instance of ArIOWritable.
-   * 2. When a signer is NOT provided in the configuration, it returns an instance of ArIOReadable.
+   * There are multiple overloads for this function:
+   * 1. When nothing is provided, it returns an instance of ArIOReadable.
+   * 1. When a signer is provided, it returns an instance of ArIOWritable.
+   * 2. When a signer is NOT provided, it returns an instance of ArIOReadable.
    *
-   *
-   * @param {ContractConfiguration & WithSigner} config - The configuration object.
+   * @param {WithSigner<ContractConfiguration<ArIOState>>} config - The configuration object.
    *    If a signer is provided, it should be an object that implements the ContractSigner interface.
    *
    * @returns {ArIOWritable | ArIOReadable} - An instance of ArIOWritable if a signer is provided, otherwise an instance of ArIOReadable.
    * @throws {Error} - Throws an error if the configuration is invalid.
    *
    * @example
-   * Overload 1: When signer is provided
+   * Overload 1: When nothing is provide, ArIOReadable is returned.
    * ```ts
-   * const writable = ArIO.init({ signer: mySigner, contract: myContract });
-   *```
-   * Overload 2: When signer is not provided
+   * const readable = ArIO.init();
+   * ```
+   * Overload 2: When signer is not provided with contract, ArIOReadable is returned.
    * ```ts
    * const readable = ArIO.init({ contract: myContract });
    * ```
+   * Overload 3: When signer is not provided with a contractTxId, ArIOReadable is returned.
+   * ```ts
+   * const readable = ArIO.init({ contractTxId: 'myContractTxId' });
+   * ```
+   * Overload 4: When signer is provided without any contract configuration, ArIOWritable is returned.
+   * ```ts
+   * const writable = ArIO.init({ signer: mySigner });
+   *```
+   * Overload 5: When signer is provided with a contract configuration, ArIOWritable is returned.
+   * ```ts
+   * const writable = ArIO.init({ signer: mySigner, contract: myContract });
+   * ```
+   * Overload 6: When signer is provided with a contractTxId, ArIOWritable is returned.
+   * ```ts
+   * const writable = ArIO.init({ signer: mySigner, contractTxId: 'myContractTxId' });
+   * ```
    */
+  static init(): ArIOReadable;
+  static init({ signer }: WithSigner): ArIOWritable;
   static init(
-    config: ContractConfiguration &
-      WithSigner &
-      ({ contract: WarpContract<ArIOState> } | { contractTxId: string }),
-  ): ArIOWritable;
-  static init(
-    config?: ContractConfiguration &
-      ({ contract?: RemoteContract<ArIOState> } | { contractTxId: string }),
+    config?: Required<ContractConfiguration<ArIOState>>,
   ): ArIOReadable;
-  static init(
-    config: ContractConfiguration & {
-      signer?: ContractSigner;
-    } = {},
-  ) {
-    if (config?.signer) {
-      const signer = config.signer;
-      const contract = this.createContract(config);
+  static init({
+    signer,
+    ...config
+  }: WithSigner<
+    // must be a WarpContract to get a ArIOWriteable
+    { contract: WarpContract<ArIOState> } | { contractTxId: string }
+  >): ArIOWritable;
+  static init(config?: OptionalSigner<ContractConfiguration<ArIOState>>) {
+    if (config && config.signer) {
+      const { signer, ...rest } = config;
+      const contract = this.createWriteableContract(rest);
       return new ArIOWritable({ signer, contract });
     } else {
       return new ArIOReadable(config);
@@ -124,21 +145,19 @@ export class ArIO {
 export class ArIOReadable implements ArIOReadContract {
   protected contract: RemoteContract<ArIOState> | WarpContract<ArIOState>;
 
-  constructor(
-    config: ContractConfiguration = {
-      contract: new RemoteContract<ArIOState>({
+  constructor(config?: ContractConfiguration<ArIOState>) {
+    if (!config) {
+      this.contract = new RemoteContract<ArIOState>({
         contractTxId: ARNS_TESTNET_REGISTRY_TX,
-      }),
-    },
-  ) {
-    if (isContractConfiguration<ArIOState>(config)) {
+      });
+    } else if (isContractConfiguration<ArIOState>(config)) {
       this.contract = config.contract;
     } else if (isContractTxIdConfiguration(config)) {
       this.contract = new RemoteContract<ArIOState>({
         contractTxId: config.contractTxId,
       });
     } else {
-      throw new Error('Invalid configuration.');
+      throw new InvalidContractConfigurationError();
     }
   }
 
@@ -512,13 +531,34 @@ export class ArIOWritable extends ArIOReadable implements ArIOWriteContract {
   protected declare contract: WarpContract<ArIOState>;
   private signer: ContractSigner;
   constructor({
-    contract,
     signer,
-  }: {
-    contract: WarpContract<ArIOState>;
-  } & WithSigner) {
-    super({ contract });
-    this.signer = signer;
+    ...config
+  }: WithSigner<
+    | {
+        contract?: WarpContract<ArIOState>;
+      }
+    | { contractTxId?: string }
+  >) {
+    if (Object.keys(config).length === 0) {
+      super({
+        contract: new WarpContract<ArIOState>({
+          contractTxId: ARNS_TESTNET_REGISTRY_TX,
+        }),
+      });
+      this.signer = signer;
+    } else if (isContractConfiguration<ArIOState>(config)) {
+      super({ contract: config.contract });
+      this.signer = signer;
+    } else if (isContractTxIdConfiguration(config)) {
+      super({
+        contract: new WarpContract<ArIOState>({
+          contractTxId: config.contractTxId,
+        }),
+      });
+      this.signer = signer;
+    } else {
+      throw new InvalidContractConfigurationError();
+    }
   }
 
   /**
diff --git a/src/common/arweave.ts b/src/common/arweave.ts
new file mode 100644
index 00000000..2d573c29
--- /dev/null
+++ b/src/common/arweave.ts
@@ -0,0 +1,23 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc. All Rights Reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import Arweave from 'arweave';
+
+export const defaultArweave = Arweave.init({
+  host: 'arweave.net',
+  port: 443,
+  protocol: 'https',
+});
diff --git a/src/common/contracts/warp-contract.ts b/src/common/contracts/warp-contract.ts
index 927b2cd1..34d3c8f8 100644
--- a/src/common/contracts/warp-contract.ts
+++ b/src/common/contracts/warp-contract.ts
@@ -24,12 +24,12 @@ import {
   Warp,
 } from 'warp-contracts';
 
-import { defaultWarp } from '../../constants.js';
 import {
   BaseContract,
   ContractSigner,
   EvaluationParameters,
   Logger,
+  OptionalSigner,
   ReadContract,
   WriteContract,
   WriteInteractionResult,
@@ -39,6 +39,7 @@ import { sha256B64Url, toB64Url } from '../../utils/base64.js';
 import { getContractManifest } from '../../utils/smartweave.js';
 import { FailedRequestError, WriteInteractionError } from '../error.js';
 import { DefaultLogger } from '../logger.js';
+import { defaultWarp } from '../warp.js';
 
 LoggerFactory.INST.setOptions({
   logLevel: 'fatal',
@@ -55,7 +56,7 @@ export class WarpContract<T>
 
   constructor({
     contractTxId,
-    cacheUrl,
+    cacheUrl = 'https://api.arns.app',
     warp = defaultWarp,
     logger = new DefaultLogger({
       level: 'info',
@@ -99,8 +100,6 @@ export class WarpContract<T>
       },
       type: 'arweave',
     });
-    //this.contract = this.contract.connect(warpSigner);
-    //this.signer = warpSigner;
     return warpSigner;
   }
 
@@ -122,11 +121,7 @@ export class WarpContract<T>
     return evaluationResult.cachedValue.state as T;
   }
 
-  async ensureContractInit({
-    signer,
-  }: {
-    signer?: ContractSigner;
-  } = {}): Promise<void> {
+  async ensureContractInit({ signer }: OptionalSigner = {}): Promise<void> {
     this.logger.debug(`Checking contract initialized`, {
       contractTxId: this.contractTxId,
     });
@@ -190,9 +185,7 @@ export class WarpContract<T>
     inputs,
     signer,
     // TODO: support dryWrite
-  }: EvaluationParameters<WriteParameters<Input>> & {
-    signer: ContractSigner;
-  }): Promise<WriteInteractionResult> {
+  }: WriteParameters<Input>): Promise<WriteInteractionResult> {
     try {
       this.logger.debug(`Write interaction: ${functionName}`, {
         contractTxId: this.contractTxId,
diff --git a/src/common/warp.ts b/src/common/warp.ts
new file mode 100644
index 00000000..cb94e6f8
--- /dev/null
+++ b/src/common/warp.ts
@@ -0,0 +1,28 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc. All Rights Reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+import { WarpFactory, defaultCacheOptions } from 'warp-contracts';
+
+import { defaultArweave } from './arweave.js';
+
+export const defaultWarp = WarpFactory.forMainnet(
+  {
+    ...defaultCacheOptions,
+    inMemory: true,
+  },
+  true,
+  defaultArweave,
+);
diff --git a/src/constants.ts b/src/constants.ts
index 8a2b45f1..d5651686 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -14,9 +14,6 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-import Arweave from 'arweave';
-import { WarpFactory, defaultCacheOptions } from 'warp-contracts';
-
 export const ARWEAVE_TX_REGEX = new RegExp('^[a-zA-Z0-9_-]{43}$');
 // sortkey: padded blockheight to 12, JS timestamp, hash of transactionID + block hash. Timestamp only applicable to L2 and normally is all zeros.
 export const SORT_KEY_REGEX = new RegExp(
@@ -27,18 +24,3 @@ export const ARNS_TESTNET_REGISTRY_TX =
 
 export const ARNS_DEVNET_REGISTRY_TX =
   '_NctcA2sRy1-J4OmIQZbYFPM17piNcbdBPH2ncX2RL8';
-
-export const defaultArweave = Arweave.init({
-  host: 'ar-io.dev',
-  port: 443,
-  protocol: 'https',
-});
-
-export const defaultWarp = WarpFactory.forMainnet(
-  {
-    ...defaultCacheOptions,
-    inMemory: true,
-  },
-  true,
-  defaultArweave,
-);
diff --git a/src/utils/smartweave.ts b/src/utils/smartweave.ts
index c1719cb9..a38dce97 100644
--- a/src/utils/smartweave.ts
+++ b/src/utils/smartweave.ts
@@ -17,9 +17,9 @@
 import Arweave from 'arweave';
 import { EvaluationManifest } from 'warp-contracts';
 
-import { ContractConfiguration, SortKey } from '../common.js';
 import { RemoteContract, WarpContract } from '../common/index.js';
 import { SORT_KEY_REGEX } from '../constants.js';
+import { ContractConfiguration, SortKey } from '../types.js';
 import { tagsToObject, validateArweaveId } from './arweave.js';
 
 export function isSortKey(sortKey: string): sortKey is SortKey {
@@ -65,7 +65,9 @@ export async function getContractManifest({
   arweave: Arweave;
   contractTxId: string;
 }): Promise<EvaluationManifest> {
-  const { tags: encodedTags } = await arweave.transactions.get(contractTxId);
+  const { tags: encodedTags } = await arweave.transactions
+    .get(contractTxId)
+    .catch(() => ({ tags: [] }));
   const decodedTags = tagsToObject(encodedTags);
   const contractManifestString = decodedTags['Contract-Manifest'] ?? '{}';
   // TODO throw if manifest is missing
@@ -74,7 +76,7 @@ export async function getContractManifest({
 }
 
 export function isContractConfiguration<T>(
-  config: ContractConfiguration,
+  config: ContractConfiguration<T>,
 ): config is {
   contract: WarpContract<T> | RemoteContract<T>;
 } {
@@ -85,6 +87,8 @@ export function isContractTxIdConfiguration(
   config: ContractConfiguration,
 ): config is { contractTxId: string } {
   return (
-    'contractTxId' in config && validateArweaveId(config.contractTxId) === true
+    'contractTxId' in config &&
+    typeof config.contractTxId === 'string' &&
+    validateArweaveId(config.contractTxId) === true
   );
 }
diff --git a/tests/integration/ant.test.ts b/tests/integration/ant.test.ts
index 0aedb34c..ae4411bc 100644
--- a/tests/integration/ant.test.ts
+++ b/tests/integration/ant.test.ts
@@ -1,19 +1,15 @@
-import { ArweaveSigner } from 'arbundles';
-
 import { ANT, ANTReadable } from '../../src/common/ant';
 import { RemoteContract } from '../../src/common/contracts/remote-contract';
 import { WarpContract } from '../../src/common/contracts/warp-contract';
 import { DefaultLogger } from '../../src/common/logger';
 import { ANTState } from '../../src/contract-state';
 import {
-  arweave,
   evaluateToBlockHeight,
   evaluateToSortKey,
+  localCacheUrl,
+  warp,
 } from '../constants';
 
-const contractTxId = 'UC2zwawQoTnh0TNd9mYLQS4wObBBeaOU5LPQTNETqA4';
-const localCacheUrl = `https://api.arns.app`;
-
 const testCases = [
   [{ sortKey: evaluateToSortKey.toString() }],
   [{ blockHeight: evaluateToBlockHeight }],
@@ -21,12 +17,20 @@ const testCases = [
 ] as const;
 
 describe('ANT contract apis', () => {
-  const ant = ANT.init({
-    contract: new RemoteContract<ANTState>({
-      cacheUrl: localCacheUrl,
-      contractTxId,
-      logger: new DefaultLogger({ level: 'none' }),
-    }),
+  let ant: ANTReadable;
+  let contractTxId: string;
+  let ownerAddress: string;
+
+  beforeAll(() => {
+    contractTxId = process.env.DEPLOYED_ANT_CONTRACT_TX_ID!;
+    ownerAddress = process.env.PRIMARY_WALLET_ADDRESS!;
+    ant = ANT.init({
+      contract: new RemoteContract<ANTState>({
+        cacheUrl: localCacheUrl,
+        contractTxId,
+        logger: new DefaultLogger({ level: 'none' }),
+      }),
+    });
   });
 
   it('should connect and return a valid instance', async () => {
@@ -81,48 +85,46 @@ describe('ANT contract apis', () => {
   it.each(testCases)(
     `should get name with evaluation options: ${JSON.stringify('%s')}`,
     async (evalTo) => {
-      const state = await ant.getName({ evaluationOptions: { evalTo } });
-      expect(state).toBeDefined();
+      const name = await ant.getName({ evaluationOptions: { evalTo } });
+      expect(name).toBeDefined();
     },
   );
 
   it.each(testCases)(
     `should get ticker with evaluation options: ${JSON.stringify('%s')}`,
     async (evalTo) => {
-      const state = await ant.getTicker({ evaluationOptions: { evalTo } });
-      expect(state).toBeDefined();
+      const ticker = await ant.getTicker({ evaluationOptions: { evalTo } });
+      expect(ticker).toBeDefined();
     },
   );
 
   it.each(testCases)(
     `should get balances with evaluation options: ${JSON.stringify('%s')}`,
     async (evalTo) => {
-      const state = await ant.getBalances({ evaluationOptions: { evalTo } });
-      expect(state).toBeDefined();
+      const balances = await ant.getBalances({ evaluationOptions: { evalTo } });
+      expect(balances).toBeDefined();
     },
   );
 
   it.each(testCases)(
     `should get balance with evaluation options: ${JSON.stringify('%s')}`,
     async (evalTo) => {
-      const state = await ant.getBalance({
-        address: 'TRVCopHzzO1VSwRUUS8umkiO2MpAL53XtVGlLaJuI94',
+      const balance = await ant.getBalance({
+        address: ownerAddress,
         evaluationOptions: { evalTo },
       });
-      expect(state).toBeDefined();
+      expect(balance).toBeDefined();
     },
   );
 
   it('should get state with warp contract', async () => {
-    const jwk = await arweave.wallets.generate();
-    const signer = new ArweaveSigner(jwk);
-    ANT.init({
+    const ant = ANT.init({
       contract: new WarpContract<ANTState>({
         cacheUrl: localCacheUrl,
         contractTxId,
         logger: new DefaultLogger({ level: 'none' }),
+        warp,
       }),
-      signer,
     });
     const state = await ant.getState();
     expect(state).toBeDefined();
diff --git a/tests/integration/ar-io.test.ts b/tests/integration/ar-io.test.ts
index 2552ab0b..0d05f896 100644
--- a/tests/integration/ar-io.test.ts
+++ b/tests/integration/ar-io.test.ts
@@ -28,6 +28,18 @@ describe('ArIO Factory', () => {
     signer = new ArweaveSigner(JSON.parse(process.env.PRIMARY_WALLET_JWK!));
   });
 
+  it('should return a readable without any configuration provided', () => {
+    const readable = ArIO.init();
+    expect(readable).toBeDefined();
+    expect(readable).toBeInstanceOf(ArIOReadable);
+  });
+
+  it('should return a writable without any configuration provided', () => {
+    const writable = ArIO.init({ signer });
+    expect(writable).toBeDefined();
+    expect(writable).toBeInstanceOf(ArIOWritable);
+  });
+
   it('should return a valid instance of ArIOWritable with contract config', async () => {
     const writeClient = ArIO.init({
       signer,
diff --git a/tests/unit/utils-smartweave.test.ts b/tests/unit/utils-smartweave.test.ts
index 3c12c065..c0744af9 100644
--- a/tests/unit/utils-smartweave.test.ts
+++ b/tests/unit/utils-smartweave.test.ts
@@ -1,5 +1,6 @@
 import { RemoteContract, WarpContract } from '../../src/common/index.js';
 import { ARNS_DEVNET_REGISTRY_TX } from '../../src/constants.js';
+import { ArIOState } from '../../src/contract-state.js';
 import {
   isContractConfiguration,
   isContractTxIdConfiguration,
@@ -7,7 +8,7 @@ import {
 
 describe('smartweave', () => {
   const contractConfig = {
-    contract: new WarpContract({
+    contract: new WarpContract<ArIOState>({
       contractTxId: ARNS_DEVNET_REGISTRY_TX,
     }),
   };
diff --git a/tsconfig.web.json b/tsconfig.web.json
index 4380fb06..ee047241 100644
--- a/tsconfig.web.json
+++ b/tsconfig.web.json
@@ -2,6 +2,9 @@
   "extends": "./tsconfig.json",
   "include": ["src/web", "src/common", "src/utils"],
   "compilerOptions": {
-    "outDir": "./lib/web"
+    "outDir": "./lib/web",
+    "paths": {
+      "arweave": ["./node_modules/arweave/node/index.js"]
+    }
   }
 }