FISCO BCOS | 開發第一個區塊鏈應用

// 查詢資產金額
function select(string account) public constant returns(int256, uint256)
// 資產註冊
function register(string account, uint256 amount) public returns(int256)
// 資產轉移
function transfer(string from_asset_account, string to_asset_account, uint256 amount) public returns(int256)

# 進入console/contracts目錄
cd ~/fisco/console/contracts/solidity
# 建立Asset.sol合約檔案
vi Asset.sol
# 將Assert.sol合約內容寫入。
# 並鍵入wq儲存退出。

pragma solidity ^0.4.24;
import "./Table.sol";
contract Asset {
    // event
    event RegisterEvent(int256 ret, string account, uint256 asset_value);
    event TransferEvent(int256 ret, string from_account, string to_account, uint256 amount);
    constructor() public {
        // 建構函式中建立t_asset表
        createTable();
    }
    function createTable() private {
        TableFactory tf = TableFactory(0x1001);
        // 資產管理表, key : account, field : asset_value
        // |  資產賬戶(主鍵)      |     資產金額       |
        // |-------------------- |-------------------|
        // |        account      |    asset_value    |
        // |---------------------|-------------------|
        //
        // 建立表
        tf.createTable("t_asset", "account", "asset_value");
    }
    function openTable() private returns(Table) {
        TableFactory tf = TableFactory(0x1001);
        Table table = tf.openTable("t_asset");
        return table;
    }
    /*
    描述 : 根據資產賬戶查詢資產金額
    引數 ：
            account : 資產賬戶
    返回值：
            引數一： 成功返回0, 賬戶不存在返回-1
            引數二： 第一個引數為0時有效，資產金額
    */
    function select(string account) public constant returns(int256, uint256) {
        // 開啟表
        Table table = openTable();
        // 查詢
        Entries entries = table.select(account, table.newCondition());
        uint256 asset_value = 0;
        if (0 == uint256(entries.size())) {
            return (-1, asset_value);
        } else {
            Entry entry = entries.get(0);
            return (0, uint256(entry.getInt("asset_value")));
        }
    }
    /*
    描述 : 資產註冊
    引數 ：
            account : 資產賬戶
            amount  : 資產金額
    返回值：
            0  資產註冊成功
            -1 資產賬戶已存在
            -2 其他錯誤
    */
    function register(string account, uint256 asset_value) public returns(int256){
        int256 ret_code = 0;
        int256 ret= 0;
        uint256 temp_asset_value = 0;
        // 查詢賬戶是否存在
        (ret, temp_asset_value) = select(account);
        if(ret != 0) {
            Table table = openTable();
            Entry entry = table.newEntry();
            entry.set("account", account);
            entry.set("asset_value", int256(asset_value));
            // 插入
            int count = table.insert(account, entry);
            if (count == 1) {
                // 成功
                ret_code = 0;
            } else {
                // 失敗? 無許可權或者其他錯誤
                ret_code = -2;
            }
        } else {
            // 賬戶已存在
            ret_code = -1;
        }
        emit RegisterEvent(ret_code, account, asset_value);
        return ret_code;
    }
    /*
    描述 : 資產轉移
    引數 ：
            from_account : 轉移資產賬戶
            to_account ： 接收資產賬戶
            amount ： 轉移金額
    返回值：
            0  資產轉移成功
            -1 轉移資產賬戶不存在
            -2 接收資產賬戶不存在
            -3 金額不足
            -4 金額溢位
            -5 其他錯誤
    */
    function transfer(string from_account, string to_account, uint256 amount) public returns(int256) {
        // 查詢轉移資產賬戶資訊
        int ret_code = 0;
        int256 ret = 0;
        uint256 from_asset_value = 0;
        uint256 to_asset_value = 0;
        // 轉移賬戶是否存在?
        (ret, from_asset_value) = select(from_account);
        if(ret != 0) {
            ret_code = -1;
            // 轉移賬戶不存在
            emit TransferEvent(ret_code, from_account, to_account, amount);
            return ret_code;
        }
        // 接受賬戶是否存在?
        (ret, to_asset_value) = select(to_account);
        if(ret != 0) {
            ret_code = -2;
            // 接收資產的賬戶不存在
            emit TransferEvent(ret_code, from_account, to_account, amount);
            return ret_code;
        }
        if(from_asset_value < amount) {
            ret_code = -3;
            // 轉移資產的賬戶金額不足
            emit TransferEvent(ret_code, from_account, to_account, amount);
            return ret_code;
        }
        if (to_asset_value + amount < to_asset_value) {
            ret_code = -4;
            // 接收賬戶金額溢位
            emit TransferEvent(ret_code, from_account, to_account, amount);
            return ret_code;
        }
        Table table = openTable();
        Entry entry0 = table.newEntry();
        entry0.set("account", from_account);
        entry0.set("asset_value", int256(from_asset_value - amount));
        // 更新轉賬賬戶
        int count = table.update(from_account, entry0, table.newCondition());
        if(count != 1) {
            ret_code = -5;
            // 失敗? 無許可權或者其他錯誤?
            emit TransferEvent(ret_code, from_account, to_account, amount);
            return ret_code;
        }
        Entry entry1 = table.newEntry();
        entry1.set("account", to_account);
        entry1.set("asset_value", int256(to_asset_value + amount));
        // 更新接收賬戶
        table.update(to_account, entry1, table.newCondition());
        emit TransferEvent(ret_code, from_account, to_account, amount);
        return ret_code;
    }
}

