예제 #1
0
파일: aesop_final.py 프로젝트: tzfeng/aesop
def subtract_ong(address, amount):
    byte_address = Base58ToAddress(address)
    assert (CheckWitness(byte_address))

    if len(byte_address) != 20:
        Notify(['Invalid address'])
        return False

    if amount < 0:
        Notify(['Negative amount'])
        return False

    param = state(byte_address)
    if Invoke(0, contract_address_ONG, 'balanceOf', param) < amount:
        Notify(['Not enough ONG in wallet'])
        return False

    else:
        from_acct = byte_address
        to_acct = contract_address

        supply = Get(ctx, ONGKEY)
        supply += amount
        Put(ctx, ONGKEY, supply)
        Notify(['ONG supply increased by', amount])

        params = state(from_acct, to_acct, amount)

        return Invoke(1, contract_address_ONG, 'transfer', [params])
예제 #2
0
def upgrade(code):
    """
    upgrade current smart contract to new smart contract.
    :param code:new smart contract avm code.
    :return: True or raise exception.
    """
    owner = getOwner()
    assert (CheckWitness(owner))

    ongBalance = Invoke(0, ONG_ADDRESS, 'balanceOf', state(CONTRACT_ADDRESS))
    res = Invoke(0, ONG_ADDRESS, "transfer", [state(CONTRACT_ADDRESS, owner, ongBalance)])
    if res != b'\x01':
        assert (False)

    ontBalance = Invoke(0, ONT_ADDRESS, 'balanceOf', state(CONTRACT_ADDRESS))
    res = Invoke(0, ONT_ADDRESS, "transfer", [state(CONTRACT_ADDRESS, owner, ontBalance)])
    if res != b'\x01':
        assert (False)

    # upgrade smart contract
    res = Migrate(code, "", "", "", "", "", "")
    if not res:
        assert (False)

    Notify(["upgrade smart contract"])

    return True
예제 #3
0
def upgrade(code):
    """
    migrate data to new contract, transfer asset to admin address
    :param code:
    :return:
    """

    assert CheckWitness(ADMIN)

    # transfer ont
    ont_balance = Invoke(VERSION, ONT_ADDRESS, "balanceOf",
                         state(CONTRACT_ADDRESS))
    ont_response = Invoke(VERSION, ONT_ADDRESS, "transfer",
                          [state(CONTRACT_ADDRESS, ADMIN, ont_balance)])
    if ont_response != INVOKE_SUCCESS:
        raise Exception("contract upgrade - transfer ont failed")

    # transfer ong
    ong_balance = Invoke(VERSION, ONG_ADDRESS, "balanceOf",
                         state(CONTRACT_ADDRESS))
    ong_response = Invoke(VERSION, ONG_ADDRESS, "transfer",
                          [state(CONTRACT_ADDRESS, ADMIN, ong_balance)])
    if ong_response != INVOKE_SUCCESS:
        raise Exception("contract upgrade - transfer ong failed")

    # migrate avm
    migrate_response = Migrate(code, "", "", "", "", "", "")
    if not migrate_response:
        raise Exception("contract upgrade - migrate avm failed")

    Notify(["upgrade", "success"])

    return True
예제 #4
0
def upgrade(code, needStorage, name, version, author, email, description):
    """
    upgrade current smart contract to new smart contract.
    :param code:new smart contract avm code.
    :return: True or raise exception.
    """
    owner = getOwner()
    assert (CheckWitness(owner))

    ontBalance = _getSelfONTBalance()
    if ontBalance > 0:
        res = Invoke(0, ONT_ADDRESS, "transfer", [state(CONTRACT_ADDRESS, owner, ontBalance)])
        assert (res)

    assert (_tryUnboundOng())
    ongBalance = _getSelfOngBalance()
    if ongBalance > 0:
        res = Invoke(0, ONG_ADDRESS, "transfer", [state(CONTRACT_ADDRESS, owner, ongBalance)])
        assert (res)
    # upgrade smart contract
    res = Migrate(code, needStorage, name, version, author, email, description)
    if not res:
        assert (False)
    Notify(["upgrade", AddressFromVmCode(code)])
    return True
def checkBalanceOf(ongFlag, account):
    param = state(ContractAddress)
    # do not use [param]
    res = Invoke(0, ONGAddress, 'balanceOf', param)
    Notify(["ContractAddress", ContractAddress, res])

    param = state(account)
    if ongFlag == 1:
        Notify(["ongFlag", ongFlag])
        res = Invoke(0, ONGAddress, 'balanceOf', param)
    else:
        Notify(["ongFlag", ongFlag])
        res = Invoke(0, ONTAddress, 'balanceOf', param)
    Notify(["checkBalanceOf", account, res])
    return res
