feat: contract builder

packages/contract-builder/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@midnight-ntwrk/midnight-js-contract-builder",
+  "version": "0.1.0",
+  "description": "Simplified API for deploying and interacting with Midnight smart contracts",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.mts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "repository": "git@github.com:midnight-ntwrk/artifacts",
+  "packageManager": "yarn@4.10.3",
+  "author": "IOHK",
+  "license": "Apache-2.0",
+  "keywords": [
+    "midnight",
+    "smart-contracts",
+    "blockchain",
+    "dapp",
+    "contract-builder"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist tsconfig.build.tsbuildinfo .rollup.cache reports coverage",
+    "build": "rollup -c rollup.config.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "deploy": "yarn npm publish"
+  },
+  "dependencies": {
+    "@midnight-ntwrk/midnight-js-contracts": "workspace:*",
+    "@midnight-ntwrk/midnight-js-network-id": "workspace:*",
+    "@midnight-ntwrk/midnight-js-types": "workspace:*",
+    "@midnight-ntwrk/midnight-js-utils": "workspace:*"
+  },
+  "peerDependencies": {
+    "@midnight-ntwrk/midnight-js-fetch-zk-config-provider": "workspace:*",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "workspace:*",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "workspace:*",
+    "@midnight-ntwrk/midnight-js-level-private-state-provider": "workspace:*",
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "@midnight-ntwrk/midnight-js-fetch-zk-config-provider": {
+      "optional": true
+    },
+    "@midnight-ntwrk/midnight-js-level-private-state-provider": {
+      "optional": true
+    },
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "devDependencies": {
+    "@fast-check/vitest": "^0.2.1",
+    "vitest": "^4.0.0"
+  }
+}

packages/contract-builder/rollup.config.mjs

@@ -0,0 +1,4 @@
+import { createRollupConfig } from '../../build-tools/rollup.config.factory.mjs';
+import packageJson from './package.json' with { type: 'json' };
+
+export default createRollupConfig(packageJson);

packages/contract-builder/src/adapter/ContractAdapter.ts

@@ -0,0 +1,165 @@
+/**
+ * Main Contract Adapter class that wraps a deployed contract
+ */
+
+import { mergeAdapterConfig } from '../config/AdapterConfig.js';
+import { PrivateStateNotConfiguredError } from '../errors/PrivateStateError.js';
+import type { PrivateStateManager } from '../private-state/PrivateStateManager.js';
+import type { AdapterConfig, ContractAdapter as IContractAdapter } from '../types/adapter-types.js';
+import type { DeployedContract, DeployTxData } from '../types/contract-types.js';
+import { createContractProxy, EventEmitter, type EventHandler } from './ContractProxy.js';
+
+/**
+ * ContractAdapter wraps a deployed contract and provides:
+ * - Automatic method proxying with interceptors
+ * - Built-in error handling
+ * - Retry logic for transient failures
+ * - Event emission for monitoring
+ * - Logging integration
+ * - Private state management (optional)
+ */
+export class ContractAdapter<TContract, TPrivateState = undefined> {
+  readonly eventEmitter: EventEmitter;
+  private readonly proxy: DeployedContract<TContract>;
+  private readonly privateStateManager?: PrivateStateManager<TPrivateState>;
+
+  constructor(
+    private readonly deployedContract: DeployedContract<TContract>,
+    private readonly config: AdapterConfig = {},
+    options?: {
+      privateStateManager?: PrivateStateManager<TPrivateState>;
+    }
+  ) {
+    this.privateStateManager = options?.privateStateManager;
+    // Merge with default config
+    const mergedConfig = mergeAdapterConfig(config);
+
+    // Create event emitter
+    this.eventEmitter = new EventEmitter();
+
+    // Register any pre-configured event handlers
+    if (mergedConfig.eventHandlers) {
+      Object.entries(mergedConfig.eventHandlers).forEach(([event, handler]) => {
+        this.eventEmitter.on(event, handler as EventHandler);
+      });
+    }
+
+    // Create the proxy
+    this.proxy = createContractProxy({
+      contract: deployedContract,
+      logger: mergedConfig.logger,
+      retryConfig: mergedConfig.retry,
+      errorHandler: mergedConfig.errorHandler,
+      eventEmitter: this.eventEmitter
+    });
+
+    // Return proxy to make this object behave like the contract
+    return this.createAdapterProxy() as unknown as ContractAdapter<TContract, TPrivateState>;
+  }
+
+  /**
+   * Register an event handler
+   */
+  private registerEventHandler(event: string, handler: EventHandler): this {
+    this.eventEmitter.on(event, handler);
+    return this;
+  }
+
+  /**
+   * Get contract address
+   */
+  get address(): string {
+    return this.deployedContract.address;
+  }
+
+  /**
+   * Get deployment transaction data
+   */
+  get deployTxData(): DeployTxData {
+    return this.deployedContract.deployTxData;
+  }
+
+  /**
+   * Get the current private state
+   */
+  async getPrivateState(): Promise<TPrivateState | null> {
+    if (!this.privateStateManager) {
+      throw new PrivateStateNotConfiguredError();
+    }
+
+    return await this.privateStateManager.getState();
+  }
+
+  /**
+   * Set the private state
+   */
+  async setPrivateState(state: TPrivateState): Promise<void> {
+    if (!this.privateStateManager) {
+      throw new PrivateStateNotConfiguredError();
+    }
+
+    return await this.privateStateManager.setState(state);
+  }
+
+  /**
+   * Get the private state ID
+   */
+  getPrivateStateId(): string | undefined {
+    return this.privateStateManager?.getStateId();
+  }
+
+  /**
+   * Creates a proxy that combines contract methods with adapter methods
+   */
+  private createAdapterProxy(): IContractAdapter<TContract, TPrivateState> {
+    // Capture reference to this for use in proxy
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const adapter = this;
+
+    const adapterProxy = new Proxy(this.proxy, {
+      get(target: DeployedContract<TContract>, prop: string | symbol): unknown {
+        // Handle 'on' method for event registration
+        if (prop === 'on') {
+          return (event: string, handler: EventHandler) => {
+            adapter.registerEventHandler(event, handler);
+            return adapterProxy;
+          };
+        }
+
+        // Handle address
+        if (prop === 'address') {
+          return adapter.address;
+        }
+
+        // Handle deployTxData
+        if (prop === 'deployTxData') {
+          return adapter.deployTxData;
+        }
+
+        // Handle private state methods
+        if (prop === 'getPrivateState') {
+          return () => adapter.getPrivateState();
+        }
+
+        if (prop === 'setPrivateState') {
+          return (state: TPrivateState) => adapter.setPrivateState(state);
+        }
+
+        if (prop === 'getPrivateStateId') {
+          return () => adapter.getPrivateStateId();
+        }
+
+        // Forward to the proxied contract's callTx methods
+        const callTx = target.callTx;
+        if (callTx && typeof callTx === 'object' && prop in callTx) {
+          return (callTx as Record<string | symbol, unknown>)[prop];
+        }
+
+        // Forward to target
+        return (target as unknown as Record<string | symbol, unknown>)[prop];
+      }
+    });
+
+    return adapterProxy as unknown as IContractAdapter<TContract, TPrivateState>;
+  }
+}