Contract Tokenization Flow

Example
HTML
Copy
// src/routes/contracts.js
const router = require('express').Router();
const authMiddleware = require('../middleware/auth');
const { pool } = require('../db');
const crypto = require('crypto');

// Utility function for a contract number
function generateContractNumber() {
  const now = new Date();
  return `CONT-${now.getFullYear()}-${crypto.randomBytes(3).toString('hex')}`;
}

// 1. Create a Draft Contract
router.post('/', authMiddleware, async (req, res) => {
  const { buyerId, sellerId, title, description, amount, currency } = req.body;

  try {
    // Contract number generation
    const contractNumber = generateContractNumber();

    // Insert draft into DB
    const insertQuery = `
      INSERT INTO contracts (
        contract_number, buyer_id, seller_id, title, description, amount, currency, status
      )
      VALUES ($1, $2, $3, $4, $5, $6, $7, 'DRAFT')
      RETURNING *
    `;
    const values = [contractNumber, buyerId, sellerId, title, description, amount, currency];
    const result = await pool.query(insertQuery, values);

    return res.status(201).json({
      message: 'Contract draft created',
      contract: result.rows[0]
    });
  } catch (error) {
    console.error(error);
    return res.status(500).json({ error: 'Internal server error' });
  }
});

module.exports = router;

Example
HTML
Copy
// 2. Finalize and store doc hash
router.post('/:id/finalize', authMiddleware, async (req, res) => {
  const contractId = req.params.id;
  // Suppose the front-end sends a base64-encoded PDF or HTML
  const { contractDocumentBase64 } = req.body;

  try {
    // 1) Compute the hash
    const buffer = Buffer.from(contractDocumentBase64, 'base64');
    const docHash = crypto.createHash('sha256').update(buffer).digest('hex');

    // 2) Update contract status and store the hash
    const updateQuery = `
      UPDATE contracts
      SET doc_hash = $1,
          status   = 'PENDING_SIGNATURE',
          updated_at = NOW()
      WHERE id = $2
      RETURNING *
    `;
    const result = await pool.query(updateQuery, [docHash, contractId]);

    if (result.rowCount === 0) {
      return res.status(404).json({ error: 'Contract not found' });
    }
    return res.json({
      message: 'Contract finalized. Signatures required.',
      contract: result.rows[0]
    });
  } catch (error) {
    console.error(error);
    return res.status(500).json({ error: 'Internal server error' });
  }
});

Example
HTML
Copy
// 3. Signing the Contract
router.post('/:id/sign', authMiddleware, async (req, res) => {
  const contractId = req.params.id;
  const userId = req.user.userId;

  try {
    // Fetch contract
    const contractResult = await pool.query(
      'SELECT * FROM contracts WHERE id = $1',
      [contractId]
    );
    if (contractResult.rows.length === 0) {
      return res.status(404).json({ error: 'Contract not found' });
    }
    const contract = contractResult.rows[0];

    // Determine if user is buyer or seller
    let updateField = null;
    if (contract.buyer_id === userId) {
      updateField = 'buyer_signed';
    } else if (contract.seller_id === userId) {
      updateField = 'seller_signed';
    } else {
      return res.status(403).json({ error: 'Not authorized to sign' });
    }

    // Mark as signed
    await pool.query(
      `UPDATE contracts
       SET ${updateField} = true, updated_at = NOW()
       WHERE id = $1`,
      [contractId]
    );

    // Check if both have signed
    const checkResult = await pool.query(
      'SELECT buyer_signed, seller_signed FROM contracts WHERE id = $1',
      [contractId]
    );
    const { buyer_signed, seller_signed } = checkResult.rows[0];
    if (buyer_signed && seller_signed) {
      // Update status to 'ACTIVE'
      await pool.query(
        `UPDATE contracts
         SET status = 'ACTIVE'
         WHERE id = $1`,
        [contractId]
      );
    }

    return res.json({ message: 'Contract signed successfully' });
  } catch (error) {
    console.error(error);
    return res.status(500).json({ error: 'Internal server error' });
  }
});

Example
HTML
Copy
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

/**
 * @title NexityContractRegistry
 * @dev Simple registry to record the hash of an off-chain contract doc plus buyer/seller addresses
 */
contract NexityContractRegistry {
    struct ContractRecord {
        address buyer;
        address seller;
        string docHash; // e.g., a SHA-256 hash of the contract text
        bool buyerSigned;
        bool sellerSigned;
        bool isActive;
    }

    // Map a unique ID (e.g. contractNumber hashed) to a ContractRecord
    mapping(bytes32 => ContractRecord) public contracts;

    event ContractCreated(bytes32 indexed contractId, address buyer, address seller, string docHash);
    event ContractSigned(bytes32 indexed contractId, address signer);

    function createContract(bytes32 _contractId, address _buyer, address _seller, string memory _docHash) public {
        // Typically restricted by some access control
        require(contracts[_contractId].buyer == address(0), "Contract already exists");
        
        contracts[_contractId] = ContractRecord({
            buyer: _buyer,
            seller: _seller,
            docHash: _docHash,
            buyerSigned: false,
            sellerSigned: false,
            isActive: false
        });

        emit ContractCreated(_contractId, _buyer, _seller, _docHash);
    }

    function signContract(bytes32 _contractId) public {
        ContractRecord storage rec = contracts[_contractId];
        require(rec.buyer != address(0), "Contract does not exist");
        require(!rec.isActive, "Contract is already active");
        
        // If the caller is the buyer or the seller, mark them as signed
        if (msg.sender == rec.buyer) {
            rec.buyerSigned = true;
        } else if (msg.sender == rec.seller) {
            rec.sellerSigned = true;
        } else {
            revert("Not authorized to sign");
        }

        emit ContractSigned(_contractId, msg.sender);

        if (rec.buyerSigned && rec.sellerSigned) {
            rec.isActive = true; // both have signed, contract is active
        }
    }
}