进销存系统区块链溯源与供应链金融

发布时间：2025-06-19 | 分类：供应链金融

引言

区块链技术以其不可篡改、可追溯、去中心化的特性，为进销存系统的商品溯源和供应链金融提供了全新的解决方案。通过区块链，可以实现商品从生产到消费的全链路透明化，同时为供应链各环节提供可信的融资服务。

区块链溯源架构

构建基于区块链的商品溯源系统：

商品溯源链上数据模型

// 区块链溯源服务
class BlockchainTraceabilityService {
  constructor(web3, contractAddress) {
    this.web3 = web3;
    this.contract = new this.web3.eth.Contract(TRACEBILITY_ABI, contractAddress);
  }

  // 创建商品溯源批次
  async createProductBatch(batchInfo) {
    const batchData = {
      batchId: this.generateBatchId(),
      productName: batchInfo.productName,
      manufacturer: batchInfo.manufacturer,
      productionDate: batchInfo.productionDate,
      expiryDate: batchInfo.expiryDate,
      quantity: batchInfo.quantity,
      unit: batchInfo.unit,
      specifications: batchInfo.specifications,
      certifications: batchInfo.certifications,
      initialLocation: batchInfo.productionLocation,
      status: 'created'
    };

    // 上链存证
    const tx = await this.contract.methods.createBatch(
      batchData.batchId,
      JSON.stringify(batchData)
    ).send({
      from: batchInfo.operator,
      gas: 500000
    });

    // 保存链下索引，方便查询
    await this.saveBatchIndex(batchData);

    return {
      batchId: batchData.batchId,
      txHash: tx.transactionHash,
      blockNumber: tx.blockNumber,
      timestamp: Date.now()
    };
  }

  // 记录流转信息
  async recordTransfer(transferInfo) {
    const transferData = {
      batchId: transferInfo.batchId,
      fromType: transferInfo.fromType,  // manufacturer, warehouse, distributor, retailer
      fromId: transferInfo.fromId,
      fromName: transferInfo.fromName,
      toType: transferInfo.toType,
      toId: transferInfo.toId,
      toName: transferInfo.toName,
      quantity: transferInfo.quantity,
      transferDate: transferInfo.transferDate,
      location: transferInfo.location,
      handler: transferInfo.handler,
      remark: transferInfo.remark,
      // 附加数据
      temperature: transferInfo.temperature,
      humidity: transferInfo.humidity,
      images: transferInfo.images
    };

    // 上链
    const tx = await this.contract.methods.recordTransfer(
      transferData.batchId,
      JSON.stringify(transferData)
    ).send({
      from: transferInfo.operator,
      gas: 300000
    });

    // 更新本地状态
    await this.updateBatchStatus(transferData.batchId, transferData.toType, transferData.toId);

    return {
      batchId: transferData.batchId,
      txHash: tx.transactionHash,
      transferId: this.generateTransferId(),
      timestamp: Date.now()
    };
  }

  // 记录质检信息
  async recordQualityCheck(checkInfo) {
    const qualityData = {
      batchId: checkInfo.batchId,
      checkType: checkInfo.checkType, // incoming, outgoing, periodic
      checkDate: checkInfo.checkDate,
      checker: checkInfo.checker,
      checkResult: checkInfo.checkResult, // passed, failed, warning
      checkItems: checkInfo.checkItems.map(item => ({
        item: item.name,
        standard: item.standard,
        actual: item.actual,
        result: item.result // pass, fail
      })),
      certificateNo: checkInfo.certificateNo,
      nextCheckDate: checkInfo.nextCheckDate,
      remark: checkInfo.remark
    };

    const tx = await this.contract.methods.recordQualityCheck(
      qualityData.batchId,
      JSON.stringify(qualityData)
    ).send({
      from: checkInfo.operator,
      gas: 300000
    });

    return {
      txHash: tx.transactionHash,
      checkId: this.generateCheckId()
    };
  }

  // 查询商品溯源信息
  async queryProductTrace(batchId) {
    // 从链上获取完整流转记录
    const transfers = await this.contract.methods.getTransfers(batchId).call();

    // 解析并排序
    const traceData = {
      batchInfo: await this.getBatchInfo(batchId),
      transfers: transfers.map(t => JSON.parse(t.data)).sort((a, b) =>
        new Date(a.transferDate) - new Date(b.transferDate)
      ),
      qualityChecks: await this.getQualityChecks(batchId)
    };

    return traceData;
  }

