FISCO链地址授权

FISCO链地址授权

FISCO方式（私钥）

请求实体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @description 外部地址账户授权输入实体
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class ApprovalForAllWithPublicUserCmd {

    // 用户私钥
    private String privateKey;

    // 用户公钥
    private String publicKey;

    // 用户地址
    private String ownerAddress;

    // 验证密钥串
    private String verifySecret;
}

秘钥串验证工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import lombok.extern.slf4j.Slf4j;
import org.folkspace.fisco.config.SecretConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/** 验证后端身份 */
@Slf4j
@Component
public class VerifySecretHelper {

    @Autowired
    private SecretConfig secretConfig;

    public Boolean verifySecret(String secret) {
        //        log.info(secretConfig.getSECRET());
        //        log.info(secret);
        // 去除双引号
        String secretReplace = secret.replace("\"", "").replace("\"", "");
        if (secretConfig.getSECRET().equals(secretReplace)) {
            return Boolean.TRUE;
        } else {
            return Boolean.FALSE;
        }
    }
}

交易服务类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@Service
@NoArgsConstructor
@Data
public class ERC1155MixedFungibleMintableService {
    public static final String ABI = IOUtil.readResourceAsString("abi/ERC1155MixedFungibleMintable.abi");

    //  public static final String BINARY = org.example.nft1155demo.utils.IOUtil.readResourceAsString("bin/ecc/ERC1155MixedFungibleMintable.bin");

    //  public static final String SM_BINARY = org.example.nft1155demo.utils.IOUtil.readResourceAsString("bin/sm/ERC1155MixedFungibleMintable.bin");

    @Value("${system.contract.eRC1155MixedFungibleMintableAddress}")
    private String address;

    @Autowired
    private Client client;

    AssembleTransactionProcessor txProcessor;

    @Autowired
    KeyToolSignTransaction keyToolSignTransaction;

    @PostConstruct
    public void init() throws Exception {
        this.txProcessor = TransactionProcessorFactory.createAssembleTransactionProcessor(this.client, this.client.getCryptoSuite().getCryptoKeyPair());
    }
  
    /**
     * 查看所有者 _owner 是否授权给用户 _operator
     *
     * @param input
     * @return
     * @throws Exception
     */
    public CallResponse isApprovedForAll(ERC1155MixedFungibleMintableIsApprovedForAllInputBO input) throws Exception {
        return this.txProcessor.sendCall(this.client.getCryptoSuite().getCryptoKeyPair().getAddress(), this.address, ABI, "isApprovedForAll", input.toArgs());
    }
  
    /**
     * 创建ABICodec对象
     *
     * @param client client对象
     * @return: 创建的ABICodec对象
     */
    public ABICodec createABICodec(Client client) {
        return new ABICodec(client.getCryptoSuite());
    }

    /**
     * 对合约调用类型的交易进行编码
     *
     * @param abiCodec   用于编码交易内容的ABICodeC对象
     * @param abiContent 合约的abi字符串(需要读取第1节生成的abi文件获取)
     * @param methodName 需要调用的合约方法名
     * @param params     调用合约的参数列表
     * @return 编码后的交易内容
     */
    public String encodeMethod(ABICodec abiCodec, String abiContent, String methodName, List<Object> params) throws ABICodecException {
        return abiCodec.encodeMethod(abiContent, methodName, params);
    }

