[Instructor] Hey everyone,
welcome back to the HaasOnline
training session.
In this session, we're going to
take a look at the C# wrapper
around the Haas API.
Now, originally, we already
looked at the Python wrapper,
which allows you to
interact with the Haas API
using a Python library or module.
In this session, we're going to
cover how to do this with C#.
So, for those who are more
with the .NET environment,
this might be a welcome surprise.
So, there's a few things
we're going to assume
you already have done, the first
is going to be that you have
Haas running with the API server enabled,
and you can verify by opening up this,
Open API Server started,
and then the stuff you set.
If you're not familiar on how to do this,
the information will
be in the wiki for you.
The other thing we're going to assume
is that you have Visual
Studio 2017 installed.
This could work with older versions,
but for the sake of simplicity,
we're going to use the
latest and greatest.
I'm using the Community Edition here,
you can use the Pro version,
that's perfectly fine.
Now, the first thing we want to do,
is we're going to need
to build the library.
The library's not pre-packaged,
as it's still actively developed,
so you have to do this yourself.
To do this, just simply go ahead
and go to the HaasOnline github,
which will be in the description below,
and you're going to look at the
Haasonline.Public.LocalAPI.CSharp.
Go ahead and click that,
and you're going to be taken to this,
and you'll see that the last
update was about a month ago,
which is about correct, that's the last,
at the time of this filming,
that was the last time
we added new endpoints.
So, we're going to go
ahead and just click this,
we're just going to download the ZIP.
Once that's downloaded, Show in folder,
you're going to need to unzip it.
To do that, just right-click,
or if you don't have PeaZip
or something fancy installed,
you can just double-click
this and extract it,
excuse me,
using Windows built-in
zip, but I use PeaZip,
so I'll just extract here.
'Kay, once it goes ahead
and does all that...
Guess I should have showed
you, sorry, multiple monitors.
But essentially what's going to happen is
you're going to have the zip
folder in your Downloads folder,
just right-click it, go to PeaZip,
or whatever zip program you're using,
Extract here.
Once it's extracted, it'll go
ahead and make this folder.
Let's go ahead and open it.
And then this package
here, the solution file,
which will be two kilobytes,
says Haasonline.Public.LocalApi.CSharp,
go ahead and double-click that,
and just click Visual Studio 2017.
Now, what this is going to do
it's going to go ahead
and open it up for us,
and as you can see here,
if you ignore my Glasswire stuff there,
we can see that we have
the HaasonlineClient,
which is what we need,
and this Program.cs file.
Now, by default, this project's designed
so you can just actively
start developing like this.
But if you're like me, you like to use,
keep your projects kind of separate,
have your DLLs, and your
APIs all wrapped together.
So, there's two ways we could do this.
We could just start developing
our application here,
and then hit Build.
But if you're like me, you
want to keep it separate.
So, what I'm going to go ahead and do is
I'm going to delete this
Program.cs folder, or file.
We're going to go here,
right-click the project
and click Properties.
And this output type,
we're going to switch that
to Class Library, and hit save.
So, now if we go ahead and
hit start on the debug,
it's going to build the library,
it's going to complain
saying it can't run,
'cause it can't.
But, if we look here, the build succeeded
and our Csharp.dll is created.
Now, there's something else I like to do,
and this is more of a personal preference.
So, if I go to Api,
ApiBase, scroll down here,
this Console.writeLine, this
actually is debug information,
it's useful for trying to see exactly
what commands are going over the REST API,
but because I'm using
this, has a separate,
has its own independent DLL,
I'm just going to go ahead
and delete that line.
Save it, and then close it,
and then just rebuild again.
And to make sure that works,
we can right-click the project,
hit rebuild, builds fine.
And since we're already
going to be working
with a release version, I don't
want the debug information.
Let's go ahead and click Release.
Rebuild that.
And that will build our Release version.
So, now if we look over here
and back into our folder,
go into this, go to bin, Release,
we will see we have two files.
The two files we care about
is Newtonsoft.json.dll
and the Csharp lib.
So, we're going to go ahead
and delete these others,
and those are the two we care about.
So, now that we're done with that,
let's go ahead and close
that Visual Studio.
Open up a new one,
and we're just going to
create a new project.
Now, what we're going
to name this project is,
we're just going to pick the default path.
We're going to make it a
Console App for our case,
and name it HaasTest, 'kay.
Hit Enter.
Once it's done being built,
we need to copy these files.
So, just right-click, Copy.
Navigate to where this project is,
and if you picked the default like me
it's going to be in
Documents, Visual Studio 2017,
well, I thought that's
where it'll be, few seconds.
Let's try this.
Go to my user, source, yeah.
So user, source, repos,
HaasTest, HaasTest,
and then right here we're
going to create a new folder
called lib, with an S.
Click it and just paste
those files in there.
Now, finally, to add the
Haas DLL to our project,
just right-click here to add,
right-click on References,
hit Add Reference, Browse,
then you're going to hit
the Browse button down here.
Go to our repos folder, libs,
and then highlight both of these.
And hit OK.
And that's it!
That's all we need to do,
we now have access to the Haas libraries.
So, if you need to take
a break, go take a break.
If not, when we come back,
or when you come back
and resume this, we'll
go ahead and continue.
All right so, let's go
ahead and get started
on actually building a useful application.
It's similar to the way
we did the Python one,
what I'm going to do is
I'm going to show you
how to connect to the Haas,
make sure you have a valid connection,
we're going to get all the account guids,
we're going to get the
account information,
then what we're going to go ahead and do
is I'm just going to show you
how to spin up a scalper bot this time
and configure it, activate
it, so on, so forth.
So, let's go ahead and get started.
Now, there is a pre-existing call
in Haas to actually get it,
find out if its credentials are correct.
But I actually prefer
to do something else.
Generally, I like to get
the wallet information,
but really, it's up to you.
When I do it, I do the wallet information
because I want to verify
the secret key is good.
But in this case,
we're just going to go ahead
and check the enabled accounts.
So, the first thing we need to do is
we need to import the Haasonline
include.
So we're going to do using
Haasonline.LocalAPI.CSharp.
And then...
Oops, messed up here, should be
Public
.LocalApi.CSharp,
and we'll just put that.
And that should pull in
everything we need from the LocalApi.
And then we're going to
do a HaasonlineClient.
Now, the HaasonlineClient's the class
that actually contains all
of the information we need,
or it contains all of the functions
to the other APIs, like
the account, the bot.
The account, the custom bots, trade bots,
manual trades, et cetera.
So, we're going to just
do this real quick,
if you're not familiar
with C#, I apologize,
but I am making a quick assumption
that you know a bit about
how to write in the language.
So the HaasonlineClient
class, or the constructor
takes three parameters,
it takes the IP address as a string,
the port number, and then the private key.
All this was set up
when you configured the local API in Haas.
So, we're just going to go
ahead, put our information here.
And if you know anything about me,
I like using "herp" for my
secret key in these videos.
And since we're in C#,
these actually have to be double quotes.
For those who are developers,
you can tell I write a lot of Python.
Okay, so now that we have
the HaasonlineClient,
what we're going to want to
do is we're going to go ahead
and get the enabled accounts.
Now, there's something
very important to note,
for developers who are familiar
with async programming,
the Haas REST library, or this wrapper
is a 100% async calls.
That means that you're
not exactly guaranteed
to have a result on
the next function call.
So, for example,
if we wanted to get the enabled accounts,
we could do var accounts equals
HaasonlineClient.AccountDataApi.GetEnabledAccounts.
Now, the problem with this,
is that if we do this,
writeLine, accounts, let's
just assume that works.
I have no guarantee
that accounts will actually
have a return value.
This is a very, very big problem!
So, if our entire app's
async, then this is fine,
but because generally the applications
people are going to make are...
Y'know, there's a word for
this, starts with an S.
Synchronous!
If for most of the apps
people are going to make
are synchronous, meaning
they have to do one action,
wait for it to finish, so on and so forth.
So, what I actually like
to do is I like to cheat.
So, to do this, I basically make a task.
So, I'll do a Task.Run, async,
and for developers who know how to write
with pure async calls in C# land,
you don't have to do this,
you can just accept it,
wait for the, I guess the appropriate word
in Javascript land would be promise,
wait for the promise,
and then just process it
when the result's there.
But for our sake, and for this tutorial,
I'm going to show you how to do this
by forcing a synchronous method.
So, if we go accounts.Wait,
and then, I'm just going to type this up
so you can see it and
then I will walk through.
Okay so, what we need to
explain here first off is
basically what we're going
to do is we create a task,
and in that task we're
actually calling this
GetEnabledAccounts, and we're awaiting it,
we're waiting for it
to finish in that task.
Then what we do is we actually
call Wait on the task itself,
that way we can guarantee
that the call is done
by the time we actually process it.
The next thing we need to do is
if you're familiar with
the Python version,
basically a Haas response is
Result, ErrorCode, and then
ErrorMessage or message.
So, what we need to do is first
we got to call the result from the task,
which will return the
object that this was.
Then we got to call the result from the
HaasApi return JSON object.
If I'm losing ya, don't worry,
all you got to remember
is check the result.
So, let's go ahead and run
this and see what happens.
So, hit start, okay it goes through,
and you'll see that it returned a name.
But let's get a little
bit more information.
So, all I'm going to do is,
for the sake of being lazy,
we're just going to do a view line,
and we're going to do
accounts.Result.Result,
and I know that Result's
a map, it's a dictionary,
'cause that's what it tells me.
Thankfully, in C# land, you
get a bit more information
about what the return
types are going to be.
And then we'll just do
a read line to pause.
Here.
So, now we see we have one
account called SIMULATED Test,
and then here is its account
guid, which is great!
We're going to need that
information moving forward.
But, like I said, when I'm trying
the first thing we need to do is
make sure we have a valid
connection, all this comes around,
and generally what I do
for C# is I check to see
if I have any length in this result,
and if that's true then I go
ahead and process correctly.
As long as my, what do you call it?
My return is larger
than zero, so to do that
I would basically just do,
if I'm right,
it's been a while since
I've wrote some C#,
Result.Count is greater than zero.
Now, this will return zero
if there isn't any valid accounts,
we're making an assumption that
there's valid accounts here.
And you can see, we're valid.
So if you're going to
make your little function,
let's just go ahead and do that,
we'll make this a static
void, VerifyConnection.
And generally, when I do C#...
I'll do this as a bool.
I just kind of copy over the objects.
Since this doesn't actually
store any information
that's important, we can copy
that wherever we need it.
So, every function I make is
essentially just going to be
creating a new logic,
and then the logic gets
destroyed later on.
So, we're going to return True, here.
Return False.
And all I'm doing is, I'm showing you
how you would break it apart.
Now, this is obviously a bit more...
A bit more involved
than the Python version,
so if you're coming from Python
and you want to see how this works,
this is a bit more complex.
So, all we're going to do is,
now we can just say,
whoops,
if VerifyConnection is equal to True,
then Console.writeLine,
success, stuff works.
Else, Console.writeLine,
credentials invalid.
Now, obviously,
this will be a problem
if you don't have any exchange
accounts already setup,
any price drivers set up.
But I'm assuming if you're at this point,
you already have it,
so we'll just do a ReadLine at the end
so we hold it open.
And we're going to go ahead and run.
All right so, stuff works!
So, now we know we have a valid connection
and we have these accounts correct.
So, let's go ahead and
I'm going to do this lazy,
but you should be doing
this smarter than this.
We're going to go ahead
and just grab the first
account guid we have, that
way we can just store it
and use it later.
So, I'm just going to do a
string called accountGuid,
all right, accountGuid equals this.
And then when we come down
here, we process this.
We're just going to do...
All right, here, let's do this better.
Let's just do account,
since I know one exists,
accountGuid equals...
Oh, what am I doing here?
There, m'kay.
Static string accountGuid
equals accounts.Result.Result.
ElementAt, and then we'll say zero.
All right, well, we need to do,
with a dot,
.Keys.at...
Okay, so it's .Keys
.ElementAt, zero.
There you go.
So, what that's going to do
is it's going to go ahead,
that's going to store the first
account good in this variable.
And then let's just make
sure that works, so...
Okay.
Well, didn't want that, but
let's go ahead and run it.
Looks like it works.
Okay so, now we have the account guid,
the first one, whatever the first one is.
Obviously you need to process this
with your foreach to get the right one,
or just statically set it.
We're going to get the first,
we get the first accountGuid
stored there to use later.
Okay, so now, just to show how we would
make another call, let's
go ahead and get the
account information for a specific guid.
And since we have the guid,
we're just going to use it.
So, we're going to make another function,
and I like to keep these all separate.
And we're just going to do void for now,
because I don't know
what the return type is.
And we're going to say
GetAccountInformation.
I doubt I can do that, yeah.
Okay so, what we're going to do is
we're going to basically copy this code,
we're going to do the same thing.
And we're going to do accountInformation.
And here, let's just get rid of this.
'Kay.
And we're going to say,
"from account data API,
"get account details."
So, we're going to do
.GetAccountDetails, and
then you'll see that
GetAccountDetails takes an account guid,
and if you remember, we
stored accountGuid globally.
So, we're going to just do that.
And then we're going to wait.
So, we're still tricking the
we're still forcing the
async call to be synchronous.
And then we're just
going to go ahead and say
let's just say foreach,
var,
accountInfo,
this should only return one,
but for the sake of being...
And we'll say accountInformation,
actually, I think that's going to fail.
This returns...
Yeah, let's just do this.
I know it exists, you should check for it,
so we're just going to do,
well, let me show you how to do it.
So, if we do, if accountInformation.Result
.ErrorCode,
ErrorCode is an enum error
code, and if you remember,
or should I say, in the Python version
we're able to check the error code
to make sure things are successful.
In C# land we're able to
do the exact same thing
and we want to do this for
every call to make sure
nothing will happen.
If something bad happened with the API,
we'll actually get the
error message from Haas.
But we're going to say that is equal to
and then we got to
EnumErrorCode., let's say Success.
Now, what that does is
it says "If this command
"was successful, then
we're going to run this."
And then, what we're going to run is,
we're just going to do
accountInformation.Result
.Result again to get the
thing, and let's say,
I want the name of the bot.
'Cause that's what we're calling,
we're calling the account information,
getting some more
information about the bot.
So, let's just go ahead, copy this,
and we're just going to put
it in this verify block.
'Kay, and then hit start.
There it is, SIMULATED Test
is the name of the account
which we know does exist.
Fantastic!
And there's some other account
information we can get.
So, if I do dot here,
you'll see we got like
the price sources, any order templates,
if it's a simulated
account, the platform type,
and all of these return
something different.
So, if you want to look at that,
you can just look at the documentation.
Which can be found on our wiki.
So, we've gotten that taken up.
So, we know we can verify the account,
we can verify we have a connection,
we can get an account, or account guid
to store to use later,
and we can pull information.
So, let's go ahead, let's move on.
Let's create a bot.
So, let me find...
I have all this saved on the
side to make this smooth.
So, let's just make a simple scalper bot.
And to do this, we're
just going to say, okay,
static again, CreateScalperBot.
'Kay.
And, as before, we're just going to copy
this line,
and this line.
'Kay.
You'll see that there's
kind of a pattern here,
and you're free to clean this up,
this just makes it
easier for me to explain.
So, all we're going to do
is with this Haas Client,
we're going to switch
our API we're accessing.
So, this time we're going
to use the CustomBotApi,
and we're going to create a new bot.
And we're going to do it
with the second option.
The second option lets us specify
what type of bot we want to create.
So, to do that, we're
going to need to pull in
some definitions.
So, we're going to just
go back to the top,
you'll see we have this.
To make it easy,
that's not what I wanted...
I'm just going to copy this
from off screen real quick.
There it is, we're going to pull in
this DataObjects
CustomBots, and this is just
storing that information, but we need that
to specify the type of
bot we want to be created.
So, for here I'll just put ScalperBot.
Now, there are other bots we could put,
we could put like a market
maker here, a market making bot,
mad hatter, so on, so forth.
But, like I said, we're going
to create a scalper bot.
And we know that a scalper bot,
we need to specify the bot type again,
we need to specify the name,
the name of the bot we want to give it.
The account guid, and then the market,
so what market it exists on.
And we're going to go
with the second type.
So, we're just going to...
Let me pull this in too,
pull in all the enums.
So, just put this right here.
And this is just going to make us
not have to type out a lot here.
So, we're just going to do
EnumCustomBotType.ScalperBot.
'Kay, and then we need to give
it a name, MyFancyScalper,
the account guid which we have stored.
And then we're going to
do the longer version,
so, we can specify based on
giving it a market object,
but I don't want to get into that,
so we're just going to do
this by specifying two coins.
So, the primary coin,
we're just going to say,
let's do BNB.
And then the secondary which
is the main trading pair, BTC,
and then no contract name.
So, what we've done here is
we've created a new scalper bot,
we've given it a name
called MyFancyScalper,
we provided the account
guid which we got earlier,
and then we are giving it
a market we want to trade.
In this case, we're telling it,
"I want to trade the BNB/BTC market."
Great!
So, let's go ahead, change
this name to createBot,
wait for that to finish,
and now, when we get to
this point, we should check,
so we should do the error code,
I'm not going to do it right
here to keep the code short,
but you should always check to
make sure every step passes.
Now what we're going to do is
we need to configure it, and
that's pretty simple also.
We're just going to say var
configuredScalper equals Tasks.Run,
and, like I said, if you know how to work
with async directly, you
don't ever have to do this
Tasks Run, but for most
people, they'll not want this.
So, you're going to do it again,
you're going to hit CustomBotApi,
in this case you're going
to put SetupScalperBot,
or ScalpingBot.
And you'll see this time we have
quite a bit more information,
we need to pass in the bot guid,
which we will get from
this createBot variable.
The bot name, again,
because we can change it,
the account guid it's connected to,
then we get the primary
and secondary coin,
the contract name, and then this is where
things get interesting.
So, we can set the leverage amount.
Now, this works if we're
trading on leverage markets,
Bitfinex, Bitmex, et cetera.
But since we're testing against Binance,
we are going to leave this as zero.
The next thing we have
is the trade amount,
so this is how much we
want to trade of BNB,
so if I want to trade
a hundred, a thousand,
whatever it is.
The next one's going to be the fee amount,
so, how much should we
be calculating fees,
in this case we're going to just put 0.1%.
The position, now the
position is where do we start,
do we have BNB or do we have BTC?
So, basically, a buy and sell position,
but specified based on the coin.
The template guid, we're
going to leave this to,
we'll set this to one
of the template guids
we have access to.
There's a series of lists,
which will be posted in
the description as well,
but what we'll be doing
is a locked limited order,
and what that says is,
basically, no timeout,
the order will always be
there until it occurs.
And this allows you to build
your crazy complex templates
and use 'em within the bots.
There's certain situations
where the Haas GUI
won't let you specify a certain template,
but because of the power
you have with the API,
you can actually sort of circumvent that.
Now, granted, if you have a
multiple buy and sell template,
it's probably still going to
fail with the scalper bot,
but hey, you know,
it's possible if you
want to give it a shot.
Next, you have the two
specific scalper bot values.
You have the target percentage,
and the safety value.
And these are the same values
that you would be setting
within the GUI itself.
But, let's just go ahead
and start populating this.
So, we know we need the bot guid,
and to make things easy I'll just do this,
newBotGuid equals, and then we just say
createBot.Result.Result.GUID.
'Kay.
So, now we can just do newBotGuid.
Then we need a name,
so we're just going to
keep it MyFancyScalper.
The account guid, which we have access to.
Primary coin, secondary coin,
the contract name, the leverage.
The trade amount, we'll say
10 BNBs, 0.1 for the fee.
We're going to say we
only have BTC right now.
Template guid we're
going to supply it with
LOCKEDLIMITORDERGUID.
Now, there's a lot more than this,
but for now that's the easiest one to use
'cause I remembered it.
And then the target percentage we want,
so let's say two percent,
and safety, 1 percent.
And let's go ahead and save that.
Now, you see there's two areas
where it's yelling at me,
because I did not specify
that it was a decimal,
so I believe to do that I
should put an m here, yep.
And that means we're
passing it a decimal value.
So, once that's done,
we're just going to do
configuredScalper.wait.
And that should do it!
So, let's go ahead and
create a scalper bot,
and let's see what happens.
So, I'm dragging off the IDE to the side,
for a second, and then
I'm just going to log in
to my local instance.
Let's go to Custom Bots.
Drag this over, let's hit start.
And there it is, MyFancyScalper!
And it has set to exactly
what we told it to.
Pretty cool, right?
So, finally, what I want to do
is I want to show you how to
actually backtest the bot.
And it's pretty straightforward,
I just got to,
let's see if we can remember it,
or I'm going to have to
look it up, 'cause C# land.
All right, so we're just going to go ahead
and we're just going to
do it after the create,
let's just run a back test to
keep it all in the same area.
So, what we're going to do is runBackTest,
and do the same thing Task.Run,
async,
await.
And then, we're going to call
the CustomBotApi.BacktestBot.
BacktestBot...
Actually, I'm pretty sure
there's a better one,
so I'm just going to
look it up real quick.
'Cause there's two.
Like in Python, there's the
ability to backtest the bot
based on the time, from the current time,
there's also a way to do it with
specifying a UNIX time for
those who know what that is.
And then there's also
a backtest on market,
and backtest on market is the
one you really want to use
when you're doing a lot of backtests,
because what it allows us to do is
it allows us to make sure
that we're not pinging the exchange
for every update for all the markets.
So, it's exceptionally useful
when we're trying to backtest
a lot of markets, and we don't
want our API to get banned.
That's important to note,
that Haas will still
try to make updates for
these, it's not as frequent,
but it will still be a lot,
so don't go backtesting a
hundred markets at a time.
Generally safe, you can do 10, 20, 30,
wait 5 minutes for Haas to unregister
from the auto updates,
then run the next batch.
So, to backtest the bot, basically,
we're going to do the command
we already had typed out,
and you'll notice that...
Come on now.
There's three different backtests.
There's the backtest on minutes
to test, basically meaning,
"From my exact current
time I run this command,
"this many minutes back I want to run."
There is a backtest with
the start and end time.
Now, it's important to note
that if you do any of these first two,
it's going to ping the
exchange for the latest time,
and then start update on that.
So, what you want to do is
you want to use the third one,
which lets us specify a market.
Now, for our case, we are just
going to use the same market.
But, what it will do is,
instead of backtesting
the main one, it's going to run a backtest
on a cloned version,
and then get rid of it.
So, we could run a bunch of backtests
and not pollute our main bot.
So, think if our main
bot has like a template.
So, let's just go ahead
and if we need the newBotGuid,
we need
minutes to test,
let's say I want
roughly two dayish.
Our accountGuid.
Our primary coin, secondary coin.
Contract name.
Okay, and then we're going
to do a runBacktest.wait.
And then once that's done,
we're going to go ahead
and do console.writeLine,
and we're going to say
runBacktest.Result.Result,
and then we can say our
ROI, and that will tell us
what our ROI percentage was
for that.
And then to make it
clean, backtest results.
Okay, and then let's
just see if this works.
Create, or was it?
Oh, we don't have to do that, okay.
So, we're going to go
ahead, just close that,
we're going to delete this bot,
and we're going to run it again.
So, what we should see
is the bot get created
and then a quick flash of another bot
being created and backtested,
and then we should get our result.
All right, well it didn't like something.
Oh, make sure we put all the parentheses.
Try it again.
And there it is, you saw it run
and then it stopped, right?
Now, there wasn't any return,
because these settings
probably aren't any good.
But let's see if we can
force a result real quick,
so we can show how this would work.
So, we have
a safety threshold of one,
yeah, so two, one.
Let's make these really small.
Can't do that while we're debugging.
Let's just do 0.3, 0.1, and
let's see if we can force
a really bad buy.
Okay, so we're going to
save that, delete that.
Now, bots can have the same name,
it just gets a bit confusing.
So, we're just going to run it again.
There we go!
So now we have a beautiful
result of -97, as expected.
This is a quick way,
or I guess this was simply trying to be
a quick introduction on
how to use the C# API
to interact with the Haas software.
And you can see, it's
pretty straightforward.
Once you get the gist
of how to do the calls
and interact with it,
everything else tends to fall in place.
You can see a full writeup
of all of the API functions,
if you go to https://wiki.haasonline.com/,
so let's go ahead.
If you look here, and you scroll down,
if we can find it.
Yeah, I'm just going to search it, api.
Local API Documentation.
And if you scroll through here,
you'll see all of the available
commands you can make.
Now, they are generally
over this REST API,
however, you can kind of
figure out what the calls are.
If you do have development experience,
you can simply look at the source itself.
So, if you open this up on the github,
go to Apis, click CustomBotApi,
you can see all the commands here.
Or, because the Python
wrapper is based on the exact same...
What's the word I'm looking for?
Design as the C#, you can go to...
Let's see if I can get to it without...
Nope, that's not the right
haasome, all right, few seconds.
But basically, you can use the
Python API documentation
to write your C# API.
So, if you go to the Haasome API,
go down to API Documentation,
and then you can actually
see the same thing.
So like, you have a CustomBotApi,
most of these commands,
or most of these functions
in Python are in the C#
wrapper, or they're very close,
they're close enough for you
to be able to figure it out.
But, yeah, hopefully that
help you guys get started.
I know we covered a lot, and
I kind of sped through it,
with less explanation than the last one.
But, that's mostly because
I'm trying to show you guys
how to use the software.
If you're a beginner
to developing software,
just go learn it.
You know, it does sound
like it takes a long time,
but if you have an end-goal in mind,
you're going to get there pretty quick,
especially with the ease of interacting
with the Haas software.
So, if you have any questions,
feel free to ping me on Discord,
or ask one of our ambassadors,
a lot of them are now
doing the development side,
they definitely can help you,
or some of the support staff
can help you as well.
If you can also leave any
questions in the comments below,
I'll make sure to check 'em out.
And, you know, generally
just have fun with it!
It's not that hard, just make
sure everything you're doing
is in a simulated account.
I myself have had situations
where I'm backtesting
and running bots live on my live account,
so that was always fun.
Anyways, 'til next time guys,
I hope you enjoyed, and I'll see you then.
