Hey there,
I finally picked a date for the testnet stress test:

       15th March beginning around 3pm UTC.

Organization
I would like to invite everyone (in particular the witness node operators) to join this Telegram channel:
https://t.me/joinchat/AAAAAA0N-zjsAdcLnUsL6A

Real-Time Stats
Turns out the new middleware for the stats seem to work pretty well. You can see the real-time stats during the stresstest on
http://stats.bitshares.eu  (make sure to select the testnet!)
After the stresstest, when the transactions are all in the blokchain, we can do some offline analysis

Spamming
Currently, the cli-wallet is the fastest to produce transactions
Python Script For the CLI wallet
import time
import json
from grapheneapi.grapheneapi import GrapheneAPI

blockinterval    = 2
numbertxperblock = 500

if __name__ == '__main__':
    client = GrapheneAPI("localhost", 8090, "", "")
    while True :
        for i in range(0,numbertxperblock) :
            print(i)
            res = client.transfer("faucet","xeroc","0.001", "TEST", "", True);
        time.sleep(blockinterval)

I hope I can finish up the basic uptick client and add a temporary flooding call there by next week, then you won't need the cli-wallet for it.

Public Witness API
Now that I have set a date, I can order a fat machine for the public API node and monitor it's RAM and bandwidth usage.
The URL will still be

  wss://node.testnet.bitshares.eu

and unless you run your own witness node (which would be very welcome), this node should hopefully have enough resources to stay up and running during the stresstest.

Is there anything else we should discuss in the meantime?

Dear shareholders,

in this post, I would like to get an impression on how much you think a new bitshares-specific python library is needed.
As some background, I have been working on a library for Steem that includes a wallet and many of the Steem-specific features so that
writing your own python programs becomes a matter of just adding this library which exposes the whole power of the Steem blockchain.

In the progress of writing python-steem, I learned many lessons that I could apply to a new python-bitshares library (which currently doesn't exist yet).

So, I would like to hear your opinion about this proposal:

Deliverables

• refactoring of python-graphene for simplicity
• bitShares-pecific python library
• including a wallet to store private keys locally (encrypted)
• an interface to the DEX that allows to buy, sell, borrow
• an interface to monitor the blockchain
• methods to monitor your account
• a command line interface similar to piston

Additionally, I would like to run a public API endpoint so that the library can speak to the network without the need to specify an API node.

Timeframe
Assuming I put 10h/week, I will probably need some 4-5 months to complete the deliverables above. This is in line with the experiences made on the python-steem library (that actually took more time)

Outlook
Once this library is complete, a Userinterface written in QT or GTK similar to electrum can probably be written very quickly as it's now only a frontend and nothing else. (Not part of the proposal)

Costs

• $100/mth public API
• $100/h=$4000/mth python development
• $100 account LTM fee
• $150 worker creation fee

After the end of the worker, the public API endpoint needs to be funded by another worker, or a witness node. Either way, the worker only covers the API endpoint for the duration of the worker.

Worker
Given that a worker will be voted in for quite some time, I would like to propose a new model of running a worker:

• I will create a new account, upgrade it to LTM and make it multisig with the committee account and trusted members of the comunity
• The worker will redeem it's funds on a regular basis and buy up bitUSD from the market (only up to above market)
• If the market doesn't offer sufficient bitUSD, the worker account will borrow bitUSD at 2.5x collateral
• For this reasons, the actual pay of the worker is 2.5x the USD value
• The worker will only pay the agreed amount of money and only in bitUSD to me
• Every thing that is not paid out after the end of the worker will be settled and returned to the reserve fund

I am proud to now publicly announce the first release of StakeMachine.
What is it?

It is a Python tool that offers:

    a unified framework for writing bots for the DEX
    a simple market making strategy
    the liquidity-providing strategy developed by @mauritso
    more strategies to come soon.

Simple Market Making

A simple market making strategy (i.e. providing liquidity) works as follows:

    Get the last price for your market
    Place a buy order at last price * 95%
    Place a sell order at last price * 105%
    Wait for any of the two orders to get filled
    Cancel the other order
    Go to 1.

This strategy is very simple and tries to makes a profit from the spread. The more volatile a market is, the more profit it will (probably) make you.

More on Steem:
https://steemit.com/bitshares/@xeroc/stakemachine-trading-infrastructure-and-simple-market-making-bot-for-bitshares--opensource-bot-for-bitshares

I have improved the `exchange` module in the python-graphenelibs such
that you could now create transactions **without** the cli_wallet and
thus write trading bots without the need for compiling BitShares.
I would call it experimental even though the code itself seems to pass
all tests.

However, I created a new branch in the python-graphene libs repository called
`feature/signing-of-trades`. I encourage everyone to give it a try.

Installation
                                                                                                                                                                             
git clone https://github.com/xeroc/python-graphenelib
git checkout feature/signing-of-trades
make install-user

Example Code

                                                                                                                                                                             
from grapheneexchange.exchange import GrapheneExchange
from pprint import pprint                                                                                                                                                             
                                                                                                                                                                                     
                                                                                                                                                                                     
class Config():                                                                                                                                                                       
    witness_url           = "wss://bitshares.openledger.info/ws"                                                                                                                     
    watch_markets         = ["USD_BTS"]                                                                                                                                               
    market_separator      = "_"                                                                                                                                                       
    account = "xeroc"                                                                                                                                                                 
                                                                                                                                                                                     
dex = GrapheneExchange(                                                                                                                                                               
    config,                                                                                                                                                                           
    safe_mode=True,                                                                                                                                                                   
    wif="YOUR-WIF-KEY"                                                                                                                                                               
)                                                                                                                                                                                     
pprint(dex.returnTicker())                                                                                                                                                           
print(dex.buy("USD_BTS", 1, 10))                                                                                                                                                     
print(dex.adjust_collateral_ratio("SILVER", 3.0))                                                                                                                                     
                                                                                                                                                                             
                                                                                                                                                                                     
Prove the `wif` key for the *active* permissions of the account provided                                                                                                             
in the config.                                                                                                                                                                       
                                                                                                                                                                                     
If you set the `safe_mode` flag when instatiating `GrapheneExchange` to                                                                                                               
`False`, it will also **broadcast** the transaction.                                                                                                                                 
                                                                                                                                                                                     
Please give it a try and also remember that there is a **TEST** network                                                                                                               
for this!                                                                                                                                                                             
                                                                                                                                                                                     
**Note**, this is still work in progress and some interfaces may change.                                                                                                             
While writing this post, I realized that the wif key should probably be                                                                                                               
put in the `Config` class aswell so that it can be put in a distinct                                                                                                                 
`config.py` file and loaded via `import config` for separation of code                                                                                                               
and access key.                                                                                                                                                                       
                                                                                                                                                                                     
Cheers 

Steem post
https://steemit.com/bitshares/[member=120]xeroc[/member]/experimental-python-trading-without-cli-wallet

After quite some coding, refacturing, cleanups and more refacturing of
processes as well as with the great progress made by jcalfee1 and svk, I
am proud to show the first minimum viable product for Peermit
2-Factor-Authentication in the testnet.

This gives you a free way to play around, setting up a secured account
and learning how things will most probably be deployed also on the main
network and hopefully gives me some material and feedback that I can use
to improve the UI and the backend code.

This is how it works:

1) Create a new account on http://testnet.bitshares.eu
2) Create a new "secured" account
3) Make a backup to secure the owner key that will give ultimate access to your account
4) Unlock your wallet
5) Open the Permissions page of your account and click on the tab "2FA"
6) Provide a mail address that shall be used to contact you on proposals Click on the "register" button and wait for confirmation from the API server
7) Provide a reference account name (a secondary account that you have control over) that has to also approve any proposals Click on the little 'add' button and don't wonder that your account name disappears afterwards
8) Enable 2 Factor Authentication
9) Finally publish the changes made to your account

