This content provides a technical walkthrough of creating and deploying a smart contract on the Ethereum testnet to execute flash loans using the Aave DeFi protocol, demonstrating both a basic pass-through loan and a more complex arbitrage strategy.
Mind Map
Click to expand
Click to explore the full interactive mind map • Zoom, pan, and navigate
hey guys what's going on in this video
we're going to be creating a smart
contract that executes a flash loan
using the Ave D5 protocol
flash loans are a relatively New Concept
that have no real equivalent in the
traditional Financial World they allow
you to borrow as many tokens as you want
without collateral provided that you pay
it back as well as a small fee all
within the same transaction
some common use cases of flash loans
include refinancing existing loans at
lower rates and Performing Arbitrage
Arbitrage is an investment strategy
where you find a token on one exchange
trading at a discount relative to
another exchange you buy low and sell
high in order to capitalize on the
opportunity and make a profit
so with flash loan Arbitrage you can
basically borrow funds with no
collateral in order to buy and sell
tokens on different exchanges pay the
loan back and walk away with a nice
profit if you don't have enough funds to
pay back the loan the entire transaction
gets reverted and so there's little to
no risk of losing money
in this video we'll go through the
entire process of building a smart
contract that can execute flash loans
for this and other use cases
so if that sounds good stick around and
let's get into it [Music]
[Music]
so if you haven't heard of Ave they're a
defy lending protocol which offers a
bunch of different Services first of all
they custody erc20 tokens and hold them
in liquidity pools in order to make them
available for borrowing anyone can
become a liquidity Provider by
depositing their tokens into liquidity
pools and earning a profit then there's
the Ave token which is used for
governance of the protocol
you can stake this token and earn
profits on your stake tokens for helping
secure the protocol and finally there
are flash loans so I definitely
encourage you guys to explore Ave and
learn about all the cool things that you
can do with this protocol
now for this tutorial we'll be working
on the ethereum gorilli test net and
we'll need some tokens for testing the
flash loan contract so what you can do
is go over to the Ave faucet and load up
on some die token and usdc
so I will provide the link to this
faucet in the video description but
basically you'll you'll go to this page
you'll connect your wallet and then
simply click on the faucet button to
withdraw some die and some usdc and
they're pretty generous with the amount
of tokens that they send through the
faucet so one tranche of each token
should be more than enough for this
tutorial all right so if we take a quick
look at the flash loan documentation
from Ave we can start to get an idea of
what requirements there are for our
smart contract to have in order to both
receive and request a loan from Ave
so if you scroll about halfway down on
this page
you'll see that there's a requirement
that we need to implement the I flash
loan simple receiver interface in
particular the execute operation function
function
so the execute operation function this
is a function that's going to be invoked
in our smart contract by Ave after
they've sent us the loan funds and what
this function does it's basically going
to execute any custom logic that we've
coded into the smart contract for
example to execute the Arbitrage operation
operation
after that we're going to have to invoke
the approve function on the token that
we've borrowed in order to give Ave
permission to pull back the borrowed
funds as well as the the fee so that's a
key point to remember there that we
don't have to actually send the funds
The Borrowed funds back to Ave we just
have to give them permission to pull
those funds back which they will do
after this function returns
all right so to put all this into
perspective let's take a quick look at
the high level architecture of the whole
flow before we start coding
okay so this diagram illustrates the
high level flow of The Flash loan so on
the left we have our flash loan contract
which we're going to be working on in
this tutorial and on the right hand side
we have the Ave V3 protocol so the first
thing that's going to happen is we're
going to invoke The Flash loan simple
function in the Ave pool contract
passing in the token that we want to
borrow and the amount now you'll notice
this is Flash loan simple there's also a
flash loan function and you'd use Flash
loan if you want to borrow several
assets at a time some of token a b and c
for this tutorial we're just using the
flashlight simple to borrow one type of
token just to keep things simple
but other options are available
so at that point the pool contract will
run some checks and then send the
borrowed funds back to our flash loan contract
contract
at that point the execute operation
function which we've defined will be
invoked and here's where we'll run any
custom logic that we want to do for
example the Arbitrage operation so we
may do some token swaps some buying and
selling via other exchanges such as
uniswap Sushi swap or other
decentralized exchanges
after that's completed we will call the
approve function on the borrowed erc20
token for the amount borrowed plus the
fee in order to allow Ave to pull back
those funds
and then at the conclusion of all these
operations Ave will indeed pull back
those borrowed funds plus the fee
automatically back into the pool
so hopefully that gives you a high level
uh bird's eye view of what we're going
to be building here and sort of the
entire process
all right guys so now for the fun part
let's go ahead and start coding our
contract so I've created a folder called
flash loan tutorial call yours whatever
you like I'm using visual studio code
and I'll be using the hard hat framework
for sort of scaffolding my project and
deploying my contract all right so
the first thing I'm going to do I'm
inside this folder I'm going to open up
the terminal
and I'm just going to go ahead and
right and I can do that by typing in npx
okay I'm going to choose create a
I'm going to say yes for the git ignore
okay and once that project is scaffolded
you'll notice that there's a little line
here that says you'll need to install
these dependencies in order to run the
sample project so you'll need to go
ahead and install those and you might
see more than what I'm showing right
here because I think I've got some of
these installed already but I'm going to
go ahead and add the full list of
dependencies in the description of the
video so go ahead and install those
alright the next step is to install the
Ave packages so I'm going to run npm I
core Dash V3 and I'm also going to
include dot the dot EnV
package so we can read our Json RPC and
as well as our secret from our EnV file
for contract deployment so go ahead and
run those
all right so once those packages are
installed the next step is to set up
your dot EnV file so just create a file
called dot EnV in the root of your
project and you want to populate your
create two entries one private key this
is going to hold the private key of your
wallet and one for your inferior
gorillight endpoint or whatever provider
you're using to connect to the
blockchain so go ahead and populate
those and then let's update our hard hat
config file
all right so the first thing I'm going
to do is require the dot EnV package so
we can use it
pull in those variables so I'll say require
require .env
and then call config
okay and then I'll go into our exports
and right underneath solidity I'll
and underneath that I'll create entry
and then I'll create two properties URL
and accounts URL so now we can access
if you're uh Gorly
Gorly
endpoint or whatever you called yours
and the next one is going to be accounts
and this is going to be an array of one
all right and once you've done that go
ahead and Save
okay so next up let's go ahead and
expand the contracts folder and we see
there's a sample contract there so let's
is not the folder of the file
all right I'm just going to call this
all right so go ahead and open up that
file and then let's go ahead and delete
everything inside the file
I'm going to add my license identifier
and then underneath that let's go ahead
and start with the pragma solidity version
and I'm going to use
0.8.10 just because that is the version
that a lot of the Ave contracts that
we'll be using also use
all right next we add our Imports and
since these are a bit long to type out
I'm just going to go ahead and paste
these in here and you guys can copy and
paste this also from the video
description or from the repository as
well and then we'll sort of go over each
one line by line and explain what they
okay so starting from the first import
flash loan simple receiver if we
remember from the documentation it said
that we need to implement this interface
in order for our smart contract to be a
receiver of a loan of a flash loan okay
so this is going to contain that execute
operation function that we talked about
as well as two getter functions an
address provider and a pool okay and
this is going to return
basically a provider that is a layer of
abstraction away from the pool address okay
okay
and we have a base contract that we can
use that does some of this
implementation for us so that we the
only thing we need to do is inherit from
this contract and then pass in the
address provider address for the network
the test Network that we're on okay and
the rest is sort of taken care of for us
here and then the only thing left for us
to do is to implement that execute
operation function in our code
and finally the last import is our good
old erc20 and we need this in order to
call the approve function on the token
that we're borrowing
all right so let's continue with coding
I'm going to define the contract
contract and we'll say flash loan
and now remember we're going to inherit
we want to be able to withdraw funds
from this contract because we'll be left
with a profit so we definitely want to
be able to implement a withdrawal
function and
um give access to the owner for that
now this is going to take an address of
the provider and I'll show you how to
so we'll pass in that address which we
can get from the Ave documentation
but then we're going to call the
Constructor of flash loan simple
okay and we're going to pass in the address
address
to instantiate an instance of the ipool
so basically we need to grab this and
okay so since the provider address is a
Constructor parameter we actually need
to pass that in in our deployment script
so let's go ahead and set that up right now
okay so there's a example file here
let's just rename that
and I'm going to call that deploy
all right and I'm going to get rid of
and then I'm just going to get rid of
all right so first I'm going to grab an
instance of a contract Factory so I'll say
flash loan
equals await hre thers
get Contract Factory
and we need to pass in our contract name
here so
okay then I'll say flash loan lowercase
instance of our contract
and we'll say away
flash loan dot deploy
all right and here's where we'll pass in
the provider address
but first let's just go ahead and finish
flash loan
all right so we we know that we've
deployed the contract here so we can go
flashed loan contract deployed
flashlight so that should output our new
address or the address of our new newly
deployed contract now let's figure out
how to where we can grab this value here
and if we go back out to Ave
there's a page called V3 test net addresses
addresses
and I'll provide this the link to this
page in the description of the video but
what we're looking for
is pool address provider right here so
copy that bring that back into our
script and just paste that right here
so now this value of the address
provider will be passed into our flash
loan Constructor
all right go ahead and save that that's
a lot of setup but we're pretty much
done one other thing that we're going to
want to do is go back to the hard hat
config if you still have that open
and just update the solidity compiler
version to 8.10
so that matches what we have in our
okay so back over on the flash loan
smart contract I want to set the owner
to the message.sender in our Constructor
I'll cast that to payable and do message
save that
okay so the next thing we need to do is to
to
um is to write the execute operation function
function
and if you remember that was referenced
in the iflash loan simple receiver interface
interface
so we could take a look at that file to
see what this should look like at least
take a look at the signature
so as you can see there are a bunch of
different parameters that are going to
be passed in I'm just going to copy this
and bring it over into my solidity
all right and since this is an interface
there's no implementation so we could
just add that with a couple of curly
braces right there
the other thing we need to do is to mark
this as an override
since we've copied this function from
from the contract that we're inheriting
that we now need to mark it as an
override in since we have a function
with the same signature in our contract
if that makes sense
all right so inside the function body
here first of all we can add any logic
that we want
so at this point we have the funds
let me just
so if we've gotten to this point we
actually have the loan funds in hand
and we can add any custom logic that we
want here
so on the first pass we're not going to
add any custom logic we're just going to
do a pass through just make sure the
flash loan works and then we're going to
add some custom logic here to do like an
Arbitrage mock Arbitrage
so the next thing we need to do is
all right so as you can see there are a
bunch of different parameters here asset
this is the token that we're borrowing
amount the amount we're borrowing
obviously premium this is the loan fee
initiator that is it's like the entity
that triggered the
the borrowing in the first place which
is irrelevant in our case and then
params the byte encoded param passed
when initiating The Flash loan so the
last two we don't need to worry about
we're not using those
so what we need to do is set up the
amount owed so I'm going to say you in
256 because this is the amount that we
need to approve for the pool contract
to take back so I'll say amount
ode and this is simply going to be the
amount from the parameters above Plus premium
premium
okay and then we can use our erc20
pass in the asset and call the approve function
and so this takes an address
so we'll say the address of the pool contract
contract
and we'll say
amount owed which we've just defined above
above
and then finally we need to return true
all right so you may be wondering where
this pool variable is coming from and if
you look in the flash loan simple
receiver base you can see it's being set
up right here in the Constructor an
instance of the ipool
interface which is being inherited right
here okay so that gives us access to our
pool and we'll use this later again to
call the um the function to initiate the
all right and you can ignore this right
now we're not using these two parameters
so go ahead and Save
all right so the next thing we need to
do is write a function that's actually
going to kick off the entire process and
request the loan
so I'm going to come down here and I'm
and let's say request
flash loan okay now this is going to
wrap the actual function call to the
pool contract
but we need to do some setup first so
I'll make this a public function
okay so that's the skeleton of this function
function
and if we want to see what this looks
like let's see this is in
the pool interface I believe
all right and what we're looking for is
Flash loan simple
receiver address asset amount params
referral code all right so let's go
and come back into our code
and I'm just going to paste this down here
okay and so I just need to know which
parameters we need to pass in so let's
go write down a couple of lines below
the function definition and I'm going to
use the pull variable again pool Dot
okay and then we're going to pass in
these so I'm going to cut that paste
that in here
get rid of the types
okay so the next thing we need to do is
to Define these parameters here so we'll
start with
and this is going to be set to the
address of the current contract so I'll
say address this
this
okay now the next two asset and amount
I want to pass those into this function
so we set them
as we call this function right so let's say
say address
address
token that way we can reuse this for
different token requests
and different amounts this is going to
be underscore amount
all right and then we'll just set those
and you went 256
amount equals underscore amount from the parameters
parameters
all right so the last two params and
referral code we're we're just going to
provide default values so if you if you
forget what the types were of those you
can always reference the pool interface
bytes call data and uint 16.
bytes
memory params and let's just use an
empty string here
and referral code we'll just set that to zero
zero
you want 16.
referral code
all right and go ahead and save that
all right so that completes our request
flash loan function
there are a couple of more just two or
three more utility functions I want to
write that's going to help us for for
testing and then we'll get to testing
this contract so the first one is going
to be a get balance function so I'm
going to say function get balance and
we'll use this at the very end after our
flash loan is completed just to
get balance
this will be even more useful when we do
the version with the Arbitrage so that
we can see any profit that's left over
all right so this is going to take a
token address so we can look up the
balance of any token external
external
view returns
un256 it's going to return a value
of the balance okay and in here we'll
make use of our
ierc20 interface we'll say
instantiate with the token address that
we're passing into this function
and then we'll just call balance of on that
that
balance of and address
address
of this contract
all right so that'll give us our balance
this contracts balance of any token that
we specify
all right next we need a withdrawal
function because we'll want a way to
withdraw our profits after the flash
loan is done
so I'll do a simple withdrawal function
um
let's let's make it so that we can
duress
so say we do Arbitrage with a usdc then
we can specify that we want to withdraw
all the usdc from this contract
all right we're going to add a only
owner modifier to this in just a second
but for now I'll say erc20
token equals ierc 20 and pass in that
oops this should be 20 by erc20
and then we'll initiate our transfer on
this token object so I'll say token
dot transfer
and this takes a
2 and uh amount okay
so we'll say message sender
which is going to be the owner of the contract
and we'll say token balance of
address this
so in other words all the Holdings of
all right and the last thing we we
definitely want to make sure that this
is gated to only the owner so I'll add that
that
even though we don't have it yet we'll
Define that
so the last thing we do here
so I'll add a modifier
and we'll add our require statement where
where
message dot sender equals owner
and if it's not we'll use our common
message that we've used in many other
contracts before
which is only the contract owner can
fix all my spelling mistakes here
okay and don't forget this uh funny bit
of syntax which is just underscore and
semicolon is a placeholder for the rest
of the function that this is being
applied to
all right and finally let's just add a
receive
just in case we want this contract to be
able to receive
receive external payable oh
oh
don't forget the curly braces at the end
and go ahead and save that
oh and this should not have a semicolon
so there there we go I think we're
looking good now all right so we are
ready to deploy this contract and then
do some testing all right so let's go
ahead and attempt a deployment to test
net I'm going to open up the terminal
and I'm gonna
paste in my deployment script so this is
again we're targeting the gorilli network
network
and this is targeting our script that we
wrote a little bit earlier so let's go
ahead and run this
and this will let us know if we have any
compilation errors or something wrong
with our deploy script
if all is well it will deploy the contract
all right in that first attempt failed
because I've got a typo in my script so
let's fix that really quick
where is that flow Ash loan all right
I'm gonna fix that to flash loan and
just making sure I didn't misspell it
anywhere else I think it was just that
one spot
yep all right let's run that again all
right and looks like second time was a
charm so here's my deployed contracts
address I'm going to go ahead and save
that to my notes
flash loan deployed so that's our most
recent deployment
and all right so I've went ahead and
opened up a remix editor window in the
browser and we're going to go ahead and
use remix to
test our deployed contract
so I'm going to drill into contracts
here and
reuse one of their sample contracts
so I'll take this number one storage one
flash loan
save that
and I'm just going to delete all of the
code in this file okay
okay
so I'm going to go back to visual code
I'm going to control a to grab all of
that code and I'm just going to paste it
right here
oops that's the wrong file
I'm looking for our solidity contract
there we go
okay much better
all right now the only problem is that
these references to my node modules
folder aren't going to work in remix
so I'm going to go ahead and copy paste
the links to the the direct GitHub
location of these contracts
and this is kind of a pain but I'm sure
there's an easier way to do this but for
now I'm just going to copy those in here
okay so these are going to work from
within remix and then save that file
go ahead and open this tab here that's
yeah there we go that's updated now
and that's fine those are just those two warnings
warnings
so let's go down to our deployment Tab
and we just need to grab our deployed
contracts address
and paste that in there
I've got way too many notes here all
right where is it
and I'll expand this a little bit so you
can see it better
but basically we we're connecting to a
contract that's already deployed so we
just need to provide an address here we
don't need to provide the Constructor parameters
parameters
since we've already done that
and here I'm going to select
and all I need to do is come down here
and hit the add address button
and here we go here's our interface for
our contract
Okay so
basically what's going to happen here we
are going to run this uh request flash
loan function right here
all right so that's going to request
we're going to do a let's start off with
one usdc so we're going to request one
usdc from Ave
it's going to send the funds to us we
don't have any custom logic all right so
this this first pass is going to be a
straight pass through we're going to
receive the funds approve the payback
and then pay them back right away and so
there is a small fee so I will need to
send a little bit of usdc to the
contract before we run this test
all right so let's send some usdc to our contract
and I'm just going to send one usdc even
though that's way Overkill because I
think the fee for this for we're going
to borrow one usdc right the fee is
going to be point zero zero zero five
so we definitely have more than enough
and that'll take a few seconds to settle
and then we'll check the balance right
here so in the meantime I will I will
grab the usdc Ave version token contract address
and we'll wait for that to to finish
once that's included in the blockchain
oh there it is one usdc okay
all right next step is going to be to
the parameters are the token that we
want to borrow and the amount all right
so I've got this all set up already and
we're going to request one usdc now
remember usdc has six decimal places
unlike a lot of tokens that have 18 so
that's why this is 1 million which
represents one usdc
all right so let's go back to remix
remix
all right here's our request flash loan
function so we'll enter that in and
that's a good sign if metamask's opening
if it was going to revert it would let
okay it's going to ask us to sign the transaction
all right and we can actually verify
this on etherscan although it's still
pending right now but let's go ahead and
and we can tell that this is still pending
pending
9e8 all right
yep and that's this one right here
so we should see that um that one usdc
followed by
the the fee which is going to be .005
yep there we go
so yeah that our flash loan was
successful here is let's see if we can
follow the trail here
this is from the pool
to the contract
from the contract
to the pool
one dollar and paid back one dollar
point zero zero zero five
awesome so good to see that working
that's pretty much the most
straightforward example of a flash loan
a total pass-through where we request
you know some funds and pay it back with
the fee right away without any custom
logic so as our next test let's add some
custom logic and let's do a proof of
concept of how we could actually send
the funds out to another contract after
receiving the loan do something with
them receive them back into the contract
pay off the loan and hopefully walk away
with some kind of profit all right so in
order to simulate an Arbitrage
opportunity that we can consistently
Repro for the purposes of this video
I've created a new smart contract called dex.sol
dex.sol
and this simulates a decentralized
exchange a simplified decentralized
Exchange so this exchange works with two
tokens die token and usdc and the way it
works is first the user would basically
approve a deposit for the the token that
they want to work with they would first
deposit let's say usdc
so this contract can custody different
erc20 tokens on the user's behalf which
they can then use to trade buy and sell
whichever of the two tokens that they
want to
so we're going to initiate this
operation from within our
execute operation function from our
flash loan smart contract okay so the
first thing we're going to do
is deposit usdc
okay so this contract will custody the
the amount of us to see that we deposit
then we're going to buy some die token
deposit that into the the die Holdings
area and then sell the die token for a
profit now how do we make a profit here
well if you notice that in the
calculation of exchange rates there are
two different rates being used Dex a
rate and Dex B rate okay so if we scroll
up here and take a look at where those
are defined
we can see that Dex a rate is 90 okay
meaning that I can buy die token for the
price of 90 cents on the usdc
and the B rate which is being used in
the cell function is 100 which
represents a one-to-one value between
die token and usdc so you can see where
the Arbitrage opportunity is here by die
at 90 cents on the usdc and sell for one usdc
usdc
okay so this is what we'll be doing in
okay so in order for our flash loan to
interact with the Dex contract we have
to make some changes right
and so I what I've done is I've created
a new contract I've basically copied the
flash loan contract and then added the
additional interactions with oops with
the Dex contract so I think this time
instead of going line by line it kind of
makes more sense for me to show you guys
the changes I've made since you're
already comfortable with putting
together the flash loan since we've done
that line by line this time I think
we'll save some typing and I'll just
sort of Step through
each New Edition that I've made
Okay so
first we need to create an interface of
the Dex contract in order for our flash
loan contract to talk to the Dex
contract so that's what I've done here
we have interface and I've listed out
the function signatures for the
functions that we're going to be using okay
okay
next we need to grab a reference to the
addresses of the tokens that we'll be
using so die and usdc in this case and
again these can be found on the Ave
website these are the Ave specific
versions of these tokens which need to
be used for testing so that's a really
important point I got stuck up on this
for a while couldn't figure out why
things weren't working with the regular
link token which I was using initially
anyway so here we're instantiating new
instances of the tokens as well as the
Dex contract so that we can call methods
on it throughout this contract
and we're doing that right here in the Constructor
Constructor
and then here's where it starts to get
interesting in the execute operation if
you remember in our original flash loan
we just had this part stubbed out right
we had no custom logic so now in this
new version of the contract we're adding
the custom logic to do the interactions
with the Dex contract that I just
described so
we're going to be requesting an initial
loan from Ave of 1000 usdc okay so at
this point we have those funds now we're
going to deposit those funds into the
Dex contract we're going to buy some die
token at that discounted rate of 90 percent
percent
we're going to deposit those die tokens
back into the Dex contract and then
finally we're going to sell those die
and so at this point the Dex contract
will send us back usdc and we'll end up
with more than we started with right so
we'll have plenty of of tokens to pay
back the loan and we should walk away
with a profit of about
all right and I believe the rest of the
contract is exactly the same as the
first one oh we have some methods down
here for the usdc and die tokens there
is one additional step before we request
our loan we're going to need to approve
some amount of usdc and die token so
that the Dex contract can pull those
amounts for our deposit okay and
unfortunately we can't do that all
within one step because those approvals
need to be available on the blockchain
before any of these functions Run Okay
so that does add one extra step to the
process but the good news is we don't
need to hold those funds in order to
approve them so we can still have a
balance of zero usdc and put through an
approval of ten thousand or or one
thousand or whatever we intend to borrow
so net result is that we can still
borrow money with the flash loan with
zero down and as far as the rest of the
contract it's exactly the same as our
original flash loan all right so let's
test out our Arbitrage example and guys
just as a reminder all of this code will
be available in the GitHub repo for this
project for this video which I will
definitely link in the description of
this video so if you guys want to follow
along and run this Arbitrage example
here's what you would do you would
download the repo so you have the code
here you would go ahead and deploy flash
loan Arbitrage as well as Dex
via hard hat
deploy that to the blockchain and go
ahead and save those public addresses
that that you'll get back from there and
from there you'll want to
copy and paste the code into remix as
we've done before with the previous
examples compile that code here in the
compile Tab and then deploy them using
the at address with the public address
of the deployed contract all right so
you get sort of the interface down here
of each contract now
as far as the steps for running the
specific Arbitrage example there are a
couple of extra things we need to do so
first we need to fund the Dex contract
with some tokens some die and usdc
tokens just so that there's some
liquidity so that the contract is able
to handle these buy and sell operations
okay so what I've done is through my
metamask wallet I have
let's see I've added 1500 die and 1500 usdc
usdc
all right so we're in the Dex contract
and we can use the
get balance which takes a token address
so this should have 1500
yep that looks good
and let's also verify the die token balance
and there we go and again the difference
in decimals is simply because the die
token takes 18 or has 18 decimal places
whereas usdc takes or has six decimal
places so that actually caused me to
have to do some
some math here for the exchange rate
where is it that's what this um
times 10 to the 12 is that's the
conversion from
18 to 6 decimal places and here we're
dividing by 10 to the 12.
all right so the next step is once
everything is deployed is to go ahead
and do the approval so we need to approve
approve
the transfer of die token and usdc for
the decks and the reason for that
is because like I said the first step is
going to be to deposit usdc and if you
look at the deposit code here it's using
transfer from and if you look at the
erc20 documentation basically in order
to perform a transfer from you have to
have pre-approval and you see the the
line right above that is checking the
allowance of this token okay and so
that's why we need to do this additional
step here
so I'm going to go down to my notes and
look at the so I'm approving
let's see how many is this one two three
four five six I'm approving 1 000 usdc
because that's the the amount I'll be depositing
depositing
that's the amount I'll be receiving from
The Flash loan
so I want to go up to where is it
oh this is on the flash loan Arbitrage contract
contract
so you'll be able to find
where is it approve usdc this one right here
here
okay that should prompt yeah metamask to open
open
all right and I need to do the same for
die so I'm going to approve
all right and we'll give those a couple
of seconds to a few minutes to settle on
the blockchain those transactions need
to be recorded on the blockchain before
we can run the test and then we can
check those approvals via the allowance
functions right here
all right so now we're ready to run the
test and request our flash loan now
remember the request flash loan function
takes a token address and a token amount
so I've got that prepared right here and
we're going to be requesting 1000 usdc
so let me go back to remix and enter
that in here and I'll go ahead and click
it's always a good sign when metamask
opens up
because again we'd see any errors right away
if the function was going to revert we
would typically see that pretty
immediately so I'm going to go ahead and
confirm this request
and I can already open it up on
etherscan so we can wait for this
it looks like it's complete I see a
success message here and let's take a
look at what's happening
all right so the first
transaction is 1000 usdc into our smart contract
contract
the second one is transfer of 1000 usdc
from Smart contract to the Dex contract
then we have a purchase of dye
and then we have a purchase of usdc with
that full amount of dye
and then finally we see the payback of
the loan plus the
.0005 fee
so everything looks good there I see all
the transactions that I was expecting
and the final confirmation is going to
be to check the balance of our flash
loan smart contract
which I can do over here back in remix
um so I'm going to check the balance of
usdc so I just need to grab the usdc address
address
come back here and what should it be
after all said and done I think about
110 or so let's see
yep there we go so if you take away six
decimal places we end up with a net
profit of 110 .6111
.6111
usdc so our flash loan was successful
and again just to recap all of the order
of operations here
first we requested 1000 usdc
okay then we deposited 1000 usdc that
full amount
into our Dex account okay then we use
those funds to buy die at a discounted
rate of 90 on the on the usdc
then we deposited that die into our Dex
contract then we used that full balance
die balance of to sell it back for usdc
which was then sent back to our contract
okay we then approved the amount of the
loan plus the fee
and our Ave pool pulled those funds back
the original loan amount plus the fee
and we ended up with our net profit of
110 usdc
great so yeah awesome to see this
working and um hopefully you guys got
the same result and everything seems to
be working as expected
so there you go flash loan with Arbitrage
Arbitrage
all right guys that'll do it for this
video thanks for watching please give it
a thumbs up and subscribe if you haven't
already I'm trying to grow this channel
so I appreciate it that helps me out a
lot I'll be doing some more D5 related
videos in the future as well as some
more beginner related videos I'm trying
to you know put out a healthy mix of of
kind of everything so yeah again
appreciate it and I will catch you guys
Click on any text or timestamp to jump to that moment in the video
Share:
Most transcripts ready in under 5 seconds
One-Click Copy125+ LanguagesSearch ContentJump to Timestamps
Paste YouTube URL
Enter any YouTube video link to get the full transcript
Transcript Extraction Form
Most transcripts ready in under 5 seconds
Get Our Chrome Extension
Get transcripts instantly without leaving YouTube. Install our Chrome extension for one-click access to any video's transcript directly on the watch page.
