Beispiel #1
0
class TestRealP2PTrade(unittest.TestCase):
    def setUp(self):
        from pwallet import PersistentWallet
        from wallet_controller import WalletController

        self.pwallet = PersistentWallet()
        self.pwallet.init_model()

    def test_real(self):
        ewctrl = EWalletController(self.pwallet.get_model())
        config = {"offer_expiry_interval": 30, "ep_expiry_interval": 30}
        comm1 = MockComm()
        comm2 = MockComm()
        comm1.add_peer(comm2)
        comm2.add_peer(comm1)
        agent1 = EAgent(ewctrl, config, comm1)
        agent2 = EAgent(ewctrl, config, comm2)

        frobla_color_desc = "obc:cc8e64cef1a880f5132e73b5a1f52a72565c92afa8ec36c445c635fe37b372fd:0:263370"
        foo_color_desc = "obc:caff27b3fe0a826b776906aceafecac7bb34af16971b8bd790170329309391ac:0:265577"

        ag1_offer = MyEOffer(
            None, {"color_spec": frobla_color_desc, "value": 100}, {"color_spec": foo_color_desc, "value": 200}
        )
        ag2_offer = MyEOffer(
            None, {"color_spec": foo_color_desc, "value": 200}, {"color_spec": frobla_color_desc, "value": 100}, False
        )

        agent1.register_my_offer(ag1_offer)
        agent2.register_my_offer(ag2_offer)
        for _ in xrange(3):
            agent1.update_state()
            agent2.update_state()
Beispiel #2
0
def main():
    import sys
    import getopt
    try:
        opts, args = getopt.getopt(sys.argv[1:], "", [])
    except getopt.GetoptError:
        print "arg error"
        sys.exit(2)

    if len(args) == 0:
        args = ['help']
    # special command
    if args[0] == 'import_config':
        with open(args[1], "r") as fp:
            config = json.load(fp)
        pw = PersistentWallet(config)
        sys.exit(0)

    pw = PersistentWallet()
    try:
        pw.init_model()
    except Exception as e:
        print "failed to initialize wallet model: %s" % e

    wallet_model = pw.get_model()
    controller = WalletController(wallet_model) \
        if wallet_model else None
    interpreter = CommandInterpreter(pw, controller)

    interpreter.run_command(*args)
Beispiel #3
0
    def __init__(self):
        parser = argparse.ArgumentParser()
        parser.add_argument("--wallet", dest="wallet_path")
        parsed_args = vars(parser.parse_args())

        self.wallet = PersistentWallet(parsed_args.get('wallet_path'))
        self.wallet.init_model()
        self.model = self.wallet.get_model()
        self.controller = WalletController(self.wallet.get_model())
Beispiel #4
0
    def __getattribute__(self, name):
        if name in ['controller', 'model', 'wallet']:
            try:
                data = self.data
            except AttributeError:
                self.data = data = {}

                pw = PersistentWallet(self.args.get('wallet_path'))
                pw.init_model()

                wallet_model = pw.get_model()

                data.update({
                    'controller': WalletController(wallet_model)
                    if wallet_model else None,
                    'wallet': pw,
                    'model': wallet_model if pw else None,
                    })
            return data[name]
        return object.__getattribute__(self, name)
Beispiel #5
0
class TestRealP2PTrade(unittest.TestCase):
    def setUp(self):
        from pwallet import PersistentWallet
        from wallet_controller import WalletController
        self.pwallet = PersistentWallet()
        self.pwallet.init_model()

    def test_real(self):
        ewctrl = EWalletController(self.pwallet.get_model())
        config = {"offer_expiry_interval": 30, "ep_expiry_interval": 30}
        comm1 = MockComm()
        comm2 = MockComm()
        comm1.add_peer(comm2)
        comm2.add_peer(comm1)
        agent1 = EAgent(ewctrl, config, comm1)
        agent2 = EAgent(ewctrl, config, comm2)

        frobla_color_desc = "obc:cc8e64cef1a880f5132e73b5a1f52a72565c92afa8ec36c445c635fe37b372fd:0:263370"
        foo_color_desc = "obc:caff27b3fe0a826b776906aceafecac7bb34af16971b8bd790170329309391ac:0:265577"

        ag1_offer = MyEOffer(None, {
            "color_spec": frobla_color_desc,
            "value": 100
        }, {
            "color_spec": foo_color_desc,
            "value": 200
        })
        ag2_offer = MyEOffer(None, {
            "color_spec": foo_color_desc,
            "value": 200
        }, {
            "color_spec": frobla_color_desc,
            "value": 100
        }, False)

        agent1.register_my_offer(ag1_offer)
        agent2.register_my_offer(ag2_offer)
        for _ in xrange(3):
            agent1.update_state()
            agent2.update_state()