No you can essentially delete your newly created wallet that contains only one
(secured) account and for which you have a backof of the owner key.

If you open up your regular wallet, you can now open the account page your your
secured account and propose a transfer from that account (e.g. the initial 1M
TEST).

Once you have proposed that transfer, you should receive an (currently ugly)
email with a link to peermit.com. After providing the secret token (similar to
poloniex) to peermit.com, we will approve your transfer.

All that is left is that you reference account ALSO approves that transfer. To
do so, open the secured account. You should see the proposal below the list of
assets. Click on "Approve" and add your approval from the corresponding
accounts.

After that approval transaction has been confirmed, the transfer will be
executed.

Happy testing. I am looking for plenty of constructive critisism.

Cheers
 -- Fabian

(This thread does NOT discuss the fee schedule but opens the discussion for new features to allow more granularity in fees)

During the creation of the current fee schedule as few points came up
that could allow more flexibility and a more natural fee schedule if
they were implemented. Here they are:

* Have a way to define which operation requires LTM and which do not.
  For instance, we could say that assets can only be created by LTMs but
  the committee could open up asset creation for basic members for a
  short period of time.

* Give the committee a means to define which operations pay into the
  referral program and which do not. This could even be extended such
  that they can choose a precentage split between: network, referal
  program, FBA, funding account etc. Replace "committee" with issuer in
  the above, we could allow the issue to topup from the network fee and
  allow them to define additional fees for some operations that involve
  their asset and the corresponding fees to be payed not only to the
  network, but also to be split between: the referral program, an
  account or a FBA.

* we need a way to distinguish fees for MPA, UIA, and Prediction markets

* It may be useful to have a way to set the fee for
  withdraw_permission_claim to be either percentage-based on the amount
  to claim, or to be dependend on the time that they vest their
  balance.

Any further ideas?

I finally took the time to upgrade my Bitshares Paperwallet code and have constructed a whole boilerplate for Graphene-compatible webpages (Thanks to @jcalfee1 for @graphene-libs).

Anyway, the first stable release 1.0.0 can be downloaded here for BTS and the testnet.
The webpage does nothing more than display a pub/priv key pair with QR codes.
There is a quick introductional help as well.

https://github.com/xeroc/graphene-paperwallet/releases/tag/1.0.0

Looking forward to some feedback

Cheers