FISCO解析国密input参数

2023-10-25

国密环境的FISCO BCOS，现在需要解析合约的输入input参数，解析为类似WeBase或浏览器的展示数据。

本文引入web3sdk，修改TransactionDecoder支持国密算法，实现input解析。

解析input，需要对应合约的ABI，如果解析方法是一个，但是有多个合约，建议合并所有合约的ABI为一个实现。合并ABI的时候不用考虑重复情况，TransactionDecoder在build的时候会追加所有合约方法到Map，重复的会自动覆盖。

如果不合并ABI的话，就需要建立映射，建立input与ABI的对应关系，解析时使用对应的ABI解析。

MyTransactionDecoder

重新定义交易编码器，复用TransactionDecoder代码实现，增加国密支持。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;
import org.fisco.bcos.web3j.abi.*;
import org.fisco.bcos.web3j.abi.datatypes.Function;
import org.fisco.bcos.web3j.abi.datatypes.Type;
import org.fisco.bcos.web3j.crypto.gm.sm3.SM3Digest;
import org.fisco.bcos.web3j.protocol.ObjectMapperFactory;
import org.fisco.bcos.web3j.protocol.core.methods.response.AbiDefinition;
import org.fisco.bcos.web3j.protocol.core.methods.response.AbiDefinition.NamedType;
import org.fisco.bcos.web3j.protocol.core.methods.response.Log;
import org.fisco.bcos.web3j.tuples.generated.Tuple2;
import org.fisco.bcos.web3j.tx.txdecode.*;
import org.fisco.bcos.web3j.utils.Numeric;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

public class MyTransactionDecoder {
    private static final Logger logger =
            LoggerFactory.getLogger(org.fisco.bcos.web3j.tx.txdecode.TransactionDecoder.class);
    private String abi;
    private String bin;
    private Map<String, AbiDefinition> methodIDMap;

    public MyTransactionDecoder(String abi) {
        this(abi, "");
    }

    public MyTransactionDecoder(String abi, String bin) {
        this.abi = "";
        this.bin = "";
        this.abi = abi;
        this.bin = bin;
        this.methodIDMap = new HashMap();
        List<AbiDefinition> funcAbiDefinitionList = ContractAbiUtil.getFuncAbiDefinition(abi);
        Iterator var4 = funcAbiDefinitionList.iterator();

        // 修改方法支持国密
        while (var4.hasNext()) {
            AbiDefinition abiDefinition = (AbiDefinition) var4.next();
            String methodSign = this.decodeMethodSign(abiDefinition);
            // String methodID = FunctionEncoder.buildMethodId(methodSign);
            byte[] input = methodSign.getBytes();
            // byte[] hash = Hash.sha3(input);
            byte[] hash = new SM3Digest().hash(input, 0, input.length);
            String methodID = Numeric.toHexString(hash).substring(0, 10);
            this.methodIDMap.put(methodID, abiDefinition);
        }
    }

    private String addHexPrefixToString(String s) {
        return !s.startsWith("0x") ? "0x" + s : s;
    }

    public String decodeInputReturnJson(String input)
            throws JsonProcessingException, BaseException {
        input = this.addHexPrefixToString(input);
        this.selectAbiDefinition(input);
        MyInputAndOutputResult inputAndOutputResult = this.decodeInputReturnObject(input);
        String result =
                ObjectMapperFactory.getObjectMapper().writeValueAsString(inputAndOutputResult);
        return result;
    }

