#!/bin/bash
# 示例 15-4-1：链码全生命周期部署脚本（Fabric v2.5+）

CHAINCODE_NAME="asset-transfer"
CHAINCODE_VERSION="1.0"
SEQUENCE=1

cd /opt/fabric/test-network

# 1) 打包链码
peer lifecycle chaincode package ${CHAINCODE_NAME}.tar.gz \
  --path ../asset-transfer/chaincode-go \
  --lang golang \
  --label {CHAINCODE_NAME}_{CHAINCODE_VERSION}

# 2) 安装到 Org1 的 peer0
export CORE_PEER_MSPCONFIGPATH=../organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
export CORE_PEER_ADDRESS=localhost:7051
export CORE_PEER_LOCALMSPID="Org1MSP"
peer lifecycle chaincode install ${CHAINCODE_NAME}.tar.gz

# 3) 安装到 Org2 的 peer0
export CORE_PEER_MSPCONFIGPATH=../organizations/peerOrganizations/org2.example.com/users/Admin@org2.example.com/msp
export CORE_PEER_ADDRESS=localhost:9051
export CORE_PEER_LOCALMSPID="Org2MSP"
peer lifecycle chaincode install ${CHAINCODE_NAME}.tar.gz

# 4) Org1 批准链码定义
peer lifecycle chaincode approveformyorg \
  --orderer orderer.example.com:7050 \
  --channelID mychannel \
  --name ${CHAINCODE_NAME} \
  --version ${CHAINCODE_VERSION} \
  --package-id <ORG1_PACKAGE_ID> \
  --sequence ${SEQUENCE} \
  --init-required \
  --signature-policy "OR('Org1MSP.peer','Org2MSP.peer')" \
  --tls --cafile /path/to/tlsca.crt

# 5) Org2 批准链码定义（修改环境变量后执行同上命令，package-id 可不同）
# ...

# 6) 查询通道内各组织的批准就绪状态
peer lifecycle chaincode checkcommitreadiness \
  --channelID mychannel \
  --name ${CHAINCODE_NAME} \
  --version ${CHAINCODE_VERSION} \
  --sequence ${SEQUENCE} \
  --signature-policy "OR('Org1MSP.peer','Org2MSP.peer')" \
  --output json

# 7) 任意组织完成提交
peer lifecycle chaincode commit \
  --orderer orderer.example.com:7050 \
  --channelID mychannel \
  --name ${CHAINCODE_NAME} \
  --version ${CHAINCODE_VERSION} \
  --sequence ${SEQUENCE} \
  --init-required \
  --signature-policy "OR('Org1MSP.peer','Org2MSP.peer')" \
  --tls --cafile /path/to/tlsca.crt

# 8) 初始化（若链码包含 Init 函数）
peer chaincode invoke -o orderer.example.com:7050 -C mychannel \
  -n ${CHAINCODE_NAME} --isInit -c '{"function":"InitLedger","Args":[]}'

# 示例 15-4-2：升级脚本（只展示关键差异）
SEQUENCE=2
CHAINCODE_VERSION="1.1"

# 重新打包安装（省略安装命令，与首次相同）
peer lifecycle chaincode package ${CHAINCODE_NAME}_v2.tar.gz \
  --path ../asset-transfer/chaincode-go \
  --lang golang \
  --label {CHAINCODE_NAME}_{CHAINCODE_VERSION}

# 各组织 approveformyorg，注意 --sequence 2、--version 1.1
# 提交后旧版本逻辑不再收到新调用

// 示例 15-4-3：Go 链码中的兼容性检查
import "github.com/hyperledger/fabric-contract-api-go/contractapi"

type SmartContract struct {
    contractapi.Contract
}

func (s *SmartContract) TransferAsset(ctx contractapi.TransactionContextInterface,
    id, newOwner string) error {
    assetJSON, err := ctx.GetStub().GetState(id)
    if err != nil {
        return fmt.Errorf("查询状态失败: %w", err)
    }
    if assetJSON == nil {
        // 兼容升级场景：旧数据不存在时返回明确错误，而非 panic
        return fmt.Errorf("资产 %s 不存在，可能因升级后数据未迁移", id)
    }
    // ... 反序列化并更新 owner
    return ctx.GetStub().PutState(id, updatedJSON)
}

