fix(tests): remove dryWrite from writeInteraction, update tests

We will add `dryWrite` support in a separate PR. Additionally standardizes tests to proper format so we can move away from `setupTest` to `globalSetup` to avoid duplicate instantiation of contracts

docker-compose.yaml

@@ -5,17 +5,20 @@ services:
     image: textury/arlocal:v1.1.35
     ports:
       - '1984:1984'
+
   arns-service:
     image: ghcr.io/ar-io/arns-service:latest
     build: .
     ports:
       - '3000:3000'
+    volumes:
+      - ./cache:/usr/src/app/cache
     environment:
-      - LOG_LEVEL=debug
+      - LOG_LEVEL=error
       - GATEWAY_HOST=arlocal
       - GATEWAY_PORT=1984
       - GATEWAY_PROTOCOL=http
-      - PREFETCH_CONTRACTS=true
+      - PREFETCH_CONTRACTS=false
       - BOOTSTRAP_CONTRACTS=false
     healthcheck:
       test: ['CMD', 'curl', '-f', 'http://localhost:3000/healthcheck']

package.json

@@ -69,7 +69,7 @@
     "format:fix": "prettier --write .",
     "test": "yarn test:unit && yarn test:integration",
     "test:unit": "yarn clean && jest --config=jest.config.mjs",
-    "test:integration": "yarn clean && docker compose up -d && jest --config=jest.integration.config.mjs --runInBand && docker compose down",
+    "test:integration": "yarn clean && docker compose up -d && jest --config=jest.integration.config.mjs --runInBand && docker compose down -v",
     "prepare": "husky install",
     "example:mjs": "yarn build:esm && node examples/node/index.mjs",
     "example:cjs": "yarn build:cjs && node examples/node/index.cjs",

src/common.ts

@@ -16,7 +16,7 @@
  */
 import { ArconnectSigner, ArweaveSigner } from 'arbundles';
 import { DataItem } from 'warp-arbundles';
-import { InteractionResult, Transaction } from 'warp-contracts';
+import { Transaction } from 'warp-contracts';
 
 import { RemoteContract, WarpContract } from './common/index.js';
 import {
@@ -90,9 +90,9 @@ export interface WriteContract {
     functionName,
     inputs,
     evaluationOptions,
-  }: EvaluationParameters<WriteParameters<Input>>): Promise<
-    Transaction | DataItem | InteractionResult<unknown, unknown>
-  >;
+  }: EvaluationParameters<
+    WriteParameters<Input>
+  >): Promise<WriteInteractionResult>;
 }
 
 export interface SmartWeaveContract<T> {
@@ -225,10 +225,7 @@ export interface ArIOWriteContract {
   }): Promise<WriteInteractionResult>;
 }
 
-export type WriteInteractionResult =
-  | Transaction
-  | DataItem
-  | InteractionResult<unknown, unknown>;
+export type WriteInteractionResult = Transaction | DataItem;
 
 export type JoinNetworkParams = GatewayConnectionSettings &
   GatewayStakingSettings &

src/common/contracts/warp-contract.ts

@@ -15,11 +15,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 import { ArconnectSigner } from 'arbundles';
-import { DataItem } from 'warp-arbundles';
 import {
   Contract,
   CustomSignature,
-  InteractionResult,
   LoggerFactory,
   Signature,
   Transaction,
@@ -34,6 +32,7 @@ import {
   Logger,
   ReadContract,
   WriteContract,
+  WriteInteractionResult,
   WriteParameters,
 } from '../../types.js';
 import { sha256B64Url, toB64Url } from '../../utils/base64.js';
@@ -136,10 +135,16 @@ export class WarpContract<T>
     this.logger.debug(`Fetching contract manifest`, {
       contractTxId: this.contractTxId,
     });
+
+    console.log('Fetching contract manifest', {
+      contractTxId: this.contractTxId,
+      warp: this.warp.arweave,
+    });
     const { evaluationOptions = {} } = await getContractManifest({
       arweave: this.warp.arweave,
       contractTxId: this.contractTxId,
     });
+
     this.contract.setEvaluationOptions(evaluationOptions);
 
     if (signer) this.contract.connect(await this.createWarpSigner(signer));
@@ -183,14 +188,15 @@ export class WarpContract<T>
 
     return evaluationResult.result;
   }