# 建立工作目錄~/fisco
mkdir -p ~/fisco
# 下載控制檯
cd ~/fisco && curl -#LO 
# 切換到fisco/console/目錄
cd ~/fisco/console/
# 若控制檯版本大於等於2.8.0，編譯合約方法如下:（可透過bash sol2java.sh -h命令檢視該指令碼使用方法）
bash sol2java.sh -p org.fisco.bcos.asset.contract
# 若控制檯版本小於2.8.0，編譯合約(後面指定一個Java的包名引數，可以根據實際專案路徑指定包名)如下：
./sol2java.sh org.fisco.bcos.asset.contract

# 其它無關檔案省略
|-- abi # 生成的abi目錄，存放solidity合約編譯生成的abi檔案
|   |-- Asset.abi
|   |-- Table.abi
|-- bin # 生成的bin目錄，存放solidity合約編譯生成的bin檔案
|   |-- Asset.bin
|   |-- Table.bin
|-- contracts # 存放solidity合約原始碼檔案，將需要編譯的合約複製到該目錄下
|   |-- Asset.sol # 複製進來的Asset.sol合約，依賴Table.sol
|   |-- Table.sol # 實現系統CRUD操作的合約介面檔案
|-- java  # 存放編譯的包路徑及Java合約檔案
|   |-- org
|        |--fisco
|             |--bcos
|                  |--asset
|                       |--contract
|                             |--Asset.java  # Asset.sol合約生成的Java檔案
|                             |--Table.java  # Table.sol合約生成的Java檔案
|-- sol2java.sh

package org.fisco.bcos.asset.contract;
public class Asset extends Contract {
    // Asset.sol合約 transfer介面生成
    public TransactionReceipt transfer(String from_account, String to_account, BigInteger amount);
    // Asset.sol合約 register介面生成
    public TransactionReceipt register(String account, BigInteger asset_value);
    // Asset.sol合約 select介面生成
    public Tuple2<BigInteger, BigInteger> select(String account) throws ContractException;
    // 載入Asset合約地址，生成Asset物件
    public static Asset load(String contractAddress, Client client, CryptoKeyPair credential);
    // 部署Assert.sol合約，生成Asset物件
    public static Asset deploy(Client client, CryptoKeyPair credential) throws ContractException;
}

# 確認您當前的java版本
$ java -version
# 確認您的java路徑
$ ls /Library/Java/JavaVirtualMachines
# 返回
# jdk-14.0.2.jdk
# 如果使用的是bash
$ vim .bash_profile 
# 在檔案中加入JAVA_HOME的路徑
# export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-14.0.2.jdk/Contents/Home 
$ source .bash_profile
# 如果使用的是zash
$ vim .zashrc
# 在檔案中加入JAVA_HOME的路徑
# export JAVA_HOME = Library/Java/JavaVirtualMachines/jdk-14.0.2.jdk/Contents/Home 
$ source .zashrc
# 確認您的java版本
$ java -version
# 返回
# java version "14.0.2" 2020-07-14
# Java(TM) SE Runtime Environment (build 14.0.2+12-46)
# Java HotSpot(TM) 64-Bit Server VM (build 14.0.2+12-46, mixed mode, sharing)