// 示例 15-5-1：基于 Fabric Gateway 的 Node.js 后端服务模板
import { connect, Contract, Gateway, Network } from '@hyperledger/fabric-gateway';
import { GrpcClient } from '@hyperledger/fabric-gateway/dist/client';
import * as grpc from '@grpc/grpc-js';
import * as fs from 'fs';
import * as path from 'path';

const CONNECTION_PROFILE_PATH = './connection-profile.yaml';
const MSP_ID = 'Org1MSP';
const CHANNEL_NAME = 'mychannel';
const CHAINCODE_NAME = 'asset-transfer';
const KEY_PATH = '/path/to/wallet/appUser/key.pem';
const CERT_PATH = '/path/to/wallet/appUser/cert.pem';

async function newGateway(): Promise<Gateway> {
  // 读取 X.509 证书与私钥
  const tlsRootCert = fs.readFileSync('/path/to/tlsca.crt');
  const key = fs.readFileSync(KEY_PATH);
  const cert = fs.readFileSync(CERT_PATH);

  // 建立 gRPC 连接
  const client = new grpc.Client('localhost:7051', grpc.credentials.createSsl(tlsRootCert));

  // 建议使用 org1 的 peer0 作为 Gateway
  const gateway = connect({
    client,
    identity: { mspId: MSP_ID, credentials: cert },
    signer: async (digest) => {
      // 简化版签名器，生产环境请使用 HSM 或更安全的私钥管理
      const crypto = require('crypto');
      const privateKey = crypto.createPrivateKey(key);
      return crypto.sign(null, digest, privateKey);
    },
  });
  return gateway;
}

// 统一查询（只读）
export async function evaluate(func: string, ...args: string[]): Promise<string> {
  const gateway = await newGateway();
  try {
    const network: Network = await gateway.getNetwork(CHANNEL_NAME);
    const contract: Contract = network.getContract(CHAINCODE_NAME);
    const resultBytes = await contract.evaluateTransaction(func, ...args);
    return new TextDecoder().decode(resultBytes);
  } finally {
    gateway.close();
  }
}

// 统一提交（写操作）
export async function submit(func: string, ...args: string[]): Promise<string> {
  const gateway = await newGateway();
  try {
    const network: Network = await gateway.getNetwork(CHANNEL_NAME);
    const contract: Contract = network.getContract(CHAINCODE_NAME);
    const result = await contract.submitTransaction(func, ...args);
    return new TextDecoder().decode(result);
  } finally {
    gateway.close();
  }
}

// 使用示例
(async () => {
  const asset = await evaluate('GetAsset', 'asset-001');
  console.log('查询结果:', asset);
  const txId = await submit('RegisterAsset', 'asset-002', 'Org1', '{"color":"blue"}');
  console.log('写交易已提交，txId:', txId);
})();

# 示例 15-5-2：connection-profile.yaml
name: "test-network"
version: "1.0"
channels:
  mychannel:
    orderers:
      - orderer.example.com
    peers:
      peer0.org1.example.com:
        endorsingPeer: true
        chaincodeQuery: true
      peer0.org2.example.com:
        endorsingPeer: true
organizations:
  Org1:
    mspid: Org1MSP
    peers:
      - peer0.org1.example.com
  Org2:
    mspid: Org2MSP
    peers:
      - peer0.org2.example.com
orderers:
  orderer.example.com:
    url: grpcs://localhost:7050
    tlsCACerts:
      path: /path/to/crypto-config/ordererOrganizations/example.com/tlsca/tlsca.example.com-cert.pem
