How to do Gasless Transactions on Ethereum/Avalanche/Polygon or any EVM

welcome back to the channel guys this is joseph from morales and in this video we'll be learning how to do a transaction on avalanche without paying any guest fees and this simple depth right here will be the final product of this tutorial where here as you can see there's a string that is stored on the smart contract and i'll be able to change the state value just by a simple minimum signing and no gas fees at all and to really demonstrate that you don't need any gas fees to do this i have prepared a madman's account that have zero avex so to do that just really quick edit storage and i'm going to change the storage the string name into hello morales and then for the signature type i'm going to choose eip712 there's also personal type and i'm going to explain further later what is the difference between both of them and then to execute the change just set storage and a metamask prompt should appear soon and as you can see i just need to sign no gas fees need to be spent so just really quickly just click sign right here and in a few moments the string should be updated and the changes will be reflected automatically and boom there you go of course since this works on avenge you'll be able to apply all this to other evm change as you can see here such as the ethereum bsc and polygon these are test net but of course they apply to mainnet as well and we'll be learning how to do all this by using both morales and by economy for those who are new to the channel morales is a web redevelopment platform that offers you a unified question sdk and also a backend infrastructure that can help you and your team integrate your smart contract in multiple blockchain and scale up your dap easily if a new chain becomes popular your dab can quickly integrate it easily with morales this will for sure save you a bunch of money and time for development bringing your dabs to the market faster and in this tutorial we'll be using by economy as an infrastructure that will help us do guest list transaction they have various products under their product menu right here but the one that we're interested in is the gasos feature right here that we will integrate within the tutorial with the morales sdk to do guestless transaction plus we'll be using the ethereum boilerplate right here to build our dab because it is the best weaponry boilerplate out there to build our dabs quickly and easily also it integrates well with the morales sdk so if we scroll down right here really quickly as you can see there are a bunch of components and hooks that is provided by the morales team out of the box and we can use this to for sure shorten our development time even further if you found any trouble on the tutorial just go to the morales forum here i'll put the form link down in the description and we'll help you as soon as possible with your problem also don't forget to like our videos and subscribe for more web3 tutorials just like this now before we start developing our dab let's first understand on high level how gasless transaction works in normal atm transaction basically the user will use their wallet to execute transaction and the user will be the one that paid the gas fees on the other hand in guestless transaction or met a transaction in formal terms the user will instead sign the wallet as i demo earlier and this will in turn tell the bi-economy relayer that we are the one that want to make the transaction and the bicoming relayer will then make the transaction on our behalf keep in mind that gasless doesn't mean free it just means instead of having the user pay for the gas fees we the developer will do that instead so when doing this make sure that there are enough avacs on the biconomy relayer then the transaction will be executed through this trusted forwarder which will do all this stuff and then forward the transaction to our smart contract which must be eip2771 compliant in short eip2771 is a secure ethereum standard to do native meta transaction smart contract that inherits this basically will be able to receive many transaction from a trusted forwarder that i showed before and the contract we don't need to deploy it anymore because it will be provided directly by by economy so without further ado let's start developing our dap so to start our development process the first thing that we need is to have a free morales account which you can get just by clicking the sign up for free button and it will be redirected to this morales dashboard but if you haven't have one yet it's gonna take a few minutes and you just need to follow the process but you have one you'll be redirected to this dashboard and once that's done you just need to create a new server and we're going to use a testnet server and here we can choose the name as meta transaction server and then just choose any region that you want preferably the nearest to your location and then you can choose any chains that you want in this case i'm going to choose koven polygon mumbai bse test net and avalanche net and by the way this uh for this tutorial we're just gonna focus on the avalanche testnet so make sure you have this one and once that's done just add the instance and your server will be created in just a few minutes once your server is created right here the next thing that we need is a bi-economy account so here just go to the bi economy website and go to the dashboard and here basically you need to sign up for a new account and it's going to be free as well and it's going to take a few minutes for you but if not then just log in and you'll be redirected to a dashboard page like this one and we'll come back later when we're setting up the buy economy in our dap once all that's done then we can just go to the github repository that where i'll put the link down in the description so make sure to check it out and we just basically need to clone the repo to our local machine so go here and then just copy the link and then open your terminal and then go to any designated directory that you want and get clone it and paste and then just enter and in a few moments this repository for a dab will be copied locally on your local computer but i don't need to do that so the next step will be just to open your favorite editor and in this case i'm going to use vs code and basically this is what the directory structure for the dap will be and as you can see it's basically a react project with a travel project inside of it and the only two files that we uh i mean two folders that we really need to focus on is the src right here which gonna contain all the uh react ui and logics basically everything front-end related and also the truffle project right here which gonna contain all the smart contracts logic and deployment and etc inside of there and to set it up before we start working on it basically we need to uh first yarn install so uh basically install the dependency you can use yarn or if you want you can use npm install whatever you choose so i'm gonna do yarn but because i already did it as you can see there's yarn lock so i uh it doesn't take too long also we have a travel project right here and we need to install dependency as well for this one as you can see there's a package.json inside here so go to the truffle directory and then once you're there also yarn install or or npm install so that you can generate a lock files such as yarn.lock right here and the other thing that we need is the environment variable and basically here as you can see i already have env.example which you can basically just copy and you just need to fill in all the informations right here and there's the morales application id server url speedy nodes and by economy related api keys uh we're gonna skip the by economy api key later until we deploy the smart contract but basically we're gonna fill in all this and for the application id server url and speed note it's gonna be right here basically go back to your morales admin dashboard and then go to your server and click view details and then go to uh oh it's gonna be right here basically so the application id is gonna be this one and the server url is gonna be this and basically you just need to copy both of this information and put it into the env file i'm not going to show this because there are some sensitive informations but basically this is where the application id will goes and this is where the server url will goes to and for the speedy nodes key it's gonna be very simple as well just go to the speedy note section right here and uh suppose we want the avalanche test net and basically you just need to focus on this one the avalanche testnet fuji and then these are the the random numbers between uh this links as you can see they're all gonna be the same basically just copy them and this is sort of gonna be what is the api key for the speed note so that you can uh deploy your smart contract through the nodes and etc and so once that's done that is gonna be basically the dot env file for the react project as you can see it's on the root folder but there's also a dot env file on the on the truffle project as you can see and there are a bunch of things uh as you can see here this either scan polygon scan and etc until snow trace are quite optional basically this is gonna be used mostly for uh verifying our smart contracts from the cli as you can see but if you don't want to of course you can just comment uh this out and you know i don't need to fill in this part uh but the most important thing is gonna be this one which is the more speedy nose key which is gonna be the same as what we used before and also the archive is going to be either true or false and it indicates whether we want to use an archive node or a non-archive node right here and it's optional so so it's it's all up to you guys so once it's done yeah just uh just basically the same and the next thing is gonna be making a dot secret file and this dot secret file basically if we see here in the truffleconfig.js.js it's going to be where you see like it's going to read the file.secret and it's going to contain the mnemonics so basically uh you just need uh because we we will interact with your uh with your uh wallet uh when deploying the smart contract basically you need to put your mnemonic or it could be also the private key but in this case i'm going to use the mnemonic and yeah so just make a dot secret file right there on the truffle project and input your 12 word or 24 word mnemonics right there and once that's done basically we're good to go so let's first start with developing our smart contracts first and to do that basically i'm here on the travel project and i make it the root folder right here for convenience so we can just focus first on the truffle project but you don't really need to make it your own root folder but basically here there's three folders that we're going to focus on which is the contracts folder list folder and the migrations folder for the contracts folder there's going to be two files the first one is going to be the migrations.sol this comes out of the box from the travel project when we initialize it and we don't necessarily need to change anything for this project so we're just going to leave it be and the second one is going to be the simple storage dot sole smart contract which is going to be contain the implementation of the smart contract that i demo before earlier where basically the requirement is that using the smart contract will be able to store a data inside a variable and also set the variable to anything any string that we want and as you can see here it's a simple storage and the data is going to be stored in this data string storage variable right here and the getter and the setter function is going to be defined right here below you see as your get storage and we're just going to return the data variable and if we want to set the storage to a new value we're just gonna pass in the new data a new data variable and then set the data into the new data variable right here but of course if we just have those it's just going to be a really bare-boned smart contract but no native uh meta transaction will be enabled and as remember to enable native meta transaction basically we need to make this contract to be eip 2771 compliant and to do that basically the contract first needs to inherit this base relay recipient smart contract which we will import from at opengsn library right here if you install the dependency you don't need to do that anymore because i already included in the package.json so yeah just import it and then make your simple storage smart contract or any smart contract you want to develop in the future to inherit this base relay recipient and once that's done uh the two functions that we need to to add is gonna be this set trusted forwarder and the version recipient so basically this version recipient is gonna be any version that we uh we want in this case since this is the first version we're just gonna return it as one the second one is going to be the set trusted folder which basically uh in the beginning if you see here in the constructor we initialize it using the using the parameter from the constructor at first but in the in some case by economy uh probably will want to upgrade their smart contracts and probably deploy a new trusted folder for secure reason or upgraded for an upgrade version and we might be wanting to use that upgrade version inside the old one so in here we set uh we define a set truss forwarder function to set a new trusted forwarder address in the smart contract right here the set trusted forwarder this is basically the underscore one is gonna be an internal function that we inherit from the base relay client and once that's done basically we just need to deploy our simple storage smart contract and pass in this trusted folder address based on the network that we have so to do that uh basically you need to go to the website the buy economy website to search for the smart contract address for the trusted forwarder but here under the list folder i already have by economy forwarder.json which i have uh store written down all the by economy trusted folder address based on the network themselves so you don't need to do that anymore and basically these are going to be the parameters that we're going to pass down the simple storage smart contract depending on on the on the network that we are going to deploy to and the last one is gonna be the migrations folder where we'll define all the logic uh of how we're going to deploy each of the smart contracts the first one is gonna be the migrations related stuff as well it's gonna be basically deployed the migrations also comes out of the box from truffle as well so we don't need to touch that the second one is uh the one that i custom write so in here basically uh i'm writing the custom migration script for how to deploy this uh simple storage smart contract and as you can see here first i uh first i import the simple simple storage smart contract by using artifacts dot require simple storage and here keep in mind that this is not the not the uh file name but instead it's gonna be the it's gonna be the contract name that is written right in here as you can see so the name of the file could be anything like simple storage one two dot soul but basically it's gonna be referred to the name of the contract right here so it's gonna import the simple storage uh smart contract and store it into this simple storage variable and then we're also going to fetch the bicarbonate forwarder json here by requiring the uh the bicone reporter json in the list folder and then uh we're gonna put the migration logic within this module that exports and here as you can see the function will have two parameters first one is deployer the second is network deployer is going to be used for deploying the smart contract the network is going to be used to indicate which network uh are we going to deploy the smart contract in and this one is going to be referred to in here if we see to the truffle config.json these as you see here if i scroll down on the networks field here right here as you can see there are some subfields right here which is develop robsten coven rank a b and we want to do deploy in avalanche either fuji or mainnet basically these are going to be the network name that is going to be passed down in this network uh variable so basically uh from there we can use the both of this variable to deploy first we need to fetch the bi economy folder by the smart by the network itself so just index it by the network something like this and then once we get uh once we get the bi economy folder by network we're gonna check whether it's null or not because uh as as you can see here uh some networks are not there for sure uh uh obviously like something like a local ganache is not going to be there so basically when it doesn't find the address and uh it's gonna return null and if it's not then it's gonna be false and it's gonna just uh console.log that no bi-economy forwarder found in this desired network something like that for example but if it found it for example like avalanche fuji right here which we have then it's gonna be true evaluated by javascript and then it's gonna run this deployer.deploy simple storage uh smart contract basically this is going to deploy our simple storage smart contract to the desired network and we're going to pass the by coming forwarder address as the parameter of the smart contract right here and since there's just one parameter we're just gonna pass it as the first one but if there's two three or more you just basically need to add more comma and pass it down uh in order of the constructor uh constructor parameter right here so basically once all that's done we just need to deploy our smart contract and to do that open your terminal and then click yarn compile to compile your smart contract and once that's done basically uh you need to deploy your uh deploy your smart contract by doing yarn migrate network and in this case i want to deploy to avalanche fuji just like that and if in a few moments it's going to deploy my smart contract into the avalanche fuji smart contract oops something is wrong let me check for a moment in the truffle right here avalanche fuji oops my bad this should be network so let's fix that really quickly and there you go seems like all good and the migration process is gonna take a while so just rest a bit and wait for a while until the whole smart contract are deployed so once the deployment process is complete as you can see here it's basically gonna take a while and maybe there will be some error on your site so don't worry about it i have some error a couple of time as well as you can see here it's gonna run the two scripts that we define on the migrations folder as you can see the first one is going to be the initial migrations which we don't really need to care about uh the one that we want to focus on is going to be to deploy simple storage and as you can see here it's deploying the simple storage smart contract and there will be a bunch of information related to the contract deployment right here but the one that we want to focus on is going to be the contract address which if we copy right here we can go to our browser and go to snowtrace.io and check out the the smart contract that we just deployed it's no trace.io i think we might need to go to the no trace testnet one testnet dot no trace yep there you go so just paste the address and there you go this is basically the smart contract that we just deployed and as you can see it's very reason so yeah basically that's it just really that simple to deploy the smart contract and if we want to we can also basically verify the smart contract as well and to do that i'm sorry and to do that really quickly we can just do yarn migrate network avalanche fuji oops i mean darn [Music] verify network avalanche fuji there you go my bad we don't want to migrate the smart contract all over again so just like that and we're gonna wait for a few moments and there you go and it's basically gonna give us the same address again and once it's done basically here as you can see it's gonna lay out all the code that we just deployed including the one that we inherit and also if we scroll down here we can also of course get the api which if you want to and other than that we of course can read the contract directly so we can basically interact with the smart contract very easily and it's gonna display all the public uh storage variables like this and the version recipient as you can see and of course if we want to write the smart contract we can do that too very easily with the set storage right here and the set trusted forwarder so yeah so now that we deployed our smart contract the next thing we'll need to do is to integrate it to our dab and using by economy and morales execute it with a meta transaction so now we're back to the front end part of the dab itself we still need to set up a few more things related to bike army specifically to set up the bike army relayer that we talked about before so to do that as you can see here in the dot env dot example we still haven't have the bi-economy api key that we talked about before and to do that basically we need to quickly jump to the bi-economy dashboard right here and then here if you're on the dashboard just click register to register your dab and give it any name you want and then select the network as avalanche testnet c chain right here and once that's done just create it and basically it will create a bicarbonate relayer for you and once it's done here i already have one for the avalanche testnet c chain we can just go to the view dab and right here we need to do two steps before we can enable the meta transaction on our smart contract on our simple storage smart contract first one is to add the contract to register contract on the bi-economy relayer and to do that just add the smart contract name add the address of the smart contract the simple storage smart contract from the snow trace also the abi and choose the meta transaction type as trusted forwarder and then once that's done just add it and the other thing that we need is to register the function itself so other than the smart contract by com we need to know which function we want to enable the mana transaction on so to do that similarly just add new api and then here we only have simple storage smart contract registered right here so just choose that and then we can choose the method that we want to enable the meta transaction as set storage and then here you can give any name you want but it doesn't need to be related to this one and then just click add and there you go the setup is finished and you'll be able to use the bi-economy relayer to execute meta transaction on your dap the other thing that i want to point out is that make sure that you have enough avax uh in this case actually like they don't really have one somehow for the avalanche but uh here if i show you in covent one as you can see there's a guest thing that will indicate how much ethereum or maybe like if you're on binances bnb and polygon it's gonna be manic like how much gas fees do you still have left on the gas tank and uh if uh this goes red uh right now is green it means it's sufficient but if it goes red then basically you need to deposit some more ethereum bnb or matic into the gas tank using metamask and making sure that uh there's enough gas fees for the relayer to pay uh on behalf of the user but yeah just that's it and once that's done you basically just need to copy the api key i also have the one for coven matic and also binance and you can just basically copy it right here on the env.example uh the the environment variable that are related uh corresponding to the chain right here and once it's done basically we're ready to look through the code and how to integrate morales and bike army sdk to execute some mana transaction so first thing first let's run our dab just yarn start it and basically this will run react server and it's going to take a while so just hang on a sec so here you go it has finished loading and basic basically this is how the dab is going to look like as i showed in a demo earlier and there's just going to be one page for this which gonna render these components right here so let's go back to our project again right here and i'm going to close this to hide the terminal and then the one that we want to explore under the front end code is going to be this src folder right here because this encapsulates all the ui logics uh everything related to executing the transaction everything is in here so the important that we want to see here right here is that as you can see if i click on index.js here if you can see there's morales provider which are going to wrap this one by coming context provider and this is going to uh wrap our app component right here and basically mariah's provider is to initialize the morales sdk itself and similarly for the bicomic context provider it is going to be used to initialize the by kami sdk itself and this is by the way uh custom so it's it doesn't come out uh out of the ethereum boilerplate by itself and let's check it out right here under the contacts for by economy provider.js and as you can see here there are a bunch of logics like right here but basically the the most important thing that we want to see is this initialized by economy uh function right here which is going to be called in the use effect right here every time one of this variable change especially when uh the user switch uh the network uh basically it's going to run this initialized by economy function and since whereas sdk integrates well with web.js it fits very nicely when integrating it with the by economy sdk itself as we shall see right here now it looks quite complicated but let me explain it really quickly so here the wallet webtree variable here is basically gonna be the web tree provider for uh for our wallet so this is gonna be fetch from rus.enableweb3 and then the next one we're going to define another uh provider but this one is going to be from the rpc url right here and this is going to be stored in the network provider and for those who are not familiar rpc url is just basically something like a node so in this case we are using uh using the morale speedy notes so right here and it's basically gonna fetch based on the chain that the user is using right now so just like that and once we define these then we can define a biconomy object by using new by economy and input the network provider as the first parameter and the second parameter is going to be a json object with wall provider as the first field here and it's going to take the walt webtree object and dot current provider and then for the api key it's going to be the api key that we just input in the dot env file before if we go to bicomic.js here this is basically where it gets the biker me api key it's getting it from the process.env which is the environment variable so once it's done we have the bike army object and basically this is the by kami relayer provider so that we can communicate with the bicameral layer to execute some meta transaction and then here basically using the webtree object that is provided by morales right here uh from use morales yep right here web3 from use morales we will able to set the biconomy relayer provider as the new uh provider and once that's done basically the rest is just an event listener here where as you can see when by economy is ready or is initialized basically here we're going to call a callback right here which going to set is by economy initialized to be true this is a react state by the way and then the second one we're going to instantiate a contract instance uh which is uh also using web3 this time and but this is uh basically using the by kami relay provider just input the api and also the contract address which is also going to be variable to the chain id and then just set it into the contract contracts react state right here and there you go it's done the other one is uh an error event listener which uh here i just put it to to output a notification error but of course you can do anything uh inside of it but yeah just like that and basically uh using all this logic it's going to initialize the by economy sdk and integrate integrated with the morales sdk and just that easy and of course basically when one of these variables change then it's going to re-initialize the bi-economy sdk again accordingly especially uh i think it is more most important when the chain change because uh here as you can see uh the network provider is going to be changed and also especially for the contract instance we need to change it as well because otherwise it it will be error because the address will not exist right there in uh in a different contract and once that initialize basically through the contracts uh contacts provider uh component we're going to pass down a few value right here which is going to be is by economy initialize and then the by company provider object right here and also the contract variable where we defined the contract instance using the bicoming relayer provider web3 object so once that's done basically uh here uh when the react run the run the dab basically it will initialize the by economy sdk and also pass down the variable that we just mentioned before and those variables will be usable throughout the app globally so when we check the app right here it's going to be defined in this in this uh in this file right here and the thing that we want to see is that as you can see here uh this is basically the routing for the dap itself and as you can see there are two routes the first one is going to be for the home page and this one is go when we're in the home page where one we want to render the contract component and the other one is a redirect component basically as you can see there's no pad so it means that any other any other page that is not home page it's going to uh redirect to the home page itself so basically this is just going to be a a really simple dab that only have a single page so here to check the contract page we need to go to components contract and index js right here and this is where all the ui all the logic for this page is encapsulated and the one that we are interested to see is the meta transaction execution so here is the here's the logic for a meta transaction right here and as you can see i define a use meta transaction right here and i define some inputs and transaction params i think it's very similar to what we have from the react hooks to execute the smart contract but let us uh let us explore further what does this really means so to do that we need to go to the hooks right down here and [Music] go to use meta transaction and basically once we're here as you can see the one that is going to execute the meta transaction is going to be on this on submit meta transaction and this is uh by the way is going to be passed down on the hook so oops sorry so here as you can see there's error if there's an error and then this mana transaction processing is going to be available to indicate whether the meta transaction is still loading or not and then the third one is going to be on submit meta transaction which are going to execute the meta transaction itself and using bicomi and morales as you can see here we will fetch the contract from the bi-economic context that we defined earlier and from there we're going to use the set storage uh set storage method to set the storage data the string and then here as you can see we're going to use the input from the uh from the input writer maybe like let me open a second window so it's easier to see yep it's gonna be this one right just close this one and open this one okay and there you go so this is going to be the use meta transaction right here and here as you can see the input is going to be the storage form dot value and the storage form.value is going to be the input right here if we edit storage this storage input.value is going to be the text that we input right here so when i type basically these are going to be the storageform.value and then going back here right here and then the transaction params is going to be from uh and this is going to be from the account which is basically my account address and this is account is from the use morales hooks right here and then the second one for the transaction param is going to be the signature type and the signature type is as you can see right here back really quickly this is going to be the eip712 or personal that we are going to choose and uh here as you can see there's eip712 and personal um basically the difference is very minimal but let me show it to you really quickly suppose i want to change the string to morales and then i'll just choose eip712 and set storage and minimize problem should appear really quickly and as you can see here there's a bunch of json that will appear right here basically eip712 is a standard so that it can give the user more info on what kind of json object or data that they are signing on because if they don't know then it'll be uh it'll be basically uh could be like on the malicious side they could hack you so yeah it's basically a better standard for signing of course like you can do personal as well which is like the one that people usually use but this one as you can see it's just gonna give you like some gibberish hashing right here which people don't know and this could be basically really dangerous because uh people really don't know what they're signing on so best to use uh eip712 in general but uh there you go those are the difference between eip712 and personal uh on a high level and yep this is going to be the one for the signature type right here so once uh we inputted this one this is going to be passed down right here and it's going to be used on the on submit transaction right here and as you can see here basically yeah we're going to set the storage and the input here the one that we type the string that we type is going to be the variable that we want to change the data for the smart contract too and then we're just going to dot send it and input some transaction params that we have right here and the reason why we do this instead of the uh the usual uh use web3 contract or use uh execute webfree function from morales is that because here uh we need some further configuration on the dot send function which morales doesn't support so we need to do this and then basically if we want to do some event listening right here on the transaction we can just use here on transaction hash and then once confirmation and then also the error event listener so the transaction hash is basically just gonna execute uh when there's a transaction hash is given but you can of course also get it from the confirmation right here but this is only gonna execute once the uh once the transaction goes through or successful so here as you can see i defined the callback as set as method transaction processing to be false because basically the transaction the native meta transaction has finished processing and also i i set the on confirmation right here to be the transaction hash which i remember this is i think the yeah this is the the callback basically like if the uh if like the meta transaction is successful it's going to call this callback if it's error right here on error it's going to be calling this on error med on error uh callback right here both in here and here so yeah just like that really simple uh basically then people can just use this to indicate whether the transaction is still loading or not and this one to call the to call the matter transaction so here as you can see if we search it basically to do that we just it's going to be right here where on submit basically uh once once uh once the user have fill in this new string right here and also choose the signature type as either eip1712 or personal then basically it will call that on submit function that we have right there on submit function and execute the on submit meta transaction right here and here as you can see there's the on confirmation call back here and also the on error callback right here which i define a bunch of things right here so yeah that's basically how it works not very complicated so just yeah we can now we can basically change it to editing one and just avalanche and we're gonna choose it to eip712 and set the storage and just like that we will sign the transaction and as before as uh with the logic that is written on the uh react code that i just shown before it will basically change the string right here in the smart contract as we did in the demo earlier so yeah just that simple and that's how we integrate the morales sdk and the bike army sdk and using the bicameral layer to execute a native meta transaction without any guest fees hope you guys enjoyed this video and hope to see you guys soon bye bye

Channel: Moralis Web3

Views: 841

Keywords: blockchain, programming, ethereum, crypto, cryptocurrency, Moralis, javascript, Ivan On Tech, cloud functions, dapps, ethereum code, create a coin, web3, web3 programming, blockchain coding, moralis programming, smart contracts, BSC, Binance Chain, polkadot, Polygon, development, coding, what is blockchain, blockchain explained, blockchain technology, blockchain for programmers, blockchain for developers, nodes crypto, blockchain archive nodes, decentralized applications, blockchain nodes

Id: r04x1YqnYLk

Length: 48min 30sec (2910 seconds)

Published: Fri Dec 17 2021