holosphere 2.0.0-alpha2 → 2.0.0-alpha5

package/src/contracts/deployer.js

@@ -0,0 +1,443 @@
+/**
+ * ContractDeployer - 1-Click deployment for Holosphere smart contracts
+ * Deploys all factories, registry, and individual holon contracts
+ */
+
+// Import ABIs
+import SplitterABI from './abis/Splitter.json' with { type: 'json' };
+import ManagedABI from './abis/Managed.json' with { type: 'json' };
+import ZonedABI from './abis/Zoned.json' with { type: 'json' };
+import AppreciativeABI from './abis/Appreciative.json' with { type: 'json' };
+import BundleABI from './abis/Bundle.json' with { type: 'json' };
+import HolonsABI from './abis/Holons.json' with { type: 'json' };
+import SplitterFactoryABI from './abis/SplitterFactory.json' with { type: 'json' };
+import ManagedFactoryABI from './abis/ManagedFactory.json' with { type: 'json' };
+import ZonedFactoryABI from './abis/ZonedFactory.json' with { type: 'json' };
+import AppreciativeFactoryABI from './abis/AppreciativeFactory.json' with { type: 'json' };
+import BundleFactoryABI from './abis/BundleFactory.json' with { type: 'json' };
+import TestTokenABI from './abis/TestToken.json' with { type: 'json' };
+
+import { getTxUrl, getAddressUrl } from './networks.js';
+
+// Export ABIs for external use
+export const ABIs = {
+  Splitter: SplitterABI,
+  Managed: ManagedABI,
+  Zoned: ZonedABI,
+  Appreciative: AppreciativeABI,
+  Bundle: BundleABI,
+  Holons: HolonsABI,
+  SplitterFactory: SplitterFactoryABI,
+  ManagedFactory: ManagedFactoryABI,
+  ZonedFactory: ZonedFactoryABI,
+  AppreciativeFactory: AppreciativeFactoryABI,
+  BundleFactory: BundleFactoryABI,
+  TestToken: TestTokenABI
+};
+
+export class ContractDeployer {
+  constructor(chainManager) {
+    this.chainManager = chainManager;
+    this.deployedContracts = {};
+    this.ethers = null;
+  }
+
+  /**
+   * Load ethers from chain manager
+   * @private
+   */
+  async _loadEthers() {
+    if (!this.ethers) {
+      this.ethers = await import('ethers');
+    }
+    return this.ethers;
+  }
+
+  /**
+   * 1-CLICK DEPLOY: Deploy entire Holosphere contract infrastructure
+   * Deploys: All factories + Holons registry + optional TestToken
+   *
+   * @param {Object} options - Deployment options
+   * @param {string} [options.botAddress] - Bot address for managed operations (defaults to deployer)
+   * @param {string} [options.testTokenSupply='1000000'] - Initial supply for test token (in whole tokens)
+   * @param {boolean} [options.deployTestToken=true] - Whether to deploy test token
+   * @param {Function} [options.onProgress] - Callback for deployment progress
+   * @returns {Promise<Object>} Deployed contract addresses and instances
+   */
+  async deployAll(options = {}) {
+    const ethers = await this._loadEthers();
+    const signer = this.chainManager.getSigner();
+    const deployerAddress = await signer.getAddress();
+
+    const botAddress = options.botAddress || deployerAddress;
+    const testTokenSupply = options.testTokenSupply || '1000000';
+    const deployTestToken = options.deployTestToken !== false;
+    const onProgress = options.onProgress || (() => {});
+
+    const deployment = {
+      network: this.chainManager.networkName,
+      chainId: this.chainManager.getChainId(),
+      deployer: deployerAddress,
+      botAddress,
+      timestamp: new Date().toISOString(),
+      contracts: {}
+    };
+
+    try {
+      // Step 1: Deploy ManagedFactory
+      onProgress({ step: 1, total: deployTestToken ? 8 : 7, message: 'Deploying ManagedFactory...' });
+      const managedFactory = await this._deployContract(
+        ManagedFactoryABI.abi,
+        ManagedFactoryABI.bytecode,
+        [botAddress]
+      );
+      deployment.contracts.managedFactory = managedFactory.address;
+      onProgress({ step: 1, done: true, address: managedFactory.address });
+
+      // Step 2: Deploy ZonedFactory
+      onProgress({ step: 2, total: deployTestToken ? 8 : 7, message: 'Deploying ZonedFactory...' });
+      const zonedFactory = await this._deployContract(
+        ZonedFactoryABI.abi,
+        ZonedFactoryABI.bytecode,
+        [botAddress]
+      );
+      deployment.contracts.zonedFactory = zonedFactory.address;
+      onProgress({ step: 2, done: true, address: zonedFactory.address });
+
+      // Step 3: Deploy SplitterFactory
+      onProgress({ step: 3, total: deployTestToken ? 8 : 7, message: 'Deploying SplitterFactory...' });
+      const splitterFactory = await this._deployContract(
+        SplitterFactoryABI.abi,
+        SplitterFactoryABI.bytecode,
+        []
+      );
+      deployment.contracts.splitterFactory = splitterFactory.address;
+      onProgress({ step: 3, done: true, address: splitterFactory.address });
+
+      // Step 4: Deploy AppreciativeFactory
+      onProgress({ step: 4, total: deployTestToken ? 8 : 7, message: 'Deploying AppreciativeFactory...' });
+      const appreciativeFactory = await this._deployContract(
+        AppreciativeFactoryABI.abi,
+        AppreciativeFactoryABI.bytecode,
+        []
+      );
+      deployment.contracts.appreciativeFactory = appreciativeFactory.address;
+      onProgress({ step: 4, done: true, address: appreciativeFactory.address });
+
+      // Step 5: Deploy BundleFactory
+      onProgress({ step: 5, total: deployTestToken ? 8 : 7, message: 'Deploying BundleFactory...' });
+      const bundleFactory = await this._deployContract(
+        BundleFactoryABI.abi,
+        BundleFactoryABI.bytecode,
+        []
+      );
+      deployment.contracts.bundleFactory = bundleFactory.address;
+      onProgress({ step: 5, done: true, address: bundleFactory.address });
+
+      // Step 6: Deploy Holons (Central Registry)
+      onProgress({ step: 6, total: deployTestToken ? 8 : 7, message: 'Deploying Holons Registry...' });
+      const holons = await this._deployContract(
+        HolonsABI.abi,
+        HolonsABI.bytecode,
+        []
+      );
+      deployment.contracts.holons = holons.address;
+      onProgress({ step: 6, done: true, address: holons.address });
+
+      // Step 7: Configure Holons Registry
+      onProgress({ step: 7, total: deployTestToken ? 8 : 7, message: 'Configuring Holons Registry...' });
+
+      // Set factories
+      await holons.contract.setFactories(managedFactory.address, zonedFactory.address);
+
+      // Register flavors
+      await holons.contract.newFlavor('Splitter', splitterFactory.address);
+      await holons.contract.newFlavor('Managed', managedFactory.address);
+      await holons.contract.newFlavor('Zoned', zonedFactory.address);
+      await holons.contract.newFlavor('Appreciative', appreciativeFactory.address);
+      await holons.contract.newFlavor('Bundle', bundleFactory.address);
+
+      onProgress({ step: 7, done: true, message: 'Registry configured' });
+
+      // Step 8: Deploy TestToken (optional)
+      if (deployTestToken) {
+        onProgress({ step: 8, total: 8, message: 'Deploying TestToken...' });
+        const supply = ethers.parseEther(testTokenSupply);
+        const testToken = await this._deployContract(
+          TestTokenABI.abi,
+          TestTokenABI.bytecode,
+          [supply]
+        );
+        deployment.contracts.testToken = testToken.address;
+        onProgress({ step: 8, done: true, address: testToken.address });
+      }
+
+      // Store deployed contracts
+      this.deployedContracts = deployment.contracts;
+
+      // Add explorer URLs
+      deployment.explorerUrls = {};
+      for (const [name, address] of Object.entries(deployment.contracts)) {
+        const url = getAddressUrl(deployment.network, address);
+        if (url) deployment.explorerUrls[name] = url;
+      }
+
+      return deployment;
+
+    } catch (error) {
+      throw new Error(`Deployment failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Deploy a Splitter contract for a holon (fractal ownership)
+   * @param {string} holonId - Holon identifier
+   * @param {string} name - Contract display name
+   * @param {number} [splitPercentage=70] - Internal/External split (e.g., 70 = 70% internal, 30% external)
+   * @param {Object} [options] - Additional options
+   * @returns {Promise<{contract, address, txHash}>}
+   */
+  async deploySplitter(holonId, name, splitPercentage = 70, options = {}) {
+    const signer = this.chainManager.getSigner();
+    const deployerAddress = await signer.getAddress();
+
+    const creatorUserId = options.creatorUserId || holonId;
+    const managedFactory = options.managedFactory || this.deployedContracts.managedFactory;
+    const zonedFactory = options.zonedFactory || this.deployedContracts.zonedFactory;
+
+    if (!managedFactory || !zonedFactory) {
+      throw new Error('Factories not deployed. Run deployAll() first or provide factory addresses.');
+    }
+
+    const result = await this._deployContract(
+      SplitterABI.abi,
+      SplitterABI.bytecode,
+      [deployerAddress, creatorUserId, name, splitPercentage, managedFactory, zonedFactory]
+    );
+
+    // Configure the split
+    await result.contract.setContractSplit(splitPercentage, 100 - splitPercentage);
+
+    // Create child contracts
+    await result.contract.createManagedContract(creatorUserId, name, 0);
+    await result.contract.createZonedContract(creatorUserId, name, 6); // 6 zones default
+
+    return {
+      ...result,
+      holonId,
+      type: 'Splitter',
+      splitPercentage
+    };
+  }
+
+  /**
+   * Deploy a Managed contract (appreciation-based distribution)
+   * @param {string} name - Contract name
+   * @param {Object} [options] - Additional options
+   * @returns {Promise<{contract, address, txHash}>}
+   */
+  async deployManaged(name, options = {}) {
+    const signer = this.chainManager.getSigner();
+    const deployerAddress = await signer.getAddress();
+    const botAddress = options.botAddress || deployerAddress;
+
+    const result = await this._deployContract(
+      ManagedABI.abi,
+      ManagedABI.bytecode,
+      [deployerAddress, name, botAddress]
+    );
+
+    return {
+      ...result,
+      type: 'Managed'
+    };
+  }
+
+  /**
+   * Deploy a Zoned contract (tier-based distribution)
+   * @param {string} name - Contract name
+   * @param {number} [nZones=6] - Number of zones
+   * @param {Object} [options] - Additional options
+   * @returns {Promise<{contract, address, txHash}>}
+   */
+  async deployZoned(name, nZones = 6, options = {}) {
+    const signer = this.chainManager.getSigner();
+    const deployerAddress = await signer.getAddress();
+    const botAddress = options.botAddress || deployerAddress;
+    const creatorUserId = options.creatorUserId || 'creator';
+
+    const result = await this._deployContract(
+      ZonedABI.abi,
+      ZonedABI.bytecode,
+      [creatorUserId, deployerAddress, name, nZones, botAddress]
+    );
+
+    return {
+      ...result,
+      type: 'Zoned',
+      nZones
+    };
+  }
+
+  /**
+   * Deploy an Appreciative contract (peer-to-peer appreciation)
+   * @param {string} name - Contract name
+   * @param {string} creatorUserId - Creator's user ID
+   * @param {Object} [options] - Additional options
+   * @returns {Promise<{contract, address, txHash}>}
+   */
+  async deployAppreciative(name, creatorUserId, options = {}) {
+    const signer = this.chainManager.getSigner();
+    const deployerAddress = await signer.getAddress();
+
+    const result = await this._deployContract(
+      AppreciativeABI.abi,
+      AppreciativeABI.bytecode,
+      [name, creatorUserId, deployerAddress]
+    );
+
+    return {
+      ...result,
+      type: 'Appreciative'
+    };
+  }
+
+  /**
+   * Deploy a Bundle contract (2-way split with steepness)
+   * @param {string} name - Contract name
+   * @param {number} [steepness=500000000000000000n] - Steepness factor (0.5e18 = 50% decay)
+   * @param {number} [nZones=6] - Number of zones
+   * @param {Object} [options] - Additional options
+   * @returns {Promise<{contract, address, txHash}>}
+   */
+  async deployBundle(name, steepness, nZones = 6, options = {}) {
+    const ethers = await this._loadEthers();
+    const signer = this.chainManager.getSigner();
+    const deployerAddress = await signer.getAddress();
+    const creatorUserId = options.creatorUserId || 'creator';
+
+    // Default steepness: 0.5e18 (50% decay per zone)
+    const steepnessValue = steepness || ethers.parseEther('0.5');
+
+    const result = await this._deployContract(
+      BundleABI.abi,
+      BundleABI.bytecode,
+      [deployerAddress, creatorUserId, name, steepnessValue, nZones]
+    );
+
+    return {
+      ...result,
+      type: 'Bundle',
+      steepness: steepnessValue,
+      nZones
+    };
+  }
+
+  /**
+   * Deploy a TestToken (ERC20 for testing)
+   * @param {string} [initialSupply='1000000'] - Initial supply in whole tokens
+   * @returns {Promise<{contract, address, txHash}>}
+   */
+  async deployTestToken(initialSupply = '1000000') {
+    const ethers = await this._loadEthers();
+    const supply = ethers.parseEther(initialSupply);
+
+    const result = await this._deployContract(
+      TestTokenABI.abi,
+      TestTokenABI.bytecode,
+      [supply]
+    );
+
+    return {
+      ...result,
+      type: 'TestToken',
+      initialSupply
+    };
+  }
+
+  /**
+   * Create a holon bundle through the Holons registry
+   * @param {string} creatorUserId - Creator's user ID
+   * @param {string} name - Bundle name
+   * @param {number} [parameter=70] - Split parameter
+   * @returns {Promise<{address, txHash}>}
+   */
+  async createHolonBundle(creatorUserId, name, parameter = 70) {
+    if (!this.deployedContracts.holons) {
+      throw new Error('Holons registry not deployed. Run deployAll() first.');
+    }
+
+    const holons = await this.chainManager.getContract(
+      this.deployedContracts.holons,
+      HolonsABI.abi
+    );
+
+    const tx = await holons.newHolonBundle(creatorUserId, name, parameter);
+    const receipt = await tx.wait();
+
+    // Get the created address from events
+    const event = receipt.logs.find(log => {
+      try {
+        const parsed = holons.interface.parseLog(log);
+        return parsed?.name === 'NewHolon';
+      } catch {
+        return false;
+      }
+    });
+
+    const address = event ? holons.interface.parseLog(event).args.addr : await holons.toAddress(name);
+
+    return {
+      address,
+      txHash: receipt.hash,
+      name,
+      creatorUserId
+    };
+  }
+
+  /**
+   * Get contract instance by address
+   * @param {string} address - Contract address
+   * @param {string} type - Contract type (Splitter, Managed, Zoned, etc.)
+   * @returns {Promise<Contract>}
+   */
+  async getContract(address, type) {
+    const abi = ABIs[type];
+    if (!abi) {
+      throw new Error(`Unknown contract type: ${type}`);
+    }
+    return this.chainManager.getContract(address, abi.abi);
+  }
+
+  /**
+   * Get deployed contract addresses
+   * @returns {Object}
+   */
+  getDeployedAddresses() {
+    return { ...this.deployedContracts };
+  }
+
+  /**
+   * Load previously deployed contracts
+   * @param {Object} addresses - Contract addresses
+   */
+  loadDeployedAddresses(addresses) {
+    this.deployedContracts = { ...addresses };
+  }
+
+  /**
+   * Internal: Deploy a contract
+   * @private
+   */
+  async _deployContract(abi, bytecode, constructorArgs) {
+    const result = await this.chainManager.deployContract(abi, bytecode, constructorArgs);
+    return {
+      contract: result.contract,
+      address: result.address,
+      txHash: result.txHash,
+      explorerUrl: getAddressUrl(this.chainManager.networkName, result.address)
+    };
+  }
+}
+
+export default ContractDeployer;