Metadata-Version: 1.2
Name: vsyspy
Version: 2020.3
Summary: A Python api wrapper for VSYS network.
Home-page: https://github.com/Icermli/vsyspy
Author: Icerm
Author-email: haohan@v.systems
License: MIT
Download-URL: https://github.com/Icermli/vsyspy/archive/version@2020.3.tar.gz
Description: [![version](https://img.shields.io/badge/version-2020.1-ff69b4.svg)](/vsyspy/version.py)
        [![license](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)
        [![downloads](https://img.shields.io/github/downloads/Icermli/vsyspy/total.svg)](https://github.com/Icermli/vsyspy/releases)
        [![issues](https://img.shields.io/github/issues/Icermli/vsyspy.svg)](https://github.com/Icermli/vsyspy/issues)
        
        # VSYSPY
        A python wrapper for vsys api.
        
        ## Install
        
        ### Install source code
        1. clone the repo under you workspace
        ```shell script
        git clone https://github.com/Icermli/vsyspy.git
        ```
        2. install packages in vsyspy/requirement.txt by 
        ```shell script
        cd vsyspy
        pip install .
        ```
        Or, for developers, you may want to install the package with a symlink,
        ```shell script
        pip install -e .
        ```
        3. Then you can ```import vsyspy``` in your workspace
        
        ### Install via PyPi
        ```shell script
        pip install vsyspy
        ```
        
        ## Usage
        
        ### chain object
        1. For testnet:
        ```python
        import vsyspy as vpy
        ts_chain = vpy.testnet_chain()
        ```
        2. For default chain:
        ```python
        import vsyspy as vpy
        main_chain = vpy.default_chain()
        ```
        
        3. For custom api node:
        ```python
        import vsyspy as vpy
        custom_wrapper = vpy.create_api_wrapper('http://<full node ip>:9922', api_key='')
        ts_chain = vpy.testnet_chain(custom_wrapper)
        ```
        
        4. For completely custom chain:
        ```python
        import vsyspy as vpy
        custom_wrapper = vpy.create_api_wrapper('http://<full node ip>:9922', api_key='')
        t_chain = vpy.Chain(chain_name='testnet', chain_id='T', address_version=5, api_wrapper=custom_wrapper)
        custom_wrapper2 = vpy.create_api_wrapper('http://<full node ip>:9922', api_key='')
        m_chain = vpy.Chain(chain_name='mainnet', chain_id='M', address_version=5, api_wrapper=custom_wrapper2)
        custom_wrapper3 = vpy.create_api_wrapper('http://<full node ip>:9922', api_key='')
        c_chain = vpy.Chain(chain_name='mychain', chain_id='C', address_version=1, api_wrapper=custom_wrapper3)
        ```
        
        ### chain api list
        1. look up current block height of the chain:
        ```python
        ts_chain.height()
        ```
        2. look up the last block info of the chain:
        ```python
        ts_chain.lastblock()
        ```
        3. look up a block info at n in the chain:
        ```python
        ts_chain.block(n)
        ```
        4. Get a transaction info by transacion id in the chain:
        ```python
        ts_chain.tx(tx_id)
        ```
        5. Validate an address of the chain:
        ```python
        ts_chain.validate_address(addr)
        ```
        
        ### address object
        1. constructed by seed
        ```python
        from vsyspy import Account
        my_address = Account(chain=ts_chain, seed='<your seed>', nonce=0)
        ```
        2. constructed by private key
        ```python
        from vsyspy import Account
        my_address = Account(chain=ts_chain, private_key='<your base58 private key>')
        ```
        3. constructed by public key
        ```python
        from vsyspy import Account
        recipient = Account(chain=ts_chain, public_key='<base58 public key>')
        ```
        4. constructed by wallet address
        ```python
        from vsyspy import Account
        recipient = Account(chain=ts_chain, address='<base58 wallet address>')
        ```
         
        ### address api list
        1. Get balance
        ```python
        # get balance
        balance = my_address.balance()
        print("The balance is {}".format(balance))
        # get balance after 16 confirmations 
        balance = my_address.balance(confirmations = 16)
        print("The balance is {}".format(balance))
        ```
        2. Send payment transaction
        ```python
        # send payment (100000000 = 1 VSYS)
        my_address.send_payment(recipient, amount=100000000)
        ```
        3. Send and cancel lease transaction
        ```python
        # send lease (100000000 = 1 VSYS)
        response = my_address.lease(recipient, amount=100000000)
        tx_id = response["id"]
        # cancel lease
        my_address.lease_cancel(tx_id)
        ```
        
        ### contract object
        1. contructed by base58 string
        ```python
        from vsyspy import Contract
        my_contract = Contract('<contract-base58-string>')
        ```
        or
        ```python
        my_contract = Contract()
        my_contract.from_base58_string('<contract-base58-string>')
        ```
        
        2. contructed from scratch
        ```python
        from vsyspy import Contract
        my_contract = Contract()
        my_contract.language_code = <language_code>
        my_contract.language_version = <language_version>
        my_contract.trigger = <trigger>
        my_contract.descriptor = <descriptor_without_split>
        my_contract.state_variable = <state_variable>
        my_contract.state_map = <state_map>
        my_contract.textual = <textual>
        ```
        
        3. default contract (token contract without split)
        ```python
        import vsyspy as vpy
        my_contract = vpy.default_contract()
        ```
            
        ### contract api list
        1. Get json
        ```python
        my_contract.json
        ```
        
        2. Get bytes
        ```python
        my_contract.bytes
        ```
        
        3. Get base58 string
        ```python
        my_contract.base58_string
        ```
        
        4. Register contract
        ```python
        from vsyspy import DataEntry, Contract
        from vsyspy.contract import Type
        # register contract of max 1000000000000 and unit 1000000
        contract = Contract('<contract-base58-string>')
        maximum = DataEntry(1000000000000, Type.amount)
        unit = DataEntry(1000000, Type.amount)
        short_txt = DataEntry('', Type.short_text)
        init_data_stack = [maximum, unit, short_txt]
        response = my_address.register_contract(contract, init_data_stack)
        contract_id = response["contractId"]
        ```
        5. Execute contract
        ```python
        # execute issue function of 1000000000 tokens
        amount = DataEntry(1000000000, Type.amount)
        issue_data_stack = [amount]
        my_address.execute_contract(contract_id, 1, issue_data_stack)
        ```
        
Keywords: api wrapper
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Requires-Python: >=3.0