    public MyInputAndOutputResult decodeInputReturnObject(String input) throws BaseException {
        String updatedInput = this.addHexPrefixToString(input);
        AbiDefinition abiDefinition = this.selectAbiDefinition(updatedInput);
        List<NamedType> inputTypes = abiDefinition.getInputs();
        List<TypeReference<?>> inputTypeReferences = ContractAbiUtil.paramFormat(inputTypes);
        Function function = new Function(abiDefinition.getName(), (List) null, inputTypeReferences);
        List<Type> resultType =
                FunctionReturnDecoder.decode(
                        updatedInput.substring(10), function.getOutputParameters());
        List<MyResultEntity> resultList = new ArrayList();

        for (int i = 0; i < inputTypes.size(); ++i) {
            MyResultEntity myResultEntity =
                    new MyResultEntity(
                            ((NamedType) inputTypes.get(i)).getName(),
                            ((NamedType) inputTypes.get(i)).getType(),
                            (Type) resultType.get(i));
            resultList.add(myResultEntity);
        }

        String methodSign = this.decodeMethodSign(abiDefinition);
        // 计算国密方法ID
        byte[] methodSignInput = methodSign.getBytes();
        byte[] hash = new SM3Digest().hash(methodSignInput, 0, methodSignInput.length);
        String methodId = Numeric.toHexString(hash).substring(0, 10);
        return new MyInputAndOutputResult(methodSign, methodId, resultList);
    }

    public String decodeOutputReturnJson(String input, String output)
            throws JsonProcessingException, BaseException {
        InputAndOutputResult inputAndOutputResult = this.decodeOutputReturnObject(input, output);
        String result =
                ObjectMapperFactory.getObjectMapper().writeValueAsString(inputAndOutputResult);
        return result;
    }

    public InputAndOutputResult decodeOutputReturnObject(String input, String output)
            throws BaseException {
        String updatedInput = this.addHexPrefixToString(input);
        String updatedOutput = this.addHexPrefixToString(output);
        AbiDefinition abiDefinition = this.selectAbiDefinition(updatedInput);
        List<NamedType> outputTypes = abiDefinition.getOutputs();
        List<TypeReference<?>> outputTypeReference = ContractAbiUtil.paramFormat(outputTypes);
        Function function = new Function(abiDefinition.getName(), (List) null, outputTypeReference);
        List<Type> resultType =
                FunctionReturnDecoder.decode(updatedOutput, function.getOutputParameters());
        List<ResultEntity> resultList = new ArrayList();

        for (int i = 0; i < outputTypes.size(); ++i) {
            resultList.add(
                    new ResultEntity(
                            ((NamedType) outputTypes.get(i)).getName(),
                            ((NamedType) outputTypes.get(i)).getType(),
                            (Type) resultType.get(i)));
        }

        String methodSign = this.decodeMethodSign(abiDefinition);
        return new InputAndOutputResult(
                methodSign, FunctionEncoder.buildMethodId(methodSign), resultList);
    }

    public String decodeEventReturnJson(String logs) throws BaseException, IOException {
        ObjectMapper mapper = ObjectMapperFactory.getObjectMapper();
        CollectionType listType =
                mapper.getTypeFactory().constructCollectionType(ArrayList.class, Log.class);
        List<Log> logList = (List) mapper.readValue(logs, listType);
        Map<String, List<List<EventResultEntity>>> resultEntityMap =
                this.decodeEventReturnObject(logList);
        String result = mapper.writeValueAsString(resultEntityMap);
        return result;
    }

    public String decodeEventReturnJson(List<Log> logList) throws BaseException, IOException {
        ObjectMapper mapper = ObjectMapperFactory.getObjectMapper();
        Map<String, List<List<EventResultEntity>>> resultEntityMap =
                this.decodeEventReturnObject(logList);
        String result = mapper.writeValueAsString(resultEntityMap);
        return result;
    }