$ cd ~/fisco
$ curl -#LO 
# 解壓得到Java工程專案asset-app
$ tar -zxf asset-app.tar.gz

repositories {
    mavenCentral()
    maven {
        allowInsecureProtocol = true
        url "
    }
    maven {
        allowInsecureProtocol = true
        url "
    }
}

testImplementation group: 'junit', name: 'junit', version: '4.12'
implementation ('org.fisco-bcos.java-sdk:fisco-bcos-java-sdk:2.9.1')

def spring_version = "4.3.27.RELEASE"
List spring = [
        "org.springframework:spring-core:$spring_version",
        "org.springframework:spring-beans:$spring_version",
        "org.springframework:spring-context:$spring_version",
        "org.springframework:spring-tx:$spring_version",
]
dependencies {
    testImplementation group: 'junit', name: 'junit', version: '4.12'
    implementation ("org.fisco-bcos.java-sdk:fisco-bcos-java-sdk:2.9.1")
    implementation spring
}

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="
       xmlns:xsi="
       xsi:schemaLocation="
    /spring-beans-4.0.xsd">
    <bean id="defaultConfigProperty" class="org.fisco.bcos.sdk.config.model.ConfigProperty">
        <property name="cryptoMaterial">
            <map>
                <entry key="certPath" value="conf" />
            </map>
        </property>
        <property name="network">
            <map>
                <entry key="peers">
                    <list>
                        <value>127.0.0.1:20200</value>
                        <value>127.0.0.1:20201</value>
                    </list>
                </entry>
            </map>
        </property>
        <property name="account">
            <map>
                <entry key="keyStoreDir" value="account" />
                <entry key="accountAddress" value="" />
                <entry key="accountFileFormat" value="pem" />
                <entry key="password" value="" />
                <entry key="accountFilePath" value="" />
            </map>
        </property>
        <property name="threadPool">
            <map>
                <entry key="channelProcessorThreadSize" value="16" />
                <entry key="receiptProcessorThreadSize" value="16" />
                <entry key="maxBlockingQueueSize" value="102400" />
            </map>
        </property>
    </bean>
    <bean id="defaultConfigOption" class="org.fisco.bcos.sdk.config.ConfigOption">
        <constructor-arg name="configProperty">
            <ref bean="defaultConfigProperty"/>
        </constructor-arg>
    </bean>
    <bean id="bcosSDK" class="org.fisco.bcos.sdk.BcosSDK">
        <constructor-arg name="configOption">
            <ref bean="defaultConfigOption"/>
        </constructor-arg>
    </bean>
</beans>

