FISCO-3-3-0-SDK拆分签名上链为两步骤

2023-10-29

在FISCO应用中，有些时候需要把上链拆分为两步骤，而不是一次性就完成签名上链，一次性上链对用户保管的私钥是不友好的。

拆分为两步骤：

构造待签名的数据返回用户；
用户使用自己保管的私钥完成签名；
上链签名后的数据。

本文提供了FISCO-3.3.0版本SDK拆分两步骤上链的demo。

签名Base

签名包服务结构如下：

sign下有data和helper两个包，data下有Transaction和TransactionDataInfo两个类，helper下有SignHelper一个类。

Transaction作为返回体，返回用户待签名数据体。

TransactionDataInfo用于接受SDK返回的待签名参数，再部分赋值到Transaction返回用户。

SignHelper是签名辅助类，签名相关的方法都封装再这个类，提供对外调用服务。

Transaction

import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 交易签名传参
 * @date 2023/8/21 4:50 PM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class Transaction {

    @ApiModelProperty(value = "交易json")
    private String jsonData;

    @ApiModelProperty(value = "交易属性")
    private Integer attribute;

    @ApiModelProperty(value = "交易hash；需要使用本地密钥完成签名")
    private String hash;

    @ApiModelProperty(value = "交易签名")
    private String sign;
}

TransactionDataInfo

import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 交易数据信息
 * @date 2023/8/21 4:18 PM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class TransactionDataInfo {

    @ApiModelProperty(value = "交易数据hex")
    private String hexData;

    @ApiModelProperty(value = "交易数据json")
    private String jsonData;

    @ApiModelProperty(value = "交易数据附加")
    private Integer attribute;

    @ApiModelProperty(value = "交易数据hash")
    private String dataHash;
}

SignHelper

import com.btsi.bcos.base.sign.data.TransactionDataInfo;
import lombok.extern.slf4j.Slf4j;
import org.fisco.bcos.sdk.jni.common.JniException;
import org.fisco.bcos.sdk.jni.utilities.tx.TransactionBuilderJniObj;
import org.fisco.bcos.sdk.v3.client.Client;
import org.fisco.bcos.sdk.v3.client.protocol.response.BcosTransactionReceipt;
import org.fisco.bcos.sdk.v3.codec.FunctionEncoderInterface;
import org.fisco.bcos.sdk.v3.codec.abi.FunctionEncoder;
import org.fisco.bcos.sdk.v3.codec.datatypes.Function;
import org.fisco.bcos.sdk.v3.crypto.CryptoSuite;
import org.fisco.bcos.sdk.v3.crypto.signature.SignatureResult;
import org.fisco.bcos.sdk.v3.model.TransactionReceipt;
import org.fisco.bcos.sdk.v3.model.callback.TransactionCallback;
import org.fisco.bcos.sdk.v3.utils.Hex;

import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 签名Helper
 * @date 2023/8/21 4:16 PM
 */
@Slf4j
public class SignHelper {

    /** 定义签名Client */
    private final Client client;

    public SignHelper(Client client) {
        this.client = client;
    }

    /**
     * 准备交易数据
     *
     * @param function 参数
     * @param abi abi
     * @param contractAddress 合约地址
     * @return TransactionDataInfo
     * @throws JniException
     */
    public TransactionDataInfo prepareTransaction(
            Function function, String abi, String contractAddress) throws JniException {

        // 编码参数
        FunctionEncoderInterface functionEncoder = new FunctionEncoder(client.getCryptoSuite());
        byte[] data = functionEncoder.encode(function);

        // 创建交易数据
        long transactionData =
                TransactionBuilderJniObj.createTransactionData(
                        client.getGroup(),
                        client.getChainId(),
                        contractAddress,
                        Hex.toHexString(data),
                        abi,
                        client.getBlockLimit().longValue());

        // 计算交易哈希
        String hash =
                TransactionBuilderJniObj.calcTransactionDataHash(
                        client.getCryptoSuite().getCryptoTypeConfig(), transactionData);

        // 编码交易数据
        String transactionDataHex = TransactionBuilderJniObj.encodeTransactionData(transactionData);

        // 获取交易json
        String jsonTrans =
                TransactionBuilderJniObj.decodeTransactionDataToJsonObj(transactionDataHex);

        // 返回交易数据
        return new TransactionDataInfo()
                .setHexData(transactionDataHex)
                .setJsonData(jsonTrans)
                .setAttribute(
                        generateTxAttributeWithDagFlag(
                                function.getName(), function.getTransactionAttribute()))
                .setDataHash(Hex.toHexString(Hex.decode(hash)));
    }

    /**
     * 生成交易属性
     *
     * @param functionName 函数名
     * @param dagAttribute dag属性
     * @return int
     */
    protected int generateTxAttributeWithDagFlag(String functionName, int dagAttribute) {
        Boolean enableDAG = false;
        int txAttribute = this.generateTransactionAttribute(functionName);
        int dagFlag = dagAttribute;
        if (enableDAG) {
            dagFlag = 4;
        }

        txAttribute |= dagFlag;
        return txAttribute;
    }

    /**
     * 生成交易属性
     *
     * @param funcName 函数名
     * @return int
     */
    private int generateTransactionAttribute(String funcName) {
        int attribute = 0;
        if (client.isWASM()) {
            attribute = 2;
            if (Objects.equals(funcName, "deploy")) {
                attribute |= 8;
            }
        } else {
            attribute |= 1;
        }

        return attribute;
    }