    public Map<String, List<List<EventResultEntity>>> decodeEventReturnObject(List<Log> logList)
            throws BaseException, IOException {
        Map<String, List<List<EventResultEntity>>> resultEntityMap = new LinkedHashMap();
        Iterator var3 = logList.iterator();

        while (var3.hasNext()) {
            Log log = (Log) var3.next();
            Tuple2<AbiDefinition, List<EventResultEntity>> resultTuple2 =
                    this.decodeEventReturnObject(log);
            if (null != resultTuple2) {
                AbiDefinition abiDefinition = (AbiDefinition) resultTuple2.getValue1();
                String eventName = this.decodeMethodSign(abiDefinition);
                if (resultEntityMap.containsKey(eventName)) {
                    ((List) resultEntityMap.get(eventName)).add(resultTuple2.getValue2());
                } else {
                    List<List<EventResultEntity>> eventEntityList = new ArrayList();
                    eventEntityList.add(resultTuple2.getValue2());
                    resultEntityMap.put(eventName, eventEntityList);
                }
            }
        }

        return resultEntityMap;
    }

    public LogResult decodeEventLogReturnObject(Log log) throws BaseException {
        List<AbiDefinition> abiDefinitions = ContractAbiUtil.getEventAbiDefinitions(this.abi);
        LogResult result = new LogResult();
        Iterator var4 = abiDefinitions.iterator();

        while (var4.hasNext()) {
            AbiDefinition abiDefinition = (AbiDefinition) var4.next();
            String eventSignature =
                    EventEncoder.buildEventSignature(this.decodeMethodSign(abiDefinition));
            List<String> topics = log.getTopics();
            if (null != topics
                    && !topics.isEmpty()
                    && ((String) topics.get(0)).equals(eventSignature)) {
                EventValues eventValued = ContractAbiUtil.decodeEvent(log, abiDefinition);
                if (null != eventValued) {
                    List<EventResultEntity> resultEntityList = new ArrayList();
                    List<NamedType> inputs = abiDefinition.getInputs();
                    List<NamedType> indexedInputs =
                            (List)
                                    inputs.stream()
                                            .filter(NamedType::isIndexed)
                                            .collect(Collectors.toList());
                    List<NamedType> nonIndexedInputs =
                            (List)
                                    inputs.stream()
                                            .filter(
                                                    (p) -> {
                                                        return !p.isIndexed();
                                                    })
                                            .collect(Collectors.toList());

                    int i;
                    EventResultEntity eventEntity;
                    for (i = 0; i < indexedInputs.size(); ++i) {
                        eventEntity =
                                new EventResultEntity(
                                        ((NamedType) indexedInputs.get(i)).getName(),
                                        ((NamedType) indexedInputs.get(i)).getType(),
                                        true,
                                        (Type) eventValued.getIndexedValues().get(i));
                        resultEntityList.add(eventEntity);
                    }

                    for (i = 0; i < nonIndexedInputs.size(); ++i) {
                        eventEntity =
                                new EventResultEntity(
                                        ((NamedType) nonIndexedInputs.get(i)).getName(),
                                        ((NamedType) nonIndexedInputs.get(i)).getType(),
                                        false,
                                        (Type) eventValued.getNonIndexedValues().get(i));
                        resultEntityList.add(eventEntity);
                    }

                    result.setLogParams(resultEntityList);
                    result.setLog(log);
                    logger.debug(" event log result: {}", result);
                    return result;
                }
            }
        }

        return null;
    }