예제 #6
0
def lock(toChainId, fromAddress, toAddress, amount):
    """
    Decrease token supply from deducter address.
    :param amount: decreased token amount.
    :return:
    """
    fee = 0
    assert (amount >= 0)
    assert (CheckWitness(fromAddress))
    assert (not isPaused())
    # eth address format:0x673dfa9caf9145fdbef98e9d9874f36e63d8a5b4,length is 42
    assert (len(toAddress) != 0)

    Put(ctx, concat(BALANCE_KEY, fromAddress), Sub(balanceOf(fromAddress), amount))
    Put(ctx, TOTAL_SUPPLY_KEY, Sub(totalSupply(), amount))

    # construct args for proxy contract in target chain
    toAssetHash = getAssetHash(toChainId)
    argsList = [toAddress, amount]

    input_bytes = _serialzieArgs(argsList)
    param = state(toChainId, toAssetHash, "unlock", input_bytes)
    assert (Invoke(0, CROSS_CHAIN_CONTRACT_ADDRESS, "createCrossChainTx", param))
    LockEvent(toChainId, fromAddress, toAddress, amount)
    return True
예제 #7
0
def _tranferNativeAsset(_nativeAssetAddress, _from, _to, _amount):
    param = state(_from, _to, _amount)
    res = Invoke(0, _nativeAssetAddress, 'transfer', [param])
    if res and res == b'\x01':
        return True
    else:
        return False
예제 #8
0
def _transferONGFromContact(toAcct, amount):
    param = state(ContractAddress, toAcct, amount)
    res = Invoke(0, ONGAddress, 'transfer', [param])
    if res and res == b'\x01':
        return True
    else:
        return False
def VerifyCaller(operation, caller, keyNo):
    authContractAddr = bytearray(
        b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06'
    )
    param = state(GetExecutingScriptHash(), caller, operation, keyNo)
    res = Invoke(0, authContractAddr, "verifyToken", param)
    Require(res)
예제 #10
0
파일: aesop_final.py 프로젝트: tzfeng/aesop
def add_ong(address, amount):
    byte_address = Base58ToAddress(address)
    assert (CheckWitness(byte_address))

    if len(byte_address) != 20:
        Notify(['Invalid address'])
        return False

    if amount < 0:
        Notify(['Negative amount'])
        return False

    supply = Get(ctx, ONGKEY)
    if supply < amount:
        Notify(['Not enough ONG in supply'])
        return False

    else:
        from_acct = contract_address
        to_acct = byte_address

        supply -= amount
        Put(ctx, ONGKEY, supply)
        Notify(['ONG supply decreased by', amount])

        params = state(from_acct, to_acct, amount)

        return Invoke(1, contract_address_ONG, 'transfer', [params])
예제 #11
0
def lock(fromAssetHash, fromAddress, toChainId, toAddress, amount):
    """
    Decrease token supply from deducter address.
    :param amount: decreased token amount.
    :return:
    """
    assert (amount >= 0)
    assert (CheckWitness(fromAddress))
    assert (len(toAddress) != 0)

    # transfer asset from fromAddress to lock proxy contract
    assert (_transferToContract(fromAssetHash, fromAddress, amount))

    # construct args for proxy contract in target chain
    toAssetHash = getAssetHash(fromAssetHash, toChainId)
    # make sure the toAssetHash is not empty
    assert (len(toAssetHash) != 0)

    argsList = [toAssetHash, toAddress, amount]
    # invoke the native cross chain manager contract to make transaction to target chain
    inputArgs = _serialzieArgs(argsList)

    toProxyHash = getProxyHash(toChainId)
    # make sure the toProxyHash is not empty
    assert (len(toProxyHash) != 0)

    param = state(toChainId, toProxyHash, "unlock", inputArgs)
    assert (Invoke(0, CROSS_CHAIN_CONTRACT_ADDRESS, "createCrossChainTx",
                   param))

    LockEvent(fromAssetHash, fromAddress, toChainId, toAssetHash, toAddress,
              amount)
    return True
예제 #12
0
파일: aesop_final.py 프로젝트: tzfeng/aesop
def view_ong(address):
    byte_address = Base58ToAddress(address)

    if len(byte_address) != 20:
        Notify(['Invalid address'])
        return False

    # check if user list exists
    user_info = Get(ctx, USERKEY)
    if user_info:
        all_users = Deserialize(user_info)
    else:
        Notify(['User list is empty'])
        return False

    # check if user has been created
    if address not in all_users:
        Notify(['User not yet created'])
        return False

    # if the above checks hold, we can check the user's wallet.
    else:
        param = state(byte_address)
        ong_balance = Invoke(0, contract_address_ONG, 'balanceOf', param)
        if ong_balance == '':
            ong_balance = 0
        Notify([ong_balance])
        return ong_balance