    // 构造交易
    public TransactionReceipt sendTransactionAndGetReceipt(CryptoKeyPair cryptoKeyPair, String methodName, List<Object> params) {
        try {
            // 1.创建ABICodeC对象
            ABICodec abiCodec = createABICodec(client);

            // 2.编码交易内容
            String txData = encodeMethod(abiCodec, ABI, methodName, params);

            return this.txProcessor.sendTransactionAndGetReceipt(this.address, txData, cryptoKeyPair);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

}

判断授权 + 执行授权

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/**
 * @description FISCO关于NFT的铸造、增发、授权、转赠服务
 * @since 2022-04-15
 */
@Service
@Slf4j
public class ERC1155Helper {

    @Autowired private ERC1155MixedFungibleMintableService erc1155MixedFungibleMintableService;

    /**
     * 查询是否授权平台操作
     *
     * @return
     * @throws Exception
     */
    public Boolean isApprovedForAll(String ownerAddress) throws Exception {

        ERC1155MixedFungibleMintableIsApprovedForAllInputBO
                erc1155MixedFungibleMintableIsApprovedForAllInputBO =
                        ERC1155MixedFungibleMintableIsApprovedForAllInputBO.builder()
                                ._owner(ownerAddress)
                                ._operator(plateAddress)
                                .build();

        CallResponse callResponse =
                erc1155MixedFungibleMintableService.isApprovedForAll(
                        erc1155MixedFungibleMintableIsApprovedForAllInputBO);

        if ((Boolean) callResponse.getReturnObject().get(0)) {
            return true;
        } else {
            return false;
        }
    }

    public Boolean setApprovalForAllFISCO(String privateKey) {
        try {
            // 合约地址
            // String to = "0x15bc967f32927dbcdde9360a5d623ccf9b65aac9";
            // String abi =
            // "[{\"constant\":false,\"inputs\":[{\"name\":\"n\",\"type\":\"string\"}],\"name\":\"set\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"get\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]";
            // String privateKey =
            // "d53369b4d969c4bf69df3d2294c6787e6f526dd4bc6db46492c73c1b83c4008a";

            ERC1155MixedFungibleMintableSetApprovalForAllInputBO approvalForAllInputBO =
                    ERC1155MixedFungibleMintableSetApprovalForAllInputBO.builder()
                            ._approved(true)
                            ._operator(plateAddress)
                            .build();

            org.fisco.bcos.sdk.crypto.CryptoSuite cryptoSuite =
                    new org.fisco.bcos.sdk.crypto.CryptoSuite(0);
            org.fisco.bcos.sdk.crypto.keypair.CryptoKeyPair cryptoKeyPair =
                    cryptoSuite.createKeyPair(privateKey);

            TransactionReceipt transactionReceipt =
                    erc1155MixedFungibleMintableService.sendTransactionAndGetReceipt(
                            cryptoKeyPair, "setApprovalForAll", approvalForAllInputBO.toArgs());
            log.info(
                    "transactionReceipt {} hash {} ",
                    transactionReceipt.getStatus(),
                    transactionReceipt.getTransactionHash());

            if (transactionReceipt == null) {
                log.info("没有返回transactionReceipt");
                return false;
            }

            // 判断返回码
            if (transactionReceipt.getStatus().substring(2).equals("")) {
                return false;
            }

            int status = Integer.parseInt(transactionReceipt.getStatus().substring(2), 16);

            if (0 != status) {
                return false;
            }

            log.info("授权平台地址成功-FISCO");
            return true;

        } catch (Exception e) {
            log.info(e.getMessage());

            return false;
        }
    }

}

执行授权

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@PostMapping("/approve")
public ServerResponse isApprovedForAllFISCO(ApprovalForAllWithPublicUserCmd cmd)
        throws Exception {
    // 密钥串验证失败
    if (!verifySecretHelper.verifySecret(cmd.getVerifySecret())) {
        log.error(cmd.getVerifySecret() + ": " + ResponseEnum.FAIL_VERIFY_SECRET);
        return ServerResponse.getInstance()
                .failed()
                .responseEnum(ResponseEnum.FAIL_VERIFY_SECRET);
    }

    // 判断是否已经授权
    Boolean result = erc1155Helper.isApprovedForAll(cmd.getOwnerAddress());
    if (result) {
        return ServerResponse.getInstance().ok();
    }

    // 执行授权
    Boolean result2 = erc1155Helper.setApprovalForAllFISCO(cmd.getPrivateKey());
    if (!result2) {
        return ServerResponse.getInstance().failed().responseEnum(FAIL_APPROVE_NFT);
    }
    return ServerResponse.getInstance().ok();
}

WeBase方式（签名）

控制层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@RestController
@RequestMapping("/fisco")
@Slf4j
public class FISCOController {

    @Autowired private ERC1155Helper erc1155Helper;
    @Autowired private VerifySecretHelper verifySecretHelper;
    @Autowired private NftTransferRecordService nftTransferRecordService;

    @PostMapping("/approve/webase")
    public ServerResponse approve(ApprovalForAllWithPublicUserCmd cmd) throws Exception {
        // 密钥串验证失败
        if (!verifySecretHelper.verifySecret(cmd.getVerifySecret())) {
            log.error(cmd.getVerifySecret() + ": " + ResponseEnum.FAIL_VERIFY_SECRET);
            return ServerResponse.getInstance()
                    .failed()
                    .responseEnum(ResponseEnum.FAIL_VERIFY_SECRET);
        }

        // 判断是否授权
        Boolean result = erc1155Helper.isApprovedForAll(cmd.getOwnerAddress());
        if (result) {
            return ServerResponse.getInstance().ok();
        }

        // 执行授权
        Boolean result2 = erc1155Helper.setApprovalForAllWithPublicUser(cmd);
        if (!result2) {
            return ServerResponse.getInstance().failed().responseEnum(FAIL_APPROVE_NFT);
        }
        return ServerResponse.getInstance().ok();
    }
}

服务Helper类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
@Service
@Slf4j
public class ERC1155Helper {

    @Autowired private ERC1155MixedFungibleMintableService erc1155MixedFungibleMintableService;
    @Autowired private RawDataApprovalHelper rawDataApprovalHelper;
    @Autowired private ContractModifyHelper contractHelperModify;

    @Value(value = "${system.plate.address}")
    private String plateAddress;

    /**
     * 查询是否授权平台操作
     *
     * @return
     * @throws Exception
     */
    public Boolean isApprovedForAll(String ownerAddress) throws Exception {

        ERC1155MixedFungibleMintableIsApprovedForAllInputBO
                erc1155MixedFungibleMintableIsApprovedForAllInputBO =
                        ERC1155MixedFungibleMintableIsApprovedForAllInputBO.builder()
                                ._owner(ownerAddress)
                                ._operator(plateAddress)
                                .build();

        CallResponse callResponse =
                erc1155MixedFungibleMintableService.isApprovedForAll(
                        erc1155MixedFungibleMintableIsApprovedForAllInputBO);

        if ((Boolean) callResponse.getReturnObject().get(0)) {
            return true;
        } else {
            return false;
        }
    }
  
    /**
     * 地址授权平台
     *
     * @param approvalForAllWithPublicUserCmd
     * @throws Exception
     */
    public Boolean setApprovalForAllWithPublicUser(
            ApprovalForAllWithPublicUserCmd approvalForAllWithPublicUserCmd) throws Exception {
        // String privateKey = "d53369b4d969c4bf69df3d2294c6787e6f526dd4bc6db46492c73c1b83c4008a";
        // String address = "0x4f86a3e86fbba9972a59f2b497012c4385db6a66";
        // String publicKey =
        // "04818ba0c0ba1dca113a0f1f9e656af812502c37ab562e2f76f1794b4fcdbc1c710da26f39d26f94747111783b24d4e97a7f6350c942f844463c40ea89913cd7cc";

        // String plateAddress = "0xb3fa56b3a79d9541b5cbc257e3cb3c7c7ac3a965";

        // 构造授权实体
        ERC1155MixedFungibleMintableSetApprovalForAllInputBO approvalForAllInputBO =
                ERC1155MixedFungibleMintableSetApprovalForAllInputBO.builder()
                        ._approved(true)
                        ._operator(plateAddress)
                        .build();

        // 交易随机数
        String randomId = new BigInteger(250, new SecureRandom()).toString();

        // 构造RawTx
        GetRawTxApprovalCmd getRawTxApprovalCmd =
                GetRawTxApprovalCmd.builder()
                        .erc1155MixedFungibleMintableSetApprovalForAllInputBO(approvalForAllInputBO)
                        .randomId(randomId)
                        .privateKey(approvalForAllWithPublicUserCmd.getPrivateKey())
                        .publicKey(approvalForAllWithPublicUserCmd.getPublicKey())
                        .build();

        // 获取RawData
        RawTransaction rawTransaction =
                rawDataApprovalHelper.getRawDataApprovalRawTransaction(getRawTxApprovalCmd);
        // String dataWithOutSign =
        // rawDataApprovalHelper.getRawDataApprovalString(getRawTxApprovalCmd);
        String dataWithOutSign = contractHelperModify.encodeBytesModify(rawTransaction);

        String signedData =
                contractHelperModify.sign(dataWithOutSign, getRawTxApprovalCmd.getPrivateKey());

        TxReceipt txReceipt =
                contractHelperModify.push(
                        getRawTxApprovalCmd.getPublicKey(), signedData, rawTransaction);

        if (txReceipt == null) {
            log.info("没有返回txReceipt");
            return false;
        }

        // 判断返回码
        if (txReceipt.getOutput().substring(2).equals("")) {
            log.info("setApprovalForAll Failed,Tx_Hash:" + txReceipt.getTransactionHash());
            log.info("                    Output :" + txReceipt.getOutput());
            return false;
        }

        int outputCode = Integer.parseInt(txReceipt.getOutput().substring(2), 16);

        if (0 != outputCode) {
            log.info("setApprovalForAll,Tx_Hash:" + txReceipt.getTransactionHash());
            log.info("                    Output :" + txReceipt.getOutput());
            return false;
        }

        log.info("授权平台地址成功-WeBase");
        return true;
    }
}

请求实体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * @description 外部地址账户授权输入实体
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class ApprovalForAllWithPublicUserCmd {

    // 用户私钥
    private String privateKey;

    // 用户公钥
    private String publicKey;

    // 用户地址
    private String ownerAddress;

    // 验证密钥串
    private String verifySecret;
}

WeBase交易输入实体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * @description 发起合约交易输入实体
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class GetRawTxApprovalCmd {

    // 地址授权BO
    ERC1155MixedFungibleMintableSetApprovalForAllInputBO erc1155MixedFungibleMintableSetApprovalForAllInputBO;

    // 交易随机数
    String randomId;

    // 用户私钥
    String privateKey;

    // 用户公钥
    String publicKey;
}

签名授权数据Helper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * @description 合约交易签名模块
 * @since 2022-04-15
 */
@Service
@Slf4j
public class RawDataApprovalHelper {

    @Autowired
    private ContractModifyHelper contractHelperModify;

    // 获取需要用户签名的RawData，返回
    public RawTransaction getRawDataApprovalRawTransaction(GetRawTxApprovalCmd getRawTxApprovalCmd) throws Exception {
        // 1、生成编码后的交易信息
        String encodedTransaction = contractHelperModify.generateSetApprovalForAllEncodedTransaction(getRawTxApprovalCmd.getErc1155MixedFungibleMintableSetApprovalForAllInputBO());
        // 2、构建rawTransaction，需要存储在某个地方，因为向链上发交易的时候再次编码需要使用此信息
        RawTransaction rawTransaction = contractHelperModify.buildRawTransaction(encodedTransaction, new BigInteger(getRawTxApprovalCmd.getRandomId()));

        return rawTransaction;
    }

    // 获取需要用户签名的RawData，返回
    public String getRawDataApprovalString(GetRawTxApprovalCmd getRawTxApprovalCmd) throws Exception {
        // 1、生成编码后的交易信息
        String encodedTransaction = contractHelperModify.generateSetApprovalForAllEncodedTransaction(getRawTxApprovalCmd.getErc1155MixedFungibleMintableSetApprovalForAllInputBO());
        // 2、构建rawTransaction，需要存储在某个地方，因为向链上发交易的时候再次编码需要使用此信息
        RawTransaction rawTransaction = contractHelperModify.buildRawTransaction(encodedTransaction, new BigInteger(getRawTxApprovalCmd.getRandomId()));
        // 3、生成待签名的数据
        String waitForSignData = contractHelperModify.encodeBytesModify(rawTransaction);

        return waitForSignData;
    }
}

合约交易确认Helper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
/**
 * @description 合约交易确认模块
 * @since 2022-04-15
 */
@Service
@NoArgsConstructor
@Data
@Slf4j
public class ContractModifyHelper {

    public static final String ABI = ERC1155MixedFungibleMintable.ABI;

    @Value(value = "${fisco.contract.eRC1155MixedFungibleMintableAddress}")
    private String contractAddress;
    @Value(value = "${fisco.groupId}")
    private String chainId;
    @Value(value = "${fisco.groupId}")
    private Long groupId;
    @Value(value = "${fisco.webaseUrl}")
    private String webaseUrl;

    private CryptoSuite cryptoSuite;
    private ABICodec abiCodec;
    private MyTransactionEncoderService myTransactionEncoderService;
    @Autowired
    private Client client;

    @PostConstruct
    public void init() throws Exception {
        cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
        abiCodec = new ABICodec(cryptoSuite);
        myTransactionEncoderService = new MyTransactionEncoderService(cryptoSuite);
    }

    /**
     * 用户自签名场景下，调用 setApprovalForAll 函数根据传入的参数得到需要被签名的字符串
     *
     * @param bo ERC1155MixedFungibleMintableSetApprovalForAllInputBO对象
     * @return 需要被编码的字符串
     * @throws ABICodecException
     */
    public String generateSetApprovalForAllEncodedTransaction(ERC1155MixedFungibleMintableSetApprovalForAllInputBO bo) throws ABICodecException {
        String functionName = "setApprovalForAll";
        List<Object> params = bo.toArgs();
        return encodeRawData(ABI, functionName, params);
    }

    /**
     * @param ABI        合约的ABI编码
     * @param methodName 合约的函数名
     * @param params     合约的函数list
     * @return 编码后需要被签名的字符串
     * @throws ABICodecException
     */
    public String encodeRawData(String ABI, String methodName, List<Object> params) throws ABICodecException {
        // CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);

        return abiCodec.encodeMethod(ABI, methodName, params);
    }

    /**
     * 向链上发送交易
     *
     * @param publicKey 发送者的公钥
     * @param signature 发送者的签名
     * @return 交易回执
     */
    public TxReceipt push(String publicKey, String signature, RawTransaction rawTransaction) {
        // 生成dataWithOutSign进行校验
        String dataWithOutSign = encodeBytesModify(rawTransaction);
        //检验
        if (!verifyEncodeTransaction(publicKey, dataWithOutSign, signature)) {
            log.info("交易校验不通过！");
            return null;
        }
        // RawTransaction rawTransaction = buildRawTransaction(dataWithOutSign);
        String signedTransaction = buildSignedTransactionStr(rawTransaction, signature);
        return sendToWeBase(signedTransaction);
    }

    public String encodeBytesModify(RawTransaction rawTransaction) {
        byte[] bytes = myTransactionEncoderService.encodeBytesModify(rawTransaction);
        return Hex.toHexString(bytes);
    }

    /**
     * 用公钥和签名 校验是否是rawData签名出来的内容
     *
     * @param publicKey          用户的公钥
     * @param encodedTransaction 编码后的交易
     * @param signature          用户的签名
     * @return true 为通过 false 为不通过
     */
    public boolean verifyEncodeTransaction(String publicKey, String encodedTransaction, String signature) {
        // CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
        byte[] hashMessageStr = Hex.decode(encodedTransaction);
        // String hashMessageStr = cryptoSuite.hash(encodedTransaction);
        return verify(publicKey, hashMessageStr, signature);
    }

    public boolean verify(String publicKey, byte[] message, String signature) {
        return cryptoSuite.verify(publicKey, Hex.toHexString(message), signature);
    }

    /**
     * 根据rawTransaction和signedData编码出要发送到链上的数据
     *
     * @param rawTransaction
     * @param signedData
     * @return String
     */
    public String buildSignedTransactionStr(RawTransaction rawTransaction, String signedData) {
        CryptoSuite cryptoSuite = new CryptoSuite(CryptoType.ECDSA_TYPE);
        TransactionEncoderService encoderService = new TransactionEncoderService(cryptoSuite);
        ECDSASignatureResult signatureResult = new ECDSASignatureResult(signedData);
        // 获得最终签名后的交易编码值，分成两个部分 rawTransaction 和 signedTx
        byte[] signedTransaction = encoderService.encode(rawTransaction, signatureResult);
        // 转十六进制字符串
        return Numeric.toHexString(signedTransaction);
    }

    /**
     * 将请求发到webase并获得response
     *
     * @param signedTransactionStr
     * @return
     */
    public TxReceipt sendToWeBase(String signedTransactionStr) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("groupId", groupId);
        map.put("signedStr", signedTransactionStr);
        map.put("sync", true);
        JSONObject jsonObject = HttpHelper.sendRequestGetStatus(webaseUrl, map);
        // log.info(jsonObject);
        TxReceipt txReceipt = new TxReceipt();
        txReceipt.setBlockHash(jsonObject.getString("blockHash"));
        txReceipt.setBlockNumber(jsonObject.getString("blockNumber"));
        txReceipt.setTransactionHash(jsonObject.getString("transactionHash"));
        txReceipt.setOutput(jsonObject.getString("status").toString());
        return txReceipt;
    }

    /**
     * 构建rawTransaction
     *
     * @param data
     * @return
     */
    public RawTransaction buildRawTransaction(String data, BigInteger randomId) {
        BigInteger blockLimit = client.getBlockLimit();
        //构建RawTransaction
        RawTransaction rawTransaction =
                RawTransaction.createTransaction(
                        randomId,
                        DefaultGasProvider.GAS_PRICE,
                        DefaultGasProvider.GAS_LIMIT,
                        blockLimit,
                        contractAddress,
                        BigInteger.ZERO,
                        data,
                        new BigInteger(chainId),
                        BigInteger.valueOf(groupId),
                        "");
        return rawTransaction;
    }

    /**
     * 签名函数
     *
     * @param dataWithOutSign 需要签名的字符串
     * @param privateKey      用户私钥
     * @return
     */
    public String sign(String dataWithOutSign, String privateKey) {
        // 创建私钥对
        CryptoKeyPair myKeyPair = cryptoSuite.createKeyPair(privateKey);
        //log.info("address:"+myKeyPair.getAddress());
        //String hashMessageStr = cryptoSuite.hash(encodedTransaction);
        //log.info("hashMessageStr: " + hashMessageStr);
        byte[] hashMessageStr = Hex.decode(dataWithOutSign);
        // 对交易编码值签名
        // SignatureResult signedTx = cryptoSuite.sign(hashMessageStr, myKeyPair);
        SignatureResult signatureTx = myTransactionEncoderService.sign(hashMessageStr, myKeyPair);
        // 签名后的 signedTx
        String signedData = signatureTx.convertToString();
        // log.info("signedData:"+signedData);
        return signedData;
        // byte[] hash2 = Hex.decode(res);
    }
}

编码服务类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/**
 * @description FISCO 交易 编码 服务类
 */
public class MyTransactionEncoderService extends TransactionEncoderService {