  // 验证商品真伪
  async verifyProduct(batchId) {
    const batchInfo = await this.getBatchInfo(batchId);

    if (!batchInfo) {
      return { valid: false, reason: 'Batch not found on blockchain' };
    }

    // 检查是否在有效期
    if (batchInfo.expiryDate && new Date(batchInfo.expiryDate) < new Date()) {
      return { valid: false, reason: 'Product expired' };
    }

    return {
      valid: true,
      batchInfo: batchInfo,
      verifiedAt: new Date().toISOString()
    };
  }

  generateBatchId() {
    return `BATCH_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

供应链金融智能合约

基于区块链的供应链金融解决方案：

// 供应链金融智能合约
class SupplyChainFinanceContract {
  constructor(web3, financeContractAddress) {
    this.web3 = web3;
    this.contract = new this.web3.eth.Contract(FINANCE_ABI, financeContractAddress);
  }

  // 应收账款融资（核心企业确权）
  async createReceivableFactoring(factoringInfo) {
    const receivableData = {
      receivableId: this.generateReceivableId(),
      // 核心企业信息
      coreEnterprise: {
        address: factoringInfo.coreEnterpriseAddress,
        name: factoringInfo.coreEnterpriseName
      },
      // 供应商信息
      supplier: {
        address: factoringInfo.supplierAddress,
        name: factoringInfo.supplierName
      },
      // 订单信息
      order: {
        orderNo: factoringInfo.orderNo,
        orderAmount: factoringInfo.orderAmount,
        currency: factoringInfo.currency || 'CNY'
      },
      // 账期信息
      paymentTerms: {
        invoiceDate: factoringInfo.invoiceDate,
        dueDate: factoringInfo.dueDate,
        paymentDays: factoringInfo.paymentDays
      },
      // 状态
      status: 'pending_confirmation',
      createdAt: Date.now()
    };

    // 核心企业确认应收账款
    const tx = await this.contract.methods.createReceivable(
      receivableData.receivableId,
      JSON.stringify(receivableData)
    ).send({
      from: factoringInfo.coreEnterpriseAddress,
      gas: 500000
    });

    return {
      receivableId: receivableData.receivableId,
      txHash: tx.transactionHash,
      status: 'pending_confirmation'
    };
  }

  // 供应商确认并发起融资
  async supplierConfirmAndFinance(receivableId, supplierAddress) {
    // 1. 供应商确认
    await this.contract.methods.confirmReceivable(receivableId).send({
      from: supplierAddress,
      gas: 200000
    });

    // 2. 获取融资机构报价
    const financingOffers = await this.getFinancingOffers(receivableId);

    return {
      receivableId: receivableId,
      status: 'confirmed',
      availableFinancing: financingOffers
    };
  }

  // 融资机构放款
  async financingDisbursement(disbursementInfo) {
    const disbursementData = {
      disbursementId: this.generateDisbursementId(),
      receivableId: disbursementInfo.receivableId,
      financingInstitution: {
        address: disbursementInfo.financInstitutionAddress,
        name: disbursementInfo.financingInstitutionName
      },
      amount: disbursementInfo.amount,
      interestRate: disbursementInfo.interestRate,
      disbursementDate: disbursementInfo.disbursementDate,
      repaymentDate: disbursementInfo.repaymentDate,
      status: 'disbursed'
    };

    const tx = await this.contract.methods.disburse(
      disbursementData.disbursementId,
      disbursementData.receivableId,
      disbursementData.amount
    ).send({
      from: disbursementInfo.financingInstitutionAddress,
      gas: 300000
    });

    return {
      disbursementId: disbursementData.disbursementId,
      txHash: tx.transactionHash,
      status: 'disbursed'
    };
  }

  // 到期自动还款
  async automaticRepayment(receivableId) {
    // 检查是否到期
    const receivable = await this.contract.methods.getReceivable(receivableId).call();

    if (new Date() < new Date(receivable.dueDate * 1000)) {
      throw new Error('Not due for repayment');
    }

    // 核心企业还款
    const tx = await this.contract.methods.repay(receivableId).send({
      from: receivable.coreEnterprise,
      gas: 200000
    });

    // 自动清算各参与方
    await this.settleParticipants(receivableId);

    return {
      receivableId: receivableId,
      status: 'repaid',
      txHash: tx.transactionHash
    };
  }

  // 多方对账与结算
  async settleParticipants(receivableId) {
    const receivable = await this.getReceivableDetails(receivableId);
    const disbursements = await this.getDisbursements(receivableId);

    // 计算各参与方应收款项
    const settlements = [];

    // 融资机构应收本金+利息
    for (const disbursement of disbursements) {
      const interest = this.calculateInterest(
        disbursement.amount,
        disbursement.interestRate,
        disbursement.disbursementDate,
        Date.now()
      );

      settlements.push({
        participant: 'financing_institution',
        address: disbursement.financingInstitution,
        amount: disbursement.amount + interest,
        type: 'repayment'
      });
    }

    // 平台服务费（如有）
    if (receivable.platformFee > 0) {
      settlements.push({
        participant: 'platform',
        address: receivable.platformAddress,
        amount: receivable.platformFee,
        type: 'service_fee'
      });
    }

    // 执行结算
    for (const settlement of settlements) {
      await this.processSettlement(settlement);
    }

    return settlements;
  }
}

商品溯源查询示例

// 商品溯源前端展示
class TraceabilityViewer {
  constructor() {
    this.blockchainService = new BlockchainTraceabilityService();
  }

  // 查询商品全链路溯源
  async traceProduct(batchId) {
    // 1. 验证商品真伪
    const verification = await this.blockchainService.verifyProduct(batchId);

    if (!verification.valid) {
      return { error: verification.reason };
    }

    // 2. 获取完整溯源数据
    const traceData = await this.blockchainService.queryProductTrace(batchId);

    // 3. 转换为可视化数据
    return this.convertToVisualizationData(traceData);
  }

  // 转换为可视化数据
  convertToVisualizationData(traceData) {
    const events = [];

    // 添加创建事件
    events.push({
      type: 'created',
      title: '商品生产',
      location: traceData.batchInfo.initialLocation,
      timestamp: traceData.batchInfo.productionDate,
      data: {
        manufacturer: traceData.batchInfo.manufacturer,
        specifications: traceData.batchInfo.specifications
      }
    });

    // 添加流转事件
    for (const transfer of traceData.transfers) {
      events.push({
        type: 'transfer',
        title: `${this.getRoleName(transfer.fromType)} → ${this.getRoleName(transfer.toType)}`,
        location: transfer.location,
        timestamp: transfer.transferDate,
        data: {
          from: transfer.fromName,
          to: transfer.toName,
          quantity: transfer.quantity
        }
      });
    }

    // 添加质检事件
    for (const check of traceData.qualityChecks) {
      events.push({
        type: 'quality',
        title: '质量检测',
        location: check.location || '检测中心',
        timestamp: check.checkDate,
        data: {
          result: check.checkResult,
          items: check.checkItems
        }
      });
    }

    return {
      batchInfo: traceData.batchInfo,
      timeline: events.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp)),
      summary: {
        totalTransfers: traceData.transfers.length,
        qualityChecks: traceData.qualityChecks.length,
        currentHolder: traceData.transfers[traceData.transfers.length - 1]?.toName
      }
    };
  }

  getRoleName(type) {
    const roleNames = {
      'manufacturer': '生产商',
      'warehouse': '仓库',
      'distributor': '经销商',
      'retailer': '零售商',
      'consumer': '消费者'
    };
    return roleNames[type] || type;
  }
}

应用场景与价值

总结

区块链溯源与供应链金融为进销存系统带来了创新价值：

• 可信溯源：全链路数据上链，不可篡改，提升商品可信度
• 快速定位」：问题商品快速定位，缩短排查时间
• 信任传递：核心企业信用传递至供应商，降低融资门槛
• 自动清算：智能合约实现自动还款和清算，提高效率
• 数据共享：多方安全共享数据，降低信息不对称

通过区块链技术，进销存系统可以实现商品流、资金流、信息流的三流合一，为企业创造更大的商业价值。