def transferOntOng(from_acct, to_acct, ont, ong):
    param = state(from_acct, to_acct, ont)
    res = Invoke(0, OntContract, "transfer", [param])
    if res != b'\x01':
        raise Exception("transfer ont error.")
    param = state(from_acct, to_acct, ong)
    Notify("transferONT succeed")
    res = Invoke(0, OngContract, "transfer", [param])

    if res and res == b'\x01':
        Notify('transfer succeed')
        return True
    else:
        Notify('transfer failed')

        return False
예제 #14
0
def _transferONT(fromAcct, toAcct, amount):
    param = state(fromAcct, toAcct, amount)
    res = Invoke(0, ONTAddress, 'transfer', [param])
    if res and res == b'\x01':
        return True
    else:
        return False
예제 #15
0
def _tryUnboundOng():
    unboundOng = _getUnboundOngBalance()
    if unboundOng > 0:
        params = state(CONTRACT_ADDRESS, ONT_ADDRESS, CONTRACT_ADDRESS,
                       _getUnboundOngBalance())
        return Invoke(0, ONG_ADDRESS, 'transferFrom', params)
    return True
예제 #16
0
def deposit_ong(address, ong_amount):
    assert (CheckWitness(address))
    assert (ong_amount >= 0)
    params = state(address, contract_address, ong_amount)
    res = Invoke(0, contract_address_ONG, 'transfer', [params])
    assert (res)
    Notify(["depositONG", address, ong_amount])
    return True
def withdrawOng(toAcct):
    param = state(ONTAddress, ContractAddress)
    unboundOngAmount = Invoke(0, ONGAddress, 'allowance', param)
    Notify(["unboundOngAmount", unboundOngAmount])
    if unboundOngAmount > 0:
        unboundOngAmount = 147
        params = state(ContractAddress, ONTAddress, toAcct, unboundOngAmount)
        res = Invoke(0, ONGAddress, "transferFrom", params)
        if res and res == b'\x01':
            Notify(["withdraw ong successful!"])
            return True
        else:
            Notify(["withdraw ong failed!"])
            return False
    else:
        Notify(["Not enough unboundOngAmount", unboundOngAmount])
        return False
def checkWithdraw(account):
    allowanceOng = checkAllowance(account)
    withdrawOngAmount = allowanceOng / 2
    params = state(account, ONTAddress, account, withdrawOngAmount)
    res = Invoke(0, ONGAddress, 'transferFrom', params)
    if res and res == b'\x01':
        Notify(["withdraw ong successful!"])
        return True
    else:
        Notify(["withdraw ong failed!"])
        return False
예제 #19
0
def makeState(fromacct, toacct, amount):
    """
    make a tranfer state parameter
    currently due to the compiler problem,
    must be created as this format
    :param fromacct:
    :param toacct:
    :param amount:
    :return:
    """
    return state(fromacct, toacct, amount)
예제 #20
0
def lock(fromAssetHash, fromAddress, toChainId, toAddress, amount, feeAmount):
    assert (amount >= 0)
    assert (feeAmount >= 0)
    assert (CheckWitness(fromAddress))
    assert (len(toAddress) > 0)

    #call lock contract lock
    res = Invoke(
        0, LOCKER_CONTRACT_ADDRESS, 'lock',
        state(fromAssetHash, fromAddress, toChainId, toAddress, amount))
    assert (res == True)

    toAssethash = Invoke(0, LOCKER_CONTRACT_ADDRESS, 'getAssetHash',
                         state(toChainId))
    # transfer fee to fee collector
    res = Invoke(0, fromAssetHash, 'transfer',
                 state(fromAddress, FEE_COLLECTOR_ADDRESS, feeAmount))
    assert (res == True)
    WrapLockEvent(toChainId, toAssethash, fromAddress, fromAssetHash,
                  toAddress, amount, feeAmount)
    return True
def transferOngToContract(account, ongAmount):
    selfContractAddress = GetExecutingScriptHash()
    Notify(["111_transferOngToContract", selfContractAddress])
    param = state(account, selfContractAddress, ongAmount)
    ongContractAddress = ToScriptHash("AFmseVrdL9f9oyCzZefL9tG6UbvhfRZMHJ")
    res = Invoke(0, ongContractAddress, 'transfer', [param])
    if res and res == b'\x01':
        Notify('transfer succeed')
        return True
    else:
        Notify('transfer failed')

        return False