Beispiel #6
0
def main():
    import sys
    import getopt
    try:
        opts, args = getopt.getopt(sys.argv[1:], "", [])
    except getopt.GetoptError:
        print "arg error"
        sys.exit(2)

    # special command
    if args[0] == 'import_config':
        with open(args[1], "r") as fp:
            config = json.load(fp)
        pw = PersistentWallet(config)
        sys.exit(0)

    pw = PersistentWallet()
    wallet_model = pw.get_model()
    cominter = CommandInterpreter(pw,
                                                              WalletController(wallet_model),
                                                              {})
    cominter.run_command(args)
Beispiel #7
0
    def __init__(self):
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        self.app = QtGui.QApplication([])

        QtGui.QMainWindow.__init__(self)
        uic.loadUi(uic.getUiPath('ngcccbase.ui'), self)

        self.overviewpage = OverviewPage()
        self.stackedWidget.addWidget(self.overviewpage)
        self.bindOverviewPage()
        self.sendcoinspage = SendcoinsPage()
        self.stackedWidget.addWidget(self.sendcoinspage)
        self.bindSendcoinsPage()

        self.bindActions()
        self.move(QtGui.QApplication.desktop().screen().rect().center() -
                  self.rect().center())
        self.show()

        self.wallet = PersistentWallet()
        self.walletController = WalletController(self.wallet.get_model())
        self.gotoOverviewPage()

        sys.exit(self.app.exec_())
Beispiel #8
0
    def __init__(self):
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        self.app = QtGui.QApplication([])

        QtGui.QMainWindow.__init__(self)
        uic.loadUi(uic.getUiPath('ngcccbase.ui'), self)

        self.overviewpage = OverviewPage()
        self.stackedWidget.addWidget(self.overviewpage)
        self.bindOverviewPage()
        self.sendcoinspage = SendcoinsPage()
        self.stackedWidget.addWidget(self.sendcoinspage)
        self.bindSendcoinsPage()

        self.bindActions()
        self.move(QtGui.QApplication.desktop().screen().rect().center()
                  - self.rect().center())
        self.show()

        self.wallet = PersistentWallet()
        self.walletController = WalletController(self.wallet.get_model())
        self.gotoOverviewPage()

        sys.exit(self.app.exec_())
Beispiel #9
0
class Wallet(object):
    def __init__(self):
        self.wallet = PersistentWallet()
        self.wallet.init_model()
        self.model = self.wallet.get_model()
        self.controller = WalletController(self.wallet.get_model())

    def get_asset_definition(self, moniker):
        adm = self.wallet.get_model().get_asset_definition_manager()
        asset = adm.get_asset_by_moniker(moniker)
        if asset:
            return asset
        else:
            raise Exception("asset not found")

    def get_all_monikers(self):
        return [
            asset.get_monikers()[0] for asset in
            self.wallet.get_model().get_asset_definition_manager()
            .get_all_assets()]

    def get_balance(self, color):
        if not isinstance(color, AssetDefinition):
            color = self.get_asset_definition(color)
        return self.controller.get_balance(color)

    def get_all_addresses(self, color):
        if not isinstance(color, AssetDefinition):
            color = self.get_asset_definition(color)
        return [addr.get_address() for addr in
                self.controller.get_all_addresses(color)]

    def send_coins(self, items):
        for item in items:
            self.controller.send_coins(
                item['address'],
                item['asset'] if 'asset' in item
                else self.get_asset_definition(item['moniker']),
                item['value'])
