該教程旨在學(xué)習(xí)智能合約的交互方式。
智能合約的創(chuàng)建和發(fā)布過程請(qǐng)閱讀上一篇博文。

一、 創(chuàng)建智能合約并發(fā)布到測(cè)試網(wǎng)絡(luò)

測(cè)試合約旨在用于版權(quán)分發(fā)，具體編譯部署教程參考上一篇博文，本篇不再解釋。
合約代碼如下：

pragma solidity ^0.4.0;

import 'zeppelin-solidity/contracts/math/SafeMath.sol';

contract CMContract {
    using SafeMath for uint256;

    address private creator; // the creator
    mapping(address => uint256) balances; // token
    mapping(string => bool) copyrights_keys; // keys for copyrights
    mapping(string => CopyRight) copyrights; // copyrights  {id_in_server : CopyRight}
    address private zero_address = 0x0000000000000000000000000000000000000000;

    // copy right
    struct CopyRight {
        string ipfs_address; //ipfs hash address
        string id_in_server; // id of this IP in internal server database
        string cp_hash; //
        mapping(address => bool) owners_keys;
        address[] owners_addresses;
        mapping(address => uint256) owners_integer;
        mapping(address => uint256) owners_decimals;
    }

    // init
    function CMContract() public {
        creator = msg.sender;
    }

    // update a copyright
    function update_copyright(string ipfs_address, string id_in_server,string cp_hash, address owner, uint256 share_integer, uint256 share_decimals) public returns (bool) {

        CopyRight storage cp = copyrights[id_in_server];
        cp.ipfs_address = ipfs_address;
        cp.id_in_server = id_in_server;
        cp.cp_hash = cp_hash;

        if (copyrights_keys[id_in_server] == false) {
            // new ip
            cp.owners_keys[owner] = true;
            cp.owners_addresses.push(owner);
            cp.owners_integer[owner] = share_integer;
            cp.owners_decimals[owner] = share_decimals;

            copyrights_keys[id_in_server] = true;

        } else {

            // if owner exits
            if (cp.owners_keys[owner] == true) {
                // update share
                cp.owners_integer[owner] = share_integer;
                cp.owners_decimals[owner] = share_decimals;
                if (share_integer == 0 && share_decimals == 0) {
                    cp.owners_keys[owner] = false;
                }
            } else {
                // push a new owner
                cp.owners_keys[owner] = true;
                cp.owners_addresses.push(owner);
                cp.owners_integer[owner] = share_integer;
                cp.owners_decimals[owner] = share_decimals;
            }
        }
        return true;
    }

    // delete a copyright
    function delete_copyright(string id_in_server) public returns (bool){
        if (copyrights_keys[id_in_server] == true) {
            copyrights_keys[id_in_server] = false;
        }
        return true;
    }

    // id_in_server : id of this IP in internal server database
    function get_copyright_share(string id_in_server, address owner) public view returns (uint256, uint256, bool) {
        if (copyrights_keys[id_in_server] == true) {
            CopyRight storage cp = copyrights[id_in_server];
            if (cp.owners_keys[owner] == true) {
                return (cp.owners_integer[owner], cp.owners_decimals[owner],true);
            } else {
                return (0,0,true);
            }
        } else {
            return (0,0,false);
        }
    }

    // get balance
    function balance_of(address _user) public view returns (uint256 balance) {
        return balances[_user];
    }
    // transfer token from a to b
    function transfer(address _from, address _to, uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        // SafeMath.sub will throw if there is not enough balance.
        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);
        return true;
    }

    // *** only creator can use the functions below ***
    // generate token for users
    function generate_token (address _to, uint256 _value) public returns (bool) {
        require(msg.sender == creator);
        balances[_to] = balances[_to].add(_value);
        return true;
    }

    // *** tools ***
    // string a equal to string b ？
    function string_equal_to(string _a, string _b) private pure returns (bool) {
        if (keccak256(_a) == keccak256(_b)) {
            return true;
        }
        return false;
    }
}

編譯部署后得到一個(gè)build文件夾

build.png

二、通過Web3.py與智能合約就行交互

以太坊客戶端通過RPC方式調(diào)用，web3.py封裝了調(diào)用的相關(guān)接口
安裝web3.py包

web3.png

新建一個(gè)py項(xiàng)目
回到第一步的build/contracts文件夾中，將CMContract.json中的"abi"和"address"的key和value拷貝下來。
在py項(xiàng)目中組合成一個(gè)簡(jiǎn)單的json對(duì)象
注意將abi中的false和true全部替換成python能識(shí)別的False和True

abi.png

abipy.png

from web3 import Web3, HTTPProvider
from web3.contract import ConciseContract

config = {
    "abi": [...],
    "address": "0x3855e692db75e5cd1e1e5e947a9dc6039ecbc0a6",
}

web3 = Web3(HTTPProvider('http://localhost:8545'))
owner = web3.eth.accounts[0]
contract_instance = web3.eth.contract(address=config['address'], abi=config['abi'],ContractFactoryClass=ConciseContract)

將智能合約的方法簡(jiǎn)單封裝一下

def update_copyright(ipfs_address,id_in_server,cp_hash,owner,share_integer,share_decimals):
    transact_hash = contract_instance.update_copyright(ipfs_address,id_in_server,cp_hash,owner,share_integer,share_decimals,transact={'from': owner})
    return transact_hash

def delete_copyright(id_in_server):
    transact_hash = contract_instance.delete_copyright(id_in_server,transact={'from': owner})
    return transact_hash

def get_copyright_share(id_in_server,owner):
    transact_hash = contract_instance.get_copyright_share(id_in_server, owner, transact={'from': owner})
    return transact_hash

def balance_of(user):
    return contract_instance.balance_of(user)

def transfer(_from, _to, _value):
    transact_hash = contract_instance.transfer(_from, _to, _value, transact={'from': owner})
    return transact_hash

def generate_token(_to, _value):
    transact_hash = contract_instance.generate_token(_to, _value, transact={'from': owner})
    return transact_hash

調(diào)用一下合約試試

if __name__ == "__main__":
    generate_token(owner, 100000)
    print(balance_of(owner))

給owner 也就是第一個(gè)賬戶生成了十萬代幣，獲取owner的代幣余額應(yīng)該打印出10萬

test.png

同時(shí)，在ganache-cli中也生成了新的block,用于記錄該交易

block.png