    private final Signature signature;
    private final TransactionSignerInterface transactionSignerService;
    private final CryptoSuite cryptoSuite;

    /**
     * 构造函数 初始化
     *
     * @param cryptoSuite
     */
    public MyTransactionEncoderService(CryptoSuite cryptoSuite) {
        super(cryptoSuite);
        this.cryptoSuite = cryptoSuite;
        this.signature = cryptoSuite.getSignatureImpl();
        this.transactionSignerService = TransactionSignerFactory.createTransactionSigner(signature);
    }

    /**
     * 交易记录编码
     *
     * @param rawTransaction
     * @return
     */
    public byte[] encodeBytesModify(RawTransaction rawTransaction) {
        //        byte[] hash = encodeAndHashBytes(rawTransaction, cryptoKeyPair);
        //        SignatureResult result = transactionSignerService.sign(hash, cryptoKeyPair);
        //        return hash;
        return cryptoSuite.hash(encode(rawTransaction, null));
    }

    /**
     * 交易签名
     *
     * @param hash
     * @param cryptoKeyPair
     * @return
     */
    public SignatureResult sign(byte[] hash, CryptoKeyPair cryptoKeyPair) {
        return transactionSignerService.sign(hash, cryptoKeyPair);
    }

    /**
     * 编码交易记录和签名结果
     *
     * @param rawTransaction
     * @param result
     * @return
     */
    public String encodeSignedStr(RawTransaction rawTransaction, SignatureResult result) {
        byte[] data = encode(rawTransaction, result);
        return Numeric.toHexString(data);
    }
}

配置文件

1
2
3
4
5
6
fisco.peers=47.93.14.150:20200
fisco.certPath=conf
fisco.hexPrivateKey=8183f6ffeab7ec48baf83e5a31ba9c0ec13627b60be5451731731670d84c150f
fisco.groupId=1
fisco.contract.eRC1155MixedFungibleMintableAddress=0x15bc967f32927dbcdde9360a5d623ccf9b65aac9
fisco.webaseUrl=http://47.93.14.150:5002/WeBASE-Front/trans/signed-transaction

FISCO方式（签名）

交易的组装和发送