Beispiel #10
0
class QtUI(QtGui.QMainWindow):
    def __init__(self):
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        self.app = QtGui.QApplication([])

        QtGui.QMainWindow.__init__(self)
        uic.loadUi(uic.getUiPath('ngcccbase.ui'), self)

        self.overviewpage = OverviewPage()
        self.stackedWidget.addWidget(self.overviewpage)
        self.bindOverviewPage()
        self.sendcoinspage = SendcoinsPage()
        self.stackedWidget.addWidget(self.sendcoinspage)
        self.bindSendcoinsPage()

        self.bindActions()
        self.move(QtGui.QApplication.desktop().screen().rect().center() -
                  self.rect().center())
        self.show()

        self.wallet = PersistentWallet()
        self.walletController = WalletController(self.wallet.get_model())
        self.gotoOverviewPage()

        sys.exit(self.app.exec_())

    def bindActions(self):
        # menu actions
        self.actionExit.triggered.connect(lambda: self.app.exit(0))
        # toolbar actions
        self.toolbarActions = [
            self.actionGotoOverview,
            self.actionGotoSendcoins,
        ]
        self.actionGotoOverview.triggered.connect(self.gotoOverviewPage)
        self.actionGotoSendcoins.triggered.connect(self.gotoSendcoinsPage)

    def bindOverviewPage(self):
        def btn_newAddressClicked():
            bitcoin_asset = self.get_asset_definition('bitcoin')
            address = self.walletController.get_new_address(bitcoin_asset)
            addresses = [
                addr.get_address() for addr in
                self.walletController.get_all_addresses(bitcoin_asset)
            ]
            self.overviewpage.update_btc_addresses(addresses)
            self.overviewpage.set_btc_address(addr.get_address())

        self.overviewpage.btn_newAddress.clicked.connect(btn_newAddressClicked)

        def btn_newAsset():
            # need change page to issue coins
            pass

        self.overviewpage.btn_newAsset.clicked.connect(btn_newAsset)

        def updateWallet():
            address = self.overviewpage.get_btc_address()
            moniker = self.overviewpage.get_moniker()
            if address and moniker:
                asset = self.get_asset_definition(moniker)
                balance = self.walletController.get_balance(asset)
                if moniker == 'bitcoin':
                    balance = '%.8f BTC' % (balance, )
                else:
                    address = '%s@%s' % (moniker, address)
                    balance = '%.8f %s' % (balance, moniker)
                self.overviewpage.update_wallet(address, balance)

        self.overviewpage.cb_addresses.currentIndexChanged.connect(
            updateWallet)
        self.overviewpage.cb_monikers.currentIndexChanged.connect(updateWallet)

    def gotoOverviewPage(self):
        # set bitcoin addresses
        bitcoin_asset = self.get_asset_definition('bitcoin')
        bitcoin_addresses = [
            addr.get_address()
            for addr in self.walletController.get_all_addresses(bitcoin_asset)
        ]
        self.overviewpage.update_btc_addresses(bitcoin_addresses)
        # set available monikers
        monikers = self.wallet.get_model().get_asset_definition_manager() \
            .assdef_by_moniker.keys()
        self.overviewpage.update_monikers(monikers)
        # goto
        self.stackedWidget.setCurrentWidget(self.overviewpage)
        # change toolbar buttons
        for action in self.toolbarActions:
            action.setChecked(False)
        self.actionGotoOverview.setChecked(True)

    def bindSendcoinsPage(self):
        def btn_send():
            recipients = self.sendcoinspage.get_data()
            for recipient in recipients:
                self.walletController.send_coins(
                    recipient['address'],
                    self.get_asset_definition(recipient['moniker']),
                    recipient['amount'])

        self.sendcoinspage.btn_send.clicked.connect(btn_send)
        self.sendcoinspage.edt_address.returnPressed.connect(btn_send)

        def amount_editingFinished():
            if self.sendcoinspage.edt_amount.hasFocus():
                btn_send()

        self.sendcoinspage.edt_amount.editingFinished.connect(
            amount_editingFinished)

        def updateAvailableBalance():
            moniker = self.sendcoinspage.get_moniker()
            if moniker:
                asset = self.get_asset_definition(moniker)
                balance = self.walletController.get_balance(asset)
                self.sendcoinspage.set_max_amount(balance)

        self.sendcoinspage.cb_monikers.activated.connect(
            updateAvailableBalance)

    def gotoSendcoinsPage(self):
        # set available monikers
        monikers = self.wallet.get_model().get_asset_definition_manager() \
            .assdef_by_moniker.keys()
        self.sendcoinspage.update_monikers(monikers)
        # goto
        self.stackedWidget.setCurrentWidget(self.sendcoinspage)
        # change toolbar buttons
        for action in self.toolbarActions:
            action.setChecked(False)
        self.actionGotoSendcoins.setChecked(True)

    def get_asset_definition(self, moniker):
        adm = self.wallet.get_model().get_asset_definition_manager()
        asset = adm.get_asset_by_moniker(moniker)
        if asset:
            return asset
        else:
            raise Exception("asset not found")