    /**
     * 签名
     *
     * @param hash hash
     * @return String
     */
    public String sign(String hash) {
        byte[] hashBytes = Hex.decode(hash);
        CryptoSuite cryptoSuite = client.getCryptoSuite();
        SignatureResult sign = cryptoSuite.sign(hashBytes, cryptoSuite.getCryptoKeyPair());
        return sign.convertToString() + cryptoSuite.getCryptoKeyPair().getHexPublicKey();
    }

    /**
     * 创建交易
     *
     * @param transactionDataJson 交易数据
     * @param attribute 交易属性
     * @param signHash 签名hash
     * @param sign 签名
     * @return String
     * @throws JniException
     */
    public String createTransaction(
            String transactionDataJson, int attribute, String signHash, String sign)
            throws JniException {
        long transactionDataPointer =
                TransactionBuilderJniObj.createTransactionDataWithJson(transactionDataJson);
        return TransactionBuilderJniObj.createSignedTransaction(
                transactionDataPointer, sign, signHash, attribute);
    }

    /**
     * 发送交易
     *
     * @param transaction
     * @return
     */
    public BcosTransactionReceipt sendTransaction(String transaction) {
        return client.sendTransaction(transaction, false);
    }

    /**
     * 发送交易
     *
     * @param transaction 交易
     * @return TransactionReceipt
     */
    public TransactionReceipt sendTransactionSync(String transaction) {
        CompletableFuture<TransactionReceipt> future = new CompletableFuture<>();
        client.sendTransactionAsync(
                transaction,
                false,
                new TransactionCallback() {
                    @Override
                    public void onResponse(TransactionReceipt receipt) {
                        log.info("receipt:{}", receipt);

                        future.complete(receipt);
                    }
                });
        TransactionReceipt transactionReceipt = null;
        try {
            transactionReceipt = future.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        return transactionReceipt;
    }
}

签名实现服务层

上文提供了签名的Base服务，现在使用Base服务，实现签名业务。

某合约创建类别方法

调用SignHelper，返回待签名数据。

public TransactionDataInfo createCategory(
        Client client, String categoryName, String metadata, String contractAddress)
        throws JniException {
    final Function function =
            new Function(
                    FUNC_CREATECATEGORY,
                    Arrays.<Type>asList(new Utf8String(categoryName), new Utf8String(metadata)),
                    Collections.<TypeReference<?>>emptyList(),
                    0);

    // 初始化sign
    SignHelper signHelper = new SignHelper(client);

    // 生成签名
    return signHelper.prepareTransaction(function, "", contractAddress);
}

返回待签名数据到用户

// 获取待签名数据
TransactionDataInfo transactionDataInfo =
        bTSIDAC.createCategory(
                client,
                createCategoryReq.getCategoryName(),
                createCategoryReq.getMetadata(),
                authentication.getDacContractAddress());

// 构造返回对象
return CreateCategoryResp.builder()
        .transaction(
                new Transaction()
                        .setJsonData(transactionDataInfo.getJsonData())
                        .setAttribute(transactionDataInfo.getAttribute())
                        .setHash(transactionDataInfo.getDataHash()))
        .build();

用户使用私钥自行签名

// 获取服务端返回的Transaction
    JSONObject jsonObject = JSON.parseObject(result);
    JSONObject jsonObjectData = JSON.parseObject(jsonObject.getString("data"));
    Transaction transaction =
            JSON.parseObject(jsonObjectData.getString("transaction"), Transaction.class);

    /// 签名 ///

// 编码交易
    byte[] hashBytes = Hex.decode(transaction);

// 指定签名身份
// privateKey为签名者私钥
    CryptoSuite cryptoSuite = new CryptoSuite(1);
    CryptoKeyPair sm2KeyPair = cryptoSuite.loadKeyPair(privateKey);

// 签名
    SignatureResult sign = cryptoSuite.sign(hashBytes, cryptoSuite.getCryptoKeyPair());
    String signedData =
            sign.convertToString() + cryptoSuite.getCryptoKeyPair().getHexPublicKey();

// 设置签名到Transaction
    transaction.setSign(signedData);

// SignHelper也有签名方法sign，不过指定的是Client的账户，在大多数自签名场景不适用，需要修改为用户传递私钥生成CryptoSuite，再进行签名。

发送交易上链方法

/**
 * 发送交易
 *
 * <p>全局通用
 *
 * @param client 客户端
 * @param transaction 交易
 * @return 交易回执
 * @throws JniException
 */
public TransactionReceipt sendTransaction(Client client, Transaction transaction)
        throws JniException {

    // 初始化sign
    SignHelper signHelper = new SignHelper(client);

    // 构造签名后的交易
    String t =
            signHelper.createTransaction(
                    transaction.getJsonData(),
                    transaction.getAttribute(),
                    transaction.getHash(),
                    transaction.getSign());

    // 上链
    return signHelper.sendTransaction(t).getTransactionReceipt();
}

实现上链

// 调用合约方法mint
TransactionReceipt transactionReceipt =
        bTSIDAC.sendTransaction(client, createCategoryReq.getTransaction());

// 从 Emit EVENT log 解析出类别ID
// 获取事件列表
List<BTSIDAC.CreateCategoryEventResponse> responseList =
        bTSIDAC.getCreateCategoryEvents(transactionReceipt);
// 只能单个操作，所以直接取第一个事件即可
BTSIDAC.CreateCategoryEventResponse response = responseList.get(0);

// 获取类别ID
BigInteger categoryId = response.categoryID;

// 构造返回对象
CreateCategoryResp createCategoryResp =
        CreateCategoryResp.builder().categoryId(categoryId).build();
createCategoryResp.setTransactionReceipt(transactionReceipt);
// 设置交易哈希
createCategoryResp.setTransactionHash(transactionReceipt.getTransactionHash());

// 返回
return createCategoryResp;