    public Tuple2<AbiDefinition, List<EventResultEntity>> decodeEventReturnObject(Log log)
            throws BaseException, IOException {
        Tuple2<AbiDefinition, List<EventResultEntity>> result = null;
        List<AbiDefinition> abiDefinitions = ContractAbiUtil.getEventAbiDefinitions(this.abi);
        Iterator var4 = abiDefinitions.iterator();

        while (var4.hasNext()) {
            AbiDefinition abiDefinition = (AbiDefinition) var4.next();
            String eventSignature =
                    EventEncoder.buildEventSignature(this.decodeMethodSign(abiDefinition));
            List<String> topics = log.getTopics();
            if (null != topics
                    && !topics.isEmpty()
                    && ((String) topics.get(0)).equals(eventSignature)) {
                EventValues eventValued = ContractAbiUtil.decodeEvent(log, abiDefinition);
                if (null != eventValued) {
                    List<EventResultEntity> resultEntityList = new ArrayList();
                    List<NamedType> inputs = abiDefinition.getInputs();
                    List<NamedType> indexedInputs =
                            (List)
                                    inputs.stream()
                                            .filter(NamedType::isIndexed)
                                            .collect(Collectors.toList());
                    List<NamedType> nonIndexedInputs =
                            (List)
                                    inputs.stream()
                                            .filter(
                                                    (p) -> {
                                                        return !p.isIndexed();
                                                    })
                                            .collect(Collectors.toList());

                    int i;
                    EventResultEntity eventEntity;
                    for (i = 0; i < indexedInputs.size(); ++i) {
                        eventEntity =
                                new EventResultEntity(
                                        ((NamedType) indexedInputs.get(i)).getName(),
                                        ((NamedType) indexedInputs.get(i)).getType(),
                                        true,
                                        (Type) eventValued.getIndexedValues().get(i));
                        resultEntityList.add(eventEntity);
                    }

                    for (i = 0; i < nonIndexedInputs.size(); ++i) {
                        eventEntity =
                                new EventResultEntity(
                                        ((NamedType) nonIndexedInputs.get(i)).getName(),
                                        ((NamedType) nonIndexedInputs.get(i)).getType(),
                                        false,
                                        (Type) eventValued.getNonIndexedValues().get(i));
                        resultEntityList.add(eventEntity);
                    }

                    result = new Tuple2(abiDefinition, resultEntityList);
                    break;
                }
            }
        }

        return result;
    }

    private AbiDefinition selectAbiDefinition(String input) throws BaseException {
        String methodID = input.substring(0, 10);
        AbiDefinition abiDefinition = (AbiDefinition) this.methodIDMap.get(methodID);
        if (abiDefinition == null) {
            throw new BaseException(
                    201203,
                    String.format("the method is not found in abi, method id:[%s]", methodID));
        } else {
            return abiDefinition;
        }
    }

    private String decodeMethodSign(AbiDefinition abiDefinition) {
        List<NamedType> inputTypes = abiDefinition.getInputs();
        StringBuilder methodSign = new StringBuilder();
        methodSign.append(abiDefinition.getName());
        methodSign.append("(");
        String params =
                (String)
                        inputTypes.stream()
                                .map(NamedType::getType)
                                .collect(Collectors.joining(","));
        methodSign.append(params);
        methodSign.append(")");
        return methodSign.toString();
    }
}

MyResultEntity

自定义MyResultEntity，复用ResultEntity实现，配合其他类实现返回结果体。

import com.alipay.api.internal.util.codec.Base64;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonProcessingException;
import org.fisco.bcos.web3j.abi.datatypes.*;
import org.fisco.bcos.web3j.protocol.ObjectMapperFactory;

import java.util.ArrayList;
import java.util.List;

public class MyResultEntity {
    private String name;
    private String type;
    private Object data;
    @JsonIgnore private Type typeObject;