# 假設我們將asset-app放在~/fisco目錄下 進入~/fisco目錄
$ cd ~/fisco
# 建立放置證照的資料夾
$ mkdir -p asset-app/src/test/resources/conf
# 複製節點證照到專案的資源目錄
$ cp -r nodes/127.0.0.1/sdk/* asset-app/src/test/resources/conf
# 若在IDE直接執行，複製證照到resources路徑
$ mkdir -p asset-app/src/main/resources/conf
$ cp -r nodes/127.0.0.1/sdk/* asset-app/src/main/resources/conf

cd ~/fisco  
# 將編譯好的合約Java類引入專案中。
cp console/contracts/sdk/java/org/fisco/bcos/asset/contract/Asset.java asset-app/src/main/java/org/fisco/bcos/asset/contract/Asset.java

package org.fisco.bcos.asset.client;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.util.List;
import java.util.Properties;
import org.fisco.bcos.asset.contract.Asset;
import org.fisco.bcos.sdk.BcosSDK;
import org.fisco.bcos.sdk.abi.datatypes.generated.tuples.generated.Tuple2;
import org.fisco.bcos.sdk.client.Client;
import org.fisco.bcos.sdk.crypto.keypair.CryptoKeyPair;
import org.fisco.bcos.sdk.model.TransactionReceipt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
public class AssetClient {
    static Logger logger = LoggerFactory.getLogger(AssetClient.class);
    private BcosSDK bcosSDK;
    private Client client;
    private CryptoKeyPair cryptoKeyPair;
    public void initialize() throws Exception {
        @SuppressWarnings("resource")
        ApplicationContext context =
                new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        bcosSDK = context.getBean(BcosSDK.class);
        client = bcosSDK.getClient(1);
        cryptoKeyPair = client.getCryptoSuite().createKeyPair();
        client.getCryptoSuite().setCryptoKeyPair(cryptoKeyPair);
        logger.debug("create client for group1, account address is " + cryptoKeyPair.getAddress());
    }
    public void deployAssetAndRecordAddr() {
        try {
            Asset asset = Asset.deploy(client, cryptoKeyPair);
            System.out.println(
                    " deploy Asset success, contract address is " + asset.getContractAddress());
            recordAssetAddr(asset.getContractAddress());
        } catch (Exception e) {
            // TODO Auto-generated catch block
            // e.printStackTrace();
            System.out.println(" deploy Asset contract failed, error message is  " + e.getMessage());
        }
    }
    public void recordAssetAddr(String address) throws FileNotFoundException, IOException {
        Properties prop = new Properties();
        prop.setProperty("address", address);
        final Resource contractResource = new ClassPathResource("contract.properties");
        FileOutputStream fileOutputStream = new FileOutputStream(contractResource.getFile());
        prop.store(fileOutputStream, "contract address");
    }
    public String loadAssetAddr() throws Exception {
        // load Asset contact address from contract.properties
        Properties prop = new Properties();
        final Resource contractResource = new ClassPathResource("contract.properties");
        prop.load(contractResource.getInputStream());
        String contractAddress = prop.getProperty("address");
        if (contractAddress == null || contractAddress.trim().equals("")) {
            throw new Exception(" load Asset contract address failed, please deploy it first. ");
        }
        logger.info(" load Asset address from contract.properties, address is {}", contractAddress);
        return contractAddress;
    }
    public void queryAssetAmount(String assetAccount) {
        try {
            String contractAddress = loadAssetAddr();
            Asset asset = Asset.load(contractAddress, client, cryptoKeyPair);
            Tuple2<BigInteger, BigInteger> result = asset.select(assetAccount);
            if (result.getValue1().compareTo(new BigInteger("0")) == 0) {
                System.out.printf(" asset account %s, value %s \n", assetAccount, result.getValue2());
            } else {
                System.out.printf(" %s asset account is not exist \n", assetAccount);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            // e.printStackTrace();
            logger.error(" queryAssetAmount exception, error message is {}", e.getMessage());
            System.out.printf(" query asset account failed, error message is %s\n", e.getMessage());
        }
    }
    public void registerAssetAccount(String assetAccount, BigInteger amount) {
        try {
            String contractAddress = loadAssetAddr();
            Asset asset = Asset.load(contractAddress, client, cryptoKeyPair);
            TransactionReceipt receipt = asset.register(assetAccount, amount);
            List<Asset.RegisterEventEventResponse> response = asset.getRegisterEventEvents(receipt);
            if (!response.isEmpty()) {
                if (response.get(0).ret.compareTo(new BigInteger("0")) == 0) {
                    System.out.printf(
                            " register asset account success => asset: %s, value: %s \n", assetAccount, amount);
                } else {
                    System.out.printf(
                            " register asset account failed, ret code is %s \n", response.get(0).ret.toString());
                }
            } else {
                System.out.println(" event log not found, maybe transaction not exec. ");
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            // e.printStackTrace();
            logger.error(" registerAssetAccount exception, error message is {}", e.getMessage());
            System.out.printf(" register asset account failed, error message is %s\n", e.getMessage());
        }
    }
    public void transferAsset(String fromAssetAccount, String toAssetAccount, BigInteger amount) {
        try {
            String contractAddress = loadAssetAddr();
            Asset asset = Asset.load(contractAddress, client, cryptoKeyPair);
            TransactionReceipt receipt = asset.transfer(fromAssetAccount, toAssetAccount, amount);
            List<Asset.TransferEventEventResponse> response = asset.getTransferEventEvents(receipt);
            if (!response.isEmpty()) {
                if (response.get(0).ret.compareTo(new BigInteger("0")) == 0) {
                    System.out.printf(
                            " transfer success => from_asset: %s, to_asset: %s, amount: %s \n",
                            fromAssetAccount, toAssetAccount, amount);
                } else {
                    System.out.printf(
                            " transfer asset account failed, ret code is %s \n", response.get(0).ret.toString());
                }
            } else {
                System.out.println(" event log not found, maybe transaction not exec. ");
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            // e.printStackTrace();
            logger.error(" registerAssetAccount exception, error message is {}", e.getMessage());
            System.out.printf(" register asset account failed, error message is %s\n", e.getMessage());
        }
    }
    public static void Usage() {
        System.out.println(" Usage:");
        System.out.println(
                "\t java -cp conf/:lib/*:apps/* org.fisco.bcos.asset.client.AssetClient deploy");
        System.out.println(
                "\t java -cp conf/:lib/*:apps/* org.fisco.bcos.asset.client.AssetClient query account");
        System.out.println(
                "\t java -cp conf/:lib/*:apps/* org.fisco.bcos.asset.client.AssetClient register account value");
        System.out.println(
                "\t java -cp conf/:lib/*:apps/* org.fisco.bcos.asset.client.AssetClient transfer from_account to_account amount");
        System.exit(0);
    }
    public static void main(String[] args) throws Exception {
        if (args.length < 1) {
            Usage();
        }
        AssetClient client = new AssetClient();
        client.initialize();
        switch (args[0]) {
            case "deploy":
                client.deployAssetAndRecordAddr();
                break;
            case "query":
                if (args.length < 2) {
                    Usage();
                }
                client.queryAssetAmount(args[1]);
                break;
            case "register":
                if (args.length < 3) {
                    Usage();
                }
                client.registerAssetAccount(args[1], new BigInteger(args[2]));
                break;
            case "transfer":
                if (args.length < 4) {
                    Usage();
                }
                client.transferAsset(args[1], args[2], new BigInteger(args[3]));
                break;
            default:
            {
                Usage();
            }
        }
        System.exit(0);
    }
}

// 函式initialize中進行初始化 
// 初始化BcosSDK
@SuppressWarnings("resource")
ApplicationContext context =
        new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
bcosSDK = context.getBean(BcosSDK.class);
// 初始化可向群組1發交易的Client
client = bcosSDK.getClient(1);
// 隨機生成傳送交易的公私鑰對
cryptoKeyPair = client.getCryptoSuite().createKeyPair();
client.getCryptoSuite().setCryptoKeyPair(cryptoKeyPair);
logger.debug("create client for group1, account address is " + cryptoKeyPair.getAddress());

// 部署合約
Asset asset = Asset.deploy(client, cryptoKeyPair);
// 載入合約地址
Asset asset = Asset.load(contractAddress, client, cryptoKeyPair);

// select介面呼叫
 Tuple2<BigInteger, BigInteger> result = asset.select(assetAccount);
// register介面呼叫
TransactionReceipt receipt = asset.register(assetAccount, amount);
// transfer介面
TransactionReceipt receipt = asset.transfer(fromAssetAccount, toAssetAccount, amount);

#!/bin/bash 
function usage() 
{
    echo " Usage : "
    echo "   bash asset_run.sh deploy"
    echo "   bash asset_run.sh query    asset_account "
    echo "   bash asset_run.sh register asset_account asset_amount "
    echo "   bash asset_run.sh transfer from_asset_account to_asset_account amount "
    echo " "
    echo " "
    echo "examples : "
    echo "   bash asset_run.sh deploy "
    echo "   bash asset_run.sh register  Asset0  10000000 "
    echo "   bash asset_run.sh register  Asset1  10000000 "
    echo "   bash asset_run.sh transfer  Asset0  Asset1 11111 "
    echo "   bash asset_run.sh query Asset0"
    echo "   bash asset_run.sh query Asset1"
    exit 0
}
    case $1 in
    deploy)
            [ $# -lt 1 ] && { usage; }
            ;;
    register)
            [ $# -lt 3 ] && { usage; }
            ;;
    transfer)
            [ $# -lt 4 ] && { usage; }
            ;;
    query)
            [ $# -lt 2 ] && { usage; }
            ;;
    *)
        usage
            ;;
    esac
    java -Djdk.tls.namedGroups="secp256k1" -cp 'apps/*:conf/:lib/*' org.fisco.bcos.asset.client.AssetClient $@

### set log levels ###
log4j.rootLogger=DEBUG, file
### output the log information to the file ###
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.DatePattern='_'yyyyMMddHH'.log'
log4j.appender.file.File=./log/sdk.log
log4j.appender.file.Append=true
log4j.appender.file.filter.traceFilter=org.apache.log4j.varia.LevelRangeFilter
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C{1}.%M(%L) | %m%n
###output the log information to the console ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C{1}.%M(%L) | %m%n

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile ("org.fisco-bcos.java-sdk:fisco-bcos-java-sdk:2.9.1")
    compile spring
    compile ('org.slf4j:slf4j-log4j12:1.7.25')
    runtime ('org.slf4j:slf4j-log4j12:1.7.25')
}
jar {
    destinationDir file('dist/apps')
    archiveName project.name + '.jar'
    exclude '**/*.xml'
    exclude '**/*.properties'
    exclude '**/*.crt'
    exclude '**/*.key'
    doLast {
        copy {
            from configurations.runtime
            into 'dist/lib'
        }
        copy {
            from file('src/test/resources/')
            into 'dist/conf'
        }
        copy {
            from file('tool/')
            into 'dist/'
        }
        copy {
            from file('src/test/resources/contract')
            into 'dist/contract'
        }
    }
}