예제 #22
0
def upgrade(code, needStorage, name, version, author, email, description):
    """
    upgrade current smart contract to new smart contract.
    :param code:new smart contract avm code.
    :return: True or raise exception.
    """
    assert (CheckWitness(Get(GetContext(), OPERATOR_PREFIX)))
    newContractHash = AddressFromVmCode(code)
    newContractAddr = bytearray_reverse(newContractHash)
    ontBalance = _getSelfONTBalance()
    if ontBalance > 0:
        res = Invoke(0, ONT_ADDRESS, "transfer",
                     [state(CONTRACT_ADDRESS, newContractAddr, ontBalance)])
        assert (res)

    assert (_tryUnboundOng())
    ongBalance = _getSelfOngBalance()
    if ongBalance > 0:
        res = Invoke(0, ONG_ADDRESS, "transfer",
                     [state(CONTRACT_ADDRESS, newContractAddr, ongBalance)])
        assert (res)

    # transfer all the asset locked within lockproxy contract to the new contract
    fahListInfo = Get(GetContext(), FROM_ASSET_LIST_KEY)
    if len(fahListInfo) > 0:
        fahList = Deserialize(fahListInfo)
        for e in fahList:
            amount = getBalanceFor(e)
            if amount > 0:
                assert (_transferFromContract(e, newContractAddr,
                                              newContractAddr))

    # upgrade smart contract
    res = Migrate(code, needStorage, name, version, author, email, description)
    assert (res)

    Notify(["upgrade smart contract"])

    return True
def _transferNativeAsset(nativeAssetHash, fromAcct, toAcct, amount):
    """
    transfer native asset, including ont or ong
    :param fromacct:
    :param toacct:
    :param amount:
    :return:
    """
    param = state(fromAcct, toAcct, amount)
    res = Invoke(0, nativeAssetHash, 'transfer', [param])
    if res and res == b'\x01':
        return True
    else:
        return False
예제 #24
0
def _transferONG(fromAcct, toAcct, amount):
    """
    transfer ONG
    :param fromacct:
    :param toacct:
    :param amount:
    :return:
    """
    param = state(fromAcct, toAcct, amount)
    res = Invoke(0, ONGAddress, 'transfer', [param])
    if res and res == b'\x01':
        return True
    else:
        return False
예제 #25
0
def main():
    a = 1
    d = 4
    c = 3
    b = 2
    t = state(a, b, c, d)
    VaasAssert(t[0] == 1)
    VaasAssert(t[1] == 2)
    VaasAssert(t[2] == 3)
    VaasAssert(t[3] == 4 + 5)
    print(t[0])
    print(t[1])
    print(t[2])
    print(t[3])
예제 #26
0
def _transferONT(fromAcct, toAcct, amount):
    """
    transfer ONT
    :param fromacct:
    :param toacct:
    :param amount:
    :return:
    """
    assert (CheckWitness(fromAcct))
    param = state(fromAcct, toAcct, amount)
    res = Invoke(0, ONTAddress, 'transfer', [param])
    if res and res == b'\x01':
        return True
    else:
        return False
def checkAllowance(account):
    # param = state(ONTAddress, account)
    # if ongFlag == 1:
    #     Notify(["ongFlag", ongFlag])
    #     unboundOngAmount = Invoke(0, ONGAddress, 'allowance', param)
    # else:
    #     Notify(["ongFlag", ongFlag])
    #     unboundOngAmount = Invoke(0, ONTAddress, 'allowance', param)
    # Notify(["checkAllowance", account, unboundOngAmount])

    param = state(ONTAddress, account)
    unboundOngAmount = Invoke(0, ONGAddress, 'allowance', param)
    Notify(["checkAllowance", account, unboundOngAmount])

    return unboundOngAmount
예제 #28
0
def transferFromNative(contractAddress, spender, fromAcct, toAcct, amount):
    """
    transferFrom ONT/ONG
    :param spender:
    :param fromacct:
    :param toacct:
    :param amount:
    :return:
    """
    param = state(spender, fromAcct, toAcct, amount)
    res = Invoke(0, contractAddress, 'transferFrom', param)
    if res and res == b'\x01':
        return True
    else:
        return False
def balanceOf1(acct):
    """
    transfer ONG from contract
    :param acct:
    :return:
    """
    # return ongContract("balanceOf", [acct])
    # return True

    # ONT native contract address
    # contractAddress = bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02')
    contractAddress = ToScriptHash("AFmseVrdL9f9oyCzZefL9tG6UbvhfRZMHJ")
    param = state(acct)
    res = Invoke(0, contractAddress, 'balanceOf', acct)
    return res
def transferONT(fromAcct, toAcct, ontAmount):
    """
    transfer ONG
    :param fromacct:
    :param toacct:
    :param amount:
    :return:
    """
    param = state(fromAcct, toAcct, ontAmount)
    res = Invoke(0, ONTAddress, 'transfer', [param])
    if res and res == b'\x01':
        Notify(["transfer ONT successful!"])
        return True
    else:
        Notify(["transfer ONT failed!"])
        return False