peers:
  peer0.org1.example.com:
    url: grpcs://localhost:7051
    tlsCACerts:
      path: /path/to/crypto-config/peerOrganizations/org1.example.com/tlsca/tlsca.org1.example.com-cert.pem
  peer0.org2.example.com:
    url: grpcs://localhost:9051
    tlsCACerts:
      path: /path/to/crypto-config/peerOrganizations/org2.example.com/tlsca/tlsca.org2.example.com-cert.pem

// 示例 15-5-3：异常处理与重试中间件
import { EndorseError, SubmitError } from '@hyperledger/fabric-gateway';

async function submitWithRetry(func: string, args: string[], maxRetries = 3): Promise<string> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await submit(func, ...args);
    } catch (error) {
      // 背书策略满足失败：立即重试通常无意义，应检查配置
      if (error instanceof EndorseError) {
        console.error(`背书失败，检查策略: ${error.message}`);
        throw error;
      }
      // 超时或 MVCC 冲突：指数退避后重试
      if (error instanceof SubmitError || (error as any).code === 'MVCC_READ_CONFLICT') {
        if (attempt === maxRetries) throw error;
        const delay = 2 ** attempt * 1000; // 2s, 4s, 8s
        console.warn(`提交失败，第 ${attempt} 次重试，等待${delay}ms`);
        await new Promise(r => setTimeout(r, delay));
      } else {
        throw error;
      }
    }
  }
  throw new Error('提交失败：超过最大重试次数');
}

// 示例 15-6-1：Express 路由设计（TypeScript）
import express, { Request, Response, NextFunction } from 'express';
import { z } from 'zod';
import { evaluate, submit }       from './fabric-gateway-service';

const app = express();
app.use(express.json());

// 请求体验证 schema
const CreateAssetSchema = z.object({
  id: z.string().min(1),
  owner: z.string(),
  metadata: z.string().optional(),
});

// 注册资产（写操作）
app.post('/api/assets', async (req: Request, res: Response, next: NextFunction) => {
  try {
    const body = CreateAssetSchema.parse(req.body);
    const result = await submit('CreateAsset', body.id, body.owner, body.metadata || '{}');
    // 异步确认：返回 txId，后续通过 /api/transactions/:txId 轮询状态
    return res.status(202).json({ success: true, txId: result, message: '交易已提交' });
  } catch (err) {
    next(err);
  }
});

// 查询单个资产（只读）
app.get('/api/assets/:id', async (req, res, next) => {
  try {
    const result = await evaluate('GetAsset', req.params.id);
    res.json({ success: true, data: JSON.parse(result) });
  } catch (err) {
    next(err);
  }
});

// 查询资产历史（只读）
app.get('/api/assets/:id/history', async (req, res, next) => {
  try {
    const result = await evaluate('GetAssetHistory', req.params.id);
    res.json({ success: true, data: JSON.parse(result) });
  } catch (err) {
    next(err);
  }
});

// 统一错误响应
app.use((err: any, _req: Request, res: Response, _next: NextFunction) => {
  const status = err.status || 500;
  res.status(status).json({ success: false, error: err.message || 'Internal Server Error' });
});

app.listen(3000, () => console.log('REST API 服务已启动: http://localhost:3000'));

#!/bin/bash
# 示例 15-6-4：cURL 快速验证脚本

BASE="http://localhost:3000/api"

# 1. 注册资产
echo "==> 注册资产"
curl -s -X POST ${BASE}/assets \
  -H "Content-Type: application/json" \
  -d '{"id":"vin-8888","owner":"Org1","metadata":"{\"model\":\"Tesla-ModelY\"}"}' | jq .

# 2. 查询资产
echo -e "\n==> 查询资产"
curl -s ${BASE}/assets/vin-8888 | jq .data

# 3. 转移资产
echo -e "\n==> 转移资产"
TX=$(curl -s -X POST${BASE}/assets/vin-8888/transfer \
  -H "Content-Type: application/json" \
  -d '{"newOwner":"Org2"}' | jq -r '.txId')
echo "交易 ID: ${TX}"

# 4. 查询历史（溯源时间线）
echo -e "\n==> 查询资产全生命周期历史"
curl -s ${BASE}/assets/vin-8888/history | jq .data