Trader is an autonomous service that performs bets on existing prediction markets. The service interacts with an AI Mech (a service that executes AI tasks), and its workflow is as follows:
- Retrieve information on existing prediction markets (for example, markets created by a given address).
- Select one of these markets for betting.
- Send a request to an AI Mech to estimate the probability of the event referenced by the prediction market question, and what confidence the AI Mech has on that prediction.
- The service will typically bet higher amounts for higher confidence predictions coming from the AI Mech.
- These parameters are configurable.
- If the response from the AI Mech meets certain criteria indicating profitability, the service will place a bet on that market. The betting amount can be adjusted based on the confidence level provided by the AI Mech.
- In case the bet is deemed unprofitable, the market will be blacklisted for a configurable duration.
- Repeat these steps continuously.
The Trader service is an agent service (or autonomous service) based on the Open Autonomy framework. Below we show you how to prepare your environment, how to prepare the agent keys, and how to configure and run the service.
-
System requirements:
- Python
== 3.10
- Poetry
>=1.4.0
- Docker Engine
- Docker Compose
- Python
-
Clone this repository:
git clone https://github.com/valory-xyz/trader.git
-
Create a development environment:
poetry install && poetry shell
-
Configure the Open Autonomy framework:
autonomy init --reset --author valory --remote --ipfs --ipfs-node "/dns/registry.autonolas.tech/tcp/443/https"
-
Pull packages required to run the service:
autonomy packages sync --update-packages
You need a Gnosis keypair and a Safe address to run the service.
First, prepare the keys.json
file with the Gnosis keypair of your agent. (Replace the uppercase placeholders below):
cat > keys.json << EOF
[
{
"address": "YOUR_AGENT_ADDRESS",
"private_key": "YOUR_AGENT_PRIVATE_KEY"
}
]
EOF
Next, prepare the Safe. The trader agent runs as part of a trader service, which is an autonomous service represented on-chain in the Autonolas Protocol by a Safe multisig. Follow the next steps to obtain a Safe address corresponding to your agent address:
- Visit https://registry.olas.network/services/mint and connect to the Gnosis network. We recommend connecting using a wallet with a Gnosis EOA account that you own.
- Fill in the following fields:
- "Owner address": a Gnosis address for which you will be able to sign later using a supported wallet. If you want to use the address you are connected to, click on "Prefill Address".
- Click on "Generate Hash & File" and enter the value corresponding to the
service/valory/trader/0.1.0
key inpackages.json
- "Canonical agent Ids": enter the number
12
- "No. of slots to canonical agent Ids": enter the number
1
- "Cost of agent instance bond (wei)": enter the number
10000000000000000
- "Threshold": enter the number
1
- Press the "Submit" button. Your wallet will ask you to approve the transaction. Once the transaction is settled, you should see a message indicating that the service NFT has been minted successfully. You should also see that the service is in Pre-Registration state.
- Next, you can navigate to https://registry.olas.network/services#my-services, select your service and go through the steps:
- Activate registration
- Register agents: here, you must use your agent address.
- This is the last step. A transaction for the Safe deployment is already prepared and needs to be executed.
- After completing the process you should see that your service is Deployed, and you will be able to retrieve your Safe contract address as shown in the image below:
You need to provide some funds (XDAI) both to your agent address and to the Safe address in order to place bets on prediction markets.
Set up the following environment variables, which will modify the performance of the trading agent. Please read their description below. We provide some defaults, but feel free to experiment with different values. Note that you need to provide YOUR_AGENT_ADDRESS
and YOUR_SAFE_ADDRESS
from the section above.
export RPC_0=INSERT_YOUR_RPC
export CHAIN_ID=100
export ALL_PARTICIPANTS='["YOUR_AGENT_ADDRESS"]'
export SAFE_CONTRACT_ADDRESS="YOUR_SAFE_ADDRESS"
export OMEN_CREATORS='["0x89c5cc945dd550BcFfb72Fe42BfF002429F46Fec"]'
export BET_AMOUNT_PER_THRESHOLD_000=0
export BET_AMOUNT_PER_THRESHOLD_010=0
export BET_AMOUNT_PER_THRESHOLD_020=0
export BET_AMOUNT_PER_THRESHOLD_030=0
export BET_AMOUNT_PER_THRESHOLD_040=0
export BET_AMOUNT_PER_THRESHOLD_050=0
export BET_AMOUNT_PER_THRESHOLD_060=30000000000000000
export BET_AMOUNT_PER_THRESHOLD_070=40000000000000000
export BET_AMOUNT_PER_THRESHOLD_080=60000000000000000
export BET_AMOUNT_PER_THRESHOLD_090=80000000000000000
export BET_AMOUNT_PER_THRESHOLD_100=100000000000000000
export BET_THRESHOLD=5000000000000000
export PROMPT_TEMPLATE='With the given question "@{question}" and the `yes` option represented by `@{yes}` and the `no` option represented by `@{no}`, what are the respective probabilities of `p_yes` and `p_no` occurring?'
These are the description of the variables used by the Trader service:
RPC_0
: RPC endpoint for the agent (you can get an RPC endpoint, e.g. here).CHAIN_ID
: identifier of the chain on which the service is running (Gnosis=100).ALL_PARTICIPANTS
: list of all the agent addresses participating in the service. In this example we only are using a single agent.SAFE_CONTRACT_ADDRESS
: address of the agents multisig wallet created in the previous section.OMEN_CREATORS
: addresses of the market creator(s) that the service will track for placing bets on Omen. The address0x89c5cc945dd550BcFfb72Fe42BfF002429F46Fec
corresponds to the Market creator agent for the Hackathon.BET_AMOUNT_PER_THRESHOLD_X
: amount (wei) to bet when the prediction returned by the AI Mech surpasses a threshold ofX
% confidence for a given prediction market. In the values provided above the amounts vary between 0.03 xDAI (60% confidence) and 0.1 xDAI (100% confidence).BET_THRESHOLD
: threshold (wei) for placing a bet. A bet will only be placed ifpotential_net_profit - BET_THRESHOLD >= 0
. See below.PROMPT_TEMPLATE
: prompt to be used with the prediction AI Mech. Please keep it as a single line including the placeholders@{question}
,@{yes}
and@{no}
.
Once you have configured (exported) the environment variables, you are in position to run the service.
-
Fetch the service:
autonomy fetch --local --service valory/trader && cd trader
-
Build the Docker image:
autonomy build-image
-
Copy your
keys.json
file prepared in the previous section in the same directory:cp path/to/keys.json .
-
Build the deployment with a single agent and run:
autonomy deploy build --n 1 -ltm autonomy deploy run --build-dir abci_build/
Please take into consideration the following:
- If the service does not have enough funds for placing a bet, you will see an
Event.INSUFICIENT_FUNDS
in the service logs. - If the service determines that a bet is not profitable
(i.e.,
potential_net_profit - BET_THRESHOLD < 0
), you will see anEvent.UNPROFITABLE
in the service logs, and the service will transition into the blacklisting round. This round blacklists a bet for a predetermined amount of time. This can be adjusted by using theBLACKLISTING_DURATION
environment variable. - For simplicity,
the current implementation considers
potential_net_profit = num_shares - net_bet_amount - mech_price - BET_THRESHOLD
, although this calculation might be refined. Thenet_bet_amount
is the bet amount minus the FPMM's fees. - When assigning
BET_THRESHOLD
take into consideration that fees (at the time of writing this guide) are in the range of 0.02 xDAI. See, for example, here. We urge you to keep an eye on these fees, as they might vary.
The trader service can be run as a multi-agent system. If you want to explore this option, you need, for the case of 4 agents:
-
One
keys.json
file containing 4 addresses and keys. -
Register these 4 keys in your service Safe as explained in this section.
-
Prepare extra environment variables need to be defined, including
export RPC_0=INSERT_YOUR_RPC export RPC_1=INSERT_YOUR_RPC export RPC_2=INSERT_YOUR_RPC export RPC_3=INSERT_YOUR_RPC export ALL_PARTICIPANTS='["AGENT_ADDRESS_0,AGENT_ADDRESS_1,AGENT_ADDRESS_2,AGENT_ADDRESS_3"]'
where
RPC_i
is the RPC endpoint for agentAGENT_ADDRESS_i
.
You can also explore the service.yaml
file, which contains all the possible configuration variables for the service.
Finally, if you are experienced with the Open Autonomy framework, you can also modify the internal business logic of the service yourself.