+
   async writeInteraction<Input>({
     functionName,
     inputs,
-    dryWrite = false,
     signer,
+    // TODO: support dryWrite
   }: EvaluationParameters<WriteParameters<Input>> & {
     signer: ContractSigner;
-  }): Promise<Transaction | DataItem | InteractionResult<unknown, unknown>> {
+  }): Promise<WriteInteractionResult> {
     try {
       this.logger.debug(`Write interaction: ${functionName}`, {
         contractTxId: this.contractTxId,
@@ -209,13 +215,6 @@ export class WarpContract<T>
         );
       }
 
-      if (dryWrite) {
-        this.logger.debug(`Dry write interaction successful`, {
-          contractTxId: this.contractTxId,
-          functionName,
-        });
-        return result;
-      }
       const writeResult = await this.contract.writeInteraction<Input>({
         function: functionName,
         ...inputs,
@@ -227,6 +226,7 @@ export class WarpContract<T>
 
       return writeResult.interactionTx;
     } catch (error) {
+      console.log(error);
       throw new WriteInteractionError(error.message);
     }
   }

src/common/http.ts

@@ -61,6 +61,8 @@ export class AxiosHTTPService implements HTTPClient {
       signal,
       params,
     });
+    this.logger.debug(`Response status: ${status} ${statusText}`);
+
     if (!allowedStatuses.includes(status)) {
       switch (status) {
         case 404:

tests/constants.ts

@@ -9,7 +9,7 @@ import { DeployPlugin } from 'warp-contracts-plugin-deploy';
 import { SmartWeaveSortKey } from '../src/utils';
 
 export const GATEWAY_PORT = process.env.GATEWAY_PORT ?? 1984;
-export const GATEWAY_HOST = process.env.GATEWAY_HOST ?? '127.0.0.1';
+export const GATEWAY_HOST = process.env.GATEWAY_HOST ?? 'localhost';
 export const GATEWAY_PROTOCOL = process.env.GATEWAY_PROTOCOL ?? 'http';
 // Arweave
 export const arweave = new Arweave({
@@ -26,9 +26,9 @@ export const warp = WarpFactory.forLocal(undefined, arweave, {
 
 export const gatewayAddress = '1H7WZIWhzwTH9FIcnuMqYkTsoyv1OTfGa_amvuYwrgo';
 export const testDomain = 'angela';
-export const evaluateToBlockHeight = 1377100;
+export const evaluateToBlockHeight = 1;
 export const evaluateToSortKey = new SmartWeaveSortKey(
-  '000001376946,0000000000000,18d52956c8e13ae1f557b4e67f6f298b8ffd2a5cd96e42ec24ca649b7401510f',
+  '000000000000,0000000000000,0000000000000000000000000000000000000000000000000000000000000000',
 );
 export const localCacheUrl =
   process.env.REMOTE_CACHE_URL || 'http://localhost:3000';

tests/integration/ant-writable.test.ts

@@ -1,14 +1,10 @@
 import { ArweaveSigner } from 'arbundles';
 
-import { ANT, WarpContract } from '../../src/common/index.js';
+import { ANT, ANTWritable, WarpContract } from '../../src/common/index.js';
 import { DefaultLogger } from '../../src/common/logger.js';
 import { ANTState } from '../../src/contract-state.js';
 import { localCacheUrl, warp } from '../constants.js';
 
-const signer = new ArweaveSigner(JSON.parse(process.env.PRIMARY_WALLET_JWK!));
-
-const contractTxId = process.env.DEPLOYED_ANT_CONTRACT_TX_ID!;
-
 const writeTestCases = Object.entries({
   setController: { controller: ''.padEnd(43, 'a') },
   removeController: { controller: ''.padEnd(43, 'a') },
@@ -24,20 +20,28 @@ const writeTestCases = Object.entries({
 });
 
 describe('ANT Writable', () => {
+  let signer: ArweaveSigner;
+  let contractTxId: string;
+  let antWritable: ANTWritable;
+
+  beforeAll(() => {
+    contractTxId = process.env.DEPLOYED_ANT_CONTRACT_TX_ID!;
+    signer = new ArweaveSigner(JSON.parse(process.env.PRIMARY_WALLET_JWK!));
+    antWritable = ANT.init({
+      contract: new WarpContract<ANTState>({
+        cacheUrl: localCacheUrl,
+        contractTxId,
+        logger: new DefaultLogger({ level: 'none' }),
+        warp: warp,
+      }),
+      signer,
+    });
+  });
+
   it.each(writeTestCases)(
     'should execute write operation: %s',
     async (method, inputs) => {
-      const antWritable = ANT.init({
-        contract: new WarpContract<ANTState>({
-          cacheUrl: localCacheUrl,
-          contractTxId,
-          logger: new DefaultLogger({ level: 'none' }),
-          warp: warp,
-        }),
-        signer,
-      });
       const result = await antWritable[method](inputs);
-
       expect(result).toBeDefined();
     },
   );

tests/integration/ar-io-writable.test.ts

@@ -1,14 +1,11 @@
 import { ArweaveSigner } from 'arbundles';
 
-import { WriteInteractionResult } from '../../src/common.js';
-import { ArIO } from '../../src/common/ar-io.js';
+import { ArIO, ArIOWritable } from '../../src/common/ar-io.js';
 import { WarpContract } from '../../src/common/index.js';
 import { DefaultLogger } from '../../src/common/logger.js';
 import { ArIOState } from '../../src/contract-state.js';
-import { localCacheUrl, warp } from '../constants.js';
+import { gatewayAddress, localCacheUrl, warp } from '../constants.js';
 
-const gatewayAddress = process.env.PRIMARY_WALLET_ADDRESS!;
-const contractTxId = process.env.DEPLOYED_REGISTRY_CONTRACT_TX_ID!;
 const writeTestCases = [
   [
     'joinNetwork',
@@ -32,22 +29,29 @@ const writeTestCases = [
   ['transfer', { target: ''.padEnd(43, 'f'), qty: 101 }],
 ] as const;
 
-describe('ArIO Client', () => {
-  const signer = new ArweaveSigner(JSON.parse(process.env.PRIMARY_WALLET_JWK!));
-  const arIO = ArIO.init({
-    signer,
-    contract: new WarpContract<ArIOState>({
-      cacheUrl: localCacheUrl,
-      contractTxId,
-      logger: new DefaultLogger({ level: 'none' }),
-      warp: warp,
-    }),
+describe('ArIOWriteable', () => {
+  let signer: ArweaveSigner;
+  let contractTxId: string;
+  let arIO: ArIOWritable;
+
+  beforeAll(() => {
+    contractTxId = process.env.DEPLOYED_REGISTRY_CONTRACT_TX_ID!;
+    signer = new ArweaveSigner(JSON.parse(process.env.PRIMARY_WALLET_JWK!));
+    arIO = ArIO.init({
+      signer,
+      contract: new WarpContract<ArIOState>({
+        cacheUrl: localCacheUrl,
+        contractTxId,
+        logger: new DefaultLogger({ level: 'none' }),
+        warp,
+      }),
+    });
   });
 
   it.each(writeTestCases)(
     'should execute write interaction with parameters: %s',
     async (functionName: string, inputs: Record<string, any>) => {
-      const tx: WriteInteractionResult = await arIO[functionName]({
+      const tx = await arIO[functionName]({
         ...inputs,
       });
       expect(tx).toBeDefined();

tests/integration/ar-io.test.ts

@@ -4,31 +4,28 @@ import { ArIO, ArIOReadable, ArIOWritable } from '../../src/common/ar-io.js';
 import { RemoteContract } from '../../src/common/contracts/remote-contract.js';
 import { WarpContract } from '../../src/common/index.js';
 import { DefaultLogger } from '../../src/common/logger.js';
-import { ARNS_DEVNET_REGISTRY_TX } from '../../src/constants.js';
 import { ArIOState } from '../../src/contract-state.js';
 import {
   evaluateToBlockHeight,
   evaluateToSortKey,
   gatewayAddress,
+  localCacheUrl,
   testDomain,
 } from '../constants.js';
 
-const contractTxId = ARNS_DEVNET_REGISTRY_TX;
-const localCacheUrl = `https://api.arns.app`;
 const testCases = [
   [{ sortKey: evaluateToSortKey.toString() }],
   [{ blockHeight: evaluateToBlockHeight }],
   [undefined],
 ] as const;
-describe('ArIO Client', () => {
-  const signer = new ArweaveSigner(JSON.parse(process.env.PRIMARY_WALLET_JWK!));
-  const arIO = ArIO.init({
-    signer,
-    contract: new WarpContract<ArIOState>({
-      cacheUrl: localCacheUrl,
-      contractTxId,
-      logger: new DefaultLogger({ level: 'none' }),
-    }),
+
+describe('ArIO Factory', () => {
+  let signer: ArweaveSigner;
+  let contractTxId: string;
+
+  beforeAll(() => {
+    contractTxId = process.env.DEPLOYED_REGISTRY_CONTRACT_TX_ID!;
+    signer = new ArweaveSigner(JSON.parse(process.env.PRIMARY_WALLET_JWK!));
   });
 
   it('should return a valid instance of ArIOWritable with contract config', async () => {
@@ -71,6 +68,20 @@ describe('ArIO Client', () => {
     expect(readClient).toBeDefined();
     expect(readClient).toBeInstanceOf(ArIOReadable);
   });
+});
+describe('ArIOReadable Client', () => {
+  let contractTxId: string;
+  let arIO: ArIOReadable;
+
+  beforeAll(() => {
+    contractTxId = process.env.DEPLOYED_REGISTRY_CONTRACT_TX_ID!;
+    arIO = ArIO.init({
+      contract: new RemoteContract<ArIOState>({
+        contractTxId,
+        cacheUrl: localCacheUrl,
+      }),
+    });
+  });
 
   it('should getState successfully', async () => {
     const state = await arIO.getState();
@@ -119,13 +130,6 @@ describe('ArIO Client', () => {
     expect(gateways[gatewayAddress]).toBeDefined();
   });
 
-  it('should return gateways at a given sort key', async () => {
-    const gateways = await arIO.getGateways({
-      evaluationOptions: { evalTo: { sortKey: evaluateToSortKey.toString() } },
-    });
-    expect(gateways[gatewayAddress]).toBeDefined();
-  });
-
   it('should return the record for an existing domain', async () => {
     const record = await arIO.getArNSRecord({ domain: testDomain });
     expect(record).toBeDefined();
@@ -285,13 +289,13 @@ describe('ArIO Client', () => {
     expect(distributions).toBeDefined();
   });
 
-  it('should return distributions at a blockheight', async () => {
+  it('should return distributions at a block height', async () => {
     const distributions = await arIO.getDistributions({
       evaluationOptions: { evalTo: { blockHeight: evaluateToBlockHeight } },
     });
     expect(distributions).toBeDefined();
   });
-  it('should return distributions at a sortkey', async () => {
+  it('should return distributions at a sortKey', async () => {
     const distributions = await arIO.getDistributions({
       evaluationOptions: { evalTo: { sortKey: evaluateToSortKey.toString() } },
     });