|-- build.gradle // gradle配置檔案
|-- gradle
|   |-- wrapper
|       |-- gradle-wrapper.jar // 用於下載Gradle的相關程式碼實現
|       |-- gradle-wrapper.properties // wrapper所使用的配置資訊，比如gradle的版本等資訊
|-- gradlew // Linux或者Unix下用於執行wrapper命令的Shell指令碼
|-- gradlew.bat // Windows下用於執行wrapper命令的批處理指令碼
|-- src
|   |-- main
|   |   |-- java
|   |   |     |-- org
|   |   |          |-- fisco
|   |   |                |-- bcos
|   |   |                      |-- asset
|   |   |                            |-- client // 放置客戶端呼叫類
|   |   |                                   |-- AssetClient.java
|   |   |                            |-- contract // 放置Java合約類
|   |   |                                   |-- Asset.java
|   |   |-- resources
|   |        |-- conf
|   |               |-- ca.crt
|   |               |-- node.crt
|   |               |-- node.key
|   |               |-- sdk.crt
|   |               |-- sdk.key
|   |               |-- sdk.publickey
|   |        |-- applicationContext.xml // 專案配置檔案
|   |        |-- contract.properties // 儲存部署合約地址的檔案
|   |        |-- log4j.properties // 日誌配置檔案
|   |        |-- contract //存放solidity約檔案
|   |                |-- Asset.sol
|   |                |-- Table.sol
|   |-- test
|       |-- resources // 存放程式碼資原始檔
|           |-- conf
|                  |-- ca.crt
|                  |-- node.crt
|                  |-- node.key
|                  |-- sdk.crt
|                  |-- sdk.key
|                  |-- sdk.publickey
|           |-- applicationContext.xml // 專案配置檔案
|           |-- contract.properties // 儲存部署合約地址的檔案
|           |-- log4j.properties // 日誌配置檔案
|           |-- contract //存放solidity約檔案
|                   |-- Asset.sol
|                   |-- Table.sol
|
|-- tool
    |-- asset_run.sh // 專案執行指令碼

# 切換到專案目錄
$ cd ~/fisco/asset-app
# 編譯專案
$ ./gradlew build

# 進入dist目錄
$ cd dist
$ bash asset_run.sh deploy
Deploy Asset successfully, contract address is 0xd09ad04220e40bb8666e885730c8c460091a4775

$ bash asset_run.sh register Alice 100000
Register account successfully => account: Alice, value: 100000
$ bash asset_run.sh register Bob 100000
Register account successfully => account: Bob, value: 100000

$ bash asset_run.sh query Alice
account Alice, value 100000
$ bash asset_run.sh query Bob
account Bob, value 100000

$ bash asset_run.sh transfer Alice Bob  50000
Transfer successfully => from_account: Alice, to_account: Bob, amount: 50000
$ bash asset_run.sh query Alice
account Alice, value 50000
$ bash asset_run.sh query Bob
account Bob, value 150000