    public MyResultEntity(String name, String type, Type data) {
        this.name = name;
        this.type = type;
        this.data = typeToObject(data);
        this.typeObject = data;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return this.type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String toJson() throws JsonProcessingException {
        return ObjectMapperFactory.getObjectMapper().writeValueAsString(this);
    }

    public Object getData() {
        return this.data;
    }

    public Type getTypeObject() {
        return this.typeObject;
    }

    public void setData(Type data) {
        this.data = data;
    }

    public static Object typeToObject(Type type) {
        Object obj = null;
        if (type instanceof NumericType) {
            obj = ((NumericType) type).getValue();
        } else if (type instanceof Bool) {
            obj = ((Bool) type).getValue();
        } else if (type instanceof Address) {
            obj = type.toString();
        } else if (type instanceof Bytes) {
            // obj = (new String(((Bytes) type).getValue(), StandardCharsets.UTF_8)).trim();
            obj = Base64.encodeBase64String(((Bytes) type).getValue());
        } else if (type instanceof DynamicBytes) {
            // obj = (new String(((DynamicBytes) type).getValue(), StandardCharsets.UTF_8)).trim();
            obj = Base64.encodeBase64String(((DynamicBytes) type).getValue());
        } else if (type instanceof Utf8String) {
            obj = ((Utf8String) type).getValue();
        } else if (type instanceof Array) {
            List<Object> r = new ArrayList();
            List l = ((Array) type).getValue();

            for (int i = 0; i < l.size(); ++i) {
                r.add(typeToObject((Type) l.get(i)));
            }

            obj = r;
        } else {
            obj = obj;
        }

        return obj;
    }

    @Override
    public String toString() {
        return "ResultEntity [name="
                + this.name
                + ", type="
                + this.type
                + ", data="
                + this.data
                + "]";
    }
}

MyInputAndOutputResult

自定义MyInputAndOutputResult，复用InputAndOutputResult实现，实现输入输出结果返回。

import java.util.List;

public class MyInputAndOutputResult {
    private String function;
    private String methodID;
    private List<MyResultEntity> result;

    public MyInputAndOutputResult() {}

    public MyInputAndOutputResult(String function, String methodID, List<MyResultEntity> result) {
        this.function = function;
        this.methodID = methodID;
        this.result = result;
    }

    public String getFunction() {
        return this.function;
    }

    public void setFunction(String function) {
        this.function = function;
    }

    public String getMethodID() {
        return this.methodID;
    }

    public void setMethodID(String methodID) {
        this.methodID = methodID;
    }

    public List<MyResultEntity> getResult() {
        return this.result;
    }

    public void setResult(List<MyResultEntity> result) {
        this.result = result;
    }

    @Override
    public String toString() {
        return "InputAndOutputResult [function="
                + this.function
                + ", methodID="
                + this.methodID
                + ", result="
                + this.result
                + "]";
    }
}

GetInputResp

自定义的业务返回体，返回最终前端需要的数据。

import com.btsi.base.bcos.MyInputAndOutputResult;
import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 获取交易输入响应实体
 * @date 2023/8/1 12:19 PM
 */
@EqualsAndHashCode(callSuper = true)
@Data
@Builder
@AllArgsConstructor
@ApiModel(value = "GetInputResp", description = "获取交易输入响应实体")
public class GetInputResp extends MyInputAndOutputResult {
}

TxParseServiceImpl

自定义的业务层，调用编码交易等base类，实现解析。

@Override
public GetInputResp getInput(GetInputReq req) {

    // 构造Lambda表达式，从数据库获取合约ABI
    // 默认取ID为1的合约ABI
    AbiEntity abiEntity = abiService.getById(1);
    // 判断合约ABI是否为空
    if (abiEntity == null || StringUtils.isBlank(abiEntity.getContent())) {
        log.error("合约ABI为空");

        throw new BTSIException("合约ABI为空，请检查后重试！");
    }

    try {
        // 构造交易解析对象
        // 使用国密算法 计算方法签名
        MyTransactionDecoder myTransactionDecoder =
                new MyTransactionDecoder(abiEntity.getContent(), "");

        // 解析交易
        MyInputAndOutputResult inputAndOutputResult =
                myTransactionDecoder.decodeInputReturnObject(req.getInputData());

        // 判断交易解析结果是否为空
        if (inputAndOutputResult == null) {
            log.error("交易解析结果为空");

            throw new BTSIException("交易解析结果为空，请检查后重试！");
        }

        // 构造交易解析响应实体
        GetInputResp resp = new GetInputResp();
        BeanUtils.copyProperties(inputAndOutputResult, resp);
        return resp;
    } catch (Exception e) {
        log.error("交易解析失败，原因：{}", e.getMessage());

        throw new BTSIException("交易解析失败，请检查后重试！");
    }
}