  • RawTransaction构造：构造不带有签名的交易
  • RawTransaction编码：对不带有签名的交易进行编码，并计算其哈希
  • SignedTransaction构造与编码：将不带有签名的交易与交易签名进行组装编码为带有签名的交易
  • SignedTransaction发送：将带有签名的交易发送到区块链上

构造 RawTransaction

构造交易内容

交易内容定义了交易要调用的指令以及参数，FISCO BCOS 中的交易采用 ABI 编码，可根据 abi 和 binary 以及参数，构造交易内容，主要包括两步：

步骤一：创建 ABICodec 对象

1
2
3
4
5
6
7
8
9
/**
 * 创建ABICodec对象
 * @param client client对象
 * @return: 创建的ABICodec对象
 */
 public ABICodec createABICodec(Client client)
{
    return new ABICodec(client.getCryptoSuite());
}

步骤二：调用创建的 ABICodec 对象对交易内容进行编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * 对合约部署类型的交易进行编码
 * @param abiCodec 用于编码交易内容的ABICodeC对象
 * @param abiContent 合约的abi字符串(需要读取第1节生成的abi文件获取)
 * @param binContent binary字符串(需要读取第1节生成的bin文件获取)
 * @param params 部署合约的初始化参数列表
 * @return 编码后的交易内容
 */
public String encodeConstructor(ABICodec abiCodec, String abiContent, String binContent, List<Object> params)
{
    return abiCodec.encodeConstructor(abiContent, binContent, params);
}

/**
 * 对合约调用类型的交易进行编码
 * @param abiCodec 用于编码交易内容的ABICodeC对象
 * @param abiContent 合约的abi字符串(需要读取第1节生成的abi文件获取)
 * @param methodName 需要调用的合约方法名
 * @param param 调用合约的参数列表
 * @return 编码后的交易内容
 */
public String encodeMethod(ABICodec abiCodec, String abiContent, String methodName, List<Object> params)
{
    return abiCodec.encodeMethod(abiContent, methodName, params);
}

构造 RawTransaction

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * 根据交易内容txData构造RawTransaction，并指定交易发送的地址为to(部署合约时，to为全0的合约地址)
 * @param transactionBuilder 交易构造对象
 * @param client Client对象，用于获取BlockLimit
 * @param to 交易发送的目标地址(部署合约时，to为全0的合约地址)
 * @param txData 编码后的交易
 * @return 创建的RawTransaction
 */
public RawTransaction createRawTransaction(TransactionBuilderInterface transactionBuilder, Client client, String to, String txData)
{
    // 获取chainId和groupId
    Pair<String, Integer> chainIdAndGroupId = TransactionProcessorFactory.getChainIdAndGroupId(client);
    return transactionBuilder.createTransaction(
                        DefaultGasProvider.GAS_PRICE,
                        DefaultGasProvider.GAS_LIMIT,
                        to,
                        txData,
                        BigInteger.ZERO,
                        new BigInteger(chainIdAndGroupId.getLeft()),
                        BigInteger.valueOf(chainIdAndGroupId.getRight()),
                        "");
}

对 RawTransaction 进行编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 对RawTransaction进行RLP编码，返回编码内容的哈希
 *
 * @param transactionEncoder 交易编码器
 * @param client client对象，用于确定使用的哈希算法类型
 * @param rawTransaction 需要编码的交易
 * @return 编码后交易的哈希
 */
public byte[] encodeRawTransactionAndGetHash(
        TransactionEncoderInterface transactionEncoder,
        Client client,
        RawTransaction rawTransaction) {
    byte[] encodedTransaction = transactionEncoder.encode(rawTransaction, null);
    return client.getCryptoSuite().hash(encodedTransaction);
}

签名服务对交易进行签名

获取 RawTransaction 的哈希后，可以调用硬件加密机或远程签名服务对该哈希进行签名，该流程因业务系统的不同而有所差异。外部签名服务需实现 RemoteSignProviderInterface 接口，具体的接口定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public interface RemoteSignProviderInterface {
    /**
     * request for signature provider service, and return the signature.
     *
     * @param dataToSign data to be signed
     * @param cryptoType: ECDSA=0,SM=1, or self defined
     * @return signature result
     */
    public String requestForSign(byte[] dataToSign, int cryptoType);

    /**
     * request for signature provider service asynchronously
     *
     * @param dataToSign data to be signed
     * @param cryptoType: ECDSA=0,SM=1, or self defined
     * @param callback transaction sign callback
     */
    public void requestForSignAsync(
            byte[] dataToSign, int cryptoType, RemoteSignCallbackInterface callback);
}

签名示例如下，其中dataToSign是获取到的交易哈希。Java SDK 收到签名服务返回的签名后 (这里设为txSignature)，需要对齐反序列化为SignatureResult对象，接口示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
public SignatureResult decodeSign(String txSignature);

// 若是非国密类型应用，从txSignature可反序列化出 v, r, s, 构造SignatureResult的方法如下:
public SignatureResult decodeECDSASignature(byte v, byte[] r, byte[] s)
{
    return new ECDSASignatureResult(v, r, s);
}

// 若是国密类型应用，从txSignature可反序列化出 pub, r, s, 构造SignatureResult的方法如下:
public SignatureResult decodeECDSASignature(byte[] pub, byte[] r, byte[] s)
{
    return new SM2SignatureResult(pub, r, s);
}

拼接未签名交易与签名

获取到签名后，需将未签名交易与签名拼接起来，产生带有签名的交易：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 根据RawTransaction和签名结果产生带有签名的交易
 *
 * @param transactionEncoder 交易编码器
 * @param transaction 不带有签名的交易
 * @param signatureResult 签名服务器返回的反序列化的签名结果
 * @return 带有签名的交易编码
 */
public byte[] createSignedTransaction(
        TransactionEncoderInterface transactionEncoder,
        RawTransaction transaction,
        SignatureResult signatureResult) {
    return transactionEncoder.encode(transaction, signatureResult);
}

发送带有签名的交易

获取带有签名的交易后，可将其发送到链上：

1
2
3
4
5
6
7
8
9
10
11
/**
 * 发送带有签名的交易
 *
 * @param txPusher 交易发送器
 * @param signedTransaction 带有签名的交易
 * @return 交易回执
 */
TransactionReceipt sendTransaction(
        TransactionPusherInterface txPusher, byte[] signedTransaction) {
    return txPusher.push(Hex.toHexString(signedTransaction));
}

交易构造整体流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class TransactionMaker
{
    // 获取配置文件路径
    public final String configFile = TransactionMaker.class.getClassLoader().getResource("config-example.toml").getPath();

    // 根据合约abi、合约方法、合约地址发送交易，其中交易签名通过签名服务产生
    public TransactionReceipt makeAndSendSignedTransaction(String abiContent, String methodName, String to, List<Object> params)
    {
         // 初始化BcosSDK
        BcosSDK sdk =  BcosSDK.build(configFile);
        // 为群组1初始化client
        Client client = sdk.getClient(Integer.valueOf(1));
         // 创建transactionEncoder
        TransactionEncoderInterface transactionEncoder = new TransactionEncoderService(client.getCryptoSuite());

        // 创建RawTransaction
        RawTransaction rawTransaction = makeTransaction(client, abiContent, methodName, to, params);

        // 请求签名服务签名
        SignatureResult signtature = requestForTransactionSignature(transactionEncoder, rawTransaction, client);

        // 产生带有签名的交易
        byte[] signedTransaction = createSignedTransaction(transactionEncoder, rawTransaction, signature);

        // 发送签名交易
        TransactionPusherInterface txPusher = new TransactionPusherService(client);
        return sendTransaction(txPusher, signedTransaction);
    }

    // 构造交易
    public RawTransaction makeTransaction(Client client, String abiContent, String methodName, String to, List<Object> params)
    {
        //1.创建ABICodeC对象
        ABICodec abiCodec = createABICodec(client);
        
        //2.编码交易内容
        String txData =  encodeMethod(abiCodec, abiContent, methodName, params);

        //3. 创建TransactionBuilder，构造RawTransaction
        TransactionBuilderInterface transactionBuilder = new TransactionBuilderService(client);
        return createRawTransaction(transactionBuilder, client, to, txData);       
    }

    // 请求签名服务
    public SignatureResult requestForTransactionSignature(TransactionEncoderInterface transactionEncoder, RawTransaction rawTransaction, Client client)
    {
        // 获取RawTransaction的哈希
        byte[] rawTxHash = encodeRawTransactionAndGetHash(transactionEncoder, client, rawTransaction);
        // 请求签名服务，获取交易签名
        String signature = requestForSign(rawTxHash， encryptType);
        // 对签名结果进行反序列化
        return decodeSign(signature);
    }
}

参考

交易的组装与发送详解

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徘徊在原子与字节的边缘<br><br>将更好的自己呈现给世界<br><br><br><br>修心至要，事上磨练<br><br>一蓑衣，一壶酒，一曲长歌，一剑天涯<br><br>见自己，见天地，见众生<br><br>