Beispiel #11
0
This file connects ngccc-server.py to wallet_controller.py
The main functions that this file has are to take the
JSON-RPC commands from the server and pass them through to
the wallet controller.
Note console_interface.py does a similar thing for ngccc.py
to wallet_controller.py
"""

from wallet_controller import WalletController
from pwallet import PersistentWallet
import pyjsonrpc
import json

# create a global wallet for this use.
wallet = PersistentWallet()
wallet.init_model()
model = wallet.get_model()
controller = WalletController(model)


def get_asset_definition(moniker):
    """Get the asset/color associated with the moniker.
    """
    adm = model.get_asset_definition_manager()
    asset = adm.get_asset_by_moniker(moniker)
    if asset:
        return asset
    else:
        raise Exception("asset %s not found" % moniker)
Beispiel #12
0
class QtUI(QtGui.QMainWindow):
    def __init__(self):
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        self.app = QtGui.QApplication([])

        QtGui.QMainWindow.__init__(self)
        uic.loadUi(uic.getUiPath('ngcccbase.ui'), self)

        self.overviewpage = OverviewPage()
        self.stackedWidget.addWidget(self.overviewpage)
        self.bindOverviewPage()
        self.sendcoinspage = SendcoinsPage()
        self.stackedWidget.addWidget(self.sendcoinspage)
        self.bindSendcoinsPage()

        self.bindActions()
        self.move(QtGui.QApplication.desktop().screen().rect().center()
                  - self.rect().center())
        self.show()

        self.wallet = PersistentWallet()
        self.walletController = WalletController(self.wallet.get_model())
        self.gotoOverviewPage()

        sys.exit(self.app.exec_())

    def bindActions(self):
        # menu actions
        self.actionExit.triggered.connect(lambda: self.app.exit(0))
        # toolbar actions
        self.toolbarActions = [
            self.actionGotoOverview,
            self.actionGotoSendcoins,
        ]
        self.actionGotoOverview.triggered.connect(self.gotoOverviewPage)
        self.actionGotoSendcoins.triggered.connect(self.gotoSendcoinsPage)

    def bindOverviewPage(self):
        def btn_newAddressClicked():
            bitcoin_asset = self.get_asset_definition('bitcoin')
            address = self.walletController.get_new_address(bitcoin_asset)
            addresses = [
                addr.get_address() for addr in
                self.walletController.get_all_addresses(bitcoin_asset)]
            self.overviewpage.update_btc_addresses(addresses)
            self.overviewpage.set_btc_address(addr.get_address())
        self.overviewpage.btn_newAddress.clicked.connect(btn_newAddressClicked)

        def btn_newAsset():
            # need change page to issue coins
            pass
        self.overviewpage.btn_newAsset.clicked.connect(btn_newAsset)

        def updateWallet():
            address = self.overviewpage.get_btc_address()
            moniker = self.overviewpage.get_moniker()
            if address and moniker:
                asset = self.get_asset_definition(moniker)
                balance = self.walletController.get_balance(asset)
                if moniker == 'bitcoin':
                    balance = '%.8f BTC' % (balance,)
                else:
                    address = '%s@%s' % (moniker, address)
                    balance = '%.8f %s' % (balance, moniker)
                self.overviewpage.update_wallet(address, balance)
        self.overviewpage.cb_addresses.currentIndexChanged.connect(
            updateWallet)
        self.overviewpage.cb_monikers.currentIndexChanged.connect(updateWallet)

    def gotoOverviewPage(self):
        # set bitcoin addresses
        bitcoin_asset = self.get_asset_definition('bitcoin')
        bitcoin_addresses = [
            addr.get_address() for addr in
            self.walletController.get_all_addresses(bitcoin_asset)]
        self.overviewpage.update_btc_addresses(bitcoin_addresses)
        # set available monikers
        monikers = self.wallet.get_model().get_asset_definition_manager() \
            .assdef_by_moniker.keys()
        self.overviewpage.update_monikers(monikers)
        # goto
        self.stackedWidget.setCurrentWidget(self.overviewpage)
        # change toolbar buttons
        for action in self.toolbarActions:
            action.setChecked(False)
        self.actionGotoOverview.setChecked(True)

    def bindSendcoinsPage(self):
        def btn_send():
            recipients = self.sendcoinspage.get_data()
            for recipient in recipients:
                self.walletController.send_coins(
                    recipient['address'],
                    self.get_asset_definition(recipient['moniker']),
                    recipient['amount'])
        self.sendcoinspage.btn_send.clicked.connect(btn_send)
        self.sendcoinspage.edt_address.returnPressed.connect(btn_send)

        def amount_editingFinished():
            if self.sendcoinspage.edt_amount.hasFocus():
                btn_send()
        self.sendcoinspage.edt_amount.editingFinished.connect(
            amount_editingFinished)

        def updateAvailableBalance():
            moniker = self.sendcoinspage.get_moniker()
            if moniker:
                asset = self.get_asset_definition(moniker)
                balance = self.walletController.get_balance(asset)
                self.sendcoinspage.set_max_amount(balance)
        self.sendcoinspage.cb_monikers.activated.connect(
            updateAvailableBalance)

    def gotoSendcoinsPage(self):
        # set available monikers
        monikers = self.wallet.get_model().get_asset_definition_manager() \
            .assdef_by_moniker.keys()
        self.sendcoinspage.update_monikers(monikers)
        # goto
        self.stackedWidget.setCurrentWidget(self.sendcoinspage)
        # change toolbar buttons
        for action in self.toolbarActions:
            action.setChecked(False)
        self.actionGotoSendcoins.setChecked(True)

    def get_asset_definition(self, moniker):
        adm = self.wallet.get_model().get_asset_definition_manager()
        asset = adm.get_asset_by_moniker(moniker)
        if asset:
            return asset
        else:
            raise Exception("asset not found")
Beispiel #13
0
 def setUp(self):
     from pwallet import PersistentWallet
     from wallet_controller import WalletController
     self.pwallet = PersistentWallet()
     self.pwallet.init_model()
Beispiel #14
0
class Wallet(object):
    thread_comm = None

    def __init__(self):
        parser = argparse.ArgumentParser()
        parser.add_argument("--wallet", dest="wallet_path")
        parsed_args = vars(parser.parse_args())

        self.wallet = PersistentWallet(parsed_args.get('wallet_path'))
        self.wallet.init_model()
        self.model = self.wallet.get_model()
        self.controller = WalletController(self.wallet.get_model())

    def get_asset_definition(self, moniker):
        if isinstance(moniker, AssetDefinition):
            return moniker
        adm = self.wallet.get_model().get_asset_definition_manager()
        asset = adm.get_asset_by_moniker(moniker)
        if asset:
            return asset
        else:
            raise Exception("asset not found")

    def add_asset(self, params):
        self.controller.add_asset_definition({
            "monikers": [params['moniker']],
            "color_set": [params['color_desc']],
            "unit": params['unit']
        })
        if len(self.get_all_addresses(params['moniker'])) == 0:
            self.get_new_address(params['moniker'])

    def get_all_asset(self):
        return self.wallet.wallet_config['asset_definitions']

    def issue(self, params):
        self.controller.issue_coins(
            params['moniker'], params['coloring_scheme'],
            params['units'], params['atoms'])
        if len(self.get_all_addresses(params['moniker'])) == 0:
            self.get_new_address(params['moniker'])

    def get_all_monikers(self):
        monikers = [asset.get_monikers()[0] for asset in
            self.model.get_asset_definition_manager().get_all_assets()]
        monikers.remove('bitcoin')
        monikers = ['bitcoin'] + monikers
        return monikers

    def get_balance(self, color):
        return self.controller.get_balance(self.get_asset_definition(color))

    def get_all_addresses(self, color):
        return [addr.get_address() for addr in
            self.controller.get_all_addresses(self.get_asset_definition(color))]

    def get_address_balance(self, color):
        asset = self.get_asset_definition(color)
        return self.controller.get_address_balance(asset)

    def get_some_address(self, color):
        wam = self.model.get_address_manager()
        cs = self.get_asset_definition(color).get_color_set()
        ar = wam.get_some_address(cs)
        return ar.get_address()

    def get_new_address(self, color):
        return self.controller. \
            get_new_address(self.get_asset_definition(color)).get_address()

    def scan(self):
        self.controller.scan_utxos()

    def send_coins(self, items):
        if isinstance(items, dict):
            items = [items]
        for item in items:
            self.controller.send_coins(
                item['asset'] if 'asset' in item \
                    else self.get_asset_definition(item['moniker']),
                [item['address']],
                [item['value']])

    def p2ptrade_init(self):
        ewctrl = EWalletController(self.model, self.controller)
        config = {"offer_expiry_interval": 30,
                  "ep_expiry_interval": 30}
        comm = HTTPComm(
            config, 'http://p2ptrade.btx.udoidio.info/messages')
        self.thread_comm = ThreadedComm(comm)
        self.p2p_agent = EAgent(ewctrl, config, self.thread_comm)
        self.thread_comm.start()

    def p2ptrade_stop(self):
        if self.thread_comm is not None:
            self.thread_comm.stop()

    def p2ptrade_make_offer(self, we_sell, params):
        asset = self.get_asset_definition(params['moniker'])
        value = asset.parse_value(params['value'])
        bitcoin = self.get_asset_definition('bitcoin')
        price = bitcoin.parse_value(params['price'])
        total = int(float(value)/float(asset.unit)*float(price))
        color_desc = asset.get_color_set().color_desc_list[0]
        sell_side = {"color_spec": color_desc, "value": value}
        buy_side = {"color_spec": "", "value": total}
        if we_sell:
            return MyEOffer(None, sell_side, buy_side)
        else:
            return MyEOffer(None, buy_side, sell_side)

    def p2ptrade_make_mirror_offer(self, offer):
        data = offer.get_data()
        return MyEOffer(None, data['B'], data['A'])
Beispiel #15
0
This file connects ngccc-server.py to wallet_controller.py
The main functions that this file has are to take the
JSON-RPC commands from the server and pass them through to
the wallet controller.
Note console_interface.py does a similar thing for ngccc.py
to wallet_controller.py
"""

from wallet_controller import WalletController
from pwallet import PersistentWallet
import pyjsonrpc
import json

# create a global wallet for this use.
wallet = PersistentWallet()
wallet.init_model()
model = wallet.get_model()
controller = WalletController(model)


def get_asset_definition(moniker):
    """Get the asset/color associated with the moniker.
    """
    adm = model.get_asset_definition_manager()
    asset = adm.get_asset_by_moniker(moniker)
    if asset:
        return asset
    else:
        raise Exception("asset %s not found" % moniker)
Beispiel #16
0
    def setUp(self):
        from pwallet import PersistentWallet
        from wallet_controller import WalletController

        self.pwallet = PersistentWallet()
        self.pwallet.init_model()
Beispiel #17
0
from wallet_controller import WalletController
from pwallet import PersistentWallet
import pyjsonrpc
import json


wallet = PersistentWallet()
model = wallet.get_model()
controller = WalletController(model)


def get_asset_definition(moniker):
    adm = model.get_asset_definition_manager()
    asset = adm.get_asset_by_moniker(moniker)
    if asset:
        return asset
    else:
        raise Exception("asset not found")


def balance(moniker):
    asset = get_asset_definition(moniker)
    return controller.get_balance(asset)


def newaddr(moniker):
    asset = get_asset_definition(moniker)
    addr = controller.get_new_address(asset)
    return addr.get_address()

Beispiel #18
0
This file connects ngccc-server.py to wallet_controller.py
The main functions that this file has are to take the
JSON-RPC commands from the server and pass them through to
the wallet controller.
Note console_interface.py does a similar thing for ngccc.py
to wallet_controller.py
"""

from wallet_controller import WalletController
from pwallet import PersistentWallet
import pyjsonrpc
import json

# create a global wallet for this use.
wallet = PersistentWallet(None, True)
wallet.init_model()
model = wallet.get_model()
controller = WalletController(model)


def get_asset_definition(moniker):
    """Get the asset/color associated with the moniker.
    """
    adm = model.get_asset_definition_manager()
    asset = adm.get_asset_by_moniker(moniker)
    if asset:
        return asset
    else:
        raise Exception("asset %s not found" % moniker)
Beispiel #19
0
 def __init__(self):
     self.wallet = PersistentWallet()
     self.wallet.init_model()
     self.model = self.wallet.get_model()
     self.controller = WalletController(self.wallet.get_model())