Forum. StockSharp

Website Acceptable Use Policy

2019-03-05T16:34:10Z

PLEASE READ THE TERMS OF THIS POLICY CAREFULLY BEFORE USING THE SITE
What's in these terms?
This Acceptable Use Policy sets out the content standards that apply when you upload content to our site, make contact with other users on our site, link to our site, or interact with our site in any other way.

Who we are and how to contact us
https://stocksharp.com is a site operated by Stocksharp LP ("We"). We are registered in Northern Ireland under number NL000703 and have our registered office at Suite 7199, 6 St Colman's Park, Newry, County Down, BT34 2BX, Northern Ireland.
To contact us, please email info@stocksharp.com.

By using our site you accept these terms
By using our site, you confirm that you accept the terms of this policy and that you agree to comply with them.
If you do not agree to these terms, you must not use our site.
We recommend that you print a copy of these terms for future reference.

There are other terms that may apply to you
Our Terms of Website Use also apply to your use of our site.

We may make changes to the terms of this policy
We amend these terms from time to time. Every time you wish to use our site, please check these terms to ensure you understand the terms that apply at that time.
Prohibited uses
You may use our site only for lawful purposes. You may not use our site:

In any way that breaches any applicable local, national or international law or regulation.
In any way that is unlawful or fraudulent or has any unlawful or fraudulent purpose or effect.
For the purpose of harming or attempting to harm minors in any way.
To send, knowingly receive, upload, download, use or re-use any material which does not comply with our content standards given below.
To transmit, or procure the sending of, any unsolicited or unauthorized advertising or promotional material or any other form of similar solicitation (spam).
To knowingly transmit any data, send or upload any material that contains viruses, Trojan horses, worms, time-bombs, keystroke loggers, spyware, adware or any other harmful programs or similar computer code designed to adversely affect the operation of any computer software or hardware.

You also agree:

Not to reproduce, duplicate, copy or re-sell any part of our site in contravention of the provisions of our Terms of Website Use.
Not to access without authority, interfere with, damage or disrupt:
any part of our site;
any equipment or network on which our site is stored;
any software used in the provision of our site; or
any equipment or network or software owned or used by any third party.

Interactive services
We may from time to time provide interactive services on our site, including, without limitation:

Chat rooms.
Bulletin boards.
Any other interactive services.

Where we do provide any interactive service, we will provide clear information to you about the kind of service offered, if it is moderated and what form of moderation is used (including whether it is human or technical).
We will do our best to assess any possible risks for users (and in particular, for children) from third parties when they use any interactive service provided on our site, and we will decide in each case whether it is appropriate to use moderation of the relevant service (including what kind of moderation to use) in the light of those risks. However, we are under no obligation to oversee, monitor or moderate any interactive service we provide on our site, and we expressly exclude our liability for any loss or damage arising from the use of any interactive service by a user in contravention of our content standards, whether the service is moderated or not.
The use of any of our interactive services by a minor is subject to the consent of their parent or guardian. We advise parents who permit their children to use an interactive service that it is important that they communicate with their children about their safety online, as moderation is not fool proof. Minors who are using any interactive service should be made aware of the potential risks to them.
Where we do moderate an interactive service, we will normally provide you with a means of contacting the moderator, should a concern or difficulty arise.

Content standards
These content standards apply to any and all material which you contribute to our site (Contribution), and to any interactive services associated with it.
The Content Standards must be complied with in spirit as well as to the letter. The standards apply to each part of any Contribution as well as to its whole.
Stocksharp LP will determine, in its discretion, whether a Contribution breaches the Content Standards.
A Contribution must:

Be accurate (where it states facts).
Be genuinely held (where it states opinions).
Comply with the law applicable in any country from which it is posted.

A Contribution must not:

Be defamatory of any person.
Be obscene, offensive, hateful or inflammatory.
Promote sexually explicit material.
Promote violence.
Promote discrimination based on race, sex, religion, nationality, disability, sexual orientation or age.
Infringe any copyright, database right or trade mark of any other person.
Be likely to deceive any person.
Breach any legal duty owed to a third party, such as a contractual duty or a duty of confidence.
Promote any illegal activity.
Be in contempt of court.
Be threatening, abuse or invade another's privacy, or cause annoyance, inconvenience or needless anxiety.
Be likely to harass, upset, embarrass, alarm or annoy any other person.
Impersonate any person or misrepresent your identity or affiliation with any person.
Give the impression that the Contribution emanates from Stocksharp LP, if this is not the case.
Advocate, promote, incite any party to commit, or assist any unlawful or criminal act such as (by way of example only) copyright infringement or computer misuse.
Contain a statement which you know or believe, or have reasonable grounds for believing, that members of the public to whom the statement is, or is to be, published are likely to understand as a direct or indirect encouragement or other inducement to the commission, preparation or instigation of acts of terrorism.
Contain any advertising or promote any services or web links to other sites.

Breach of this policy
When we consider that a breach of this Acceptable Use Policy has occurred, we may take such action as we deem appropriate.
Failure to comply with this Acceptable Use Policy constitutes a material breach of the Terms of Website Use upon which you are permitted to use our site, and may result in our taking all or any of the following actions:

Immediate, temporary or permanent withdrawal of your right to use our site.
Immediate, temporary or permanent removal of any Contribution uploaded by you to our site.
Issue of a warning to you.
Legal proceedings against you for reimbursement of all costs on an indemnity basis (including, but not limited to, reasonable administrative and legal costs) resulting from the breach.
Further legal action against you.
Disclosure of such information to law enforcement authorities as we reasonably feel is necessary or as required by law.

We exclude our liability for all action we may take in response to breaches of this Acceptable Use Policy. The actions we may take are not limited to those described above, and we may take any other action we reasonably deem appropriate.

Which country's laws apply to any disputes?
If you are a consumer, please note that the terms of this policy, its subject matter and its formation are governed by Northern Ireland law. You and we both agree that the courts of the Northern Ireland will have exclusive jurisdiction.
If you are a business, the terms of this policy, its subject matter and its formation (and any non-contractual disputes or claims) are governed by Northern Ireland law. We both agree to the exclusive jurisdiction of the courts of the Northern Ireland.

Website Privacy Policy GDPR

2019-03-05T17:09:01Z

Introduction
Welcome to https://stocksharp.com’s privacy policy.
https://stocksharp.com respects your privacy and is committed to protecting your personal data. This privacy policy will inform you as to how we look after your personal data when you visit our website (regardless of where you visit it from) and tell you about your privacy rights and how the law protects you.

1. Important information and who we are

Purpose of this privacy policy
This privacy policy aims to give you information on how https://stocksharp.com collects and processes your personal data through your use of this website, including any data you may provide through this website when you purchase a product or service.
This website is not intended for children and we do not knowingly collect data relating to children.
It is important that you read this privacy policy together with any other privacy policy or fair processing policy we may provide on specific occasions when we are collecting or processing personal data about you so that you are fully aware of how and why we are using your data. This privacy policy supplements other notices and privacy policies and is not intended to override them.

Controller
Stocksharp is the controller and responsible for your personal data (collectively referred to as "Stocksharp", "we", "us" or "our" in this privacy policy).
We have appointed a data privacy manager who is responsible for overseeing questions in relation to this privacy policy. If you have any questions about this privacy policy, including any requests to exercise your legal rights, please contact the data privacy manager using the details set out below.

Contact details
If you have any questions about this privacy policy or our privacy practices, please contact our data privacy manager in the following ways:
Full name of legal entity: StockSharp LP
Email address: info@stocksharp.com
Postal address: Suite 7199, 6 St Colman's Park, Newry, County Down, BT34 2BX, Northern Ireland

Changes to the privacy policy and your duty to inform us of changes
We keep our privacy policy under regular review.
It is important that the personal data we hold about you is accurate and current. Please keep us informed if your personal data changes during your relationship with us.

Third-party links
This website may include links to third-party websites, plug-ins and applications. Clicking on those links or enabling those connections may allow third parties to collect or share data about you. We do not control these third-party websites and are not responsible for their privacy statements. When you leave our website, we encourage you to read the privacy policy of every website you visit.

2. The data we collect about you
Personal data, or personal information, means any information about an individual from which that person can be identified. It does not include data where the identity has been removed (anonymous data).
We may collect, use, store and transfer different kinds of personal data about you which we have grouped together as follows:

Identity Data includes first name, last name, username or similar identifier, title, date of birth and.
Contact Data includes billing address, address, email address and telephone numbers.
Financial Data includes bank account and payment card details.
Transaction Data includes details about payments to and from you and other details of products and services you have purchased from us.
Technical Data includes internet protocol (IP) address, your login data, browser type and version, time zone setting and location, browser plug-in types and versions, operating system and platform, and other technology on the devices you use to access this website.
Profile Data includes your username and password, purchases or orders made by you, your interests, preferences, feedback and survey responses.
Usage Data includes information about how you use our website, products and services.
Marketing and Communications Data includes your preferences in receiving marketing from us and our third parties and your communication preferences.

We also collect, use and share Aggregated Data such as statistical or demographic data for any purpose. Aggregated Data could be derived from your personal data but is not considered personal data in law as this data will not directly or indirectly reveal your identity. For example, we may aggregate your Usage Data to calculate the percentage of users accessing a specific website feature. However, if we combine or connect Aggregated Data with your personal data so that it can directly or indirectly identify you, we treat the combined data as personal data which will be used in accordance with this privacy policy.
We do not collect any Special Categories of Personal Data about you (this includes details about your race or ethnicity, religious or philosophical beliefs, sex life, sexual orientation, political opinions, trade union membership, information about your health, and genetic and biometric data). Nor do we collect any information about criminal convictions and offences.

If you fail to provide personal data
Where we need to collect personal data by law, or under the terms of a contract we have with you, and you fail to provide that data when requested, we may not be able to perform the contract we have or are trying to enter into with you (for example, to provide you with goods or services). In this case, we may have to cancel a product or service you have with us but we will notify you if this is the case at the time.

3. How is your personal data collected?
We use different methods to collect data from and about you including through:

Direct interactions. You may give us your Identity, Contact and Financial Data by filling in forms or by corresponding with us by post, phone, email or otherwise. This includes personal data you provide when you:
apply for our products or services;
create an account on our website;
subscribe to our service;
give us feedback or contact us.
Automated technologies or interactions. As you interact with our website, we will automatically collect Technical Data about your equipment, browsing actions and patterns. We collect this personal data by using cookies, server logs and other similar technologies. Please see our Cookie Policy for further details.
Third parties or publicly available sources. We will receive personal data about you from various third parties and public sources as set out below:
Technical Data from analytics providers such as Google based outside the EU.
Contact, Financial and Transaction Data from providers of technical, payment and delivery services.
Identity and Contact Data from data brokers or aggregators.
Identity and Contact Data from publicly available sources.

4. How we use your personal data
We will only use your personal data when the law allows us to. Most commonly, we will use your personal data in the following circumstances:

Where we need to perform the contract we are about to enter into or have entered into with you.
Where it is necessary for our legitimate interests (or those of a third party) and your interests and fundamental rights do not override those interests.
Where we need to comply with a legal obligation.

Generally, we do not rely on consent as a legal basis for processing your personal data although we will get your consent before sending third party direct marketing communications to you via email or text message. You have the right to withdraw consent to marketing at any time by contacting us.

Purposes for which we will use your personal data
We have set out below, in a table format, a description of all the ways we plan to use your personal data, and which of the legal bases we rely on to do so. We have also identified what our legitimate interests are where appropriate.
Note that we may process your personal data for more than one lawful ground depending on the specific purpose for which we are using your data. Please contact us if you need details about the specific legal ground we are relying on to process your personal data where more than one ground has been set out in the table below.

Marketing
We strive to provide you with choices regarding certain personal data uses, particularly around marketing and advertising.

Promotional offers from us
We may use your Identity, Contact, Technical, Usage and Profile Data to form a view on what we think you may want or need, or what may be of interest to you. This is how we decide which products, services and offers may be relevant for you (we call this marketing).
You will receive marketing communications from us if you have requested information from us or purchased goods or services from us and you have not opted out of receiving that marketing.

Third-party marketing
We will get your express opt-in consent before we share your personal data with any third party for marketing purposes.

Opting out
You can ask us or third parties to stop sending you marketing messages at any time by logging into the website and checking or unchecking relevant boxes to adjust your marketing preferences.
Where you opt out of receiving these marketing messages, this will not apply to personal data provided to us as a result of a product/service purchase, warranty registration, product/service experience or other transactions.

Cookies
You can set your browser to refuse all or some browser cookies, or to alert you when websites set or access cookies. If you disable or refuse cookies, please note that some parts of this website may become inaccessible or not function properly. For more information about the cookies we use, please see our Cookie Policy.

Change of purpose
We will only use your personal data for the purposes for which we collected it, unless we reasonably consider that we need to use it for another reason and that reason is compatible with the original purpose. If you wish to get an explanation as to how the processing for the new purpose is compatible with the original purpose, please contact us.
If we need to use your personal data for an unrelated purpose, we will notify you and we will explain the legal basis which allows us to do so.
Please note that we may process your personal data without your knowledge or consent, in compliance with the above rules, where this is required or permitted by law.

5. Disclosures of your personal data
We may share your personal data with the parties set out below for the purposes set out in the table above.

Internal Third Parties as defined below.
External Third Parties as defined below.
Third parties to whom we may choose to sell, transfer or merge parts of our business or our assets. Alternatively, we may seek to acquire other businesses or merge with them. If a change happens to our business, then the new owners may use your personal data in the same way as set out in this privacy policy.

We require all third parties to respect the security of your personal data and to treat it in accordance with the law. We do not allow our third-party service providers to use your personal data for their own purposes and only permit them to process your personal data for specified purposes and in accordance with our instructions.

International transfers
We share your personal data within the Stocksharp Group. This will involve transferring your data outside the European Economic Area (EEA).
Whenever we transfer your personal data out of the EEA, we ensure a similar degree of protection is afforded to it by ensuring at least one of the following safeguards is implemented:
• We will only transfer your personal data to countries that have been deemed to provide an adequate level of protection for personal data by the European Commission. For further details, see European Commission: Adequacy of the protection of personal data in non-EU countries.
• Where we use providers based in the US, we may transfer data to them if they are part of the Privacy Shield which requires them to provide similar protection to personal data shared between Europe and the US. For further details, see European Commission: EU-US Privacy Shield.
Please contact us if you want further information on the specific mechanism used by us when transferring your personal data out of the EEA.

6. Data security
We have put in place appropriate security measures to prevent your personal data from being accidentally lost, used or accessed in an unauthorised way, altered or disclosed. In addition, we limit access to your personal data to those employees, agents, contractors and other third parties who have a business need to know. They will only process your personal data on our instructions and they are subject to a duty of confidentiality.
We have put in place procedures to deal with any suspected personal data breach and will notify you and any applicable regulator of a breach where we are legally required to do so.

7. Data retention
How long will you use my personal data for?
By law we have to keep basic information about our customers (including Contact, Identity, Financial and Transaction Data) for six years after they cease being customers for tax] purposes.
In some circumstances you can ask us to delete your data: see below for further information.
In some circumstances we will anonymise your personal data (so that it can no longer be associated with you) for research or statistical purposes, in which case we may use this information indefinitely without further notice to you.

8. Your legal rights
Under certain circumstances, you have rights under data protection laws in relation to your personal data. Please click on the links below to find out more about these rights:

Request access to your personal data.
Request correction of your personal data.
Request erasure of your personal data.
Object to processing of your personal data.
Request restriction of processing your personal data.
Request transfer of your personal data.
Right to withdraw consent.

If you wish to exercise any of the rights set out above, please contact us.

No fee usually required
You will not have to pay a fee to access your personal data (or to exercise any of the other rights). However, we may charge a reasonable fee if your request is clearly unfounded, repetitive or excessive. Alternatively, we could refuse to comply with your request in these circumstances.

What we may need from you
We may need to request specific information from you to help us confirm your identity and ensure your right to access your personal data (or to exercise any of your other rights). This is a security measure to ensure that personal data is not disclosed to any person who has no right to receive it. We may also contact you to ask you for further information in relation to your request to speed up our response.

Time limit to respond
We try to respond to all legitimate requests within one month. Occasionally it could take us longer than a month if your request is particularly complex or you have made a number of requests. In this case, we will notify you and keep you updated.

9. Glossary

LAWFUL BASIS
Legitimate Interest means the interest of our business in conducting and managing our business to enable us to give you the best service/product and the best and most secure experience. We make sure we consider and balance any potential impact on you (both positive and negative) and your rights before we process your personal data for our legitimate interests. We do not use your personal data for activities where our interests are overridden by the impact on you (unless we have your consent or are otherwise required or permitted to by law). You can obtain further information about how we assess our legitimate interests against any potential impact on you in respect of specific activities by contacting us.
Performance of Contract means processing your data where it is necessary for the performance of a contract to which you are a party or to take steps at your request before entering into such a contract.
Comply with a legal obligation means processing your personal data where it is necessary for compliance with a legal obligation that we are subject to.

THIRD PARTIES
Internal Third Parties
Other companies in the Stocksharp Group and who provide IT and system administration services and undertake leadership reporting.
External Third Parties

Service providers.
Professional advisers.
HM Revenue & Customs, regulators and other authorities .

YOUR LEGAL RIGHTS
You have the right to:
Request access to your personal data (commonly known as a "data subject access request"). This enables you to receive a copy of the personal data we hold about you and to check that we are lawfully processing it.
Request correction of the personal data that we hold about you. This enables you to have any incomplete or inaccurate data we hold about you corrected, though we may need to verify the accuracy of the new data you provide to us.
Request erasure of your personal data. This enables you to ask us to delete or remove personal data where there is no good reason for us continuing to process it. You also have the right to ask us to delete or remove your personal data where you have successfully exercised your right to object to processing (see below), where we may have processed your information unlawfully or where we are required to erase your personal data to comply with local law. Note, however, that we may not always be able to comply with your request of erasure for specific legal reasons which will be notified to you, if applicable, at the time of your request.
Object to processing of your personal data where we are relying on a legitimate interest (or those of a third party) and there is something about your particular situation which makes you want to object to processing on this ground as you feel it impacts on your fundamental rights and freedoms. You also have the right to object where we are processing your personal data for direct marketing purposes. In some cases, we may demonstrate that we have compelling legitimate grounds to process your information which override your rights and freedoms.
Request restriction of processing of your personal data. This enables you to ask us to suspend the processing of your personal data in the following scenarios:

If you want us to establish the data's accuracy.
Where our use of the data is unlawful but you do not want us to erase it.
Where you need us to hold the data even if we no longer require it as you need it to establish, exercise or defend legal claims.
You have objected to our use of your data but we need to verify whether we have overriding legitimate grounds to use it.

Request the transfer of your personal data to you or to a third party. We will provide to you, or a third party you have chosen, your personal data in a structured, commonly used, machine-readable format. Note that this right only applies to automated information which you initially provided consent for us to use or where we used the information to perform a contract with you.
Withdraw consent at any time where we are relying on consent to process your personal data. However, this will not affect the lawfulness of any processing carried out before you withdraw your consent. If you withdraw your consent, we may not be able to provide certain products or services to you. We will advise you if this is the case at the time you withdraw your consent.

Broker

2024-12-08T16:11:39Z

Hi,
Does your software support Dukascopy trading? Do you have a connector to this broker?

About subscription issues？

2024-06-18T05:55:09Z

What does it mean to subscribe to Pro, which does not support API？

Leveraging JavaScript for Concurrent Execution of Quantitative Strategies: Encapsulating Go Functions

2024-04-18T07:35:23Z

When implementing the quantitative strategy, concurrent execution can reduce latency and improve efficiency in many cases. Taking the hedging robot as an example, we need to obtain the depth of two coins. The code executed in sequence is as follows:
```
var depthA = exchanges[0].GetDepth()
var depthB = exchanges[1].GetDepth()
```
There is a delay in requesting a rest API. Assuming that it is 100ms, the time for obtaining the depth is actually different. If more access is required, the delay problem will become more prominent and affect the implementation of the strategy.

JavaScript has no multithreading, so the Go function is encapsulated at the bottom to solve this problem. However, due to the design mechanism, the implementation is relatively cumbersome.
```
var a = exchanges[0].Go("GetDepth")
var b = exchanges[1].Go("GetDepth")
var depthA = a.wait() // Call the wait method to wait for the return of the depth result asynchronously
var depthB = b.wait()
```
In most simple cases, there is nothing wrong with writing the strategy this way. However, it is noted that this process should be repeated for each strategy loop. The intermediate variables a and b are only temporary aids. If we have a lot of concurrent tasks, we need to record the corresponding relationship between a and depthA, and b and depthB. When our concurrent tasks are uncertain, the situation becomes more complex. Therefore, we want to implement a function: when writing Go concurrently, bind a variable at the same time, and when the result of concurrent operation returns, the result will be automatically assigned to the variable, thus eliminating the intermediate variable and making the program more concise. The specific implementation is as follows:
```
function G(t, ctx, f) {
return {run:function(){
f(t.wait(1000), ctx)
}}
}
```
We define a G function, where the parameter t is the Go function to be executed, ctx is the recording program context, and f is the specific assignment function. You will see the function later.

At this time, the overall program framework can be written as similar to the "producer-consumer" model (with some differences). The producer keeps sending out tasks, and the consumer executes them concurrently. The following code is only for demonstration, not involving the program execution logic.
```
var Info = [{depth:null, account:null}, {depth:null, account:null}] // If we need to obtain the depth and account of the two exchanges, more information can also be put in, such as order ID, status, etc.
var tasks = [ ] // Global list of tasks

function produce(){ // Issue various concurrent tasks
// The logic of task generation is omitted here, for demonstration purposes only.
tasks.push({exchange:0, ret:'depth', param:['GetDepth']})
tasks.push({exchange:1, ret:'depth', param:['GetDepth']})
tasks.push({exchange:0, ret:'sellID', param:['Buy', Info[0].depth.Asks[0].Price, 10]})
tasks.push({exchange:1, ret:'buyID', param:['Sell', Info[1].depth.Bids[0].Price, 10]})
}
function worker(){
var jobs = []
for(var i=0;i<tasks.length;i++){
var task = tasks[i]
tasks.splice(i,1) // Delete executed tasks
jobs.push(G(exchanges[task.exchange].Go.apply(this, task.param), task, function(v, task) {
Info[task.exchange][task.ret] = v // The v here is the return value of the concurrent Go function wait(), which can be experienced carefully.
}))
}
_.each(jobs, function(t){
t.run() // Execute all tasks concurrently here
})
}
function main() {
while(true){
produce() // Send trade orders
worker() // Concurrent execution
Sleep(1000)
}
}
```
It seems that only one simple function has been implemented after going around in circles. In fact, the complexity of the code has been simplified greatly. We only need to care about what tasks the program needs to generate. The worker() program will automatically execute them concurrently and return the corresponding results. The flexibility has improved a lot.

From: https://blog.mathquant.c...ate-the-go-function.html

The Secret to Survival: 19 Professionals Share Their Advice on Digital Currency Trading

2024-04-18T06:37:31Z

I have never worried about the digital currency market as much as I worry about it today. The market situation is very bad. Frankly speaking, it is weakening my sleep mode, and it is destroying my work efficiency. I'm torn. Should I sell or hold? You're in the same boat, I know.

You can't keep yourself away from the chart. Every 5 minutes, a small voice comes into your mind.

"Look at the chart, maybe the market has changed," the voice said.

You know that the market will not change. You also know that looking at these price charts won't make you feel better. But you should do it anyway. Because you have real money invested in the market, and lots of it.

This is not the first time you have done this. Maybe this is the second time. No, no, it's at least the third time. I know it's painful.

What I'm about to tell you next will change your trading skills forever. These contents are not only applicable to the digital currency market, but also applicable to trading in any market, especially in the bear market - as we are facing, it is very necessary. What I want to tell you is how to keep calm when the "fire alarm" flashes.

I will tell you what trading skills I learned after interviewing 19 digital currency trading professionals for a week.

The first rule of the traders' club is...
Let's start.

1. Have a trading plan at all times

Now it seems obvious to me.

But I have changed this plan too many times. It's too easy to say that you have a trading plan, because most of us have a loose definition of entry before trading. However, there is a huge difference between making a plan and sticking to it.

I know you may have made the same mistake before. You often change plans at the last minute, so you buy too early or sell too late.

You need to set standards. When the market appears in one way or another, you must abide by clearly defined rules. Every professional has a trading plan - they follow it faithfully.

So it's time for us to think like professionals. It's time to make a trading plan. The trading plan can help you focus on the key points in all transactions.

After making the plan, I want you to print it and paste it in the place where you do most of the transactions. It needs to be in the obvious sight. When the market meets the threshold in any of these plans, what you need to do is execute.

Writing down the plan and putting it in front of you will make it more difficult to ignore.

Attention: Sometimes, it is also helpful to go through some sort of fire drill-like training. For example, I often ask myself, "If the market crashes now, what will I do?" - If the answer is "Nothing," then continue what I am doing. If the answer is "I will never recover", please reconsider your method.

2. Integrate your portfolio

Browse your portfolio and separate currencies with long-term potential from currencies without long-term potential.

This is a bear market. The ship may not have started to sink officially, but it will definitely go through a rough process.

Any extra weight will make you sink faster.

Henry, a trader with seven years of stock trading experience and digital currency trading experience, told me about his trading plan in the case of a sharp decline in the market.

"Reduce your weight. In a bull market, hold your position and stick to it. In a bull market, the investment target you choose is not important - the market rises, everyone is a winner, but some people win more than others."

Because in such a market, everything is changing. You are taking risks with real money. If you don't act quickly, you will lose them.

Henry stressed how important it is to take decisive action when the market falls. Not acting in a timely manner results in everything coming to naught.

Even look at currencies that you think have potential in the long run.

Ask yourself, is the risk worth it? Because if you exit, put your money into a better investment target or you really believe that you can resist the risk of price collapse.

Henry is very good at his major!

ACTION: Add this to your trading plan list, list all your currencies and their priorities. When the market collapses, where will you start to cut investment or loss?

3. Reduce the noise

You need to stay away from the nonsense of those warlocks and bullshitters.

Of the 19 professional traders I spoke with, all 19 emphasized this point.

Long-term profit means positioning yourself in front or behind the crowd. Never be in the crowd. Stay away from chat rooms and trading forums. Each of these groups has his own motives.

Many people spend their time in discussions like Slack, Reddit, Telegram, Facebook, and Discord... The list continues. You need to keep a distance from these groups. There are too many wrong messages spread, which will lead you to make hasty decisions and buy and sell too early.

Your only job as a trader is to observe charts and make judgments. To make accurate judgments, it is not necessary to collect as much data as possible. Only obtain quality information, which need not be too much, but must be correct.

What kind of information is quality information? Some traders suggest joining VIP groups. These are closely connected communities, and they hope to share their views and conduct better transactions as a group.

ACTION: Question your source of information. Ask yourself - is this information necessary? Do I focus on the sources of information that really help my trading actions? If not, delete them.

4. Build your "star team"

The suggestion comes from Sparky, a trader from Sweden. Sparky is 43 years old. He has a wife and two children. Due to family reasons, his trading time is limited. So he came up with an ingenious solution.

Sparky has a small team of five traders. Each of them subscribed to 2-3 main sources of information. Every day, they study these resources and send the best data back to Sparky, which is everyone's mission.

Only the best of the information is shared.

Sparky made five times better trading decisions therefore.

It's not difficult to start!

ACTION: Go out and socialize, find a few people who make trades, and those you trust. Start group chat on Facebook Messenger or any platform you like. Each of you should study 2 - 3 reliable sources. Team members should study their sources of information every day and pass it on to only one member of the team. Don't share it with everyone. Only focus on the sources that are critical to the transaction decision.

5. Titan's tools

"Give a man a fish, and you feed him for a day. Teach a man to fish, and you feed him for a lifetime." - but you can't effectively "teach" when you don't even have a fishing rod.

Let me introduce some good "fishing rods" and help you install them. Here are some useful trading tools I found when talking with professional traders.

- Trading View (Pro)

TradeingView is a very good platform that can apply almost all content related to digital currency transactions.

This tool will take you to a new level of experience. One of the best functions is the split screen function.

The software supports up to four independent and fully interactive price charts in any window. You can control each screen, each indicator, and each chart separately.

TradingView is like a task control center, controlling every currency you have as you like.

- signalgroups.com

We have all experienced that the price warning sounded at 4am. You are bullish on the market, but the price has been falling all night, and you're about to reach the stop-loss. Your price warning sounded, but you didn't wake up. In the morning, the price is deep red, and you are in a completely unprotected state. If this has not happened to you, I promise you that it will happen.

This is where Signal made by Signalgroups.com can be used. You can stop profit or loss at the same time. Therefore, you can take a rest without having to pay attention to the price in front of the computer all day.

If you take your transaction seriously, you must be prepared for this feature.

- FMZ.com

The best digital currency quantitative trading platform in the world. Now that you have read this article, I need not say more.

To put it in a nutshell...

Trading is a stressful job - I'm sure you don't need me to tell you. But when you properly arm yourself with the best skills in trading, you will dominate.

I hope these suggestions can help you - here are some key points I extracted from the sharing of these 19 traders:

1. Develop a trading plan: prepare for every possibility and always have a strategy for closing your positions.

2. Choose your currency wisely: invest in the currencies that can make profits only, and reduce the currencies that cannot make profits.

3. Reduce noise: Be suspicious of the masses, which will affect your thinking and make it more tempting to make unreasonable decisions.

4. Build a star team: find the traders you trust and let you know the situation in time.

5. Use professional tools: these and your careful attention will be the biggest improvement in your trading career.

From: https://blog.mathquant.c...al-currency-trading.html

Create a Bitcoin trading robot that won't lose money

2024-04-18T05:08:53Z

Let's use reinforcement learning in AI to build a digital currency trading robot.

In this article, we will create and apply an enhanced learning frame number to learn how to make a Bitcoin trading robot. In this tutorial, we will use the gym of OpenAI and the PPO robot from the stable-baselines library, which is a branch of the OpenAI baseline library.

Thank you very much for the open source software provided by OpenAI and DeepMind for the researchers of deep learning in the past few years. If you haven't seen their amazing achievements with AlphaGo, OpenAI Five, AlphaStar and other technologies, you may have been living in isolation last year, but you should check them out.
https://stocksharp.com/file/150389

AlphaStar training: https://deepmind.com/blo...tegy-game-starcraft-ii/

Although we will not create anything impressive, it is still not easy to trade Bitcoin robots in daily transactions. However, as Teddy Roosevelt once said,

There is no value in anything that is too simple.

Therefore, not only should we learn to trade ourselves, but also let robots trade for us.

Plan

1. Create a gym environment for our robot to perform machine learning

2. Render a simple and elegant visual environment

3. Train our robot to learn a profitable trading strategy

If you are not familiar with how to create gym environments from scratch, or how to simply render the visualization of these environments. Before continuing, please feel free to google an article of this kind. These two actions will not be difficult for even the most junior programmers.

Getting Started
In this tutorial, we will use the Kaggle dataset generated by Zielak. If you want to download the source code, it will be provided in my Github repository, along with the .csv data file. Ok, let's start.

First, let's import all the necessary libraries. Make sure to use pip to install any libraries you are missing.
```
import gym
import pandas as pd
import numpy as np
from gym import spaces
from sklearn import preprocessing
```
Next, let's create our class for the environment. We need to pass in a Pandas data frame number and an optional initial_balance and a lookback_indow_size, which will indicate the number of past time steps observed by the robot in each step. We default the commission of each transaction to 0.075%, that is, the current exchange rate of Bitmex, and default the serial parameter to false, which means that our data frame number will be traversed by random fragments by default.

We also call dropna() and reset_index() on the data, first delete the row with NaN value, and then reset the index of frame number, because we have deleted the data.
```
class BitcoinTradingEnv(gym.Env):
"""A Bitcoin trading environment for OpenAI gym"""
metadata = {'render.modes': ['live', 'file', 'none']}
scaler = preprocessing.MinMaxScaler()
viewer = None
def __init__(self, df, lookback_window_size=50,
commission=0.00075,
initial_balance=10000
serial=False):
super(BitcoinTradingEnv, self).__init__()
self.df = df.dropna().reset_index()
self.lookback_window_size = lookback_window_size
self.initial_balance = initial_balance
self.commission = commission
self.serial = serial
# Actions of the format Buy 1/10, Sell 3/10, Hold, etc.
self.action_space = spaces.MultiDiscrete([3, 10])
# Observes the OHCLV values, net worth, and trade history
self.observation_space = spaces.Box(low=0, high=1, shape=(10, lookback_window_size + 1), dtype=np.float16)
```
Our action_space is represented as a group of 3 options (buy, sell or hold) here and another group of 10 amounts (1/10, 2/10, 3/10, etc.). When we choose to buy, we will buy amount * self.balance word of BTC. For selling, we will sell amount * self.btc_held worth of BTC. Of course, holding will ignore the amount and do nothing.

Our observation_space is defined as a continuous floating point set between 0 and 1, and its shape is (10, lookback_window_size+1). + 1 is used to calculate the current time step. For each time step in the window, we will observe the OHCLV value. Our net worth is equal to the number of BTCs we buy or sell, and the total amount of dollars we spend or receive on these BTCs.

Next, we need to write the reset method to initialize the environment.
```
def reset(self):
self.balance = self.initial_balance
self.net_worth = self.initial_balance
self.btc_held = 0
self._reset_session()
self.account_history = np.repeat([
[self.net_worth],
[0],
[0],
[0],
[0]
], self.lookback_window_size + 1, axis=1)
self.trades = []
return self._next_observation()
```
Here we use self._reset_session and self._next_observation, which we haven't defined yet. Let's define them first.

Trade session
https://stocksharp.com/file/150390

An important part of our environment is the concept of trading sessions. If we deploy this robot outside the market, we may never run it for more than a few months at a time. For this reason, we will limit the number of consecutive frames in self.df, which is the number of frames that our robot can see at one time.

In our _reset_session method, we reset the current_step to 0 first. Next, we will set steps_left to a random number between 1 to MAX_TRADING_SESSIONS, which we will define at the top of the program.
```
MAX_TRADING_SESSION = 100000 ＃ ~2 months
```
Next, if we want to traverse the number of frames consecutively, we must set it to traverse the entire number of frames, otherwise we set frame_start to a random point in self.df and create a new data frame named active_df, which is just a slice of self.df and it's getting from frame_start to frame_start + steps_left.
```
def _reset_session(self):
self.current_step = 0
if self.serial:
self.steps_left = len(self.df) - self.lookback_window_size - 1
self.frame_start = self.lookback_window_size
else:
self.steps_left = np.random.randint(1, MAX_TRADING_SESSION)
self.frame_start = np.random.randint(self.lookback_window_size, len(self.df) - self.steps_left)
self.active_df = self.df[self.frame_start - self.lookback_window_size:self.frame_start + self.steps_left]
```
An important side effect of traversing the number of data frames in the random slice is that our robot will have more unique data for use in long-term training. For example, if we only traverse the number of data frames in a serial way (that is, from 0 to len(df)), we will only have as many unique data points as the number of data frames. Our observation space can only use a discrete number of states at each time step.

However, by traversing the slices of the data set randomly, we can create a more meaningful set of trading results for each time step in the initial data set, that is, the combination of trading behavior and price behavior seen previously to create more unique data sets. Let me give an example to explain.

When the time step after resetting the serial environment is 10, our robot will always run in the data set at the same time, and there are three options after each time step: buy, sell or hold. For each of the three options, you need another option: 10%, 20%, ... or 100% of the specific implementation amount. This means that our robot may encounter one of the 10 states of any 103, a total of 1030 cases.

Now back to our random slicing environment. When the time step is 10, our robot may be in any len(df) time step within the number of data frames. Assuming that the same choice is made after each time step, it means that the robot can experience the unique state of any len(df) to the 30th power in the same 10 time steps.

Although this may bring considerable noise to large data sets, I believe that robots should be allowed to learn more from our limited data. We will still traverse our test data in a serial way to obtain the freshest and seemingly 'real-time' data, in order to obtain a more accurate understanding through the effectiveness of the algorithm.

Observed through the eyes of a robot
Through effective visual environment observation, it is often helpful to understand the type of functions that our robot will use. For example, here is the visualization of observable space rendered using OpenCV.

Observation of OpenCV visualization environment

Each line in the image represents a row in our observation_space. The first four lines of red lines with similar frequencies represent OHCL data, and the orange and yellow dots directly below represent trading volume. The fluctuating blue bar below represents the net value of the robot, while the lighter bar below represents the transaction of the robot.

If you observe carefully, you can even make a candle map yourself. Below the trading volume bar is a Morse code interface, displaying the trading history. It seems that our robot should be able to learn sufficiently from the data in our observation_space, so let's continue. Here, we will define the _next_observation method, we scale the observed data from 0 to 1.

- It is important to extend only the data observed by the robot so far to prevent leading deviation.
```
def _next_observation(self):
end = self.current_step + self.lookback_window_size + 1
obs = np.array([
self.active_df['Open'].values[self.current_step:end],
self.active_df['High'].values[self.current_step:end],
self.active_df['Low'].values[self.current_step:end],
self.active_df['Close'].values[self.current_step:end],
self.active_df['Volume_(BTC)'].values[self.current_step:end],])
scaled_history = self.scaler.fit_transform(self.account_history)
obs = np.append(obs, scaled_history[:, -(self.lookback_window_size + 1):], axis=0)
return obs
```
Take action
We have established our observation space, and now it is time to write our ladder function, and then take the robot's scheduled action. Whenever self.steps_left == 0 for our current trading session, we will sell our BTC and call _reset_session(). Otherwise, we will set reward to the current net value. If we run out of funds, we will set done to True.
```
def step(self, action):
current_price = self._get_current_price() + 0.01
self._take_action(action, current_price)
self.steps_left -= 1
self.current_step += 1
if self.steps_left == 0:
self.balance += self.btc_held * current_price
self.btc_held = 0
self._reset_session()
obs = self._next_observation()
reward = self.net_worth
done = self.net_worth <= 0
return obs, reward, done, {}
```
Taking trading action is as simple as getting current_price, determining the actions to be executed and the quantity to buy or sell. Let's quickly write _take_action so that we can test our environment.
```
def _take_action(self, action, current_price):
action_type = action[0]
amount = action[1] / 10
btc_bought = 0
btc_sold = 0
cost = 0
sales = 0
if action_type < 1:
btc_bought = self.balance / current_price * amount
cost = btc_bought * current_price * (1 + self.commission)
self.btc_held += btc_bought
self.balance -= cost
elif action_type < 2:
btc_sold = self.btc_held * amount
sales = btc_sold * current_price * (1 - self.commission)
self.btc_held -= btc_sold
self.balance += sales
```
Finally, in the same method, we will attach the transaction to self.trades and update our net value and account history.
```
if btc_sold > 0 or btc_bought > 0:
self.trades.append({
'step': self.frame_start+self.current_step,
'amount': btc_sold if btc_sold > 0 else btc_bought,
'total': sales if btc_sold > 0 else cost,
'type': "sell" if btc_sold > 0 else "buy"
})
self.net_worth = self.balance + self.btc_held * current_price
self.account_history = np.append(self.account_history, [
[self.net_worth],
[btc_bought],
[cost],
[btc_sold],
[sales]
], axis=1)
```
Our robot can start a new environment now, complete the environment gradually, and take actions that affect the environment. It's time to watch the trade.

Watch our robot trade

Our rendering method can be as simple as calling print (self.net_word), but it is not interesting enough. Instead, we will draw a simple candle chart, which contains a separate chart of the trading volume column and our net worth.

We will get the code in StockTrackingGraph.py from my last article and redesign it to adapt to the Bitcoin environment. You can get the code from my Github.

The first change we need to make is to update self.df ['Date '] to self.df ['Timestamp'] and delete all calls to date2num, because our date is already in unix timestamp format. Next, in our rendering method, we will update the date tag to print human-readable dates instead of numbers.
```
from datetime import datetime
```
First, import the datetime library, and then we will use utcfromtimestampmethod to obtain the UTC string from each timestamp and strftime so that it is formatted as a string: Y-m-d H:M format.
```
date_labels = np.array([datetime.utcfromtimestamp(x).strftime('%Y-%m-%d %H:%M') for x in self.df['Timestamp'].values[step_range]])
```
Finally, we will change self. df['Volume '] to self. df['Volume_ (BTC)'] to match our dataset. After completing these, we are ready. Back to our BitcoinTradingEnv, we can write rendering methods to display the chart now.
```
def render(self, mode='human', **kwargs):
if mode == 'human':
if self.viewer == None:
self.viewer = BitcoinTradingGraph(self.df,
kwargs.get('title', None))
self.viewer.render(self.frame_start + self.current_step,
self.net_worth,
self.trades,
window_size=self.lookback_window_size)
```
We can watch our robots trade Bitcoin now.

Visualize our robot trading with Matplotlib

The green phantom label represents the buying of BTC, and the red phantom label represents the selling. The white label in the upper right corner is the current net value of the robot, and the label in the lower right corner is the current price of Bitcoin. It's simple and elegant. Now, it's time to train our robots and see how much money we can make!

Training time
One of the criticisms I received in the previous article was lack of cross-validation and the failure to divide the data into training sets and test sets. The purpose of this is to test the accuracy of the final model on new data that has never been seen before. Although this is not the focus of that article, it is really very important. Because we use time series data, we don't have many choices in cross validation.

For example, a common form of cross-validation is called k-fold validation. In this validation, you divide the data into k equal groups, one by one, individually, as the test group and use the rest of the data as the training group. However, time series data are highly dependent on time, which means that subsequent data is highly dependent on previous data. So k-fold will not work, because our robot will learn from future data before trading, which is an unfair advantage.

When applied to time series data, the same flaw applies to most other cross-validation strategies. Therefore, we only need to use a part of the complete data frame number as the training set from the frame number to some arbitrary indexes, and use the rest of the data as the test set.
```
slice_point = int(len(df) - 100000)
train_df = df[:slice_point]
test_df = df[slice_point:]
```
Next, since our environment is only set up to handle a single number of data frames, we will create two environments, one for the training data and one for the test data.
```
train_env = DummyVecEnv([lambda: BitcoinTradingEnv(train_df, commission=0, serial=False)])
test_env = DummyVecEnv([lambda: BitcoinTradingEnv(test_df, commission=0, serial=True)])
```
Now, training our model is as simple as creating a robot using our environment and calling model.learn.
```
model = PPO2(MlpPolicy,
train_env,
verbose=1,
tensorboard_log="./tensorboard/")
model.learn(total_timesteps=50000)
```
Here, we use tensor plates, so we can visualize our tensor flow charts easily and view some quantitative indicators about our robot. For example, the following is the discounted rewards chart of many robots with more than 200,000 time steps:
https://stocksharp.com/file/150393

Wow, it seems that our robot is very profitable! Our best robot can even achieve 1000x balance in 200,000 steps, and the rest will increase at least 30 times on average!

At this time, I realized that there was a mistake in the environment... After fixing the bug, this is the new reward chart:
https://stocksharp.com/file/150392

As you can see, some of our robots are doing well, while others are going bankrupt. However, robots with good performance can reach 10 times or even 60 times the initial balance at most. I must admit that all profitable machines are trained and tested without commission, so it is unrealistic for our robots to make any real money. But at least we found the way!

Let's test our robots in the test environment (using new data they have never seen before) to see how they will behave.
https://stocksharp.com/file/150391

Our well-trained robots will go bankrupt when trading new test data

Obviously, we still have a lot of work to do. By simply switching models to use A2C with stable baseline instead of the current PPO2 robot, we can improve our performance on this data set greatly. Finally, according to Sean O'Gorman's suggestion, we can update our reward function slightly, so that we can add reward to net worth, rather than just realize high net worth and stay there.
```
reward = self.net_worth - prev_net_worth
```
These two changes alone can improve the performance of the test dataset greatly, and as you can see below, we were finally able to profit on new data that were not available in the training set.
https://stocksharp.com/file/150394

But we can do better. In order to improve these results, we need to optimize our super parameters and train our robots for a longer time. It's time for the GPU to start working and firing on all cylinders!

So far, this article has been a little long, and we still have many details to consider, so we plan to take a rest here. In the next article, we will use Bayesian optimization to partition the best hyperparameters for our problem space and prepare for training/testing on GPU using CUDA.

Conclusion
In this article, we begin to use reinforcement learning to create a profitable Bitcoin trading robot from scratch. We can complete the following tasks:

1. Create a Bitcoin trading environment from scratch using OpenAI's gym.

2. Use Matplotlib to build the visualization of the environment.

3. Use simple cross-validation to train and test our robot.

4. Adjust our robots slightly to achieve profits.

Although our trading robot was not as profitable as we had hoped, we are already moving in the right direction. Next time, we will ensure that our robots can consistently beat the market. We will see how our trading robots process real-time data. Please continue to follow my next article and Viva Bitcoin!

From: https://blog.mathquant.c...hat-wont-lose-money.html

From Quantitative Trading to Asset Management - CTA Strategy Development for Absolute Return

2024-04-18T03:37:38Z

Preface
Why should I take this course?
What do you gain from taking this course? First of all, this course is based on JavaScript and Python programming languages. Language is only a technology. Finally, we should apply this technology into an industry. Quantitative trading is an emerging industry, which is currently in a rapid development stage and has a large demand for talents.

Through the systematic learning of this course, you can have a deeper understanding of the field of quantitative trading. If you are a student preparing to enter the field of quantitative trading, it will also help you. If you are a stock or futures investment enthusiast, then quantitative trading can assist your subjective trading. By developing trading strategies, you can gain profits in the financial market, and also broaden the channels and platforms for your investment and financial management.

Before that, let me talk about my personal trading experience. I am not a finance major, I studied statistics. At first, I began to trade stocks subjectively in my school days. Later, I became a quantitative trading practitioner of domestic private equity funds, mainly engaged in strategy research and strategy development.

I have been trading in this circle for more than ten years, and have developed various types of strategies. My investment philosophy is: risk control is above all else and focuses on absolute returns. The topic of our topic is: from quantitative trading to asset management - CTA strategy development for absolute return.

1. Futures CTA strategy money-making logic
1.1 Understanding Futures CTA
Someone may ask what CTA is? What exactly is the CTA? CTA is called commodity trading advisors in foreign countries and investment manager in China. The traditional CTA is to collect the funds of the majority of investors, then entrust them to professional investment institutions, and finally invest in stock index futures, commodity futures, and treasury bond futures through trading advisers (namely CTA).

But in fact, with the continuous development and expansion of the global futures market, the concept of CTA is also expanding, and its scope is far beyond traditional futures. It can invest not only in the futures market, but also in the interest rate market, the stock market, the foreign exchange market and the option market. As long as there is a certain amount of historical data for this variety, it can develop corresponding CTA strategies based on these historical data.

As early as the 1980s, the electronic trading technology was not mature. At that time, most traders judged the future trend of commodity futures by drawing technical indicators manually, such as William index, KDJ, RSI, MACD, CCI, etc. Later, traders set up a special CTA fund to help customers manage assets. It was not until the popularization of electronic trading in the 1980s that the real CTA fund began to appear.

*Changes in CTA fund management size*
https://stocksharp.com/file/150373

In billions of dollars

Let's look at the chart above. Especially with the rise of quantitative trading, the scale of global CTA funds has increased from US $130.6 billion in 2005 to more than US $300 billion in 2015. CTA strategy has also become one of the mainstream investment strategies of global hedge funds.

Rising alongside the size is the performance of CTA funds. Let's look at the Barclays CTA index in the chart below. The Barclay CTA index is a representative industry benchmark for global commodity trading advisers. From the end of 1979 to the end of 2016, the cumulative return of the Barclay CTA Fund Index was up to 28.95 times, the annualized return was 9.59%, the Sharp ratio was 0.37, and the maximum withdrawal was 15.66%.

Because in the asset allocation portfolio, the CTA strategy usually maintains very low correlation with other strategies. As shown in the red circle below, during the global stock bear market from 2000 to 2002 and the global subprime crisis in 2008, the Barclay CTA fund index not only did not fall but also achieved positive returns. When the stock market and bond market were in crisis, CTA could provide strong returns. In addition, we can see that the profit level of the Barclay Commodity CTA Index since 1980 has been stronger than the S&P 500, and the withdrawal is also much lower than the S&P 500.
https://stocksharp.com/file/150375

The development of CTA in China has only been in the past ten years, but the momentum is very strong. This is mostly due to the relatively open trading environment of domestic commodity futures, the low threshold of trading funds, the use of margin system to trade in both long and short positions, the low transaction costs, the more advanced technical structure of the exchange compared with stocks, and the easier system trading.

Since 2010, CTA funds have mainly existed in the form of private funds. With the gradual opening of the investment scope of the fund special account in domestic policies, CTA funds began to exist in the form of fund special account. Its more transparent and open operation mode has also become a necessary tool for more investors to allocate assets.

CTA strategies are also more suitable for individual traders than other trading strategies in terms of ease of entry, capital threshold, execution of trading strategies, and API connectivity. Domestic futures contracts are very small. For example, corn or soybean meal can be traded for thousands of yuan, and there is almost no capital threshold. In addition, because some CTA strategies come from traditional technical analysis, it is relatively easy compared with other strategies.

The design process of CTA strategy is also relatively simple. First, the historical data is processed initially, and then input into the quantitative model. The quantitative model includes the trading strategy formed by mathematical modeling, programming design and other tools, and the trading signal is generated by calculating and analyzing these data. Of course, in actual development, it is not as simple as the above chart. Here we just give you an overall concept.

1.2 Type of futures CTA strategy
From the perspective of trading strategy, CTA strategy is also diversified: it can be a trend strategy or an arbitrage strategy; It can be a large-period medium and long-term strategy, or an intraday short term strategy; The strategy logic can be based on technical analysis or fundamental analysis; It can be a subjective transaction or system transaction.

CTA strategy has different classification methods. According to the transaction method, it can be divided into subjective transaction and system transaction. The development of foreign CTA strategy is relatively advanced, and the CTA strategy of system transaction has been close to 100%. According to the analysis method, it can be divided into basic analysis and technical analysis. According to the source of income, it can be divided into trend trading and oscillatory trading.

In general, the CTA strategy accounts for about 70% of the total trading market, the trend strategy accounts for about 25%, and the counter trend or trend reversal strategy accounts for about 5%. Among them, the trend strategy with the largest proportion can be divided into high-frequency trading, intra-day trading, short- and medium-term trading, and medium- and long-term trading according to the position period.

High-frequency market making strategy
At present, there are two mainstream high-frequency trading strategies on the market: one is high-frequency market making strategy, the other is high-frequency arbitrage strategy. Market making strategy is to provide liquidity in the trading market. That is to say, in the trading market with a market maker, if someone wants to trade, the market maker must ensure that his order can be traded. If there is insufficient liquidity in the market and the order cannot be traded, the market maker must buy or sell the counterparty's order.

High-frequency arbitrage strategy
High frequency arbitrage refers to trading two highly correlated stocks or ETF and ETF portfolio. According to the calculation method of ETF, the expected price of an ETF can be calculated in the same way. The ETF index price may subtract the ETF expected price to get a price difference. Usually, the price difference will run in a price channel. If the price difference breaks through the upper and lower channels, you can trade the price difference, wait for the return of the price difference, and earn income from it.

Intraday strategy
In the literal sense, as long as there is no position overnight, it can be called intra-day trading strategy. Due to the short holding period of intraday trading, it is usually impossible to make profits immediately after entering the market, and then leave the market quickly. Therefore, this trading mode bears low market risk. However, because the market changes rapidly in a short period of time, the intra-day strategy usually has higher requirements for traders.

Medium and long-term strategy
In theory, the longer the holding period is, the greater the strategic capacity and the lower the risk-return ratio will be. Especially in institutional transactions, because of the limited capacity of short-term strategies, large funds cannot enter and exit the market in a short period of time, more long-term strategies will be allocated. Generally, the position period is several days and months, or even longer.

CTA strategy data
Generally speaking, the CTA strategy is studied with minute, hour and daily data, which include: opening price, highest price, lowest price, closing price, trading volume, etc; Only a few CTA strategies will use Tick data, such as buy price, sell price, buy volume, sell volume and other in-depth data in L2 data.

As for the basic idea of CTA strategy, the first thing we think of is based on traditional technical indicators, because there are many public reference materials in this area, and the logic is usually simple, most of which are based on statistical principles. For example, we are familiar with various technical indicators: MA, SMA, EMA, MACD, KDJ, RSI, BOLL, W&R, DMI, ATR, SAR, BIAS, OBV, etc.

There are also some classic trading models on the market, which can also be used for reference and improved, including: multiple moving average combination, DualThrust, R-Breaker, Turtle trading method, grid trading method, etc.

All of these are trading strategies based on traditional technical analysis. The process is to extract factors or trading conditions with probability advantages according to historical data and correct trading concepts, and assume that the market will still have such laws in the future. Finally, the trading strategy is realized by code and fully automatic trading. Open positions, stop profits, stop losses, increase positions, reduce positions, etc., which generally do not require manual intervention. In fact, it is a strategy of buying the winners by using the positive autocorrelation coefficient of the price time series.

The biggest advantage of CTA strategy is that no matter whether the current market is rising or falling, it can obtain absolute returns, especially when the market is rapidly changing, or the market trend is obviously smooth, the advantage of the strategy is obvious, in short, if there is a trend, there is a gain. However, if the market is in a volatile situation or the trend is not obvious, the strategy may buy at a high point and sell at a low point, and stop the loss back and forth.

1.3 Profit principle of futures CTA strategy
The futures CTA strategy is profitable mainly because of the following points:

- 1. There is reflexivity in the price trend, which always continues in the way of trend. When investors observe that the price rises, they will follow the trend and buy, resulting in a further rise in the price. The same is true of price decreasing. Because investors are more irrational, sometimes we can see that the price rises abnormally and falls abnormally.
- 2. Each investor has an asymmetrical tolerance for the ratio of profit to loss and a different tolerance for risk. For most retail investors, they are more inclined to choose a more conservative homeopathic trading method, and the market is also more prone to the trend.
- 3. The formation of the price is determined by the transaction. It is true that the transaction is driven by people, but human nature is difficult to change. This is the reason why the fixed pattern will recur. The strategy is effective in the historical data backtesting, which indicates that it may also be effective in the future.

In addition, the trading feature of trend tracking is to lose a small amount of money when there is no market, and make great fortune when the market comes. However, people who have done trading know that the market is volatile most of the time, and only in a small amount of time is the trend market. Therefore, the trend tracking strategy has a low winning rate in trading, but the overall profit and loss of each transaction is relatively large.

Because the trend tracking strategy is unstable in terms of income, many investment institutions will use multiple varieties and strategies to build a portfolio, which will also be configured with a certain amount of reversal strategies. The reverse strategy is an autocorrelation with a negative coefficient in the time series of prices, i.e., high selling and low taking.

Correlation between CTA and traditional assets
https://stocksharp.com/file/150376

Let's look at the above chart. Theoretically, various strategies with different styles or relatively low correlation will sometimes the same and sometimes different trading signals at the same time when facing various changes in market prices. As multiple return curves overlap each other, the overall return is complementary, and the return curve will become more flat, thus reducing the volatility of returns.

From the above point of view, it can be concluded that it is better to develop multiple moderate sub-strategies than to develop a master strategy. How to control these strategies? Here we can learn from the random forest algorithm in machine learning. The random forest is not an independent algorithm, it is a decision framework containing multiple decision trees. It is equivalent to the parent strategy above the sub-strategy of the decision tree. The substrategy cluster is organized and controlled through the parent strategy.

Next, we need to design a parent strategy. We can evaluate the liquidity, profitability and stability of each variety in the entire commodity futures market to screen out the commodity futures variety portfolio with low volatility of earnings, and then conduct industry neutral screening, further reduce the overall volatility through the industry dispersion of the portfolio, and finally build the actual commodity futures multi-variety portfolio through market value matching for trading.

Each variety can also be configured with multi-parameter strategies, and it can select the parameter combination with good performance in the backtest. When the market trend is obvious, the multi-parameter strategies will generally perform consistently, which is equivalent to adding positions; When the market is in a volatile situation, the performance of multiple sets of parameter strategies will usually be inconsistent, so that they can hedge risks by going long or short, respectively, which is equivalent to reducing positions. This can further reduce the maximum backtest rate of the portfolio, while maintaining the overall rate of return unchanged.

2. Classic futures CTA strategy example

Newton once said: If I see further than others, it is because I stand on the shoulders of giants.

The CTA strategies publicly available on the market include the SMA strategy, the Bollinger band strategy, the turtle trading rules, the momentum strategy, the arbitrage strategy, and so on. Quantitative trading strategies have one characteristic, that is, they will slowly fail once they are made public. But this does not affect us to learn from these strategies and learn from the essence of them, so that we can solve problems on the shoulders of giants.

2.1 Analysis of futures fundamentals (inventory, basis difference, price)

The fundamental analysis does not need to care about the short-term price trend. It is believed that the value will be reflected in the price ultimately. It is more about analyzing the factors behind the price to determine how much the variety is worth. Generally, the top-down analysis method is adopted: from macro factors, variety factors and other factors.
https://stocksharp.com/file/150377

We can see from the above chart that there are many factors that affect commodity prices, and these data are changing constantly. It is beyond the ability of individual retail investors to obtain these huge data, let alone objective analysis.

In fact, the fundamental analysis of commodity futures is not to analyze all the factors. We only need to grasp the core elements of fundamental analysis to find out the rules from the complex information.

Macro factors
Macroeconomic data is complex and changeable. Every day, every moment, there are many economic data published, from national politics, central banks, investment banks, official and unofficial. In addition to the political and economic crisis, macro-analysis is a good material for chatting, but not practical. Peter Lynch, a famous fund management expert in the United States, once said: "I spend no more than 15 minutes on the analysis of the economic situation every year".

Variety factor
In the fundamental analysis, the variety analysis is mainly to analyze premium and discount, supply and demand relationship, commodity inventory, industrial profit, etc. It can be said that mastering the variety factor analysis of commodity futures can judge most of the market trend.

As friends who have done futures know, domestic commodity futures can be simply divided into industrial products and agricultural products. The analysis methods of industrial products and agricultural products are different. We will elaborate on the two aspects of supply and demand. In industrial products, supply is relatively stable. Unless there is a major technological breakthrough, production capacity is unlikely to change significantly in a short period of time. Therefore, the main factor affecting the price of industrial products is demand. The demand for agricultural products is relatively stable. In the long run, the demand for agricultural products changes, but in the short run, the demand for agricultural products tends to be stable, so the main factor affecting the price of agricultural products is supply.

Therefore, according to the laws of economics, it is the relationship between supply and demand that determines the price of goods ultimately. In theory, as long as the data of supply and demand can be obtained, the future price of goods can be determined. For industrial products, the supply data is easy to obtain, but it is difficult to obtain the demand data. For agricultural products, the demand data is easy to obtain, and it is difficult to obtain the supply data.

In fact, we can further subtract. The mutual result of supply and demand in the economic market is inventory. We can judge the strength of the relationship between market supply and demand through inventory data. If the inventory of a commodity is very high, it means that the market supply is greater than the demand, and the commodity price will decrease on the premise that the external conditions remain unchanged. If the inventory of a commodity is very low, it means that the market demand is greater than supply, and the commodity price will increase on the premise that the external conditions remain unchanged.

In addition to analyzing commodity inventory, we also need to analyze the price difference between the spot market and the futures market, which is also called the basis difference. If the futures price is greater than the spot price, we call it the futures premium; If the futures price is less than the spot price, we call it the futures discount. According to the futures delivery system, on the futures delivery date, the futures price should be equal to the spot price.

Regardless of the premium or discount, due to the constraints of the futures delivery system, the futures price on the delivery date should be equal to the spot price in theory. As the delivery date approaches, both the spot price and the futures price will tend to be consistent. One is the return of futures to spot, and the other is the return of spot to futures.

According to the above principle, we can use inventory and basis difference to determine future futures prices at the same time. If the inventory of a commodity is low, and if the futures price is much lower than the spot price, we can judge that the demand of the spot market is greater than the supply, and the probability of the spot price increasing in the future is large; Also due to the futures delivery system, as the delivery date approaches, the futures price will rise, and it will be equal to the spot price. The probability of futures price increasing is greater in the future.

Finally, we judge the probable direction of the future price through the inventory and basis difference, but there is no accurate point of buying and selling, so we need to cooperate with technical analysis to give a clear signal of entry and exit. The structure of the whole fundamental analysis is: low inventory + deep discount + technical analysis long position signal = go long; High inventory + substantial premium + technical analysis short position signal = go short.

2.2 Turtle trading rules
When it comes to trading strategies, we have to talk about the representative turtle trading rules. The turtle trading rule comes from the most famous experiment in the history of trading. Richard Dennis, a commodity speculator, wants to know whether great traders are born or trained. To this end, in 1983, he recruited 13 people and taught them the basic concepts of futures trading, as well as his own trading methods and principles. These students were called "turtles".

In the following four years, the Turtles achieved an average annual compound interest of 80%. Dennis proved that with a simple system and rules, people with little or no trading experience can become excellent traders. However, some turtles sell turtle trading rules on the website for profit. In order to prevent this behavior, two original turtles, Curtis Firth and Arthur Maddock, decided to make the turtle trading rules available to the public free of charge on the website.

After the truth came out, people found that the Turtle trading rules adopted the optimized Donchian channel and used ATR indicators for position management. After decades of historical tests, it has become an easy trading method for ordinary retail investors to make profits. It still works today in some varieties.

Turtle core principles

- Mastering advantages: find a trading strategy with positive expectations, because in the long run, it can create positive returns.
- Manage risk: control risk and hold your position, otherwise you may not wait for a day to make profits.
- Perseverance: Only by unswervingly implementing your strategy, can you truly achieve systematic results.
- Simple and clear: In the long run, simple systems have more vitality than complex systems.

So next, let's see what the Turtle trading rules say.
1. Market - what to buy and sell, essentially in which markets to trade. Turtles are futures traders. They choose the markets with large trading volume and high liquidity only. Because choosing the markets with inactive trading will increase the extra slippage of entry and exit, and will also miss many opportunities of trend.
2. Position size - how much to buy or sell is a very important part of the whole strategy, which is usually ignored or wrongly treated by most people. The Turtle trading rule adopts ATR, that is, the average real volatility index, to calculate the open position, increase position signal and stop loss signal. This is a very ingenious design. The original intention is to adjust the size of the position through the absolute volatility of the market. When the market volatility is strong, reduce the position, and when the market volatility is weak, increase the position. It first defines a unit whose formula is: (total assets * 1%)/ATR. The initial position is 1 unit. Even if the decline of the variety on that day reaches the level of ATR, the loss on that day can be controlled within 1% of the total asset. If the price rises by 0.5 unit, the long position will increase their positions by 1 unit, up to 4 units.
3. Market entry - Turtle's market entry is based on the Donchian channel. When the price rises above the highest price of the first 20 or 55 K lines, it will enter the market to go long. When the price falls below the lowest price of the first 20 or 55 K lines, it will enter the market to go short. When the signal appears, enter the market for trading, without waiting for the close or the next K-line.
4. Stop loss - In the long run, transactions that do not stop loss will not succeed, but most traders are holding loss positions and trying to take chances to hope that the market will turn over. Turtle rules stipulate when to withdraw from the loss position strictly. If you hold long position orders and the price drops by 2 units, the long position is closed with a stop loss. If you hold a short position order and the price rises by 2 units, the short position will be closed with a stop loss.
5. Stop profit - In Turtle rules, stop profit means losing a lot of floating profits, which is also an unacceptable part for many traders. If you currently hold long position orders and the price falls below the track of the Donchian channel of ten days, close all long orders; If the current short position order is held and the price rises above the track of the Donchian channel of ten days, close all short positions.

Thus we can see that although the Turtle trading rules look very simple, in fact it has formed a real sense of the prototype of the trading system. It covers all aspects of a complete trading system, leaving no room for traders to make subjective imaginative decisions, which just makes the advantages of programmed operation of the system play, including: entry and exit rules, fund management and risk control, etc.

The biggest advantage of the turtle trading method is to help us establish a set of effective trading methods. It is a combination of batch opening, dynamic stop profits and stop loss, and the trend following strategy of the market, especially the use of ATR value and the concept of position management, which is very worth learning. Of course, it also has a common problem with trend tracking strategy, that is, floating profit and taking back. It is likely that all the floating profits gained from buying the winners will be taken out due to the following wave of sharp falls. It is very strong in the general trend, and not as good as expected in the volatile market.

3. Develop futures CTA strategy in practice
3.1 Development of CTA trend strategy based on MyLanguage
At the end of the last century, a very amazing trading method began to prevail in the field of financial investment in the United States. After thousands of people's practice, people found that this method has effectiveness and great practical value. At the same time, it has been recognized by many investment experts and professional traders. Until now, it can be applied to almost all financial investment fields perfectly, whether foreign exchange, gold, stocks, futures, crude oil, or index and bond, which is chaos operation method.

The word chaos refers to the description of the chaotic state of the universe originally. Its idea is that the result is inevitable, but because the existing knowledge cannot calculate the result, because the calculation itself is also changing the result, the maximum or minimum result may appear at last, but there is no inevitable result. This is very similar to the trading market. Participants also change the market when they analyze the market and buy and sell. The market has eternal variability. When the participants understand the new form of the market, the market also understands that it is recognized by the participants, so the variation occurs. And it will tend to change in the unknown direction of the participants. It has enough wisdom to prevent the participants from catching its change rules, that is, the market is not stable, and the understanding of the past of the market cannot represent the future.

The chaos operation method is a complete set of investment ideas, trading strategies and entry and exit signals, invented by Bill Williams. At present, many investors in the world adopt chaos operation to participate in market transactions. Because the development of China's financial market lags behind, and chaos theory is also a relatively new idea, there are few people studying chaos operation methods in China. Since chaos operation method is a trading strategy with high universality and can be applied to almost all financial investment fields, including stocks, bonds, futures, foreign exchange, and digital currency, this course uses a simplified version of chaos strategy as a starting point to improve your investment interest and income.

As the name implies, the theoretical basis of chaos operation method is chaos theory, which was proposed by meteorologist Edward Lorenz. It was one of the greatest scientific discoveries at the end of the 20th century. He put forward the famous "butterfly effect". Bill Williams applied chaos theory to the field of financial investment creatively, combined with fractal geometry, nonlinear dynamics and other disciplines, and created a series of very effective technical analysis indicators.

The entire Chaos operation method is composed of five major dimensions (technical indicators):

- Alligator

- The Fractal

- The Momentum

- Acceleration

- The Balance Line
https://stocksharp.com/file/150378

Let's look at the above chart. The Alligator is a set of equilibrium lines using fractal geometry and nonlinear dynamics. Its essence is to extend the exponentially weighted moving average, which is a kind of mean line, but its calculation method is slightly more complicated than the ordinary mean line. Next, let's look at how to define the Alligator in MyLanguage:
```
// Parameters
N1:=11;
N2:=21;

// Defining the price median
N3:=N1+N2;
N4:=N2+N3;
HL:=(H+L)/2;

// Alligator
Y^^SMA(REF(HL,N3),N4,1);
R:=SMA(REF(HL,N2),N3,1);
G:=SMA(REF(HL,N1),N2,1);
```
First, we define 2 external parameters N1 and N2, and then calculate the average HL of the highest price and the lowest price according to the external parameters, and then calculate the average HL with different parameters. For teeth, it is the average of the middle period of the midline, and the jaw is the average of the large period of the midline. In this strategy, we use the jaw.

In the chaos operation method, a fractal concept is defined vividly. We can make an analogy: open the palm of the hand, with the fingers facing up, the middle finger is the upper fractal, the left little finger and the ring finger, and the right index finger and thumb respectively, represent the K-line with no record high. A basic fractal is composed of these five K-lines. Then you can define fractal with the following code:
```
// Fractal
TOP_N:=BARSLAST(REF(H,2)=HHV(H,5))+2;
BOTTOM_N:=BARSLAST(REF(L,2)=LLV(L,5))+2;

TOP:=REF(H,TOP_N);
BOTTOM:=REF(L,BOTTOM_N);

MAX_YRG^^MAX(MAX(Y,R),G);
MIN_YRG^^MIN(MIN(Y,R),G);

TOP_FRACTAL^^VALUEWHEN(H>=MAX_YRG,TOP);
BOTTOM_FRACTAL^^VALUEWHEN(L<=MIN_YRG,BOTTOM);
```
After calculating the alligator and fractal, we can write a simple chaos operation strategy based on these two conditions, and use a group of exponentially weighted moving average lines as the benchmark price for calculating the alligator and fractal index. Of course, the original chaotic operation strategy will be more complex. The code is as follows:
```
// If there are no current long position orders and the closing price rises above the upper fractal and the upper fractal is above the alligator, open a long position.
BKVOL=0 AND C>=TOP_FRACTAL AND TOP_FRACTAL>MAX_YRG,BPK(1);
// If there are no current short position orders and the closing price falls below the lower fractal and the lower fractal is below the alligator, open a short position.
SKVOL=0 AND C<=BOTTOM_FRACTAL AND BOTTOM_FRACTAL<MIN_YRG,SPK(1);

// Long positions are closed if the closing price falls below the jaws of the alligator.
C<Y,SP(BKVOL);
// Short positions are closed if the closing price rises above the jaws of the alligator.
C>Y,BP(SKVOL);
```
For ease of understanding, I wrote the detailed comments into the code directly. We can simply list the trading logic of this strategy as follows:

- Long opening position: if there are no long position orders at present, and the closing price rises below the upper fractal, and the upper fractal is above the alligator.
- Short opening position: if there are no short position orders at present, and the closing price falls below the lower fractal, and the lower fractal is below the alligator.
- Long closing position: if the closing price falls below the alligator chin.
- Short closing position: if the closing price rises above the alligator chin.

Next, let's see what the results of this simple chaos operation strategy backtest actually look like. In order to make the backtest more close to the real market environment, the commission is set to twice the exchange rate, and the opening and closing positions are subject to a sliding point of two jumps each. The backtest data type is the rebar index, and the trading type is the rebar main force continuous, with a fixed 1 lot opening position. The following is the preliminary backtest performance report at the 1-hour level.
https://stocksharp.com/file/150379

From the capital curve and backtest performance data, the strategy performed well, and the overall capital curve was steadily upward. However, since the end of 2016, the market characteristics of rebar varieties have changed, from the unilateral trend of high volatility to the broad volatility trend. From the perspective of capital curve, the profit from 2017 to now is obviously weak.

In a word, the essence of chaos operation method is to find a turning point, without caring about how the market goes or whether it is true or false breakout. If it breaks through the fractal, it will enter the market directly. Never try to predict the market, but be an observer and follower.

3.2 Development of CTA arbitrage strategy based on JavaScript language
George Soros put forward an important proposition in "The Alchemy of Finance" written in 1987: I believe the market prices are always wrong in the sense that they present a biased view of the future. He believed that the market efficiency hypothesis is only a theoretical hypothesis. In fact, market participants are not always rational, and at each time point, participants cannot completely obtain and objectively interpret all information. Moreover, even if it is the same information, everyone's feedback is different. That is to say, the price itself already contains the wrong expectations of market participants, so in essence, the market price is always wrong. This may be the profit source of arbitrageurs.

According to the above principles, we can know that in an ineffective futures market, the reason why the market impact on delivery contracts in different periods is not always synchronous, and the pricing is not completely effective. Then, based on the delivery contract price of the same transaction object in different periods, if there is a large price difference between the two prices, we can buy and sell futures contracts in different periods at the same time for cross-period arbitrage.

Like commodity futures, digital currency also has a cross-period arbitrage contract portfolio. For example, in the OKEX exchange, there are: ETC current week, ETC next week, ETC quarter. For example, suppose that the price difference between the current week of ETC and the quarter of ETC remains around 5 for a long time. If the price difference reaches 7 one day, we expect that the price difference will return to 5 in the future. Then we can sell ETC that week and buy ETC quarter at the same time to go short the price difference, vice versa.

Although this price difference exists, there are many uncertainties in manual arbitrage due to time-consuming manual operations, poor accuracy and the impact of price changes. The charm of quantitative arbitrage lies in capturing arbitrage opportunities through quantitative models and formulating arbitrage trading strategies, as well as placing trading orders automatically to exchanges through programmed algorithms, so as to capture opportunities quickly and accurately and make profits efficiently and stably.

This course will teach you how to use the FMZ Quant Trading Platform and the ETC futures contract in the OKEX exchange to demonstrate how to capture the instantaneous arbitrage opportunities, seize the profits that can be seen every time, and hedge the risks that may be encountered in the digital currency trading with a simple arbitrage strategy.

Create a cross-period arbitrage strategy for digital currency
Difficulty: Normal

Strategy environment

- Transaction object: Ether Classic (ETC)
- Spread data: ETC current week - ETC quarter (omit cointegration test)
- Transaction period: 5 minutes
- Transaction period: 5 minutes
- Transaction type: cross period of the same type

Strategy logic

- Conditions for opening positions with going long the price difference: if the current account has no positions and the price difference is less than the lower bound of the ball, then go long the price difference. That is, buy opening positions ETC for the week, sell opening positions ETC for the quarter.
- Conditions for opening positions with going short the price difference: if there is no position in the current account, and the price difference is greater than the upper bound of the ball, then go short the price difference. That is, sell opening positions ETC for the week, buy opening positions ETC for the quarter.
- Conditions for closing positions with going long the price difference: if the current account holds going long orders of ETC in the current week and holds going short orders of ETC quarter, and the price difference is greater than the middle bound of the ball, then close long the price difference. That is, sell closing positions ETC for the week, buy closing positions ETC for the quarter.
- Conditions for closing positions with going short the price difference: if the current account holds going short orders of ETC in the current week, and holds going long orders of ETC quarter, and the price difference is less than the middle bound of the ball, then close short the price difference. That is, buy closing positions ETC for the week, sell closing positions ETC for the quarter.

The above is a simple logic description of the cross-period arbitrage strategy of digital currency. So how to implement our ideas in the program? We try to build the framework on the FMZ Quant Trading Platform.
```
function Data() {} // Basic data function
Data.prototype.mp = function () {} // Position function
Data.prototype.boll = function () {} // Indicator function
Data.prototype.trade = function () {} // Order placement function
Data.prototype.cancelOrders = function () {} // Order withdrawal function
Data.prototype.isEven = function () {} // Processing single contract function
Data.prototype.drawingChart = function () {} // Drawing function

function onTick() {
var data = new Data(tradeTypeA, tradeTypeB); // Create a basic data object
var accountStocks = data.accountData.Stocks; // Account balance
var boll = data.boll(dataLength, timeCycle); // Calculate the technical indicators of boll
data.trade(); // Calculate trading conditions to place an order
data.cancelOrders(); // Cancel orders
data.drawingChart(boll); // Drawing
data.isEven(); // Processing of holding individual contract
}

//Entry function
function main() {
while (true) { // Enter the polling mode
onTick(); // Execute onTick function
Sleep(500); // Sleep for 0.5 seconds
}
}
```
Imagine what our trading process is like in supervisory trading. There is no essential difference in system transactions. It is nothing more than acquiring data, calculating data, placing an order transaction, and processing after placing an order. The same is true in the program. First, the program will execute the main function in line 20, which is a convention. When the program completes the trading strategy preprocessing (if any), it will enter the infinite loop mode, that is, the polling mode. In the polling mode, the onTick function will be executed repeatedly.

Then in the onTick function, it is our trading process in the subjective transaction: first, obtain the basic price data, then obtain the account balance, then calculate the index, then calculate the trading conditions and place the order, and finally the processing after placing the order, including order cancellation, drawing, and processing a single contract.

The strategy framework can be easily set up according to the strategy idea and transaction process. The whole strategy can be simplified into three steps:

- Pre-processing before transaction.
- Get and calculate data.
- Place an order and deal with it later.

Next, we need to fill in the necessary detail code in the strategy framework according to the actual transaction process and transaction details.

I. Pre-processing before transaction

1. Declare the necessary global variables in the global scope.

- Declare a chart object for the configuration chart
```
var chart = {}
```
- Call Chart function and initialize the chart
```
var ObjChart = Chart ( chart )
```
- Declare an empty array to store price difference series
```
var bars = []
```
- Declare a record history data timestamp variable
```
var oldTime = 0
```
2. Configure the external parameters of the strategy.
```
var tradeTypeA = "this_week"; // Arbitrage A Contract
var tradeTypeB = "quarter"; // Arbitrage B Contract
var dataLength = 10; // Indicator period length
var timeCycle = 1; // K-line period
var name = "ETC"; // Currencies
var unit = 1; // Order quantity
```
3. Define the data processing function

- Basic data function: Data()
Create a constructor, Data, and define its internal properties. Including: account data, position data, K-line data timestamp, buy/sell price of arbitrage A/B contract, and positive/negative arbitrage price difference.
```
function Data(tradeTypeA, tradeTypeB) { // Pass in arbitrage A contract and arbitrage B contract
this.accountData = _C(exchange.GetAccount); // Get account information
this.positionData = _C(exchange.GetPosition); // Get position information
var recordsData = _C(exchange.GetRecords); // Get K-line data
exchange.SetContractType(tradeTypeA); // Subscription arbitrage A contract
var depthDataA = _C(exchange.GetDepth); // Depth data of arbitrage A contract
exchange.SetContractType(tradeTypeB); // Subscription arbitrage B contract
var depthDataB = _C(exchange.GetDepth); // Depth data of arbitrage B contract
this.time = recordsData[recordsData.length - 1].Time; // Time of obtaining the latest data
this.askA = depthDataA.Asks[0].Price; // Sell one price of Arbitrage A contract
this.bidA = depthDataA.Bids[0].Price; // Buy one price of Arbitrage A contract
this.askB = depthDataB.Asks[0].Price; // Sell one price of Arbitrage B contract
this.bidB = depthDataB.Bids[0].Price; // Buy one price of Arbitrage B contract
// Positive arbitrage price differences (Sell one price of contract A - Buy one price of contract B)
this.basb = depthDataA.Asks[0].Price - depthDataB.Bids[0].Price;
// Negative arbitrage price differences (Buy one price of contract A - Sell one price of contract B)
this.sabb = depthDataA.Bids[0].Price - depthDataB.Asks[0].Price;
}
```
- Get the position function: mp ( )
Traverse the entire position array and return the position quantity of the specified contract and direction. If not, return false.
```
Data.prototype.mp = function (tradeType, type) {
var positionData = this.positionData; // Get position information
for (var i = 0; i < positionData.length; i++) {
if (positionData[i].ContractType == tradeType) {
if (positionData[i].Type == type) {
if (positionData[i].Amount > 0) {
return positionData[i].Amount;
}
}
}
}
return false;
}
```
- K-line and indicator function: boll()
A new K-line sequence is synthesized according to the positive arbitrage/negative arbitrage price difference data. The data of upper track, middle track and lower track calculated by the boll indicator are returned.
```
Data.prototype.boll = function (num, timeCycle) {
var self = {}; // Temporary objects
// Median value of positive arbitrage price difference and negative arbitrage price difference
self.Close = (this.basb + this.sabb) / 2;
if (this.timeA == this.timeB) {
self.Time = this.time;
} // Compare two depth data timestamps
if (this.time - oldTime > timeCycle * 60000) {
bars.push(self);
oldTime = this.time;
} // Pass in the price difference data object into the K-line array according to the specified time period
if (bars.length > num * 2) {
bars.shift(); // Control the length of the K-line array
} else {
return;
}
var boll = TA.BOLL(bars, num, 2); // Call the boll indicator in the talib library
return {
up: boll[0][boll[0].length - 1], // boll indicator upper track
middle: boll[1][boll[1].length - 1], // boll indicator middle track
down: boll[2][boll[2].length - 1] // boll indicator down track
} // Return a processed boll indicator data
}
```
- Order function: trade()
Pass in the order contract name and order type, then place the order with consideration, and return the result after placing the order. Since it is necessary to place two orders in different directions at the same time, the buy/sell one price is converted within the function according to the contract name of the order.
```
Data.prototype.trade = function (tradeType, type) {
exchange.SetContractType(tradeType); // Resubscribe to a contract before placing an order
var askPrice, bidPrice;
if (tradeType == tradeTypeA) { // If the order is placed in contract A
askPrice = this.askA; // set askPrice
bidPrice = this.bidA; // set bidPrice
} else if (tradeType == tradeTypeB) { // If the order is placed in contract B
askPrice = this.askB; // set askPrice
bidPrice = this.bidB; // set bidPrice
}
switch (type) { // Match order placement mode
case "buy":
exchange.SetDirection(type); // Set order placement mode
return exchange.Buy(askPrice, unit);
case "sell":
exchange.SetDirection(type); // Set order placement mode
return exchange.Sell(bidPrice, unit);
case "closebuy":
exchange.SetDirection(type); // Set order placement mode
return exchange.Sell(bidPrice, unit);
case "closesell":
exchange.SetDirection(type); // Set order placement mode
return exchange.Buy(askPrice, unit);
default:
return false;
}
}
```
- Cancel Order Function: cancelOrders()
Get an array of all outstanding orders and cancel them one by one. In addition, false is returned if there is an unfilled order, and true is returned if there is no unfilled order.
```
Data.prototype.cancelOrders = function () {
Sleep(500); // Delay before cancellation, because some exchanges, you know what I mean
var orders = _C(exchange.GetOrders); // Get an array of unfilled orders
if (orders.length > 0) { // If there are unfilled orders
for (var i = 0; i < orders.length; i++) { // Iterate through the array of unfilled orders
exchange.CancelOrder(orders[i].Id); // Cancel unfilled orders one by one
Sleep(500); // Delay 0.5 seconds
}
return false; // Return false if an unfilled order is cancelled
}
return true; // Return true if there are no unfilled orders
}
```
- Handle holding a single contract: isEven()
In the case of a single leg in the arbitrage transaction, we will simply close all positions. Of course, it can also be changed to the tracking method.
```
Data.prototype.isEven = function () {
var positionData = this.positionData; // Get position information
var type = null; // Switch position direction
// If the remaining 2 of the position array length is not equal to 0 or the position array length is not equal to 2
if (positionData.length % 2 != 0 || positionData.length != 2) {
for (var i = 0; i < positionData.length; i++) { // Iterate through the position array
if (positionData[i].Type == 0) { // If it is a long order
type = 10; // Set order parameters
} else if (positionData[i].Type == 1) { // If it is a short order
type = -10; // Set order parameters
}
// Close all positions
this.trade(positionData[i].ContractType, type, positionData[i].Amount);
}
}
}
```
- Drawing function: drawingChart ( )
Call ObjChart Add () method, draw the necessary market data and indicator data in the chart: upper track, middle track, lower track, positive/negative arbitrage price difference.
```
Data.prototype.drawingChart = function (boll) {
var nowTime = new Date().getTime();
ObjChart.add([0, [nowTime, boll.up]]);
ObjChart.add([1, [nowTime, boll.middle]]);
ObjChart.add([2, [nowTime, boll.down]]);
ObjChart.add([3, [nowTime, this.basb]]);
ObjChart.add([4, [nowTime, this.sabb]]);
ObjChart.update(chart);
}
```
4. In the entry function main(), execute the pre-transaction pre-processing code, which will only run once after the program is started, including:
- ```SetErrorFilter ( )``` to filter the unimportant information in the console
- ```exchange.IO ( )``` to set the digital currency to be traded
- ```ObjChart.reset ( )``` to clear the previous chart drawn before starting the program
- ```LogProfitReset ( )``` to clear the status bar information before starting the program

After the above pre-transaction pre-processing is defined, the next step is to enter the polling mode and execute the onTick() function repeatedly. It also sets the sleep time for Sleep () polling, because the API of some digital currency exchanges has built-in access limit for a certain period of time.
```
function main() {
// Filter the unimportant information in the console
SetErrorFilter("429|GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout|Futures_OP");
exchange.IO("currency", name + '_USDT'); // Set the digital currency to be traded
ObjChart.reset(); // Clear the previous chart drawn before starting the program
LogProfitReset(); // Clear the status bar information before starting the program
while (true) { // Enter the polling mode
onTick(); // Execute onTick function
Sleep(500); // Sleep for 0.5 seconds
}
}
```
II. Get and calculate data

1. Obtain basic data object, account balance, and boll indicator data for use in the trading logic.
```
function onTick() {
var data = new Data(tradeTypeA, tradeTypeB); // Create a basic data object
var accountStocks = data.accountData.Stocks; // Account balance
var boll = data.boll(dataLength, timeCycle); // Get boll indicator data
if (!boll) return; // Return if there is no boll data
}
```
III. Place an order and handle the follow-up

1. Execute the buying and selling operation according to the above strategic logic. First, judge whether the price and indicator conditions are valid, then judge whether the position conditions are valid, and finally execute the trade () order function.
```
// Explanation of the price difference
// basb = (Sell one price of contract A - Buy one price of contract B)
// sabb = (Buy one price of contract A - Sell one price of contract B)
if (data.sabb > boll.middle && data.sabb < boll.up) { // If sabb is higher than the middle track
if (data.mp(tradeTypeA, 0)) { // Check whether contract A has long orders before placing an order
data.trade(tradeTypeA, "closebuy"); // Contract A closes long position
}
if (data.mp(tradeTypeB, 1)) { // Check whether contract B has short orders before placing an order
data.trade(tradeTypeB, "closesell"); // Contract B closes short position
}
} else if (data.basb < boll.middle && data.basb > boll.down) { // If basb is lower than the middle track
if (data.mp(tradeTypeA, 1)) { // Check whether contract A has short orders before placing an order
data.trade(tradeTypeA, "closesell"); // Contract A closes short position
}
if (data.mp(tradeTypeB, 0)) { // Check whether contract B has long orders before placing an order
data.trade(tradeTypeB, "closebuy"); // Contract B closes long position
}
}
if (accountStocks * Math.max(data.askA, data.askB) > 1) { // If there is balance in the account
if (data.basb < boll.down) { // If basb price difference is lower than the down track
if (!data.mp(tradeTypeA, 0)) { // Check whether contract A has long orders before placing an order
data.trade(tradeTypeA, "buy"); // Contract A opens long position
}
if (!data.mp(tradeTypeB, 1)) { // Check whether contract B has short orders before placing an order
data.trade(tradeTypeB, "sell"); // Contract B opens short position
}
} else if (data.sabb > boll.up) { // If sabb price difference is higher than the upper track
if (!data.mp(tradeTypeA, 1)) { // Check whether contract A has short orders before placing an order
data.trade(tradeTypeA, "sell"); // Contract A opens short position
}
if (!data.mp(tradeTypeB, 0)) { // Check whether contract B has long orders before placing an order
data.trade(tradeTypeB, "buy"); // Contract B opens long position
}
}
}
```
2. After the order is placed, it is necessary to deal with the abnormal situations such as the unsettled order and the holding of a single contract. And draw the chart.
```
data.cancelOrders(); // cancel orders
data.drawingChart(boll); // drawing
data.isEven(); // Handle holding individual contracts
```
As above, we have created a simple cross-period arbitrage strategy of digital currency completely through more than 200 lines code. The complete code is as follows:
```
// Global variable
// Declare a chart object for the configuration chart
var chart = {
__isStock: true,
tooltip: {
xDateFormat: '%Y-%m-%d %H:%M:%S, %A'
},
title: {
text: 'transaction profit and loss curve (detailed)'
},
rangeSelector: {
buttons: [{
type: 'hour',
count: 1,
text: '1h'
}, {
type: 'hour',
count: 2,
text: '3h'
}, {
type: 'hour',
count: 8,
text: '8h'
}, {
type: 'all',
text: 'All'
}],
selected: 0,
inputEnabled: false
},
xAxis: {
type: 'datetime'
},
yAxis: {
title: {
text: 'price difference'
},
opposite: false,
},
series: [{
name: "upper track",
id: "line1,up",
data: []
}, {
name: "middle track",
id: "line2,middle",
data: []
}, {
name: "down track",
id: "line3,down",
data: []
}, {
name: "basb",
id: "line4,basb",
data: []
}, {
name: "sabb",
id: "line5,sabb",
data: []
}]
};
var ObjChart = Chart(chart); // Drawing object
var bars = []; // Storage price difference series
var oldTime = 0; // Record historical data timestamp

// Parameters
var tradeTypeA = "this_week"; // Arbitrage A contract
var tradeTypeB = "quarter"; // Arbitrage B contract
var dataLength = 10; // Indicator period length
var timeCycle = 1; // K-line period
var name = "ETC"; // Currencies
var unit = 1; // Order quantity

// basic data
function Data(tradeTypeA, tradeTypeB) { // Pass in arbitrage A contract and arbitrage B contract
this.accountData = _C(exchange.GetAccount); // Get account information
this.positionData = _C(exchange.GetPosition); // Get position information
var recordsData = _C(exchange.GetRecords); // Get K-line data
exchange.SetContractType(tradeTypeA); // Subscribe to arbitrage A contract
var depthDataA = _C(exchange.GetDepth); // Arbitrage A contract depth data
exchange.SetContractType(tradeTypeB); // Subscribe to arbitrage B contract
var depthDataB = _C(exchange.GetDepth); // Arbitrage B contract depth data
this.time = recordsData[recordsData.length - 1].Time; // Time to get the latest data
this.askA = depthDataA.Asks[0].Price; // Sell one price of arbitrage A contract
this.bidA = depthDataA.Bids[0].Price; // Buy one price of arbitrage A contract
this.askB = depthDataB.Asks[0].Price; // Sell one price of arbitrage B contract
this.bidB = depthDataB.Bids[0].Price; // Buy one price of arbitrage B contract
// Positive arbitrage price difference (Sell one price of contract A - Buy one price of contract B)
this.basb = depthDataA.Asks[0].Price - depthDataB.Bids[0].Price;
// Negative arbitrage price difference (Buy one price of contract A - Sell one price of contract B)
this.sabb = depthDataA.Bids[0].Price - depthDataB.Asks[0].Price;
}

// Get position
Data.prototype.mp = function (tradeType, type) {
var positionData = this.positionData; // Get position information
for (var i = 0; i < positionData.length; i++) {
if (positionData[i].ContractType == tradeType) {
if (positionData[i].Type == type) {
if (positionData[i].Amount > 0) {
return positionData[i].Amount;
}
}
}
}
return false;
}

// Synthesis of new K-line data and boll indicator data
Data.prototype.boll = function (num, timeCycle) {
var self = {}; // Temporary objects
// Median value of between positive arbitrage price difference and negative arbitrage price difference
self.Close = (this.basb + this.sabb) / 2;
if (this.timeA == this.timeB) {
self.Time = this.time;
} // Compare two depth data timestamps
if (this.time - oldTime > timeCycle * 60000) {
bars.push(self);
oldTime = this.time;
} // Pass in the price difference data object into the K-line array according to the specified time period
if (bars.length > num * 2) {
bars.shift(); // Control the length of the K-line array
} else {
return;
}
var boll = TA.BOLL(bars, num, 2); // Call the boll indicator in the talib library
return {
up: boll[0][boll[0].length - 1], // boll indicator upper track
middle: boll[1][boll[1].length - 1], // boll indicator middle track
down: boll[2][boll[2].length - 1] // boll indicator down track
} // Return a processed boll indicator data
}

// Place an order
Data.prototype.trade = function (tradeType, type) {
exchange.SetContractType(tradeType); // Resubscribe to a contract before placing an order
var askPrice, bidPrice;
if (tradeType == tradeTypeA) { // If the order is placed in contract A
askPrice = this.askA; // Set askPrice
bidPrice = this.bidA; // Set bidPrice
} else if (tradeType == tradeTypeB) { // If the order is placed in contract B
askPrice = this.askB; // Set askPrice
bidPrice = this.bidB; // Set bidPrice
}
switch (type) { // Match order placement mode
case "buy":
exchange.SetDirection(type); // Set order placement mode
return exchange.Buy(askPrice, unit);
case "sell":
exchange.SetDirection(type); // Set order placement mode
return exchange.Sell(bidPrice, unit);
case "closebuy":
exchange.SetDirection(type); // Set order placement mode
return exchange.Sell(bidPrice, unit);
case "closesell":
exchange.SetDirection(type); // Set order placement mode
return exchange.Buy(askPrice, unit);
default:
return false;
}
}

// Cancel orders
Data.prototype.cancelOrders = function () {
Sleep(500); // Delay before cancellation, because some exchanges, you know what I mean
var orders = _C(exchange.GetOrders); // Get an array of unfilled orders
if (orders.length > 0) { // If there are unfilled orders
for (var i = 0; i < orders.length; i++) { // Iterate through the array of unfilled orders
exchange.CancelOrder(orders[i].Id); // Cancel unfilled orders one by one
Sleep(500); // Sleep for 0.5 seconds
}
return false; // Return false if an unfilled order is cancelled
}
return true; // Return true if there are no unfilled orders
}

// Handle holding individual contracts
Data.prototype.isEven = function () {
var positionData = this.positionData; // Get position information
var type = null; // Switch position direction
// If the remaining 2 of the position array length is not equal to 0 or the position array length is not equal to 2
if (positionData.length % 2 != 0 || positionData.length != 2) {
for (var i = 0; i < positionData.length; i++) { // Iterate through the position array
if (positionData[i].Type == 0) { // If it is a long order
type = 10; // Set order parameters
} else if (positionData[i].Type == 1) { // If it is a short order
type = -10; // Set order parameters
}
// Close all positions
this.trade(positionData[i].ContractType, type, positionData[i].Amount);
}
}
}

// Drawing
Data.prototype.drawingChart = function (boll) {
var nowTime = new Date().getTime();
ObjChart.add([0, [nowTime, boll.up]]);
ObjChart.add([1, [nowTime, boll.middle]]);
ObjChart.add([2, [nowTime, boll.down]]);
ObjChart.add([3, [nowTime, this.basb]]);
ObjChart.add([4, [nowTime, this.sabb]]);
ObjChart.update(chart);
}

// Trading conditions
function onTick() {
var data = new Data(tradeTypeA, tradeTypeB); // Create a basic data object
var accountStocks = data.accountData.Stocks; // Account balance
var boll = data.boll(dataLength, timeCycle); // Get boll indicator data
if (!boll) return; // Return if there is no boll data
// Explanation of price difference
// basb = (Sell one price of contract A - Buy one price of contract B)
// sabb = (Buy one price of contract A - Sell one price of contract B)
if (data.sabb > boll.middle && data.sabb < boll.up) { // If sabb is higher than the middle track
if (data.mp(tradeTypeA, 0)) { // Check whether contract A has long orders before placing an order
data.trade(tradeTypeA, "closebuy"); // Contract A closes long position
}
if (data.mp(tradeTypeB, 1)) { // Check whether contract B has short orders before placing an order
data.trade(tradeTypeB, "closesell"); // Contract B closes short position
}
} else if (data.basb < boll.middle && data.basb > boll.down) { // If basb is lower than the middle track
if (data.mp(tradeTypeA, 1)) { // Check whether contract A has short orders before placing an order
data.trade(tradeTypeA, "closesell"); // Contract A closes short position
}
if (data.mp(tradeTypeB, 0)) { // Check whether contract B has long orders before placing an order
data.trade(tradeTypeB, "closebuy"); // Contract B closes long position
}
}
if (accountStocks * Math.max(data.askA, data.askB) > 1) { // If there is a balance in the account
if (data.basb < boll.down) { // If basb price difference is lower than the down track
if (!data.mp(tradeTypeA, 0)) { // Check whether contract A has long orders before placing an order
data.trade(tradeTypeA, "buy"); // Contract A opens long position
}
if (!data.mp(tradeTypeB, 1)) { // Check whether contract B has short orders before placing an order
data.trade(tradeTypeB, "sell"); // Contract B opens short position
}
} else if (data.sabb > boll.up) { // If sabb price difference is higher than the upper track
if (!data.mp(tradeTypeA, 1)) { // Check whether contract A has short orders before placing an order
data.trade(tradeTypeA, "sell"); // Contract A opens short position
}
if (!data.mp(tradeTypeB, 0)) { // Check whether contract B has long orders before placing an order
data.trade(tradeTypeB, "buy"); // Contract B opens long position
}
}
}
data.cancelOrders(); // Cancel orders
data.drawingChart(boll); // Drawing
data.isEven(); // Handle holding individual contracts
}

// Entry function
function main() {
// Filter unimportant information in the console
SetErrorFilter("429|GetRecords:|GetOrders:|GetDepth:|GetAccount|:Buy|Sell|timeout|Futures_OP");
exchange.IO("currency", name + '_USDT'); //Set the digital currency to be traded
ObjChart.reset(); // Clear the previous chart drawn before starting the program
LogProfitReset(); // Clear the status bar information before starting the program
while (true) { // Enter polling mode
onTick(); // Execute the onTick function
Sleep(500); // Sleep for 0.5 seconds
}
}
```
Arbitrage trading originated from the stock trading strategy of Morgan Stanley. Its idea is that the price difference of two highly correlated varieties conforms to the "popcorn process", that is, the price difference keeps returning to the mean from a position that deviates from the historical mean, and then deviates again from the mean.

Therefore, we can buy low and sell high on the price difference to gain profits. Then, according to the principle of standard deviation in statistics, the Bollinger band is formed by a middle track and the upper and lower tracks calculated by the standard deviation, the formation of three mesh band, which are very practical in the price difference arbitrage transaction.

After testing, operating according to this strategy, the overall income is relatively stable, although the income is not very much each time without considering the handling fee and impact cost. It should be noted that due to the statistical arbitrage, there is a risk of reverse expansion of the price difference. We must consider the stop-loss problem when designing. Secondly, we also need to pay attention to the impact cost. When the liquidity of the two contracts involved in the transaction shrinks, it will have a great impact on the income, and investors should avoid it as appropriate.

4. Advanced iteration of CTA strategy development
4.1 Avoid the pitfalls of futures CTA strategy

In the last two classes, we wrote a trend strategy in MyLanguage and an arbitrage strategy in JavaScript. We didn't see any problems in the strategy backtest. However, quantitative trading is not a program, whose backtest can be done directly without any problems.

In fact, the backtest is only a simulation of the strategy. It is only used to evaluate the performance of the strategy in the historical data. It allows traders to evaluate and discard some trading strategies quickly.

In many cases, strategies that look great in the backtest often fail to meet the backtest standard in the real market for a variety of reasons. Some of them are beyond the control of traders, but some of the failures are caused by common or potential errors.

Static data and dynamic data
We should have a concept of static data and dynamic data to quantify first. In the backtest, we use static historical data. The price of opening high and closing low with each K-line is complete, and each transaction signal can be closed 100%. But the data in the real market is dynamic. For example, if the maximum price is greater than the maximum price within 1 hour of opening, buy. But if the current K-line has not finished, the maximum price is dynamic, and the trading signal may flicker back and forth. This situation indicates that the strategy uses the future function in judging the conditions of the buy and sell trading.

Future function
What is the future function? Let's take a look at Baidu Encyclopedia's explanation first: A quantity depends on another quantity, such as quantity A and quantity B. If B changes, A changes, then A is a function of B. If B is a later quantity, A is an earlier quantity, A changes with B, and A is a future function of B. You may be confused.

Generally speaking, it is a function of quoting future data, such as forecasting tomorrow's price with tomorrow's price. If a technical indicator contains a future function, its signal is uncertain. It is often the current transaction signal. When the next K-line appears, the signal disappears or changes position.

The closing price is a future function. The closing price is always changing until the latest K-line runs out. You must wait until the K-line runs out to determine the closing price. Since the closing price itself is a future function, all technical indicators based on the closing price are also future functions.

Therefore, if a technical indicator uses the confirmed closing price as the basic data, the trading signal will not change no matter how long it has passed, it can be said that the technical indicator does not refer to the future function. But the basic data it uses is the unconfirmed closing price, so this technical indicator refers to the future function, and the trading signal may change in practical application.

Past prices
The future function uses the future price, which may also use the past price on the contrary. This is also a problem that many novices tend to ignore. To better illustrate this problem in the future, let's take an example: if the current maximum price is greater than the maximum price within 1 hour after the opening, buy at the opening price. Obviously, there is no problem with the conditions of the buying and selling signal, but the price of the order has used the past price.

In the backtest, the strategy is normal, because the backtest engine based on static data can be closed 100% only if there is a buy signal. However, when the highest price is greater than the highest price within 1 hour after the opening, it is certain that the order cannot be issued at the previous price opening price.

Price vacuum
The so-called price vacuum refers to the prices displayed on the K-line chart, but the prices that cannot be traded in the real market, mainly divided into the following cases:

- 1. Anyone who has done trading knows that it is difficult to buy when the price is up and difficult to sell when the price is down. But it can be concluded in the backtest.
- 2. The matching mechanism of the exchange is price priority and time priority. Some varieties will often have a large number of orders in the market. If you are trading with orders in the real market, you must rank behind others' orders. You can only trade after others' orders are traded. Even before the price can be traded, the price has changed. However, in the backtest, if your strategy is to deal with the order, you will deal in time, which is different from the real market environment.
- 3. If you use an arbitrage strategy, the profit of the backtest is very high, because it is assumed that you have captured these price differences every time. In reality, many price differentials can't be grabbed, or only one leg can be grabbed. Generally speaking, it must be the one that is not conducive to your direction. Then you need to fill the other leg immediately. At this time, the sliding point is no longer 1 or 2 points, and the arbitrage strategy itself aims to earn the price difference of these points. This situation cannot be simulated in the backtest. The real profit is not as good as the backtest.
- 4. Although the black swan event is not used commonly, it still has a great impact on quantitative trading. As shown in the chart below, in the case of the black swan event of the foreign exchange Swiss franc, both high and low prices can be seen from the chart. In fact, in the extreme market of the day, the middle price is vacuum, and a large number of stop loss orders cause stampede events. The liquidity is zero, and it is very difficult to deal with, but it can stop loss in the backtest.
https://stocksharp.com/file/150381

Overfitting
Overfitting is a common mistake made by quantitative trading beginners. What is overfitting? To take a simple example, some people use a great deal of exercises to memorize each question in the school exam. He can't do it if the subject changes a little during the exam. Because he memorized the practice of each question in a very complex way, he did not abstract the general rules.
https://stocksharp.com/file/150380

Like the chart above, a model can adapt to data perfectly as long as it is complex enough. This is also true of overfitting in quantitative trading. If your strategy is complex and it has many external parameters, there will always be one or several parameters that can perfectly fit the historical market in the limited historical data backtest.

However, in the future real market, the price change may exceed your strategy limit. In fact, the essence of quantitative trading strategy development is the process of matching local non-random data from a large number of seemingly random data. Therefore, we need to use statistical knowledge to avoid the trap. How do we do it?

The compromise solution is to use intra-sample and extra-sample data. Divide the whole data into two parts, and use the intra-sample as the training set, which is responsible for the data backtest. The extra-sample is used as the test set and is responsible for verification. If there is little historical data, you can also use the cross-test method.

If you find that the data out of the sample performs not well, and you feel that it is too bad to lose the model or you are unwilling to admit that your model is not good, and you continue to optimize the model for the extra-sample data until the extra-sample data also perform well, then you must lose your money in the end.

Survivorship bias
The survivorship bias can be explained by the following examples:
1. When standing at the tuyere, pigs will fly.
2. People who sell parachutes online are praised, because people with problems with parachutes don't live anymore.
3. The reporter interviewed whether passengers have bought tickets on the bus, because people without tickets can't get on the bus at all.
4. The media advertises that the lottery can be won, because the media will not actively promote people who do not win the lottery.

In the above example, we can find that the information that people usually receive is actually filtered, which makes a large number of data or samples ignored selectively, and the result is that the conclusions based on survivorship bias have deviated from real-time. So in quantitative trading, we also need to focus on whether the results of the backtest are part of luck. In many cases, the results of the backtest may be the best performance in the whole backtest. Pay attention to the following figure:
https://stocksharp.com/file/150382

- Left chart (semblance): A very good trading strategy. Without major withdrawal, investors can obtain stable investment returns.
- Right chart (the reality): This is only the best one in 200 random trading backtests.

The picture on the left is a very good trading strategy. The capital curve is good, and there is no significant withdrawal, and stable profit returns can be obtained. But look at the picture on the right. It is only the best one in the hundreds of backtest transactions. On the other hand, when we look at the financial market, there are always more stars and less longevity stars. If the strategy of the traders is consistent with the market situation, then the market every year can create a batch of stars, but it is difficult to see longevity stars who can make steady profits for more than three years in a row.

Cost shock
Unless you are pending an order, you may have a sliding price when trading. On the varieties with active trading, the bid-price and ask-price are usually different in one point. On the varieties with inactive trading, the difference may be greater. Every time you want to take the initiative to close a deal, you need one point difference at least, or even more. However, in the backtest, we do not need to consider the issue of transaction, as long as there is a signal, we can trade, so in order to simulate the real trading environment, we must add one sliding price at least.

Especially for the strategy that is traded more frequently, if the sliding price is not added when the strategy is backtested, the capital curve will always tilt upward, and once the reasonable sliding price is added, it will turn to a loss immediately. In addition, this phenomenon is not only caused by point difference, but also needs to be considered in the real trading environment: network delay, software and hardware systems, server response and other issues.

Strategy capacity
The same strategy will be quite different in efficient and inefficient markets, even the opposite. For example, in inefficient markets such as domestic stock markets, commodity futures, and foreign digital currencies, due to the small base of trading volume, the capacity of high-frequency strategy itself is not very large, and there is no profit space for more people, and even the strategy that was originally profitable has become a loss. But in an efficient foreign exchange market, it can accommodate many different types of high-frequency strategies.

The above are the problems and pitfalls that may occur in the development and use of strategies. For an experienced trading system developer, backtesting is a must. Because it can tell you whether a strategic idea can be verified in historical transactions. But many times, backtesting does not mean that it will be profitable in the future. Because there are too many pitfalls in the backtest, you won't understand without paying for some lessons. This course can help you avoid many quantitative detours and pitfalls at least.

4.2 Establish the best position management
In "Reminiscences of a stock operator", there is a very interesting paragraph: the Old Turkey (formerly known as Partridge) who is in the same securities company as the hero Livermore, always makes a big deal. When he was advised to sell after taking profits and buy again after the stock price had retraced. The Old Turkey always intoned: No, you know, this is a bull market!

Even Livermore sighed finally: There is nothing remarkable about the trend. There are always many people who are bullish in the bull market and bearish in the bear market. But they are always good at bargaining with the market, trying to buy at the lowest point and sell at the highest point. Like the Old Turkey, it is those who see the market and hold their positions that really make a great fortune, which is also the most difficult to learn. This not only faces the choice of target and timing, but also faces a more important question: how much position (risk) should we hold (bear)?

All failed traders have one-sided thinking. When trading, greedy people only see profits rather than risks, while timid people only see risks rather than profits. Greedy and timid people forget risks when rising, and forget profits when falling. However, successful traders will consider both risks and returns, that is to say, they will bear several dollars of risk for every dollar they earn. Then the index to measure return and risk is the return risk ratio.

Many people know that the risk is as big as the profit, that is, the return is proportional to the risk. In the view of some people, the relationship between return and risk should be as follows: the horizontal axis is the percentage of risk, and the vertical axis is the percentage of return:
https://stocksharp.com/file/150387

But in the actual transaction, the return and risk are far from being as simple as two points of a line, at least it doesn't always move linearly. The real risk is the maximum amount of loss that can be taken with the expected return, or what we call the maximum volatility. Although sometimes the maximum floating loss does not always equal the closing loss in terms of the outcome of the trade, the maximum floating loss is real.

From this, we can know that the ratio of return to risk in the figure above is not the real performance. In a real trading environment, the ratio of return to risk should be the same as in the chart below:
https://stocksharp.com/file/150388

Let's look at the chart above. The yellow curve shows the fluctuation of net worth at different risks. With the expected returns expanding, the risks are also expanding gradually. If we set bankruptcy at 0.5, that is, the maximum loss reaches 50%, then this is a failed trading strategy. Although the final return of the strategy is positive from the result, it has already gone bankrupt in the middle.

Even if your strategy is a positive one, it will be liquidations under the wrong position management. So from this point of view, how much to buy and sell is more important than when to buy and sell. How to manage the position scientifically has become a fundamental issue in financial transactions. So before trying to solve this problem, let's see how to bet scientifically in gambling.
https://stocksharp.com/file/150386

Let's take the coin toss as an example. Suppose that both sides of a coin are equally weighted. If there is a head profit of 2 yuan and a tail loss of 1 yuan, it is obvious that this is a positive expectation game. The winning rate is 50% and a loss of 2. Here comes the question: Now that you have 100 yuan, how can you repeat the bet so that 100 yuan can reach 1 million yuan at the fastest speed.

If we don't think carefully, we will think that since the return of each bet is 50% * 2-50% * 1, that is, 50%, then in order to achieve the maximum return quickly, we should invest as much capital as possible in each bet. This bet must be 100%.

However, it is obvious that it is unreasonable to invest 100% of the principal in every game of gambling, because as long as you lose the principal once, it will be lost, even if it is very unlikely. Because as long as you gamble enough times, losing money will happen definitely.

Someone may ask, since 100% bet is unreasonable, what about 90% or lower bet? In fact, to solve this problem, we can make an experiment to simulate the gambling game and see how the result of each bet is. As shown in the following chart:
https://stocksharp.com/file/150384

From the chart, we can see that when we gradually reduce the position from 90%, 80%, 70%, 60% and 50%, in the same gamble, the results are completely different. Careful friends may have noticed that with the gradual reduction of the position, the final capital is expanding gradually.

Then some people may ask whether the smaller the bet each time is, the better, such as 10%. It is impossible to calculate every bet proportion. This is the problem to be solved by the famous Kelly Criterion. In statistics, Kelly Criterion can maximize the long-term growth rate of a strategy with positive expectation of repeated bets, and it can calculate the best bet ratio in each bet.

Not only that, assuming that the principal and the bet can be divided endlessly, it is impossible to go bankrupt in any bet by using the Kelly Criterion. Especially in the practical application of financial transactions, it is a position management strategy with both attack and defense. Let's look at how Kelly Criterion is calculated, and see the following figure:
https://stocksharp.com/file/150383

- f is the optimal betting ratio for the available capital;
- b is the odds ratio, which can also be called the profit/loss ratio in trading;
- p is the success rate;
- q is the failure rate.

Then we can calculate the gambling example in this lesson according to the Kelly Criterion. The initial capital of 100 yuan can reach 1 million yuan at the fastest speed by using the betting ratio when the winning ratio is 50% and the odds is 2. Set into the Kelly Criterion, the calculation process is as follows:

(0.5*(2+1) -1)/2=0.25

The winning rate of 50% is 0.5. Multiply the odds by 2 plus 1, then subtract 1, and then divide by 2. The calculation result is 0.25. That is to say, in each bet, using 25% of the principal, you can reach 1 million yuan at the fastest speed. We can simulate manually according to the calculation results to see if it is correct.
https://stocksharp.com/file/150385

The figure above is the result of manual simulation. Please see the last line. In the same bet, after more than 100 rounds, 25% of the positions reached 1 million yuan first. The result of 90%, 80%, 70% and 60% positions is negative, which shows that even a positive expectation trading strategy will go bankrupt under the wrong position management.

We can also see that 50% of the positions will not lose or win in the end, which is also consistent with the result of the law of large numbers. In order to further illustrate the problem, a position of 10% was also added in the manual simulation. Although the final result was a positive return, the effect was several orders of magnitude worse than that of a position of 25%.

You can see the power of Kelly Criterion. If you choose 10% of the principal position in the actual application, your principal will become more than 30,000 in more than 100 bets. Although the return is large, compared with 25% of the principal position, it is equivalent to no profit. This is the power of knowledge.

If you want to make profits from Kelly Criterion in life, you need to meet the application conditions of Kelly Criterion. There is no doubt that this bet must come from the financial market. Especially in quantitative trading, we can roughly calculate the corresponding winning ratio and odds through historical data backtesting.

Of course, the practical application of Kelly Criterion in financial transactions cannot be so simple, and there are many details to be dealt with, such as the cost of capital in leveraged transactions, the capital and position in real transactions can not be divided wirelessly, and the winning ratio and loss ratio in transactions are changing dynamically, and so on. Whatever, Kelly Criterion shows us how to establish the best position management method.

From: https://blog.mathquant.c...for-absolute-return.html

9 trading rules help a trader earn $46,000 from $1,000 in less than a year

2024-04-18T02:45:58Z

No, I am not a successful trader. I have been lucky many times, and I am still refining and trying strategies; On the other hand, I am still one of the people who constantly trade to increase the profit of the portfolio. Although some results can be attributed to luck, most of them are based on fundamentals, good habits and experience.

The result of good habits
Miles is the co-founder of Pure Investments. In May 2017, he began with $1,000, which he saved by saving 10% of his salary every month. Today, his income is $46,000; In other words, he increased his portfolio by 46 times in less than one year.

Similarly, after starting Pure Investments in September 2017, Miles accepted his first community member, who was nicknamed "SP" on the Discord channel. When SP started trading, it invested $40,000. By January 2018, his investment income had exceeded $1 million.

Although the cryptocurrency market price is extremely volatile, and all investors are affected by price fluctuations, including Miles, SP, me and you, good habits will help reduce losses and maximize profits.

9 cryptocurrency trading rules
Please note that these are not specific investment suggestions. Please bear your own investment risk!

1. Only invest in what you can lose. During the price collapse in January 2018, many amateur investors were cleaned out of the market. Their funny performance is that the ground is full of broken monitors, the balance in laptops and bank accounts has shrunk significantly. Although sequential trading steps and methods are important, there is no doubt that the principles behind these trading steps and methods are more important. Once your funds are converted into cryptocurrency, by default that the money has been lost. The market can never guarantee that you can take it back. The loss is not only from the decline of the market; External factors such as hackers, loopholes and government regulation may mean that you will never see any part of the funds again. If you can't afford to lose when investing, you need to step back and reassess your current financial situation, because what you will do will be accompanied by despair. This includes: using credit cards, mortgages, applying for loans, selling everything and traveling around the world (which sounds fascinating).

2. Always pay attention to Bitcoin. Most Altcoins (every cryptocurrency except Bitcoin) are more closely related to Bitcoin than Asian currencies and the US dollar during the Asian financial crisis. If the price of Bitcoin rises sharply, people will try to exit the Altcoins to gain BTC profits, and the price of Altcoins will decrease; On the contrary, if the price of Bitcoin decreases sharply, the price of Altcoins will also decrease, because people withdraw from Altcoins to exchange for fiat currency. When Bitcoin shows a sideways shock or fall, the best period for the growth of Altcoins will appear.

3. Do not put all the eggs in one basket. Investment needs diversification. Although the amount you invest in digital currency increases the potential to earn more profits, the possibility of losing more will also be magnified. Another way of thinking is to take the cryptocurrency market as a whole; If you think this is just the beginning, the entire market value of cryptocurrency will increase. What is the probability that the market value increase will be driven by one currency rather than many currencies? The best way to safely capture the overall growth of cryptocurrencies is to diversify and benefit from multiple currencies. In addition, the interesting fact is that from January 2016 to January 2018, Corgicoin increased by 60,000 times and Verge increased by 13,000 times. Over the same period, Bitcoin has increased 34 times. Although you will get impressive benefits from Bitcoin, expanding to other currencies may give you greater benefits.

4. Don't be greedy. It is human nature to have losses and gains. When a currency begins to grow, our inner greed follows. If a currency increases by 30%, why not consider profits? Even if the target is set at 40% or 50%, if a currency fails to meet the target, you should get some profits from it at least. If you wait too long or try to exit at a higher point, you may lose the profits you have earned, or even turn profits into losses. If you want to continue to gain potential profits, form the habit of stopping profits and looking for re-entering the market.

5. Don't invest blindly. Some people in the world will sell a pair of glasses to a blind person without limit, as long as the business can bring him profits. Such people also exist in the cryptocurrency market, and they will take every opportunity to deceive investors with little knowledge. They will tell you what to buy or claim that some currencies will decrease, just to raise or depress the price so that they can cash out. Due to the highly speculative nature of today's cryptocurrency market, an excellent investor must always conduct his own research in order to take full responsibility or potential investment results. Even if the information comes from the best investors, it is only a good information at best, but it is by no means a commitment, so you can still incur losses.

6. Don't worry about profits and losses. This is where people often lose money. A typical case of manipulation in December, the joint speculation of the two media, the announcement of the Chicago Mercantile Exchange and the Chicago Options Exchange, and a large number of news pushed the price of Bitcoin from $10,000 to $20,000. Since then, Bitcoin has fallen to a low of $9,000, and is currently about $11,000. It's easy to go back and say, "If I only waited for one month, I could buy it at the price of $9,000 instead of waiting for Bitcoin to reach $20,000 again, so that I could make both ends meet." But the reality is that the decision of insatiable greed and blind investment will indeed make Bitcoin reach a record high, but it is also a terrible decision to stand firmly at a high position. In any speculative market, if an investment target blowouts rapidly, it will certainly correct itself - it is only a matter of time. The correction mechanism after excessive speculation almost always follows. Although trying to jump on a train at full speed sounds as exciting as a James Bond movie, I believe most of us agree that if we wait for it at the next station, we may retain some limbs.

7. Classify your investment and try to look at the long line chart. During your research, you will eventually find that you have encountered several different types of currencies. For some of them, you believe they have excellent teams, good vision, amazing publicity and successful implementation records. That's great! Put them into the medium or long-term vision, and then marinate them into delicious bacon. When the price falls, do not consider selling, because anything in the medium-term or long-term portfolio should remain unaffected by the price for a period of time. BNB is a good example of currency that Miles considers a long-term holding. Recently, it has declined by 20% temporarily. In our community, we have witnessed some panic selling to protect profits. A week later, it rose nearly three times in a period of time.

8. Always learn from mistakes. Never wait for a position to close when you are close to liquidation. Always evaluate the market situation and try to find out why it happened. Take this assessment as the basis for your next action, and if you continue to do so, you will know more than before and make more informed decisions. We are all amateurs, and we will lose money in the whole trading process. In his first month of trading, Miles lost from $1,000 to $300. Most of these losses were caused by selling through fear. No one is perfect, no one will win every transaction. Don't let losses discourage you, because the reality is that if you choose to learn from losses, they will make you a better trader.

9. If you are conducting any trading activities, please set a stop loss. For any currency that is not in your medium or long-term holding, always set a stop loss. This is important for several reasons - the most obvious is to reduce your losses. But more importantly, you force yourself to decide the acceptable loss point, and because you now have a reference point, you can measure the effectiveness of your reservation or adjustment of future transactions. Sometimes, during the decline of the market, Altcoins may plummet and can be used to re-enter at a lower price through automatic selling.

10. One extra note: always check the currency code. Code symbols are not universal and may vary from exchange to exchange in rare cases. However, these small probability situations may still turn around and bite you. For example, Bitcoin cash is traded as BCH in some exchanges and BCC in other exchanges. BCC, also the code of BitConnect, recently went bankrupt as a Ponzi scheme. If you think you are buying Bitcoin cash and end up buying BitConnect, you will lose a lot of money.

You don't have to do it alone
Although these rules are by no means the only courses you need, they are definitely a good starting point. But sometimes things are easier said than done. For example, you still have the iron will to resist the sell button when you watch the value of your portfolio plummet. One of the best solutions I have found is to join a like-minded cryptocurrency investor community. Educated digital currency traders and community members will fully support your work and will be with you during the tough times.

From: https://blog.mathquant.c...in-less-than-a-year.html

When FMZ encounters ChatGPT, an attempt to use AI to assist in learning quantitative trading

2024-04-18T02:05:46Z

ChatGPT
ChatGPT has been very popular recently. There are various videos applied to real-world scenarios on the Internet. Let me introduce what ChatGPT is briefly. ChatGPT is a language model developed by OpenAI. Unlike previous AI, ChatGPT has very strong language understanding ability. There are many videos about the introduction, registration and use of ChatGPT on the network. I will not repeat them here.

When FMZ encounters ChatGPT
In the field of quantitative trading learning, beginners have always been very difficult at the entry stage. Because most beginners are based on 0, they lack both grammatical knowledge and thinking logic for code, so they will feel it is very difficult to learn.

OK, the next article is not written by me. Let's show some appetizers.

**part1**
When FMZ encounters ChatGPT, an attempt to use AI to assist in learning quantitative trading

As a beginner, I have been looking for effective ways to learn quantitative trading. After searching online, I found FMZ and ChatGPT. So I decided to try to use them to deepen my understanding of quantitative trading.

First, I learned how to use PINE script to write a trading strategy on FMZ. On this platform, I found templates for various strategies and tested their effects by adjusting parameters. In addition, I also learned how to use the backtesting function to evaluate the returns of the strategy.

Next, I use ChatGPT to get more help. On this platform, I found an AI assistant named Assistant, who can answer my various questions. Through communicating with Assistant, I learned a lot of useful knowledge and got many valuable suggestions.

In the process of using FMZ and ChatGPT, I gained a lot. Not only learned how to write trading strategies, but also gained more knowledge about quantitative trading. I believe that as I continue to learn and practice,

**part2**
I will be able to further improve my trading skills and achieve better returns in the future.

Although using FMZ and ChatGPT can get a lot of help, I also realize that quantitative trading is a continuous learning process. I still have a lot to learn, and I will continue to work hard to improve myself.

In the end, I hope my attempt can help other beginners. If you also want to learn quantitative trading, try FMZ and ChatGPT platforms, which may become powerful assistants for you to learn.

**part3**
Of course, quantitative trading is not an easy task. It requires continuous learning and practice to improve skills. Therefore, I also suggest that you participate in various training courses and community activities, exchange trading experience with professionals, and always staycurious and inquisitive.

In addition, it is also very important to pay attention to risk management. There are many uncertain factors in quantitative trading, so we must set a reasonable stop-loss strategy and select the trading variety and trading period carefully.

**part4**
To sum up, I believe using FMZ and ChatGPT platforms to learn quantitative trading is a good choice. They provide us with rich learning resources and assistance, so that we can grasp knowledge and practice easily. However, we should also remember that learning quantitative trading is a continuous process, and we need to make continuous efforts to achieve greater success in this field.

Ok, I'll start writing again, you can believe it! The above part1 ~ part4 are written by ChatGPT. Let me show some evidence:
https://stocksharp.com/file/150367

When FMZ encounters ChatGPT, an attempt to use AI to assist in learning quantitative trading

As a beginner, I have been looking for effective ways to learn quantitative trading. After searching online, I found FMZ and ChatGPT. So I decided to try to use them to deepen my understanding of quantitative trading.

First, I learned how to use PINE script to write a trading strategy on FMZ. On this platform, I found templates for various strategies and tested their effects by adjusting parameters. In addition, I also learned how to use the backtesting function to evaluate the returns of the strategy.

Next, I use ChatGPT to get more help. On this platform, I found an AI assistant named Assistant, who can answer my various questions. Through communicating with Assistant, I learned a lot of useful knowledge and got many valuable suggestions.

In the process of using FMZ and ChatGPT, I gained a lot. Not only learned how to write trading strategies, but also gained more knowledge about quantitative trading. I believe that as I continue to learn and practice,

Go on:
https://stocksharp.com/file/150367

I will be able to further improve my trading skills and achieve better returns in the future.

Although using FMZ and ChatGPT can get a lot of help, I also realize that quantitative trading is a continuous learning process. I still have a lot to learn, and I will continue to work hard to improve myself.

In the end, I hope my attempt can help other beginners. If you also want to learn quantitative trading, try FMZ and ChatGPT platforms, which may become powerful assistants for you to learn.

Go on:
https://stocksharp.com/file/150367

Of course, quantitative trading is not an easy task. It requires continuous learning and practice to improve skills. Therefore, I also suggest that you participate in various training courses and community activities, exchange trading experience with professionals, and always stay curious and inquisitive.

In addition, it is also very important to pay attention to risk management. There are many uncertain factors in quantitative trading, so we must set a reasonable stop-loss strategy and select the trading variety and trading period carefully.

To sum up, I believe using FMZ and ChatGPT platforms to learn quantitative trading is a good choice.

Let's start the topic again.

Let AI write a strategy for me
If I am an introductory learner of the PINE language on the FMZ platform with 0 basics, I can put forward a simple requirement for ChatGPT to see if AI can help me write code:

Propose requirements:

Can you use the PINE script to write a double EMA strategy for me? The moving average index of different periods is that the up cross is to open long positions, the down cross is to open short positions, and the stop loss is 100 points. And give me the complete PINE script strategy. Use version control code://@ version=4
https://stocksharp.com/file/150367

Certainly. This is an example of using PINE script to write a double EMA strategy, starting with version control code://@ version=4
https://stocksharp.com/file/150368

In this code, we first set two parameters that can be adjusted: long-term average period and short-term average period. Then, we calculate the two moving averages and use the statement to determine whether there is an up cross or a down cross. If an up cross occurs, go long; if a down cross occurs, go short. Finally, we set a stop loss point. If the price falls below the stop loss point, the position will be closed.

Note: This is only an example, and it does not guarantee that the strategy will yield good returns. Risk should be carefully considered when using any trading strategy.

```
// @version=4
strategy("double EMA strategy", overlay=true)

longTerm = input(title="long-term average period", type=input.integer, defval=200)
shortTerm = input(title="short-term average period", type=input.integer, defval=50)
stopLoss = input(title="stop loss point", type=input.integer, defval=100)

longMA = sma(close, longTerm)
shortMA = sma(close, shortTerm)

if (shortMA > longMA)
strategy.entry("go long", strategy.long)
if (shortMA < longMA)
strategy.entry("go short", strategy.short)

strategy.exit("stop loss", "go long", stop=strategy.position_avg_price - stopLoss)
strategy.exit("stop loss", "go short", stop=strategy.position_avg_price + stopLoss)
```
It wrote the code out. Let me run it on the FMZ platform backtest system!
https://stocksharp.com/file/150369
https://stocksharp.com/file/150370

PINE script is running!

Next, let ChatGPT help us explain the strategy, which can also help us learn about quantitative trading.

Ask the question:
```
strategy("test", overlay = true)

varip a = na
varip highPrice = na
varip isTrade = false
varip offset = 30

if not barstate.ishistory and not isTrade
strategy.entry("test 1", strategy.long, 1)
strategy.exit("exit 1", "test 1", 1, trail_price=close+offset, trail_offset=offset)
a := close + offset
runtime.log("The price per point is:", syminfo.mintick, ", current close:", close)
isTrade := true

if close > a and not barstate.ishistory
highPrice := na(highPrice) ? close : highPrice
highPrice := close > highPrice ? close : highPrice

plot(a, "trail_price trigger line")
plot(strategy.position_size>0 ? highPrice : na, "current highest price")
plot(strategy.position_size>0 ? highPrice-syminfo.mintick*offset : na, "moving stop loss trigger line")

Can you explain the detailed logic of this script?
```
Screenshots:
https://stocksharp.com/file/150372
https://stocksharp.com/file/150367
https://stocksharp.com/file/150371

It can get the meaning of this script and summarize it. I am wondering if there is a quantitative trading researcher answering my question behind this page...

Imperfections
Of course, ChatGPT is not perfect yet. For example, when communicating with it in Chinese, it often breaks off. It needs to continue with the dialogue of "continue to speak". For some questions that it doesn't know very well, it will talk nonsense with you. We need to combine search engines to determine the answers given, and we can't blindly believe it. However, ChatGPT is still very helpful for quantitative trading learning on FMZ. It can help us understand the code that is difficult to understand. At least it can give us some hints and inspiration, so that we know what to learn. It can also help us write some simple code prototypes, give some basic solutions and code implementation. There should be more advanced methods. We can continue to explore in the future. We hope that ChatGPT will become more and more powerful and help more quantitative trading beginners get started easily.

I hope that there will no longer be "from getting started to giving up" in the study of quantitative trading in the future!

From: https://blog.mathquant.c...uantitative-trading.html

Elegant and simple! Accessed Uniswap V3 on FMZ with 200 lines of code

2024-04-17T06:31:43Z

With the popularity of Defi concept in recent years, Uniswap V3 is one of the most popular topics in the field of decentralized finance (DeFi). As a leading decentralized swap protocol, Uniswap V3 provides a more efficient, safer and better user experience. Now, with only 200 lines of code, traders and developers can access Uniswap V3 on the FMZ platform easily.

FMZ is a quantitative trading platform that supports the development, backtesting and real market deployment of quantitative trading strategies. Its easy-to-use interface and powerful functions are not difficult to understand why FMZ is becoming the first choice of DeFi traders and developers.

The process of integrating Uniswap V3 into FMZ is simple and easy to understand, requiring only 200 lines of code to complete. This means that even if you are new to code, you can easily connect to Uniswap V3 on FMZ and start trading immediately.

FMZ has encapsulated a series of web3 basic functions. Besides Uniswap, it can also encapsulate other DEX exchanges with few codes. Next, let me take you to learn the concepts and technologies in defi application from scratch. Due to the space, the following description is as simple as possible. It may not be very precise, but it is easy to understand.

[Uniswap V3 Trade Template](https://www.fmz.com/strategy/397260) disclosed by FMZ platform

The code is as follows:
```
/* jshint esversion: 7 */

const ABI_Route = '[{"inputs":[{"internalType":"address","name":"_factoryV2","type":"address"},{"internalType":"address","name":"factoryV3","type":"address"},{"internalType":"address","name":"_positionManager","type":"address"},{"internalType":"address","name":"_WETH9","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"WETH9","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveMax","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveMaxMinusOne","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveZeroThenMax","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveZeroThenMaxMinusOne","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"callPositionManager","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"paths","type":"bytes[]"},{"internalType":"uint128[]","name":"amounts","type":"uint128[]"},{"internalType":"uint24","name":"maximumTickDivergence","type":"uint24"},{"internalType":"uint32","name":"secondsAgo","type":"uint32"}],"name":"checkOracleSlippage","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint24","name":"maximumTickDivergence","type":"uint24"},{"internalType":"uint32","name":"secondsAgo","type":"uint32"}],"name":"checkOracleSlippage","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactInputParams","name":"params","type":"tuple"}],"name":"exactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IV3SwapRouter.ExactInputSingleParams","name":"params","type":"tuple"}],"name":"exactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IV3SwapRouter.ExactOutputSingleParams","name":"params","type":"tuple"}],"name":"exactOutputSingle","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getApprovalType","outputs":[{"internalType":"enum IApproveAndCall.ApprovalType","name":"","type":"uint8"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"}],"internalType":"struct IApproveAndCall.IncreaseLiquidityParams","name":"params","type":"tuple"}],"name":"increaseLiquidity","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"internalType":"struct IApproveAndCall.MintParams","name":"params","type":"tuple"}],"name":"mint","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"previousBlockhash","type":"bytes32"},{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"positionManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"pull","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"refundETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowed","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowedIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"swapExactTokensForTokens","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMax","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"swapTokensForExactTokens","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"sweepTokenWithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"sweepTokenWithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"unwrapWETH9","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"}],"name":"unwrapWETH9","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"unwrapWETH9WithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"unwrapWETH9WithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"wrapETH","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]';
const ABI_Pool = '[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Burn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"name\":\"Collect\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"name\":\"CollectProtocol\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paid0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paid1\",\"type\":\"uint256\"}],\"name\":\"Flash\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"observationCardinalityNextOld\",\"type\":\"uint16\"},{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"observationCardinalityNextNew\",\"type\":\"uint16\"}],\"name\":\"IncreaseObservationCardinalityNext\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"}],\"name\":\"Initialize\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol0Old\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol1Old\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol0New\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"feeProtocol1New\",\"type\":\"uint8\"}],\"name\":\"SetFeeProtocol\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"amount0\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"amount1\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"liquidity\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"}],\"name\":\"Swap\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount0Requested\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1Requested\",\"type\":\"uint128\"}],\"name\":\"collect\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount0Requested\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1Requested\",\"type\":\"uint128\"}],\"name\":\"collectProtocol\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fee\",\"outputs\":[{\"internalType\":\"uint24\",\"name\":\"\",\"type\":\"uint24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeGrowthGlobal0X128\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeGrowthGlobal1X128\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"flash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"observationCardinalityNext\",\"type\":\"uint16\"}],\"name\":\"increaseObservationCardinalityNext\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"liquidity\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxLiquidityPerTick\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"observations\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"blockTimestamp\",\"type\":\"uint32\"},{\"internalType\":\"int56\",\"name\":\"tickCumulative\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityCumulativeX128\",\"type\":\"uint160\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32[]\",\"name\":\"secondsAgos\",\"type\":\"uint32[]\"}],\"name\":\"observe\",\"outputs\":[{\"internalType\":\"int56[]\",\"name\":\"tickCumulatives\",\"type\":\"int56[]\"},{\"internalType\":\"uint160[]\",\"name\":\"secondsPerLiquidityCumulativeX128s\",\"type\":\"uint160[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"positions\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"liquidity\",\"type\":\"uint128\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthInside0LastX128\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthInside1LastX128\",\"type\":\"uint256\"},{\"internalType\":\"uint128\",\"name\":\"tokensOwed0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"tokensOwed1\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"protocolFees\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"token0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"token1\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"feeProtocol0\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"feeProtocol1\",\"type\":\"uint8\"}],\"name\":\"setFeeProtocol\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"slot0\",\"outputs\":[{\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"},{\"internalType\":\"uint16\",\"name\":\"observationIndex\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"observationCardinality\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"observationCardinalityNext\",\"type\":\"uint16\"},{\"internalType\":\"uint8\",\"name\":\"feeProtocol\",\"type\":\"uint8\"},{\"internalType\":\"bool\",\"name\":\"unlocked\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"}],\"name\":\"snapshotCumulativesInside\",\"outputs\":[{\"internalType\":\"int56\",\"name\":\"tickCumulativeInside\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityInsideX128\",\"type\":\"uint160\"},{\"internalType\":\"uint32\",\"name\":\"secondsInside\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"zeroForOne\",\"type\":\"bool\"},{\"internalType\":\"int256\",\"name\":\"amountSpecified\",\"type\":\"int256\"},{\"internalType\":\"uint160\",\"name\":\"sqrtPriceLimitX96\",\"type\":\"uint160\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"swap\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"amount0\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1\",\"type\":\"int256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int16\",\"name\":\"\",\"type\":\"int16\"}],\"name\":\"tickBitmap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tickSpacing\",\"outputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"name\":\"ticks\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"liquidityGross\",\"type\":\"uint128\"},{\"internalType\":\"int128\",\"name\":\"liquidityNet\",\"type\":\"int128\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthOutside0X128\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthOutside1X128\",\"type\":\"uint256\"},{\"internalType\":\"int56\",\"name\":\"tickCumulativeOutside\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityOutsideX128\",\"type\":\"uint160\"},{\"internalType\":\"uint32\",\"name\":\"secondsOutside\",\"type\":\"uint32\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token0\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token1\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]'
const ABI_Factory = '[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"}],\"name\":\"FeeAmountEnabled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnerChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token0\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token1\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"}],\"name\":\"PoolCreated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"},{\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"}],\"name\":\"createPool\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"}],\"name\":\"enableFeeAmount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint24\",\"name\":\"\",\"type\":\"uint24\"}],\"name\":\"feeAmountTickSpacing\",\"outputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint24\",\"name\":\"\",\"type\":\"uint24\"}],\"name\":\"getPool\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parameters\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token1\",\"type\":\"address\"},{\"internalType\":\"uint24\",\"name\":\"fee\",\"type\":\"uint24\"},{\"internalType\":\"int24\",\"name\":\"tickSpacing\",\"type\":\"int24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]'

let ContractV3Factory = "0x1F98431c8aD98523631AE4a59f267346ea31F984"
let ContractV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"

function computePoolPrice(decimals0, decimals1, sqrtPriceX96) {
[decimals0, decimals1, sqrtPriceX96] = [decimals0, decimals1, sqrtPriceX96].map(BigInt);
const TWO = BigInt(2);
const TEN = BigInt(10);
const SIX_TENTH = BigInt(1000000);
const Q192 = (TWO ** BigInt(96)) ** TWO;
return (
Number((sqrtPriceX96 ** TWO * TEN ** decimals0 * SIX_TENTH) / (Q192 * TEN ** decimals1)) /
Number(SIX_TENTH)
);
}

function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}

function toInnerAmount(n, decimals) {
return (BigDecimal(n)*BigDecimal(Math.pow(10,decimals))).toFixed(0)
}

$.NewUniswapV3 = function(e) {
e = e || exchange
if (e.GetName() !== 'Web3') {
panic("only support Web3 exchange")
}

let self = {
tokenInfo: {},
walletAddress: e.IO("address"),
pool: {}
}

// register
e.IO("abi", ContractV3Factory, ABI_Factory)
e.IO("abi", ContractV3SwapRouterV2, ABI_Route)

self.addToken = function(name, address) {
let ret = e.IO("api", address, "decimals")
if (!ret) {
throw "get token decimals failed"
}
let decimals = Number(ret)
self.tokenInfo[name] = {
name: name,
decimals: decimals,
address: address
}
}
self.waitMined = function(tx) {
while (true) {
Sleep(1000)
let info = e.IO("api", "eth", "eth_getTransactionReceipt", tx)
if (info && info.gasUsed) {
return true
}
Log('Transaction not yet mined', tx)
}
}

self.swapToken = function(tokenIn, amountInDecimal, tokenOut, options) {
// options like {gasPrice: 11, gasLimit: 111, nonce: 111}
let tokenInInfo = self.tokenInfo[tokenIn]
let tokenOutInfo = self.tokenInfo[tokenOut]
if (!tokenInInfo) {
throw "not found token info " + tokenIn
}

if (!tokenOutInfo) {
throw "not found token info " + tokenOut
}

let amountIn = toInnerAmount(amountInDecimal, tokenInInfo.decimals)
let recipientAddress = self.walletAddress
if (tokenInInfo.name != 'ETH') {
let allowanceAmount = e.IO("api", tokenInInfo.address, "allowance", self.walletAddress, ContractV3SwapRouterV2);
let realAmount = toAmount(allowanceAmount, tokenInInfo.decimals)
if (realAmount < toAmount(amountIn, tokenInInfo.decimals)) {
Log("realAmount is", realAmount, "too small, try to approve large amount")
if (tokenInInfo.name == 'USDT') {
// As described in Tether code: To change the approve amount you first have to reduce the addresses allowance to 0 calling approve(spender, 0)
let txApprove = e.IO("api", tokenInInfo.address, "approve", ContractV3SwapRouterV2, 0)
if (!txApprove) {
throw "approve error"
}
Log("wait reduce approve", txApprove)
self.waitMined(txApprove)
}

let txApprove = e.IO("api", tokenInInfo.address, "approve", ContractV3SwapRouterV2, '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
if (!txApprove) {
throw "approve error"
}
Log("wait approve", txApprove)
self.waitMined(txApprove)
Log("approve success amountIn", amountIn)
} else {
Log("allowance", realAmount, "no need to approve")
}
}

if (tokenOutInfo.name == 'ETH' || tokenOutInfo.address.toLowerCase() == '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2') {
/*
ADDRESS_THIS https://degencode.substa...m/p/uniswapv3-multicall
https://etherscan.io/add...85e0e4c7bd8665fc45#code
*/
recipientAddress = '0x0000000000000000000000000000000000000002'
}

let swapToken = e.IO("encode", ContractV3SwapRouterV2, "swapExactTokensForTokens", amountIn, 1, [tokenInInfo.address, tokenOutInfo.address], recipientAddress)
let data = [swapToken]
if (tokenOutInfo.name == 'ETH') {
data.push(e.IO("encode", ContractV3SwapRouterV2, "unwrapWETH9(uint256,address)", 1, self.walletAddress))
}
let tx = e.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInInfo.name == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {})
if (tx) {
Log("tx: ", tx)
self.waitMined(tx)
Log("swap", tokenInInfo.name, "to", tokenOutInfo.name, "success")
return true
} else {
Log("trans error")
return false
}
}

self.getETHBalance = function(address) {
return toAmount(e.IO("api", "eth", "eth_getBalance", address || self.walletAddress, "latest"), 18)
}

self.balanceOf = function(token, address) {
let tokenInfo = self.tokenInfo[token]
if (!tokenInfo) {
throw "not found token info " + token
}

return toAmount(e.IO("api", tokenInfo.address, "balanceOf", address || self.walletAddress), tokenInfo.decimals)
}

self.sendETH = function(to, amount, options) {
return e.IO("api", "eth", "send", to, toInnerAmount(amount, 18), options || {})
}

self.getPrice = function(pair) {
let arr = pair.split('_')
let token0 = self.tokenInfo[arr[0]]
if (!token0) {
throw "token " + arr[0] + "not found"
}
let token1 = self.tokenInfo[arr[1]]
if (!token1) {
throw "token " + arr[1] + "not found"
}
let reverse = false
if (BigInt(token0.address) > BigInt(token1.address)) {
let tmp = token0
token0 = token1
token1 = tmp
reverse = true
}
let key = token0.address + '/' + token1.address
if (typeof(self.pool[key]) == 'undefined') {
let pool = e.IO("api", ContractV3Factory, "getPool", token0.address, token1.address, 3000)
if (pool) {
self.pool[key] = pool
// register pool address
e.IO("abi", pool, ABI_Pool)
}
}
if (typeof(self.pool[key]) == 'undefined') {
throw "pool " + pair + " not found"
}

let slot0 = e.IO("api", self.pool[key], "slot0")

if (!slot0) {
return null
}

let price = computePoolPrice(token0.decimals, token1.decimals, slot0.sqrtPriceX96)
if (reverse) {
price = 1 / price
}
return price
}

return self
}

$.testUniswap = function() {
let ex = $.NewUniswapV3()
Log("walletAddress: ", ex.walletAddress)
let tokenAddressMap = {
"ETH": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
"USDT": "0xdac17f958d2ee523a2206206994597c13d831ec7",
"1INCH": "0x111111111117dC0aa78b770fA6A738034120C302",
}
for (let name in tokenAddressMap) {
ex.addToken(name, tokenAddressMap[name])
}

Log(ex.getPrice('ETH_USDT'))
Log(ex.getPrice('1INCH_USDT'))
// swap 0.01 ETH to USDT
Log(ex.swapToken('ETH', 0.01, 'USDT'))
let usdtBalance = ex.balanceOf('USDT')
Log("balance of USDT", usdtBalance)
// swap reverse
Log(ex.swapToken('USDT', usdtBalance, 'ETH'))

Log("balance of ETH", ex.getETHBalance())

// Log(ex.sendETH('0x11111', 0.02))
}
```
Ethereum network
Ethereum network can be understood as a software infrastructure, on which various smart contracts can be deployed and run. Smart contracts have various functions and application scenarios. The devices running the Ethereum client constitute the nodes in the Ethereum network.

Some concepts in Uniswap V3
Students who are not familiar with the ```Uniswap V3``` protocol need to understand a few concepts first. ```Uniswap V3``` is also a smart contract deployed and running on Ethereum.

1. Route: Route is also a smart contract, which is used to manage the exchange of ```token```.
2. Pool: The pool is also a smart contract for storing two kinds of Ethereum tokens and exchanging between these two tokens.
3. Factory contract: A factory contract is a smart contract used to create a pool.
4. ABI: (Application Binary Interface) is a specification that describes how smart contracts communicate with the outside world. It specifies the function name, parameter type and return value type of the smart contract, how to encode and decode data, and determines the external interface of the smart contract. It can be understood that to call an interface, it must be called according to the agreed standards of the interface, and the ABI records a series of agreed standards.

Once the smart contract is deployed on Ethereum, there will be an address.

Analyze the code of Uniswap V3 Trade Template
The Uniswap V3 trading class library code is mainly divided into four parts, which we will explain one by one.

Part 1: Constants used when interacting with Uniswap V3
```
const ABI_Route = '[{"inputs":[{"internalType":"address...
const ABI_Pool = '[{\"inputs\":[],\"stateMutability\":\"nonpayable...
const ABI_Factory = '[{\"inputs\":[],\"stateMutability\":\"...

let ContractV3Factory = "0x1F98431c8aD98523631AE4a59f267346ea31F984"
let ContractV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
```
With the above basic concept preview, it's easy to understand here.

```ABI_Route``` The string stored by this constant is the ABI of the routing smart contract.
```ABI_Pool``` stores the ABI of the pool contract.
```ABI_Factory``` The ABI of the factory contract.

Since these strings are long, they are just excerpts. These contents provide a standard for the program to call the smart contract method (for example, what are the parameters of the smart contract interface, how many parameters, what type are they, and what type of returned data are).

As we mentioned just now, once the smart contract is deployed in Ethereum, there will be an address.

```ContractV3Factory```: The address of the factory contract is recorded.
```ContractV3SwapRouterV2```: The router V2 address of Uniswap V3. Note that Uniswap has V1 and V2. The router of Uniswap V3 also has V1 and V2. Different contract addresses are different.

Part2: Tool functions
1. ```computePoolPrice``` function is used to calculate the price of the token in the pool.
```
function computePoolPrice(decimals0, decimals1, sqrtPriceX96) {
[decimals0, decimals1, sqrtPriceX96] = [decimals0, decimals1, sqrtPriceX96].map(BigInt); // Use the BigInt function for processing. Because of the precision of JavaScript language values, it is necessary to use one of FMZ's underlying processing functions, BigInt, to process.
const TWO = BigInt(2); // Define constant 2 to calculate
const TEN = BigInt(10); // Define constant 10 to calculate
const SIX_TENTH = BigInt(1000000); // Define the 6th power of constant 10, i.e. 1e6
const Q192 = (TWO ** BigInt(96)) ** TWO; // 2^192
return (
Number((sqrtPriceX96 ** TWO * TEN ** decimals0 * SIX_TENTH) / (Q192 * TEN ** decimals1)) /
Number(SIX_TENTH)
);
}
```
If the trading pair is ```ETH_ USDT```, then ```token0``` is ```ETH```, and ```token1``` is ```USDT```. ```decimals0``` is the precision data of ```token0```, and ```decimals1``` is the precision data of ```token1```. ```SqrtPriceX96``` is the price-related data (not the direct price value), which can be obtained from the ```slot0``` method of the pool contract.

sqrtPriceX96 : The current price of the pool as a sqrt(token1/token0) Q64.96 value
Q64.96 is a data processing and storage standard.

These three data ```decimals0```, ```decimals1```, ```sqrtPriceX96``` are passed into the ```computePoolPrice``` function as parameters to calculate the price of the trading pair ```ETH_USDT```. The algorithm in the last ```return``` statement of this function is the process of restoring ```sqrtPriceX96``` to ```token1/token0```. For example, the number of token0 (ETH) in the pool is 1, and the number of token1 (USDT) is 1100. So ```1100/1=1100```, the current price in the ```ETH_USDT``` pool is 1100.

2. ```toAmount``` function is used to convert numeric data in the chain into readable data.

Code

```

function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}

Code

```

To put it simply, for example, an ETH token is 1e18 when the number is represented on the chain, i.e., the 18th power of 10, because the precision data of ETH is 18. Not all tokens have a precision of 18, and the precision of USDT is not the same as that of ETH. The ```toAmount``` function is to convert 1e18 to 1.

3. The ```toInnerAmount``` function is the opposite of the ```toAmount``` function, which converts readable data into values used in the chain.
```
function toInnerAmount(n, decimals) {
return (BigDecimal(n)*BigDecimal(Math.pow(10,decimals))).toFixed(0)
}
```
Next, let's analyze the code of "Uniswap V3 Trade Template".

Part3: Constructor of Uniswap V3 operation object
The core of this template class library is the Uniswap V3 operation object, which implements the basic operations on Uniswap V3. More functions may be upgraded in the future. By analyzing this code example, even if you do not use the FMZ platform, you will increase your knowledge and understanding of the processes and details of each link of Uniswap DEX. Now let's learn how these basic functions are designed and implemented on FMZ.

Constructor code of Uniswap V3 operation object:
```
$.NewUniswapV3 = function(e) {
e = e || exchange // If the parameter e is not passed, the exchange object exchange is used, that is, the first exchange added in the strategy.
if (e.GetName() !== 'Web3') { // Determine if the exchange object is Web3, because this template only supports Web3 exchange objects.
panic("only support Web3 exchange")
}

let self = { // The current function is a constructor, and the constructed object is the object self.
tokenInfo: {}, // Member variable of the self object, used to record the registration information of the token.
walletAddress: e.IO("address"), // Record the address of the wallet to which the current exchange object is bound.
pool: {} // Used to record registered pool information.
}

// register
e.IO("abi", ContractV3Factory, ABI_Factory) // ABI for registered factory contracts
e.IO("abi", ContractV3SwapRouterV2, ABI_Route) // ABI for registered routing contracts

self.addToken = function(name, address) { // Used to register token
let ret = e.IO("api", address, "decimals") // Call the decimals method to get token precision information
if (!ret) {
throw "get token decimals failed"
}
let decimals = Number(ret)
self.tokenInfo[name] = {
name: name,
decimals: decimals,
address: address
}
}
self.waitMined = function(tx) { // It is used to wait for the result of an operation on Ethereum. The hash is a tx parameter.
while (true) {
Sleep(1000)
let info = e.IO("api", "eth", "eth_getTransactionReceipt", tx) // Query results using eth_getTransactionReceipt method, if it's not found, loop to continue query.
if (info && info.gasUsed) {
return true
}
Log('Transaction not yet mined', tx)
}
}

self.swapToken = function(tokenIn, amountInDecimal, tokenOut, options) { // For token exchange
// options like {gasPrice: 11, gasLimit: 111, nonce: 111}
let tokenInInfo = self.tokenInfo[tokenIn] // Get the information of the exchanged token
let tokenOutInfo = self.tokenInfo[tokenOut] // Get the information of the converted token
if (!tokenInInfo) {
throw "not found token info " + tokenIn
}

if (!tokenOutInfo) {
throw "not found token info " + tokenOut
}

let amountIn = toInnerAmount(amountInDecimal, tokenInInfo.decimals) // Convert to data used on smart contracts
let recipientAddress = self.walletAddress
if (tokenInInfo.name != 'ETH') {
let allowanceAmount = e.IO("api", tokenInInfo.address, "allowance", self.walletAddress, ContractV3SwapRouterV2); // Query the number of authorizations
let realAmount = toAmount(allowanceAmount, tokenInInfo.decimals)
if (realAmount < toAmount(amountIn, tokenInInfo.decimals)) { // If the number of licenses is insufficient
Log("realAmount is", realAmount, "too small, try to approve large amount")
if (tokenInInfo.name == 'USDT') {
// As described in Tether code: To change the approve amount you first have to reduce the addresses allowance to 0 calling approve(spender, 0)
let txApprove = e.IO("api", tokenInInfo.address, "approve", ContractV3SwapRouterV2, 0) // If the authorized token is USDT, it needs to be authorized to 0 first.
if (!txApprove) {
throw "approve error"
}
Log("wait reduce approve", txApprove)
self.waitMined(txApprove)
}

let txApprove = e.IO("api", tokenInInfo.address, "approve", ContractV3SwapRouterV2, '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'); // Authorize Router contracts to operate the wallet's tokens
if (!txApprove) {
throw "approve error"
}
Log("wait approve", txApprove)
self.waitMined(txApprove)
Log("approve success amountIn", amountIn)
} else {
Log("allowance", realAmount, "no need to approve")
}
}

if (tokenOutInfo.name == 'ETH' || tokenOutInfo.address.toLowerCase() == '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2') {
/*
ADDRESS_THIS https://degencode.substa...m/p/uniswapv3-multicall
https://etherscan.io/add...85e0e4c7bd8665fc45#code
*/
recipientAddress = '0x0000000000000000000000000000000000000002'
// When exchanging other coins for WETH, you have to let the contract hold WETH before you can redeem it.
}

let swapToken = e.IO("pack", ContractV3SwapRouterV2, "swapExactTokensForTokens", amountIn, 1, [tokenInInfo.address, tokenOutInfo.address], recipientAddress) // Packaged swapExactTokensForTokens to call.
let data = [swapToken]
if (tokenOutInfo.name == 'ETH') { // If the token exchanged back is ETH, which in this case is actually WETH, then it needs to unpack.
data.push(e.IO("pack", ContractV3SwapRouterV2, "unwrapWETH9(uint256,address)", 1, self.walletAddress)) // So here is another unwrapWETH9 unpacking to call
}
let tx = e.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInInfo.name == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {}) // Use multicall to perform these packaged operations (swapExactTokensForTokens, unwrapWETH9)
if (tx) {
Log("tx: ", tx)
self.waitMined(tx)
Log("swap", tokenInInfo.name, "to", tokenOutInfo.name, "success")
return true
} else {
Log("trans error")
return false
}
}

self.getETHBalance = function(address) { // Check your wallet's ETH balance
return toAmount(e.IO("api", "eth", "eth_getBalance", address || self.walletAddress, "latest"), 18)
}

self.balanceOf = function(token, address) { // Query the balance of a token in a wallet (determined by parameters)
let tokenInfo = self.tokenInfo[token]
if (!tokenInfo) {
throw "not found token info " + token
}

return toAmount(e.IO("api", tokenInfo.address, "balanceOf", address || self.walletAddress), tokenInfo.decimals)
}

self.sendETH = function(to, amount, options) { // Sending ETH tokens to an address, i.e. transfer
return e.IO("api", "eth", "send", to, toInnerAmount(amount, 18), options || {})
}

self.getPrice = function(pair, fee) { // Get price of trading pair
let arr = pair.split('_')
let token0 = self.tokenInfo[arr[0]]
if (!token0) {
throw "token " + arr[0] + "not found"
}
let token1 = self.tokenInfo[arr[1]] // First, get the two token information that constitute the trading pair
if (!token1) {
throw "token " + arr[1] + "not found"
}
let reverse = false
if (BigInt(token0.address) > BigInt(token1.address)) {
let tmp = token0
token0 = token1
token1 = tmp
reverse = true
}
let key = token0.address + '/' + token1.address
if (typeof(self.pool[key]) == 'undefined') {
let pool = e.IO("api", ContractV3Factory, "getPool", token0.address, token1.address, typeof(fee) === 'number' ? fee : 3000) // Call the getPool method of the factory contract to obtain the address of the exchange pool
if (pool) {
self.pool[key] = pool // Register the pool address and register the ABI of the pool contract
// register pool address
e.IO("abi", pool, ABI_Pool)
}
}
if (typeof(self.pool[key]) == 'undefined') {
throw "pool " + pair + " not found"
}

let slot0 = e.IO("api", self.pool[key], "slot0") // Call the slot0 method of the pool contract to get price related information

if (!slot0) {
return null
}

let price = computePoolPrice(token0.decimals, token1.decimals, slot0.sqrtPriceX96) // Calculate the readable price
if (reverse) {
price = 1 / price
}
return price
}

return self
}
```
Students who may be not familiar with FMZ see the function ```$.NewUniswapV3``` has a strange name. Functions with ```$``` at the beginning indicates that this function is the interface function of the template class library on FMZ (what is the template class library can be [viewed](https://www.fmz.com/api#template - library), simply put, the ```$. NewUniswapV3``` function can be called by other strategies that reference the **template class library** directly. The strategy has the function of ```Uniswap V3``` directly.

The function ```$.NewUniswapV3``` directly constructs and creates an object, which can be used to perform some operations:

- Token exchange: implemented by the ```swapToken``` method of the object.
- ETH balance query: implemented by the ```getETHBalance``` method of the object.
- Token balance query: implemented by the ```balanceOf``` method of the object.
- Transaction pair price query: implemented by the ```getPrice``` method of the object.
- Send ETH for transfer: implemented by the ```sendETH``` method of the object.

This class library may not be limited to these functions in the future, and may even upgrade and add "add liquidity" and other functions. Let's continue to analyze the code:
```
e = e || exchange
if (e.GetName() !== 'Web3') {
panic("only support Web3 exchange")
}

let self = {
tokenInfo: {},
walletAddress: e.IO("address"),
pool: {}
}

// register
e.IO("abi", ContractV3Factory, ABI_Factory)
e.IO("abi", ContractV3SwapRouterV2, ABI_Route)
```
The constructor ```$.NewUniswapV3``` has only one parameter ```e```, which means the exchange object (the exchange configuration on FMZ). Because the strategy on FMZ can be designed to be multi-exchange, so if a specific exchange is passed here, it means that the ```Uniswap V3``` object created is the one that operates the exchange object. If the parameter ```e``` is not passed, the first added exchange object is operated by default.

Configure the node service address, private key (you can deploy the private key locally, local deployment only uses the configuration path), and an exchange object is created. It can be added to the strategy at the time of the real market, this object is reflected in the strategy code is ```exchange``` also known as ```exchanges[0]```, if you add the second, it's ```exchanges[1]```, add the third for ```exchanges[2]```, ...
https://stocksharp.com/file/150335

The node address I configured in the screenshot: https://mainnet.infura.io/v3/xxx, which is an infura node, which can be applied by individuals. Each account has its own specific address. xxx here is the mask, and the xxx part of each account is different.

Continue with the code. The constructor starts to determine whether the exchange object is Web3, if not, an error will be reported. Then a variable ```self``` is created. The self is the object finally returned by the constructor. Subsequent constructors add various functions to this object and implement specific functions. The variable self has three attributes:

- tokenInfo: records the token information registered in the object, including token address, token precision, and token name.
- walletAddress: the wallet address of the current exchange object.
- pool: the exchange pool information registered in the object, mainly including the name and address of the exchange pool.

Then we use the concept we learned in the previous chapter:
```
e.IO("abi", ContractV3Factory, ABI_Factory) // Register ABI for Uniswap V3 factory contract
e.IO("abi", ContractV3SwapRouterV2, ABI_Route) // Register ABI for Uniswap Router V2 routing
```
Why register this interface information?

Because some functions to be implemented in the future need to call the interfaces of these smart contracts. Next, the constructor adds various methods to the self object. In addition to the above mentioned self object methods: exchange token, query balance, etc., there are also some tool functions belonging to the self object. Let's analyze these tool functions first.

Tool functions for self objects
1. ```self.addToken = function(name, address)```

By observing the specific code of this function, we can see that this function is used to add (in other words, register) a token information to the current object ```self``` in the member ```tokenInfo``` that records ```token``` information. Because the precision data of ```token``` is often used in subsequent calculations, when this function adds (registers) token information, it calls the ```let ret=e.IO ("api", address, "decimals")``` function, and calls the ```"decimals"``` method of token contract through the FMZ encapsulated exchange.IO function (we mentioned that e is the exchange object passed in) to obtain the precision of token.

So ```self. tokenInfo``` is a dictionary structure. Each key name is the token name, and the key value is the token information, including address, name, and precision. It looks like this:
```
{
"ETH": {name: "ETH", decimals: 18, address: "0x..."},
"USDT": {name: "USDT", decimals: 6, address: "0x..."},
...
}
```
2. ```self.waitMined = function(tx)```

This function is used to wait for the execution result of the smart contract on Ethereum. From the implementation code of this function, we can see that this function has been calling ```let info=e.IO ("api", "eth", "eth_getTransactionReceipt", tx)``` in a loop. By calling the RPC method ```eth_ GetTransactionReceipt``` of Ethereum to query the transaction hash and return the transaction receipt. The parameter ```tx``` is the transaction hash.

```eth_ GetTransactionReceipt``` and other relevant data can be viewed at: https://ethereum.org/zh/...h_gettransactionreceipt

Some students may ask: Why do we need this function?

Answer: When performing some operations, such as token exchange, it is necessary to wait for the result.

Next we will look at the other main functions of the object self created by the ```$.NewUniswapV3``` function, we start with the simplest one.

Main function functions
1. ```self.getETHBalance = function(address)```

The query of token balance can be divided into the query of ETH balance and the query of other ERC20 token balance. The getETHBalance function of the self object is used to query the ETH balance. When the specific wallet address parameter address is passed in, the ETH balance of this address is queried. If the address parameter is not passed, then the ETH balance of the ```self.walletAddress``` address (i.e. the wallet configured on the current exchange) is queried.

If the address parameter is not passed, then the ETH balance of the ```self.walletAddress``` address (i.e. the wallet configured on the current exchange) is queried.

These are achieved by calling the RPC method ```eth_getBalance``` of Ethereum.

2. ```self.balanceOf = function(token, address)```

To query the token balance other than ETH, you need to pass in the parameter token, that is, the token name, such as USDT. Pass in the address of the wallet to be queried, and if no address is passed in, query the balance of the address of ```self.walletAddress```. By observing the code implemented by this function, we can see that only the token registered through the ```self.addToken``` function can be queried, because the precision information and address of the token (token) are required when calling the ```balanceOf``` method of the token contract.

3. ```self.sendETH = function(to, amount, options)```

The function of this function is ETH transfer. To transfer a certain amount of ETH to a wallet address (using the parameter ```to``` to set), you can set another ```options``` parameter (data structure: ```{gasPrice: 111, gasLimit: 111, nonce: 111}```) to specify the ```gasLimit/gasPrice/once``` parameter. The system default setting is used without passing in the options parameter.

```GasLimit/gasPrice``` affects the ETH consumed when performing operations on Ethereum (some operations on Ethereum consume gas, that is, certain ETH tokens).

4. ```self.getPrice = function(pair, fee)```

This function is used to obtain the price of a trading pair on Uniswap. You can see from the function implementation code that the trading pair will be parsed at the beginning of the function execution to obtain the baseCurrency and quoteCurrency. For example, the trading pair is ETH_USDT, it will be split into ETH and USDT. Then query whether there are two kinds of token information in ```self.tokenInfo```. If there is no information, an error will be reported.

The exchange pool address on Uniswap is composed of two token addresses and Fee (rate standard) calculations. So when querying the pool address recorded in ```self. tool``` (we have mentioned self.tool before, you can check it), if not found, use the two token addresses and Fee to calculate the pool address. So a trading pair may have multiple pools, because the Fee may be different.

The address of the query and calculation exchange pool is obtained by calling the ```getPool``` method of the factory contract in Uniswap V3 (so you need to register the ABI of the factory contract at the beginning).

Get the pool address of the trading pair, and you can register the ABI of the pool contract. In this way, the ```slot0``` method of this pool (smart contract) can be called to get the price data. Of course, the data returned by this method is not a human-readable price, but a price-related data structure. Further processing is needed to obtain a readable price. At this time, we use the ```computePoolPrice``` function mentioned in the previous section.

5. ```self.swapToken = function(tokenIn, amountInDecimal, tokenOut, options)```

The function of this function is token exchange. The parameter tokenIn is the name of the token paid during exchange, the parameter tokenOut is the name of the token obtained during exchange, and the parameter amountInDecimal is the exchange quantity (human-readable quantity). The parameter options, as we mentioned earlier, can be set for gas consumption, nonce, etc. during exchange.

When the function is executed, the information of token (token) is first obtained from the ```self. tokenInfo``` variable. There are many details of the exchange. First, if the token involved in the exchange is not ETH, then the **routing** (smart contract responsible for exchange) needs to be authorized first. Before authorization, check whether there is enough authorization.
```
let allowanceAmount = e.IO("api", tokenInInfo.address, "allowance", self.walletAddress, ContractV3SwapRouterV2);
```
Use the token contract allowance method to query the authorized amount. By comparing the authorized amount with the current amount of exchange, if the authorized amount is enough to exchange, no authorization is needed. If the amount is insufficient, the authorization processing will be executed.

There is also a detail of authorization here. If the authorized token is a USDT, you need to reset the number of authorization to 0 before authorization. The approve method of the token contract is authorized. Note that the approval authorization method is a gas consumption method, which will consume a certain amount of ETH. So you need to use the self.waitMined function to wait for the processing result.

In order to avoid frequent authorization and pay unnecessary ETH, this authorization operation is the maximum one-time authorization.
```
let txApprove = e.IO("api", tokenInInfo.address, "approve", ContractV3SwapRouterV2, '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
```
With enough exchange limits, you can exchange. However, there are also details here. If the token involved in the exchange, the token obtained after the exchange is ETH, then you need to change the receiving address:
```
recipientAddress = '0x0000000000000000000000000000000000000002'
```
The specific reasons are more complex and are not described here, please refer to:

ADDRESS_THIS https://degencode.substa...m/p/uniswapv3-multicall
https://etherscan.io/add...85e0e4c7bd8665fc45#code

Then use the packaging function ```e.IO("pack", ...```) encapsulated by the FMZ platform to package the swapExactTokensForTokens method call for routing (smart contract). If the token obtained after exchange is ETH, you need to add a step of WETH9 unpacking operation:
```
data.push(e.IO("pack", ContractV3SwapRouterV2, "unwrapWETH9(uint256,address)", 1, self.walletAddress))
```
Because WETH is involved in the exchange. This is a packaged token of ETH. For real ETH, unpacking operation is required. After the unpacking operation is also packaged, the multicast method of routing (smart contract) can be called to perform this series of operations. Here is another detail to pay extra attention to: if the trading pair participating in the exchange, the payment token is ETH, the number of ETH transferred needs to be set in the following steps. If it is not ETH, set 0.
```
let tx = e.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInInfo.name == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {})
```
The setting is reflected here: ```(tokenInInfo. name=='ETH '? AmountIn: 0)```. I did not make it clear before that I did not set 0 when tokenIn was not equal to ETH token, resulting in the wrong transfer of ETH. So be careful when writing the transfer code.

Part4: How to use Uniswap V3 operation objects
The code in this template is actually less than 200 lines in terms of function implementation. The following paragraph is a demonstration of its use.
```
$.testUniswap = function() {
let ex = $.NewUniswapV3()
Log("walletAddress: ", ex.walletAddress)
let tokenAddressMap = {
"ETH": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH
"USDT": "0xdac17f958d2ee523a2206206994597c13d831ec7",
"1INCH": "0x111111111117dC0aa78b770fA6A738034120C302",
}
for (let name in tokenAddressMap) {
ex.addToken(name, tokenAddressMap[name])
}

Log(ex.getPrice('ETH_USDT'))
Log(ex.getPrice('1INCH_USDT'))
// swap 0.01 ETH to USDT
Log(ex.swapToken('ETH', 0.01, 'USDT'))
let usdtBalance = ex.balanceOf('USDT')
Log("balance of USDT", usdtBalance)
// swap reverse
Log(ex.swapToken('USDT', usdtBalance, 'ETH'))

Log("balance of ETH", ex.getETHBalance())

// Log(ex.sendETH('0x11111', 0.02))
}
```
The function ```$. testUniswap=function()``` is only a demonstration. Do not call it without practical use. Let's use this function to see how to use this template class library to operate the function of Uniswap V3.

In the code, execute ```let ex=$. NewUniswapV3()``` to construct a Uniswap V3 operation object first. If you want to get the wallet address bound by the current exchange, you can use ```ex. walletAddress``` to get it. Then, the code uses the ```ex.addToken``` to register three kinds of tokens, namely ETH, USDT and 1INCH.

Print the price of a trading pair (token needs to be registered first):
```
Log(ex.getPrice('ETH_USDT'))
Log(ex.getPrice('1INCH_USDT'))
```
The getPrice function uses the default rate of 3,000 if no Fee is set, which is converted to a readable value of 0.3%.

If you want to convert 0.01 ETH to USDT, then check the balance and then convert back, use the code:
```
Log(ex.swapToken('ETH', 0.01, 'USDT'))

let usdtBalance = ex.balanceOf('USDT') // Check the balance of USDT after exchange
Log("balance of USDT", usdtBalance)

Log(ex.swapToken('USDT', usdtBalance, 'ETH')) // Exchange USDT to ETH
Log("balance of ETH", ex.getETHBalance()) // Check ETH Balance

// Log(ex.sendETH('0x11111', 0.02)) // ETH transfer operations
```
Testing with the test network Goerli
1. Configure the test network exchange object

Note that setting up the node requires setting up the node as a test network Goerli.
https://stocksharp.com/file/150336

2. Write a strategy and test it on the test network Goerli.
```
function main() {
let ex = $.NewUniswapV3()
Log("walletAddress: ", ex.walletAddress)
let tokenAddressMap = {
"ETH" : "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6", // WETH
"LINK" : "0x326C977E6efc84E512bB9C30f76E30c160eD06FB",
"UNI" : "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
}
for (let name in tokenAddressMap) {
ex.addToken(name, tokenAddressMap[name])
}

// ETH_UNI 、 UNI_ETH
Log("ETH_UNI:", ex.getPrice('ETH_UNI'))
Log("UNI_ETH:", ex.getPrice('UNI_ETH'))

// ETH
Log("balance of ETH", ex.getETHBalance())

// UNI
let uniBalance = ex.balanceOf('UNI')
Log("balance of UNI", uniBalance)

// LINK
let linkBalance = ex.balanceOf('LINK')
Log("balance of LINK", linkBalance)

// swap 0.001 ETH to UNI
Log(ex.swapToken('ETH', 0.001, 'UNI'))

// swap UNI to LINK
Log(ex.swapToken('UNI', ex.balanceOf('UNI') - uniBalance, 'LINK'))
}
```
In the test code, we tested the printing of wallet address, registration of token information, printing of asset balance, and a continuous exchange of ```ETH ->UNI ->LINK```. It should be noted that the token address registered here is on the Goorli test network of Ethereum, so the token address with the same name is different. As for the test token, you can use the faucet of this test network to apply for the test token, and the details can be queried by Google.
https://stocksharp.com/file/150337

Note that you must check the "Uniswap V3 Trade Template" to use the ```$. NewUniswapV3()``` function. If your FMZ account does not have this template, you can click [Get here](https://www.fmz.com/strategy/397260).

Asset values displayed on the Uniswap page

https://app.uniswap.org/
https://stocksharp.com/file/150339

These operations can also be queried in the chain:

https://goerli.etherscan.io/
https://stocksharp.com/file/150341

ETH was converted to UNI once, UNI authorization was executed once, and UNI was exchanged to LINK once.

END
There are many functions of this class library that can be extended, and can even be extended to package multiple exchanges to realize ```tokenA ->tokenB ->tokenC``` path exchange. It can be optimized and expanded according to the needs. This kind of library code is mainly for teaching.

Update
The ```swapToken``` function has been upgraded to support ```tokenA ->tokenB ->tokenC... -> TokenD``` continuous exchange function. You can check the latest code of the template published by Strategy Square on FMZ platform.

From: https://blog.mathquant.c...h-200-lines-of-code.html

Build probability thinking to improve your trading pattern

2024-04-17T05:09:12Z

Summary
Trading is both a science and an art. There are many methods in trading, whether it is value investment, technical analysis, event hot spots, arbitrage hedging, etc., which seem logically rigorous on the surface, and it can also be plausible theoretically. But in fact, they often contradict each other. Sometimes, the rigor of science cannot explain the unconstrained nature of art.

Although various trading methods have different starting points, all roads lead to Rome. The advantage of value investment is that it can divide a margin of safety for price fluctuations according to value; The advantage of technical analysis is that the three major assumptions make the transaction scientific.

However, they all have a common feature, that is, the price analysis of the future can only be predicted roughly not accurately. Even if fundamental analysis and technical analysis are combined, the problem of improving "accuracy" cannot be solved, so trading is a probability game from beginning to end.

Probability game
In fact, not only trading is a game of probability. When you cross the road (green light, is it safe to cross the road now?); What kind of friends do you make (is this friend reliable?); What kind of business you are engaged in (is career trading really a good business?), who you marry (will we be happy together?), and so on, are all probability games to evaluate risks and returns. Because we do not have the ability to predict, even if we are more confident about everything, risks always exist, and we cannot achieve 100% certainty.

The important reason why many people make mistakes in trading is that they lack probability thinking and are too emotional rather than rational in trading. Sensibility is actually our primitive instincts. In the market, these primitive instincts can stimulate many weaknesses of people and magnify them exponentially. This is also the reason why most people come to the market and end up with failure.

Reasons for trading failure
Reason 1: Because of human nature
Most people have one weakness: they like to take small advantages but they are afraid of small losses. Once there is a small profit in the market, they will immediately cash out, take profits out; Once there is a loss, they hold on to the loss position and try to get lucky to get back their capital. As a result, small losses accumulate into large losses gradually.

The price will either go up or down, or it will not move. In the long run, the probability of making profits and losing money is about 50% without considering the handling fee and sliding point, so the trading method of most people will become a negative expectation strategy with limited profits and unlimited risks. Their transaction statements should be as follows: small profit >> ... >>small profit >>great loss.

In real life, this is very similar to the thinking of the poor and the rich. The poor are risk-averse and afraid of loss, they like the work of ensuring harvest in drought and flood, and pursue stability. Even if they are not absolutely sure about doing something, they will never do it. On the surface, there seems to be nothing wrong with this, but there are huge opportunity risks behind it.

The rich are more willing to take risks. They know that risks are always proportional to returns. Only risks breed opportunities. They can reasonably evaluate risks and make bold bets when risks are controllable.

Reason 2: Like to make quick money
A foreign organization once made statistics. In the long run, the annualized return on net assets of most industries is difficult to exceed 15%. On the contrary, many retail investors think that they can earn 15% in the market and are embarrassed to say hello to others. People like to make fast money. In action, they are large position trading and short-term trading.

Large position
Large positions, high leverage and capital allocation are very attractive and dangerous. Success leads to success, and failure leads to disaster. If you have a trading strategy with a winning rate of 50%, and a full position plus matching operation, you may win more than ten times in a row if you are lucky. It is also possible for wealth to change from quantitative to qualitative.

However, you only need to make a mistake once, and then you will return to zero. Even if you just take a large position without matching, there is a risk that your account will return to zero, because you cannot guarantee that you will lose more than ten times in the next market. Even large position trading can turn a trading strategy that was expected to be positive into a strategy that is not equal to winning or losing.

Short-term
In the trading world, manual order speculation, intra-day short-term trading and quantitative high-frequency trading have always been very mysterious. I am not suspicious of those who watch the stopwatch to trade, but try to persuade you to give up short-term trading from another perspective.

We can judge whether a method is feasible, not only by those who succeed in these methods, but also by those who fail in these methods. In other words, you can't think that buying lottery tickets is a positive strategy just because some people win the lottery.

In addition, look at the list of private placement products. How many of the top 100 in the list for more than three years are engaged in speculation or short-term trading? There is no doubt that the rate of short-term production is very low. Even if it is successful, this method of making money quickly is difficult to maintain for a long time. If you are not gifted, be careful to use this kind of unique skill. After all, Simmons has only one.

Reason 3: Prejudice
If you can, it is recommended that you spend 100 minutes watching a movie - "Twelve Angry Men". A film remade by four countries, the first edition in the United States in 1957, the Japanese version in 1991, the Russian version in 1997, and the Chinese version in 2014. Although this film does not teach you how to do trading, it does teach you how to look at things and learn to know yourself, which is very important.

Because human experience is limited, so is human cognition. Everyone is more or less biased according to their own experience. In many cases, prejudice has become the habit of most people, and it is natural to judge many things with their own emotions.

Back to the market, whether your judgment of the market is based on fundamental analysis or technical analysis, these are not really important. If your point of view is different from that of the majority of the market, the price is more biased towards the majority of the market, and the market will not operate according to your point of view.

Therefore, in the transaction, we must keep in mind "judgment, but not rely on judgment". Ultimately, we should be based on facts and prices. The only strength of price rise and fall is the expectation of most people for the future. Your judgment has no weight in the market. Don't let your judgment form your own prejudice.

Reason 4: Pursuit of perfection.
Market participants include elites from all walks of life, including physics, statistics, mathematics, astronomy, etc. Many people try to explain the market with their professional knowledge.

But the main body of market participation is people, and people themselves have cognitive limitations, which means that the market itself is wrong and imperfect. So how can we use these "perfect" methods to explain the market? Isn't that against the nature of the market?

The above lists the reasons why the vast majority of people who came to the market ended in failure. In addition to the main reasons mentioned above, there are many factors that will not be listed here. In short, in addition to your confidence in winning, everything else is a stumbling block to your success.

Those who make profits in the market because of good luck will eventually give it back to the market as time goes by. Therefore, the futures market is a negative sum game market. Only by changing your own way of thinking and establishing your own trading strategy, can you succeed.

What is the thinking mode of probability?
Probabilistic thinking is a literary name. To put it more popular, it is gambling thinking. You heard me right. Trading is gambling. When you hear about gambling, you may think of "who gambles and loses his money or runs away in debt or splits his wife and children" and avoid it.

There are also some red-eyed gamblers in society. But gambling ≠ gamblers. "Gambling" is probably one of the most misunderstood words. If your strategy is negative, you are a gambler; If your strategy is positive expectation, it is gambling.

If we remove the derogatory meaning of "gambling" and understand it as an activity that takes certain risks and obtains certain rewards, then life is really "gambling" everywhere. Which major to choose in school, whether to buy a house, whether to start a project, whether to work or start a business, etc.

Even saving money in a bank is also a gamble, because you are not sure whether inflation will occur in the future and whether the bank will go bankrupt (refer to the Greek debt crisis). In short, from cradle to grave, every process of life is gambling.

How to win gambling for a long time
With the concept of gambling, we need to further solve it. How can we win at gambling for a long time? Before we study the strategy of "win at gambling for a long time", let's first study the principle of those strategies of "win at gambling for a long time". In addition to the money printing machine, what else can we win at gambling for a long time?

That's what's in the casino: baccarat, roulette, slot machine, blackjack, etc. No matter how you change the playing method, the casino will win in the end. In fact, there is a secret that casinos never say: the law of large numbers.

The principle of dice games
Three dice, bet size, 4-10 is small, 11-17 is big, bet right and win money. And the dice has a kind of round dice, that is, the three dice have the same number of points, and the probability of the round dice is 2.8%. Then the probability of large and small occurrence is 48.6%, respectively. The casino is based on this 2.8% probability. If each gambler bet 100 yuan per game, the casino will win 280 yuan after playing 100 games.

(0.486+0.028)100100-0.486100100=280

However, this casino strategy is flawed. If a big player decides to bet tens of billions of dollars on a whim and wins again, the casino will go bankrupt. Therefore, the casino will set a betting limit. If the limit is exceeded, no more bets can be made. In this way, even if the gambler is lucky to win money for a while, in the long run, he will still lose to the probability. In the infinite number of dice games, the gambler will lose 2.8% of the money.

Law of large numbers
The advantage of the casino owner is only 2% more than that of the gambler. In a single gambling game, the boss may lose money or even suffer continuous losses. However, the casino owner will not be frightened by the loss, because he knows that the "law of large numbers" plays a role in his ability to make money. As long as someone continues to gamble, only a 2% weak advantage is needed to make a long-term stable profit.

So the casino is not afraid of you winning, but afraid of you not coming. Over the years, you have even heard of bank failures, but when did you hear of casino failures? In the long run, casinos will always be winners. That is to say, gambling for a long time will win.

Similar examples of winning a long bet are: various lotteries. The lottery pool funds have accumulated more and more since the lottery was listed. Of course, the money comes from the vast number of lottery users. Do you know the probability of 5 million in a double-color ball? The answer is 1 in 17.7 million.

Change of probability
Suppose there is a coin with the same weight as the front and back, and the probability of throwing the word (back) and the flower (front) is 50%, and each coin toss is independent of the previous result. If you flip the coin 10,000 times in succession, the probability of a flower side is about 50%.

However, if you only throw 10 times, the probability of a flower side changes, which is not necessarily 50%. Therefore, the casino dealer must ensure that the positive expectation strategy is triggered enough times to be effective. This is also the reason why private equity institutions cannot stop the quantitative trading strategy unless they have special conditions.

How to use the "law of large numbers" to create a winning strategy in the financial market will be the content of our next series of courses, so look forward to it!

To sum up
Above, we have explained to you how to use a scientific approach to deal with trading from the aspects of probability, the reason for trading failure, the correct way of thinking about trading, and the principle of winning at gambling for a long time. I believe that if you have learned something, the change of thinking will be the change of your behavior, and the change of behavior will be the change of your success.

After-school exercises
1. Why is trading a game of probability?
2. What are the reasons for trading failure?

From: https://blog.mathquant.c...our-trading-pattern.html

"Get the best deal" analysis of the vulnerability in the exchange

2024-04-17T03:24:29Z

NO.1 Preface
In recent years, the digital currency industry based on blockchain technology and cryptography has witnessed explosive growth. As one of the most important links in the digital currency industry chain, the blockchain asset exchange undoubtedly has the priority position. It connects the secondary market of blockchain investment, as well as the project side and ordinary investors.

Background of blockchain asset trading market

- Operating time of the exchange: the average operating time of the top big exchanges is less than 3 years
- Exchange team: led by small entrepreneurial team
- Number of global trading users: about 10 million to 20 million global trading users
- Global daily transaction fee income: about $25 million
- Growth of the number of global exchanges: from dozens to hundreds

According to statistics, at present, more than 300 exchanges have been included by non-small platforms, and even thousands of those have not been included. Even so, entrants still enjoy it. Under the background that everyone is involved in the trading, almost every exchange has dozens or even hundreds of trading objects, so in the market with limited stock, small and medium-sized blockchain assets and exchanges will face the situation of lack of flow and a situation of no price and no market.

NO.2
Why market maker strategies are just what's needed
The emergence of market maker robots has changed this situation. By participating in market making, we can curb excessive speculation in the market due to the asymmetry of information and resources, and maintain the good operation of the trading platform. It also reduces the phenomenon that the so-called dealer secretly manipulates the price in the traditional trading mode to enhance the market attractiveness, improve liquidity and trading volume, meet the buying and selling needs of ordinary investors, and stabilize market confidence.

Market maker
Buying and selling at asking price
■ Arbitrators
■ Short-term bias
■ Earning spreads

Market taker
Buyer or seller
■ Traders
■ Investors
■ Producer/consumer
■ Earning or hedging from price fluctuations

Today, in order to make the new exchange and new currency better connect with ordinary investors and solve many problems faced by them at the initial stage of listing, both small and medium-sized exchanges and blockchain project parties have to rely on market robots.

NO.3
Principle of market maker strategy
Market-making strategy tracks price changes through market making system, and provides two-way quotations for buying and selling constantly. Through a large number of high-frequency buying and selling transactions, accumulate the price difference between each transaction price and the theoretical price gradually, and adjust the price difference dynamically according to the characteristics of the position.

There are two common market maker strategies in general exchanges:

Passive market making: Market makers follow the in-depth data and transaction data of the mainstream exchanges through the strategy of tracking, instead of making a big active choice, but passively follow the market. They pursue the maximum degree of close tracking and complete replication, and try to achieve the same K-line data as the mainstream exchanges.

Free market making: This market making mode does not refer to other trading targets, but makes the market according to its own cost and setting of order. This model is suitable for the environment where the pricing power of relevant currencies is relatively concentrated, such as small blockchain assets or currencies issued by the exchange itself.

NO.4
Market maker strategy vulnerability
Whether it is a passive market making or a free market making, it is necessary to solve not only the price problem of the transaction object, but also the liquidity problem. Therefore, in order to activate the market, it is necessary for the marketers to buy and sell themselves, otherwise it is difficult to form a decent K-line.

The common method is to sell at a random price near the market and immediately buy at the same price. Or buy before selling according to the random price. Generally, due to the short time interval between trading and buying, the corresponding listing can not be found in the depth data, but the transaction record can be left in the historical data. The K-line is drawn by this market making method.

**Please pay attention! This is how the vulnerability appears.**

In order to generate a continuous K-line, the market maker strategy has hidden the vulnerability in the self-buying and self-selling list near the opening of the market. Although the buying order and selling order of the strategy are issued at the same time, the network problem and the matching speed are not ideal, nor can they be ideal, which leads to a certain probability that the order of the marketing strategy will be closed by others.

Imagine that if there is another high-frequency order strategy in the market, it always deals with the selling orders of the market strategy at a lower price, and deals with the purchase orders of the market strategy at a higher price. As long as the price difference obtained by this high-frequency order strategy can cover the handling charges, it will generate profits. This leads to the strategy of selling low and buying high in the market, think carefully!

NO.5
Practical demonstration
After observation, there is a market making phenomenon in **the ETHUSDT trading pair of a certain exchange**, and the reference object may be the ETHUSDT data of Binance. By observing the data of its market order book, it is found that there is a self-closing order, and the trading direction is random. The chart below shows the K-line generated by the market making strategy on that day.
https://stocksharp.com/file/150331

Usually, the high-frequency order strategy is not randomly priced at the opening of the market, but randomly changes with reference to the last transaction price of the market strategy. In fact, it is difficult for the transaction price to reach the low and high market prices, and the success rate of obtaining market making strategy orders is limited, so there is almost no profit.

They even have to bear the risk of unilateral positions. This seems to be impeccable, but if we take advantage of the bug that market making orders must be placed in the market, we can easily crack the market strategy of the exchange and make great profits.

NO.6
The specific steps are as follows:
When expecting a low price deal, add a certain price to the buy one price to pend a selling order. When the buy price is 200, pend a selling order of 200.1, then keep pending a buying order of 200.09, and withdraw immediately. When the transaction is completed, reverse the operation immediately and sell the traded currency at a high price, thus completing a loop.

Although such a success rate is not very high, through a large number of frequent pending order and cancellation transactions, this opportunity will be greatly increased and the profit will still be considerable.
https://stocksharp.com/file/150330

As shown in the chart above, **a high-frequency order strategy was written through the FMZ Quant Trading Platform (FMZ) and run in the real market with almost no withdraw**. In only one night, the profit of 1,000USDT was transferred to 4,000USDT.

This is a gentle order. If you use multiple accounts, multiple contracts, and multiple threads, you will increase profits. After the high-frequency order strategy takes advantage of this vulnerability, it steals a huge amount of money and leaves behind a dreadful of the K-line, as shown in the following chart:
https://stocksharp.com/file/150332

NO.7
The source code of the order strategy based on the vulnerability of the exchange market
https://stocksharp.com/file/150333

The above strategy source code is based on the FMZ Quant Trading Platform (www.fmz.cn)

NO.8
Prevention methods
For this market making strategy, it is easy to solve the problem after knowing the principle. For example, when the transaction price of the market making strategy is at a low level, only the buy order is placed first and then the sell order, and vice versa, so that others will not buy it at a low price and sell it at a high price. Or put all transactions and pending orders in the scope that can be hedged in other exchanges.

Words to follow
**Although the exchange is at the top of the entire blockchain industry**, it is like a giant outside, revealing more attack areas and exploitable vulnerabilities.

Objectively speaking, the irrationality that can be deduced from the order book may have more hidden bugs. For example, by taking advantage of the obvious vulnerabilities in the strategies of exchange market makers, attackers can skillfully design various covert attack strategies, and they can also do it unknowingly.

**Today, digital currency has become a new target for investment, and exchanges have become an arena for many hackers**. The hackers hiding in the dark are like hungry wolves, waiting for the opportunity to move, staring at the flaws of the exchange, and preparing for a fatal attack. The blockchain centralized exchange can only strengthen its own defense deployment, so that customers can have worry-free transactions.

From: https://blog.mathquant.c...ity-in-the-exchange.html

Can we make quantitative trading without code? Let's find out...

2024-04-17T02:14:57Z

NO.1
On Wall Street, quantitative trading has become the leading role of market trading. Many of the world's top investment banks have banned manual directional speculative trading. The development of quantitative trading in China is also very rapid. Institutions are using it, and future tycoons are also using it. There are more and more people participating in quantitative trading.

But there are also many manual traders who are interested in quantitative trading. At the beginning, they were full of confidence. After reading the long and complex code, they often hesitated or stopped. In order to popularize the public, reduce the threshold of quantitative trading programming, and improve the efficiency of writing greatly, FMZ has developed a visual quantitative trading platform.

NO.2
In traditional programming, you should be familiar with the basic grammar, data operation, data structure, logic control... of programming language. Let's write a program that outputs "hello, world" in Java to experience traditional programming, as follows:
https://stocksharp.com/file/150316

It took 5 lines of code just to output a string program. I believe that most beginners only know the "hello, world" in parentheses, and nothing else. Therefore, it is a better choice to start with visual programming.

Visual programming has a long history and is not new. The "what you see is what you get" programming idea, carrying various control modules, can build code logic and complete trading strategy design just by dragging, and the process is very like building blocks.
https://stocksharp.com/file/150317

As shown in the chart above, the same program needs only one line of code in blockly visual programming, which reduces the programming threshold greatly, especially for those traders who do not understand programming at all. This is a very good operating experience. The FMZ Quant visual programming is also realized through the blocky visualization tool released by Google. In design, it is the same as the Scratch launched by Massachusetts Institute of Technology, so there is really - no barrier.
https://stocksharp.com/file/150319

The FMZ Quant visual programming, with hundreds of commonly used trading modules built in, will have more trading modules added in the future to support traders' new ideas and new applications, which will be jointly developed and maintained by developers. Although the grammar is simple, it does have performance. It can almost meet most quantitative trading strategies. In terms of function and speed, it is not inferior to conventional programming languages such as Python and JavaScript. In the future, financial applications with complex logic will be supported.

NO.3
**How to use**

**Step 1**: Register and sign in the FMZ Quant (**FMZ**) website at: www.fmz.com
https://stocksharp.com/file/150315

**Step 2**: Go to Dashboard
https://stocksharp.com/file/150318

**Step 3**: Click add strategy
https://stocksharp.com/file/150320

**Step 4**: Select Blockly and Template Include
https://stocksharp.com/file/150321

**Finally**, we are in the visual programming interface, as follows:
https://stocksharp.com/file/150319

NO.4
Try to write a program that outputs "hello, world" using the FMZ Quant blockly editor

**Step 1: Select Log module**
https://stocksharp.com/file/150323

**Step 2: Select Text module**
https://stocksharp.com/file/150326

**Step 3: Backtest settings**
https://stocksharp.com/file/150324

**Step 4: Backtest result**
https://stocksharp.com/file/150325

NO.5
**A complete dynamic balancing strategy for digital currencies**

**Strategy logic**

- Condition for buying: If the market value of the current position minus the current available balance is less than 5% of the negative current available balance, open a position to buy.

- Condition for selling: If the market value of the current position minus the current available balance is more than 5% of the negative current available balance, close a position to sell.

**Prerequisites and requirements**

- Current market

- Current assets

- Total market value of currency

- Asset difference

**Blockly strategy-writing Step 1**

We calculate the four prerequisites and prerequisites of the trading strategy and assign values to each variable. With visual programming, the code block is like this, as shown below:
https://stocksharp.com/file/150322

It should be noted that the total market value of the currency is the total market value of the current currency holdings. The calculation method is to multiply the current total currency holdings by the current latest price. The asset difference is the total market value of the currency minus the current available balance.

**Blockly strategy-writing Step 2**

After the assignment of prerequisites and prerequisites is completed, the trading logic needs to be written. This is not as complicated as expected. It is nothing more than to express the above strategy logic in the form of code blocks. That is, if the asset difference is less than 5% of the negative available balance, buy it, and if the asset difference is greater than 5% of the available balance, sell it. As shown below:
https://stocksharp.com/file/150328

The whole strategy seems to have finished, but you should know that the program is executed from top to bottom, and then it stops. However, our trading strategy is not to execute the trading conditions once, but to execute them in a loop repeatedly. In other words, the program needs to check whether the strategic conditions have been reached constantly. If so, it will execute the trading, otherwise it will continue to check. At this time, another loop statement is needed, as shown in the following figure:
https://stocksharp.com/file/150327

There is no essential difference between the visualization strategy and the strategy written in other programming languages. It also supports the historical data test with multiple periods and accuracies. Of course, it also supports the real market trading of domestic and foreign commodity futures and digital currency. The following is the backtest information of the strategy:
https://stocksharp.com/file/150329

So far, a complete trading strategy has finished. In order to take care of the lazy guys, this strategy has been shared in the strategy square and it can be copied for study directly.

Strategy link address:

https://www.fmz.com/strategy/121404

NO.6
The law of ten thousand hours always exists, but for traders with zero basis, it is impossible to spend ten thousand hours practicing again. So you must have a ladder, and for traders with zero programming foundation, the FMZ Quant visual programming is a ladder to get started quickly.

With visual programming, you don't need to remember the grammar and method name, just simply browse the function module to find what you want. The original intention of the FMZ Quant is also to help more quantitative beginners reduce the entry threshold and increase their interest in quantification. Everyone can become a quantitative trader!

However, in other words, visual programming is no problem as a step to quantitative entry, but it also has its own limitations, such as the inability to develop overly complex and sophisticated trading strategies. But this does not affect you to take the first step of quantitative trading!

Finally, I wish all friends who want to do quantitative trading, regardless of whether they are based on zero, can achieve their learning goals through action. Thank you for reading!

From: https://blog.mathquant.c...-code-lets-find-out.html

Concurrent Strategy Execution with JavaScript Multithreading Support

2024-04-17T01:07:43Z

When developing strategies on FMZ using the JavaScript language, since the strategy architecture is polled. If there is a concurrent design scenario, the ```exchange.Go``` function is used to make concurrent calls to some interfaces, so as to meet the requirements of some concurrent scenarios. But if you want to create a single thread to perform a series of operations, it is impossible. For example, like the Python language, use the ```threading``` library to do some concurrent design.

Based on this requirement, the FMZ platform has upgraded the bottom layer of the system. True multithreading support has also been added to the JavaScript language. Detailed features include:

- Create threads to execute custom functions concurrently.
- Inter-thread communication.
- Variables stored between shared threads.
- Wait for the thread to finish executing to reclaim resources and return the execution result.
- Forcibly end the thread and reclaim resources.
- Get the current thread ID in the concurrent thread execution function.

Next, I will take you to understand each function one by one.

Create threads to execute custom functions concurrently
The ```__Thread``` function can create a thread and execute a function concurrently. For example, you need to create a concurrent function ```func1```, what does the ```func1``` function do? We can let it accumulate from 0 to 9. In order to see the gradual accumulation process, we use the for loop in the func1 function to pause each time (the Sleep function is used to sleep for a certain number of milliseconds) for a certain period of time.
```
function func1(sleepMilliseconds) {
var sum = 0
for (var i = 0 ; i < 10 ; i++) {
sum += i
Sleep(sleepMilliseconds)
Log("sum:", sum)
}

return sum
}

function main() {
// Use the __Thread function to create a thread concurrently, and the parameter 200 is the parameter of the func1 function,
// If the func1 function has multiple parameters, here we pass the corresponding parameters.
var thread1Id = __Thread(func1, 200)

// Here we need to wait for the execution result of the thread whose thread Id is thread1Id, otherwise all threads will be released directly after the main function is executed.
var ret = __threadJoin(thread1Id)
Log("ret:", ret)
}
```
In practical applications, we can make http requests concurrently like this:
```
function main() {
let threads = [
"https://www.baidu.com",
"https://www.163.com"
].map(function(url) {
return __Thread(function(url) {
Log("GET", url)
return HttpQuery(url)
}, url)
})
threads.forEach(function(tid) {
Log(__threadJoin(tid))
})
}
```
Wait for the end of thread execution to reclaim resources and return the execution result
In the above example, we used the ```__threadJoin``` function in the main function finally to wait for the concurrent threads to finish executing. The variable ```ret``` receives the return value of the ```__threadJoin``` function, and we print the return value, we can observe the specific results of the concurrent thread execution.
```
// id: thread ID, terminated: whether it was forced to stop, elapsed: time-consuming (nanoseconds), ret: the return value of the thread execution function
ret: {"id":1,"terminated":false,"elapsed":2004884301,"ret":45}
```
End the thread forcibly and reclaim resources
```
function func1(sleepMilliseconds) {
var sum = 0
for (var i = 0 ; i < 10 ; i++) {
sum += i
Sleep(sleepMilliseconds)
Log("sum:", sum)
}

return sum
}

function main() {
var thread1Id = __Thread(func1, 200)
Sleep(1000)
retThreadTerminate = __threadTerminate(thread1Id)
Log(retThreadTerminate) // true
}
```
We still use the example just now, after creating a thread, you can forcibly terminate the execution of the thread after waiting for 1 second.

Inter-thread communication
Inter-thread communication mainly uses the ```__threadPostMessage``` function and the ```__threadPeekMessage``` function. Let's look at the following simple example:
```
function func1() {
var id = __threadId()
while (true) {
var postMsg = "Message from thread function func1" with "from id:" + id +
__threadPostMessage(0, postMsg) // Send a message to the main thread
var peekMsg = __threadPeekMessage() // Receive messages from other threads
Log(peekMsg)
Sleep(5000)
}
}

function main() {
var threadId = __Thread(func1)

while (true) {
var postMsg = "Messages from the main function of the main thread"
__threadPostMessage(threadId, postMsg)
var peekMsg = __threadPeekMessage(threadId)
Log(peekMsg, "#FF0000") // #FF0000 , Set the log to red for distinction
Sleep(5000)
}
}
```
The ```__threadPostMessage``` function is used to send a message to a thread. The first parameter is the ID of the specific thread to send to, and the second parameter is the message to be sent, which can be a string, a value, an array, or a JSON object and so on. Messages can be sent to the main thread in concurrent thread functions, and the ID of the main thread is defined as 0.

The ```__threadPeekMessage``` function is used to monitor the message sent by a certain thread. It can set the timeout time (in milliseconds), or it can be set to 0, which means blocking, and it will not return until there is a message.

Of course, except for concurrent threads communicating with the main thread. Concurrent threads can also communicate with each other directly.

Get the current thread ID in the concurrent thread execution function
In the above example, the function ```var id = __threadId()，__threadId()``` is used to get the ID of the current thread.

Variables stored between shared threads
In addition to communication between threads, shared variables can also be used for interaction.
```
function testFunc() {
__threadSetData(0, "testFunc", 100) // Stored in the current thread environment, key-value pair testFunc : 100
Log("testFunc execution completed")
}

function main() {
// threadId is 1, the created thread with threadId 1 will be executed first, as long as the thread resources are not reclaimed, the variables stored locally in the thread will be valid
var testThread = __Thread(testFunc)

Sleep(1000)

// export in main, get testFunc: 100
Log("in main, get testFunc:", __threadGetData(testThread, "testFunc")) // Take out the value whose key name is testFunc
}
```
The above is a simple demonstration of all functions.

From: https://blog.mathquant.c...javascript-strategy.html

How to Solve the World Pi Day OKX Private Key Puzzle Award (with complete code)

2024-04-16T09:22:15Z

I saw some Tycoons in the group saying that OKX was holding a World Pi Day Mystery Event, with the theme of "Exploration, Never Ending".

As a veteran programmer, when I saw the news, I smiled and opened my MacBook Pro, and without further ado, let's get started!

> Analysis

Officially, there are 61 bits of key in the picture and the part of the circumference overlap, as we all know, the length of private key is 32 byte, converted to hex is 64 bits plus 0x prefix, a total of 66 bits, there are already 61 bits, for the first look, the "0X" at the first line in the chart is obviously not Pi, it is the start of the private key prefix, then there are about 5 bits (0123456789ABCDEF). The characters are arranged randomly, so there's nothing wrong with running them directly, so let's get started~

Let's use a Mac tool to sharpen the color simply:
https://stocksharp.com/file/150303

In this way, the Mac can recognize the characters on the picture automatically. Let's copy them directly:
```
3.141592653589793230X1D64338
А694502884197169399375105820
974925E123078164062862089986
28033DB034211706409914808651
32823066470ED424609550582231
8B3
81284
• Exploration,
038
Never Ending
027
493
05%
0128
4756482337867831731712019091
47D9E56692346034861045432664
8213393607743749141273724587
006606315588174881BEEA209628
2925409192744436789259036001
```
It cannot be used directly. Let's correct it manually. The unconfirmed ones covered by the picture are marked with *. Not sure. Let's talk about it later.
The others blocked by the figure can be judged by observing the stroke shape of other fonts. At this time, we use Python to calculate the difference between the two, and use '_' for the same ones and only showing the different ones.
```
img = '''
3.141592653589793230X1D64338
A694502884197169399375105820
974925E123078164062862089986
28033DB034211706409914808651
32823066470ED424609550582231
8B32594081284811174502841027
0193**2*D2299964462294895493
0381960EFC8103F9365933446128
4756482337867831731712019091
47D9E56692346034861045432664
82133936077A3749141273724587
006606315588174881BEEA209628
2925409192744436789259036001
'''
# True Pi
real='''
3.14159265358979323846264338
3279502884197169399375105820
9749445923078164062862089986
2803482534211706798214808651
3282306647093844609550582231
7253594081284811174502841027
0193852110555964462294895493
0381964428810975665933446128
4756482337867831652712019091
4564856692346034861045432664
8213393607260249141273724587
0066063155881748815209209628
2925409171536436789259036001
'''

items = img.strip().split('\n')
diffStr = ''
for pos, line in enumerate(real.strip().split('\n')):
for i, c in enumerate(line):
imgLine = list(items[pos])
if line[i] == imgLine[i]:
imgLine[i] = '_'
else:
diffStr += imgLine[i]
items[pos] = ''.join(imgLine)
print('\n'.join(items))
print(diffStr, 'Len:', len(diffStr))
```
The implementation results are as follows:
```
___________________0X1D_____
A694________________________
____25E1____________________
____3DB0________4099________
___________ED42_____________
8B32________________________
____**_*D2299_______________
______0EFC___3F93___________
________________731_________
_7D9E_______________________
__________7A37______________
__________________BEEA______
________92744_______________
0X1DA69425E13DB04099ED428B32***D22990EFC3F937317D9E7A37BEEA92744 Len: 64
```
There are three more, and there are just three uncertain ones. Try to remove them, because the other 61 bits are all right after exclusion, leaving only the most definite difference. Finally, the prefix is as follows:
```
0X1DA69425E13DB04099ED428B32D22990EFC3F937317D9E7A37BEEA92744
```
Next, we shall use Python and use force to crawl the balance on the OK chain. We can compare which private key has the balance. In fact, we can also select the public key with 314 USDT transfer first, which is faster. Seeing information on the official website said that we can check the balance directly if there is gas, the code is a little messy.
```
import sys
import web3,time,logging
from eth_account import Account
from web3 import Web3
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s')
w3 = Web3(Web3.HTTPProvider("https://exchainrpc.okex.org"))
logging.info(w3.clientVersion)
found = None

def get_balance_gas(key):
global found
_counter += 1
address = Account.from_key(key).address
logging.info('fetch address %s %s' % (found, address))
while True:
try:
balance = w3.eth.get_balance(address)
break
except:
logging.warning(traceback.format_exc())
time.sleep(1)
continue
if balance != 0:
found = key
raise BaseException('Found balance: %s %s' % (address, balance))
return balance

from concurrent.futures import ThreadPoolExecutor
executor = ThreadPoolExecutor(max_workers=50)
keys = []
prefix = '1DA69425E13DB04099ED428B32D22990EFC3F937317D9E7A37BEEA92744'
# It doesn't matter how to optimize the algorithm. Run the secret key against the clock.
ch = '0123456789ABCDEF'
for a in range(0, 16):
for b in range(0, 16):
for c in range(0, 16):
for d in range(0, 16):
for e in range(0, 16):
keys.append("0x"+prefix+ch[a]+ch[b]+ch[c]+ch[d]+ch[e])
print('all keys:', len(keys))
tasks = [None for t in keys]
for idx, key in enumerate(keys):
tasks[idx] = executor.submit(get_balance_gas, key)
for t in tasks:
t.result()

```
We can see that it takes 1048576 iterations, but it's much faster with multi-threading, running it on one of my servers.
```
2023-03-15 00:20:19,491 exchain-v1.6.8.5
all keys: 1048576
2023-03-15 00:20:20,372 fetch address None 0xc20C41f06F2428a0FD84ef03Ec6960992F5f8016
2023-03-15 00:20:20,473 fetch address None 0xcFa87ee54bc1c14c09a3AB3f41640bBab5C5480a
2023-03-15 00:20:20,483 fetch address None 0x126E922652f8B276F231D0eCA94d98685a26a45D
The following is omitted...
```
Anxious waiting~~~, bad news came, and there was no result before the strategy exited. All of them were displayed as None.

> The path winds along mountain ridges

I don't think so, I can't figure it out, I started to look at the discussion on twitter, and I found that everyone and I arrived at the same steps, but the strange thing is that no one has said that the decryption is successful, and the official has not announced the correct first 61 bits, then a strange reply caught my attention, because there is a difference ```D2299``` in the middle, I am very sure, but he looks terribly confident.
https://stocksharp.com/file/150300

However, he posted a 61-bit D2290. He also said that he had been checked carefully. It doesn't matter. Take a chance. Anyway, it's a waste of electricity.
With the attitude of trying, I found a few other people who said that they had found 61-bit. They were all very confident.
The prefixes found in the comments section are collected, with the code just traversed, the basic code has not changed, and it will not be pasted repeatedly.
```
prefixs =[
'1DA69425E13DB04099ED428B3202290EFC3F9317317D9E7A37BEEA92744',
'1DA69425E13DB04099ED428B32D2290EFC3F9373177D9E7A37BEEA92744',
'1DA69425E13DB04099ED428B320D2290EFC3F937317D9E7A37BEEA92744',
'1DA694255E3DB040990ED428B3208890EFC3F937317D9E7A37BEEA92744',
'1DA69425E13DB04099ED428B3202299EFC3F9317317D9E7A37BEEA92744',
'1DA69425E13DB01099ED428B3202290EFC3F9317317D9E7A37BEEA92744',
'1DA69425E13DB04099ED428B32D2290EFC3F9317317D9E7A37BEEA92744',
'1DA69425E13DB04099ED428B32D22990EFC3F937317D9E7A37BEEA92744',
]
```
In fact, there are more new messages later, one brother's PI value is different from mine, it's amazing!
Let's run with these first, I can't believe my eyes, but it came out, it means that one of the prefixes above is correct, which is very unscientific, the private key is:
```
1DA69425E13DB04099ED428B32D2290EFC3F9373177D9E7A37BEEA92744C8155
```
Here is D229, but the picture is clearly D2299, and 731 is followed by 7, here is two, but actually, this is the correct 61 bits, how he calculated it himself is unknown, incredibly curious, but I do not doubt my own operation, I saw one of the comments said that the official customer service said Pi has another version, it was me who were ignorant, with what I have learned and the current human understanding of the universe understanding, the circumference of this irrational number can represent the infinity of the universe, its fractional part never repeats or terminates, you can interpret it as the UUID of the universe you are in, if there are other versions, probably from parallel worlds.

> Web3 currency conversion code

Finally, it's the code to transfer the bonus away, for this time, I use the FMZ platform Web3 directly, set the chain address to OKC, the private key added to the exchange at random, and then two lines will be done, execute it in the debug tool mode directly.
https://stocksharp.com/file/150302

> Proof

Address of the decrypted public key
```
>>> from eth_account import Account
>>> Account.from_key('0x1DA69425E13DB04099ED428B32D2290EFC3F9373177D9E7A37BEEA92744C8155').address
'0x0bd08825e05e540C9508961a32E58D14da47275A'
```
Check out the link: https://www.okx.com/cn/e...508961a32e58d14da47275a

TX after being led by me: https://www.okx.com/cn/e...9a9456eb5aba5fe8c5d4e2c

We can see that the recipient address is:
```
0x25f0a126be95f437ee71d7c4de725567c5f6c731
```
https://stocksharp.com/file/150301

To prove that this address is mine, I used this recipient's address to make a transfer to a black hole address.

https://www.okx.com/cn/e...31429052e3e3c5614bcdb6e

The black hole address is:
```
0x0000000000000000005757572e464d5a2e434f4d
```
This black hole address contains a URL decoded as:

```
~ % python -c 'print(bytes.fromhex("0000000000000000005757572e464d5a2e434f4d"))'
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00WWW.FMZ.COM'
```
> Postscript

This is the end of the story, and in retrospect, I'm grateful for the knowledge I've accumulated over the years, otherwise I wouldn't have been able to crack it so fast and I would have been beaten by others.
I'm sure there was a mistake in the official diagram, but in any case, I was lucky enough to crack the answer before it was made public, and I hope OKX will be more rigorous next time they hold a similar activity.

From: https://blog.mathquant.c...-with-complete-code.html

Digital Currency High-Frequency Strategy Detailed Introduction

2024-04-16T08:28:19Z

I wrote an article in 2020 introducing high-frequency strategies, https://www.fmz.com/bbs-topic/9750. Although it received quite a bit of attention, it was not very in-depth. More than two years have passed since then, and the market has changed. After that article was published, my high-frequency strategy could make profits stably for a long time, but gradually, the profits declined and even stopped at one point. In recent months I have spent some effort to revamp it, and now it can still make some profits. In this article, I will provide a more detailed introduction to my high-frequency strategy ideas and some simplified code as a starting point for discussion; communications and feedbacks are welcome.

High-frequency trading conditions
- Rebate accounts, taking Binance as an example, it has a maker rebate of 0.0005% currently. If the daily transaction amount is 100 million U, the rebate will be 5000 U. Of course, taker fees are still based on VIP rates, so if the strategy does not require takers, VIP level has little impact on high-frequency strategies. Different levels of exchanges generally have different rebate rates and require maintaining a high transaction amount. In the early times when some currency markets fluctuated greatly, there were profits even without rebates. As competition intensified, rebates accounted for a larger proportion of profits or even relied solely on them; high-frequency traders pursued top-level fees.

- Speed. The reason why high-frequency strategies are called high-frequency is because they are very fast. Joining the exchange's colo server, obtaining the lowest latency and most stable connection has also become one of the conditions for internal competition. The internal consumption time of the strategy should be as little as possible, and this article will introduce the websocket framework I use, which adopts concurrent execution.

- Suitable market. High-frequency trading is known as the pearl of quantitative trading, and many programmatic traders have tried it, but most people stopped because they can't make profit and can't find a direction for improvement. The main reason should be that they chose the wrong trading market. In the initial stage of strategy development, relatively easy markets should be chosen to make profits in trading so that there are profits and feedback for improvement, which is conducive to the progress of strategy. If you start competing in the most competitive market with many potential opponents, no matter how hard you try, you will lose money and soon give up. I recommend newly listed perpetual contract trading pairs when there are not so many competitors, especially those with relatively large transaction amount; this is when making profits is easiest. BTC and ETH have the largest transaction amount and are most active in transactions but also hardest to survive.

- Facing competition. The market for any transaction is changing constantly, and no trading strategy can last forever, especially in high-frequency trading. Entering this market means competing with the smartest and most diligent traders directly. In a zero-sum game market, the more you earn, the less others will earn. The later you enter, the higher the difficulty; those already in the market must also improve continuously. 3-4 years ago was probably the best opportunity; recently, overall activity in digital currency markets has declined, making it very difficult for newcomers to start high-frequency trading now.

High-frequency principle
There are various high-frequency strategies:

- High-frequency hedging, finding hedging opportunities through this exchange or other exchanges, relying on speed advantage to grab orders and make profits;
- High-frequency trend, making profits by judging short-term trends;
- Market maker, placing orders on both the buying and selling sides, controlling positions well and making profits through the rebates;
- There are many others that I won't state one by one.
My strategy is a combination of trend and market maker. First, we judge the trend, then place an order. After the transaction is completed, place an order immediately to sell without holding inventory positions. Next, I will introduce it in conjunction with the strategy code.

Strategy framework
The following code is based on the basic framework of Binance perpetual contracts, mainly subscribing to websocket depth, depth order flow trades market data, and position information. Since the market data and account information are subscribed separately, it is necessary to use read(-1) continuously to determine whether the latest information has been obtained. Here EventLoop(1000) is used to avoid direct endless loops and reduce system load. EventLoop(1000) will block until there are wss or concurrent task returns with a timeout of 1000ms.
```
var datastream = null
var tickerstream = null
var update_listenKey_time = 0

function ConncetWss(){
if (Date.now() - update_listenKey_time < 50*60*1000) {
return
}
if(datastream || tickerstream){
datastream.close()
tickerstream.close()
}
//Need APIKEY
let req = HttpQuery(Base+'/fapi/v1/listenKey', {method: 'POST',data: ''}, null, 'X-MBX-APIKEY:' + APIKEY)
let listenKey = JSON.parse(req).listenKey
datastream = Dial("wss://fstream.binance.com/ws/" + listenKey + '|reconnect=true', 60)
//Symbols are the set trading pairs
let trade_symbols_string = Symbols.toLowerCase().split(',')
let wss_url = "wss://fstream.binance.com/stream?streams="+trade_symbols_string.join(Quote.toLowerCase()+"@aggTrade/")+Quote.toLowerCase()+"@aggTrade/"+trade_symbols_string.join(Quote.toLowerCase()+"@depth20@100ms/")+Quote.toLowerCase()+"@depth20@100ms"
tickerstream = Dial(wss_url+"|reconnect=true", 60)
update_listenKey_time = Date.now()
}

function ReadWss(){
let data = datastream.read(-1)
let ticker = tickerstream.read(-1)
while(data){
data = JSON.parse(data)
if (data.e == 'ACCOUNT_UPDATE') {
updateWsPosition(data)
}
if (data.e == 'ORDER_TRADE_UPDATE'){
updateWsOrder(data)
}
data = datastream.read(-1)
}
while(ticker){
ticker = JSON.parse(ticker).data
if(ticker.e == 'aggTrade'){
updateWsTrades(ticker)
}
if(ticker.e == 'depthUpdate'){
updateWsDepth(ticker)
}
ticker = tickerstream.read(-1)
}
makerOrder()
}

function main() {
while(true){
ConncetWss()
ReadWss()
worker()
updateStatus()
EventLoop(1000)
}
}
```
Strategy indicators
As mentioned earlier, my high-frequency strategy requires determining the trend before executing buying and selling. The short-term trend is mainly judged based on tick-by-tick transaction data, that is, the aggTrade in the subscription, which includes transaction direction, price, quantity, transaction time, etc. Buying and selling mainly refer to depth and trading amount. The following are detailed introductions of the indicators to be concerned about; most of them are divided into buying and selling groups and are counted dynamically within a certain time window. The time window of my strategy is within 10 seconds.

- Average transaction amount per trade, per trade transactions are the collection of different orders with the same direction and price within 100ms, reflecting the size of buy and sell orders. This data has a high weight, it can be assumed that if the volume of buy orders is greater than sell orders, this is a buyer-dominated market.
- Order frequency or order interval, it is also based on transaction-by-transaction data, the average transaction amount mentioned earlier does not take into account the concept of time and is not entirely accurate. If an order in one direction has a small average transaction amount but a high frequency, it still contributes to the strength of that direction. The average transaction amount * order frequency represents the total transaction amount at fixed intervals and can be used for direct comparison. The arrival of orders follows a Poisson distribution, which can be used to simply estimate how much the total amount of orders arriving within a specific time interval is and provide reference for placing order positions.
- Average spread, this is relatively easy to understand, that is, sell one minus buy one. The current market mostly has a 1-tick spread. If the spread becomes larger, it often means that there is a market trend.
- Average buying and selling price, calculate the average price of each transaction separately, and compare it with the latest price. If the recent purchase order price is higher than the average purchase order price, it can be judged preliminarily that a breakthrough has occurred.

Strategy logic
Determine short-term trend
```
//bull represents short-term bullish, bear represents short-term bearish
let bull = last_sell_price > avg_sell_price && last_buy_price > avg_buy_price &&
avg_buy_amount / avg_buy_time > avg_sell_amount / avg_sell_time;
let bear = last_sell_price < avg_sell_price && last_buy_price < avg_buy_price &&
avg_buy_amount / avg_buy_time < avg_sell_amount / avg_sell_time;
```
If the latest selling price is higher than the average selling price, the latest buying price is higher than the average buying price, and the fixed interval buying order value is greater than the selling order value, then it is judged to be short-term bullish. Conversely, it's bearish.

Price for placing orders
```
function updatePrice(depth, bid_amount, ask_amount) {

let buy_price = 0
let sell_price = 0
let acc_bid_amount = 0
let acc_ask_amount = 0

for (let i = 0; i < Math.min(depth.asks.length, depth.bids.length); i++) {
acc_bid_amount += parseFloat(depth.bids[i][1])
acc_ask_amount += parseFloat(depth.asks[i][1])
if (acc_bid_amount > bid_amount && buy_price == 0) {
buy_price = parseFloat(depth.bids[i][0]) + tick_size
}
if (acc_ask_amount > ask_amount && sell_price == 0) {
sell_price = parseFloat(depth.asks[i][0]) - tick_size
}
if (buy_price > 0 && sell_price > 0) {
break
}
}
return [buy_price, sell_price]
}
```
Here, we still adopt the old approach, iterating to the required depth. Assuming that 10 coins can be traded in 1 second, without considering new pending orders, the selling price is set at the position where 10 coins are bought. The specific size of the time window needs to be set by yourself.

Order amount
```
let buy_amount = Ratio * avg_sell_amount / avg_sell_time
let sell_amount = Ratio * avg_buy_amount / avg_buy_time
```
Ratio represents a fixed proportion, which means that the buy order quantity is a fixed proportion of the recent sell order quantity. In this way, the strategy can adjust the order size adaptively according to the current buying and selling activity.

Place order conditions
```
if(bull && (sell_price-buy_price) > N * avg_diff) {
trade('buy', buy_price, buy_amount)
}else if(position.amount < 0){
trade('buy', buy_price, -position.amount)
}
if(bear && (sell_price-buy_price) > N * avg_diff) {
trade('sell', sell_price, sell_amount)
}else if(position.amount > 0){
trade('sell', sell_price, position.amount)
}
```
Where avg_diff is the average market price difference, and a buy order will only be placed when the bid-ask spread is greater than a certain multiple of this value and it's bullish. If holding a short position, it will also close the position to avoid holding for an extended period. Orders can be placed as only-maker orders to ensure they are executed. Additionally, Binance's custom order ID can be used so that there is no need to wait for the order response.

Concurrent structure
```
var tasks = []
var jobs = []

function worker(){
let new_jobs = []
for(let i=0; i<tasks.length; i++){
let task = tasks[i]
jobs.push(exchange.Go.apply(this, task.param))
}
_.each(jobs, function(t){
let ret = t.wait(-1)
if(ret === undefined){
new_jobs.push(t)//Unreturned tasks will continue to wait next time
}
})
jobs = new_jobs
tasks = []
}

/*
Write the required task parameters in param
tasks.push({'type':'order','param': ["IO", "api", "POST","/fapi/v1/order",
"symbol="+symbol+Quote+"&side="+side+"&type=LIMIT&timeInForce=GTX&quantity="+
amount+"&price="+price+"&newClientOrderId=" + UUID() +"&timestamp="+Date.now()]})
*/
```
Monitored data
- Delay, the importance of high-frequency strategy speed has been emphasized. In the strategy, various delays need to be monitored and recorded, such as placing orders, canceling orders, position returns, depth, order flow, positions, overall loops and so on. Any abnormal delays should be investigated in time and try to shorten the overall strategy delay.
- Transaction amount ratio, calculate the transaction amount as a percentage of the total transaction amount. If the ratio is low, there is still room for growth. At peak times, it is possible for the strategy to account for more than 10% of the total trading amount.
- Profit rate of closing positions, calculating the average closing position profit rate is the most important reference for judging whether a strategy is effective.
- Rebate ratio, the proportion of rebates in total revenue, reflects the degree of reliance on rebates by the strategy. Exchange platforms have different rebate levels, and unprofitable strategies may be profitable with a higher level of rebate.
- Placing order failure rate, orders are only traded by placing an order. Due to the delay in placing an order, it may not be placed. If this ratio is high, it means that the strategy's speed is not advantageous.
- The proportion of completed orders, platforms often have requirements for the transaction rate. If it is too low, it means that the strategy cancels orders too frequently and needs to be resolved.
- Average buying and selling order distance, which reflects the strategy of placing orders and the gap between the market, we can see that most of them still occupy the position of buying one and selling one.

Other suggestions
- Trade multiple currencies, the high-frequency strategy in this article only refers to a single exchange, single currency and single market. It has great limitations, and most situations and currencies cannot make profits. However, it is impossible to predict which currency will be profitable in the future, so you can trade multiple or even all currencies without missing opportunities. Even under the frequency limit of exchanges, a robot can trade multiple trading pairs. Of course, for optimal speed, one sub-account can trade one trading pair with one server corresponding to one robot; however, this would result in much higher costs.
- Determine the order quantity and order conditions based on the yield. Trading with multiple currencies will result in high cost of attempts, if monitoring is not profitable, use the minimum transaction amount and reduce the trading frequency until the strategy dynamically monitors a positive return rate, then increase the transaction amount to improve returns gradually.
- Obtain more information, another feature of high-frequency trading is that it processes a larger amount of data and uses more information. All market information for a single trading pair within a single exchange should be referenced, and perpetual contracts can also refer to spot market data, as well as data from other exchanges for the same trading pair, or even data from other currencies. The more data there is, the greater the corresponding advantage. For example, Binance can subscribe to the best pending order information by Symbol, because the shortest push time for depth and order flow is 100ms; only this is real-time and very valuable for high-frequency strategies.
- Binance's server is in aws Tokyo, other exchanges' servers vary, you can consult the technical staff of the exchange for details.
- The strategy code in this article is just a simplified example code, with many cumbersome but necessary details removed. The indicators used are for reference only and should not be used directly. There are many details to pay attention to when running a high-frequency strategy, and it requires patience to modify and improve.

From: https://blog.mathquant.c...tailed-introduction.html

How ChatGPT improves your quantitative productivity significantly

2024-04-16T06:42:59Z

For quantitative trading and programmatic trading beginners, what are the biggest difficulties in learning? Generally speaking, there are several reasons:

- Basic knowledge deficiency: including basic concepts, market rules, trading knowledge, strategic thinking, etc.
- Poor programming foundation: including logical expression, program design and writing, program debugging and error correction.
- Weak logical thinking: the process of thinking can cause confusion easily, and the more you think, the more confused you become.
- Self-study difficulties: When encountering problems, it is difficult to know where to start solving them, and the direction of problem searching may not even be clear.

With the development of AI technology, solutions to these problems can be found to some extent. The recently popular **ChatGPT** can be used as a tool for quantitative trading learning, research, and creation. With FMZ platform's new upgrade for strategy editor and integration with ChatGPT, it improves the productivity of quantification greatly. Let's explore **the new functions of FMZ strategy editor** together!

Use ChatGPT to assist in code design
Although the current capabilities of ChatGPT are already very powerful, and it can understand human questions very well, the answers it provides are still highly sensitive to factors such as **the completeness and accuracy of the question description**. If the described scenario or question content is not accurate, ChatGPT may be unable to provide a perfect answer. Therefore, when using it to solve some problems, it is necessary to try to express them correctly and completely.

Next, we will use the ChatGPT function of the FMZ platform strategy editor to solve a code design problem. Log in to the FMZ platform and go to the strategy editing page.

1. Summon ChatGPT
https://stocksharp.com/file/150281

Right-click on the blank space, select ChatGPT option and click to call out ```ChatGPT```, or **use Ctrl+K to call out ChatGPT**.

2. The technique of asking questions
If I am a quantitative trading beginner now, I have a requirement:

> Use one-minute K-line to synthesize any period K-line data.

As a beginner, my programming ability is poor, and I really don't know how to write such an algorithm. In the past, I could only search for information and ask experts for help. Now, with ChatGPT, I can ask it for answers directly. Of course, as mentioned above, describing the requirement directly: "**Use one-minute K-line data to synthesize any period K-line data**". GPT is unlikely to give you a 100% usable answer, so you still need to try your best to describe the problem thoroughly. Taking the requirement as an example, I kept adjusting my questions and asked many times before getting a usable answer that met my needs.

So let's make this requirement description a little more complete:
```
> On the FMZ platform, calling the exchange.GetRecords(60) function can obtain one-minute K-line data, and the data structure is: [{
> Time : Millisecond timestamp, // Start time of the period
> Open : 1000,
> High : 1500,
> Low : 900,
> Close : 1200,
> Volume : 1000000
> }, ...]
> Please design an algorithm that uses one-minute K-line data to synthesize any minute's K-line data. For periods that can be divided by 60 minutes, start counting from the whole point of 0 minutes. Implement it in Javascript language, write this algorithm as a separate function, test it in the function main() and use $.PlotRecords(KLineData, "name") for drawing.
```
After calling out ChatGPT, you can fill in the optimized question content mentioned above.
https://stocksharp.com/file/150282

ChatGPT starts working.
https://stocksharp.com/file/150284

Wait for it to finish writing.
https://stocksharp.com/file/150283

Sometimes ```ChatGPT``` adds ``` symbols to wrap the code, which in markdown indicates that the wrapped content is code. So we just need to remove the first and last lines. Since I asked it to use ```$.PlotRecords(KLineData, "name")``` for drawing, the strategy needs to reference a drawing library in order to draw. The purpose of drawing is to verify whether the K-line data synthesized by Chat GPT's code is correct.
Regarding what a template library is, I will not elaborate here; you can refer to FMZ's API documentation for more information, [The address of the Plot Library](https://www.fmz.com/strategy/27293).

The code provided by ```ChatGPT``` can be backtested directly. I set the default K-line period of the backtesting system as 5 minutes, which is used for comparing with K-line charts drawn from K-line data calculated by Chat GPT's algorithm.
https://stocksharp.com/file/150285

3. Backtest test code given by ChatGPT
https://stocksharp.com/file/150287
https://stocksharp.com/file/150286

Preliminarily, it seems that the algorithm given by ChatGPT to synthesize 5-minute K-line from 1-minute K-line is correct.

4. Complete code written by ChatGPT:
```
/*
Synthesize arbitrary minute K-line data
@param {Array} records - One-minute K-line data
@param {Number} period - Synthetic period, unit in minutes
@return {Array} - Synthesized K-line data
*/
function composeKLineData(records, period) {
var result = [];
var index = 0;
var open = records[0].Open;
var high = records[0].High;
var low = records[0].Low;
var close = records[0].Close;
var volume = records[0].Volume;
var time = records[0].Time - records[0].Time % (period * 60 * 1000);
for (var i = 1; i < records.length; i++) {
var record = records[i];
if (record.Time < time + period * 60 * 1000) {
high = Math.max(high, record.High);
low = Math.min(low, record.Low);
close = record.Close;
volume += record.Volume;
} else {
result[index] = {
Time: time,
Open: open,
High: high,
Low: low,
Close: close,
Volume: volume
};
index++;
open = record.Open;
high = record.High;
low = record.Low;
close = record.Close;
volume = record.Volume;
time = record.Time - record.Time % (period * 60 * 1000);
}
}
result[index] = {
Time: time,
Open: open,
High: high,
Low: low,
Close: close,
Volume: volume
};
return result;
}

function main() {
var records = exchange.GetRecords(60);
var kLineData = composeKLineData(records, 5); // Synthesize 5-minute K-line data
$.PlotRecords(kLineData, "KLineData");
}
```

Use ChatGPT to explain code
FMZ's integrated ChatGPT not only helps you write code, but also helps you explain the code. Select the ```composeKLineData``` function in the code just written by ChatGPT, right-click to show the menu:
https://stocksharp.com/file/150289

Use ChatGPT to give suggestions and optimize code
Even ChatGPT can provide optimization suggestions and optimized code.
https://stocksharp.com/file/150288

Other functions added to the editor
The FMZ editor update, in addition to adding the ChatGPT function. It also optimizes and enhances the online programming experience, adding many convenient functions.

View shortcut combinations
Right-click in the blank space or when selecting code to show the menu.
https://stocksharp.com/file/150290

It displays various shortcut key combinations.
https://stocksharp.com/file/150292

Modify variable name
Rename Symbol to modify the local variable name.
https://stocksharp.com/file/150291
https://stocksharp.com/file/150294

It only changed the variable name ```records``` in the ```main``` function of the above picture.

Modify all the same content
Change All Occurrences, select a variable name, word, and edit all the same content in the text simultaneously.
https://stocksharp.com/file/150293
https://stocksharp.com/file/150297

Formatting (code optimization, automatic alignment format)
Format Selection, format the selected code.

Format Document, format all code.
https://stocksharp.com/file/150296

Go to Definition, Reference
Go to Definition: Go to Definition.
Go to References: Go to References.
Go to Symbol...: Go to variable names, function names, etc.
https://stocksharp.com/file/150295

Peek Definition, Peek References
Peek Definition: Definition preview, view the definition of the selected code without leaving the current line of code.
Peek References: Quote preview, view the references to the current code line in other code lines without leaving the current code line, it can go quickly, in order to understand the code logic and structure better.
https://stocksharp.com/file/150298

From: https://blog.mathquant.c...ivity-significantly.html

Get Started with web3 Development Easily Based on Ethereum Using FMZ (7)

2024-04-16T05:12:05Z

### Execute Read method calldata

For the execution of the ```calldata``` of the Read method, we use the previously learned RPC method: ```eth_call``` to execute it. We explained the ```eth_call``` RPC method of the Ethereum only did a demonstration of the ```Write``` method of the smart contract, in this section, we use the ```calldata``` method to demonstrate the execution of the smart contract Read method call. Let's use the ```balanceOf``` method of the WETH contract to read the current balance of WETH tokens in the wallet.

We use the debugging tool to test on the Ethereum mainnet at:

```javascript
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// ABI for WETH contracts
var abiWETH = `[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}]`

// WETH contract address
var wethAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"

// Register ABI for WETH contracts
exchange.IO("abi", wethAddress, abiWETH)

// The wallet address of the currently configured exchange object
var walletAddress = exchange.IO("address")

// Coded WETH contract's deposit method call
var calldataForDeposit = exchange.IO("encode", wethAddress, "balanceOf(address)", walletAddress)
Log("calldataForDeposit:", "0x" + calldataForDeposit)

// Construct the transaction as the first parameter of eth_call
var transaction = {
"from" : walletAddress,
"to" : wethAddress,
"data" : "0x" + calldataForDeposit,
}

// The second parameter of eth_call
var blockNumber = "latest"

// Call with eth_call
var ret = exchange.IO("api", "eth", "eth_call", transaction, blockNumber)
var wethBalance = exchange.IO("decode", "uint256", ret) // You can use exchange.IO("decode", ...) function to decode
Log("wethBalance:", toAmount(wethBalance, 18)) // Converted from wei to WETH units
}
```

Run in the debugging tool:

```run
2023-06-15 11:51:31 Info wethBalance: 0.015
2023-06-15 11:51:31 Info calldataForDeposit: 0x70a082310000000000000000000000006b3f11d807809b0b1e5e3243df04a280d9f94bf4
```

If the method of a smart contract has a return value, you can use the ```exchange.IO("decode", ...)``` function to decode it. You can see that the passing ```calldata``` method is the same as calling the smart contract's ```balanceOf``` method directly, getting the WETH balance of 0.015 WETH for my test wallet.

### Execute Write method calldata

For the execution of the Write method calldata, it is necessary to use the RPC method: ```eth_sendRawTransaction```.

Let's use the debugging tool and test it on the Ethereum mainnet at:

```javascript
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(s, decimals) {
return (BigDecimal(s)*BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
// ABI for WETH contracts
var abiWETH = `[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}]`

// WETH contract address
var wethAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"

// Register ABI for WETH contract
exchange.IO("abi", wethAddress, abiWETH)

// The wallet address of the currently configured exchange object
var walletAddress = exchange.IO("address")

// Coded WETH contract's deposit method call
var calldataForDeposit = exchange.IO("encode", wethAddress, "deposit")
Log("calldataForDeposit:", "0x" + calldataForDeposit)

// Get nonce
var nonce = exchange.IO("api", "eth", "eth_getTransactionCount", walletAddress, "pending")

// Get gasPrice
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")

// Call the deposit method to change ETH to WETH, you need to transfer ETH, here we convert 0.01ETH to a hexadecimal value in wei
var innerAmount = BigInt(Number(toInnerAmount(0.005, 18))).toString(16)

// The transaction call object:
var obj = {
"from" : walletAddress,
"to" : wethAddress,
"gasPrice" : gasPrice,
"value" : "0x" + innerAmount,
"data" : "0x" + calldataForDeposit,
}

// Calculate gasLimit
var gasLimit = exchange.IO("api", "eth", "eth_estimateGas", obj)

// Construct a transaction
var transaction = {
"to": wethAddress,
"value": toAmount("0x" + innerAmount, 0), // Convert to decimal
"data": "0x" + calldataForDeposit,
"gasLimit": toAmount(gasLimit, 0), // Convert to decimal
"gasPrice": toAmount(gasPrice, 0), // Convert to decimal
"nonce": toAmount(nonce, 0), // Convert to decimal
"chainId": 1, // Ethereum mainnet Id
}
Log("transaction:", transaction)

// Signature, your key is replaced with your private key
var signedTx = Encode("signTx", "string", "hex", JSON.stringify(transaction), "hex", "0x" + "your key")
Log("signedTx:", "0x" + signedTx)

// Call eth_sendRawTransaction to send a transaction
var ret = exchange.IO("api", "eth", "eth_sendRawTransaction", "0x" + signedTx)
return ret
}
```

Run in the debugging tool:

```run
2023-06-15 09:58:50 Info signedTx: 0xf86f4f8504202067888...
2023-06-15 09:58:50 Info transaction: {"to":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","value":5000000000000000,"data":"0xd0e30db0","gasLimit":27938,"gasPrice":17718863752,"nonce":79,"chainId":1}
2023-06-15 09:58:50 Info calldataForDeposit: 0xd0e30db0
```

Execute ```var ret = exchange.IO("api", "eth", "eth_sendRawTransaction", "0x" + signedTx)``` function and the returned Transaction Hash is: ``` 0x2ff585504b0fe59b0122f696e8808abfe2f3ce263448066533f3bb8a4f55e8e6```. The ```eth_sendRawTransaction``` call executes the calldata in it, calling the ```deposit``` method of the WETH contract to swap the 0.005 ETH sent for WETH.

## Listening to mempool

Before a user's transaction is packaged into the Ethereum blockchain by miners, all transactions will be pooled in ```Mempool``` (transaction memory pool), where "miners" also look for transactions with high fees to be packaged first, in order to maximize mining benefits. Therefore, usually the higher the transaction's gasPrice setting, the more likely it is to be packaged.

Some transaction scripts will also sniff ```Mempool``` in the hope of finding some profitable transactions. For example, if a transaction is set with a high exchange slippage, the transaction could be subject to a "sandwich attack'' by these transactionscripts. So how do these scripts listen for ```pending``` (pending, to-be-packaged) transactions in ```Mempool```?

### Listening with the REST protocol

Use the RPC method we learned before: ```eth_getBlockByNumber```, but we do not pass the specific ```blockNumber``` this time, we use the ```"pending"``` tag.

```javascript
function main() {
var data = exchange.IO("api", "eth", "eth_getBlockByNumber", "pending", true)
if (Array.isArray(data.transactions)) {
for (var i = 0; i < data.transactions.length; i++) {
Log(data.transactions[i])
}
}
}
```

Run in the debugging tool:

```run
2023-06-18 19:23:05 Info {"blockNumber":"0x10b2027","type":"0x2","accessList":[],"blockHash":"0xf833ed36435c53d63bd7109bb1e85383075534410c14573881bf26d912f46a89","from":"0xd50521974d62f1fa34b8e81cb742ccf6147d05ff","gasPrice":"0x32ea2db37","hash":"0xf8f10f8f473c340b021298feb48d0affe529e8737a309c4cc1902e8989ef0914","input":"0xa22cb4650000000000000000000000001e0049783f008a0085193e00003d00cd54003c710000000000000000000000000000000000000000000000000000000000000001","v":"0x0","value":"0x0","maxFeePerGas":"0x48a413364","maxPriorityFeePerGas":"0x5f5e100","nonce":"0x8","r":"0x8c1cc36f43b02c9e9e454153588cc9d38757f1da69ec49d3cfdda74ab69e06a8","s":"0x2f3dd3e5ddf9e5d42c128a8e900026aca7568fa83c68cf332e1328066ee8d03a","transactionIndex":"0x3a","chainId":"0x1","gas":"0x1142d","to":"0x8c3c0274c33f263f0a55d129cfc8eaa3667a9e8b"}
2023-06-18 19:23:05 Info {"input":"0x646174613a2c7b2270223a226572632d3230222c226f70223a226d696e74222c227469636b223a2265746873222c226964223a223139323732222c22616d74223a2231303030227d","nonce":"0x1d","blockHash":"0xf833ed36435c53d63bd7109bb1e85383075534410c14573881bf26d912f46a89","from":"0xe7fa86855af674837cea1b58f88b5352543ca27b","gas":"0x81cc","gasPrice":"0x32ea2db37","to":"0xe7fa86855af674837cea1b58f88b5352543ca27b","chainId":"0x1","transactionIndex":"0x39","type":"0x2","value":"0x0","accessList":[],"blockNumber":"0x10b2027","hash":"0x55702f5d14736fc9d0c58fdac2d2052a602db171c46b5e1fa9ff6af5c277f9a2","maxFeePerGas":"0x48a413364","maxPriorityFeePerGas":"0x5f5e100","r":"0x5a703d389d23b51adf8ef0f55db8876e7392636797b68a4be6afe73e76d7e1f2","s":"0x4b4bb11257c4434a0acc2672357f8793476e4bfdf98bc30d2389ce335e7de64e","v":"0x1"}
2023-06-18 19:23:05 Info {"gas":"0x186a0","nonce":"0x46533","r":"0xfeea052a4ac2283ca058a657a806ba0916d8e7d52d2a577f150c40eb1dfbec65","s":"0x5bf0089a3c060ba787b67a205b44e1065a0d11d132b41737ab9adf0f55066811","transactionIndex":"0x38","value":"0x78f0975742c400","blockHash":"0xf833ed36435c53d63bd7109bb1e85383075534410c14573881bf26d912f46a89","chainId":"0x1","hash":"0x56bdf1b38e23db66e8d1c4014d1e9f690a9217d8a0232489210325fc69e25cf9","v":"0x25","input":"0x","type":"0x0","blockNumber":"0x10b2027","gasPrice":"0x4a817c800","from":"0x97b9d2102a9a65a26e1ee82d59e42d1b73b68689","to":"0xcb513e99c020e9d15a6eafef873fef5d9f078221"}
...
```

Extract one piece of the data:

```javascript
{
"blockNumber": "0x10b2027",
"type": "0x2",
"accessList": [],
"blockHash": "0xf833ed36435c53d63bd7109bb1e85383075534410c14573881bf26d912f46a89",
"from": "0xd50521974d62f1fa34b8e81cb742ccf6147d05ff",
"gasPrice": "0x32ea2db37",
"hash": "0xf8f10f8f473c340b021298feb48d0affe529e8737a309c4cc1902e8989ef0914",
"input": "0xa22cb4650000000000000000000000001e0049783f008a0085193e00003d00cd54003c710000000000000000000000000000000000000000000000000000000000000001",
"v": "0x0",
"value": "0x0",
"maxFeePerGas": "0x48a413364",
"maxPriorityFeePerGas": "0x5f5e100",
"nonce": "0x8",
"r": "0x8c1cc36f43b02c9e9e454153588cc9d38757f1da69ec49d3cfdda74ab69e06a8",
"s": "0x2f3dd3e5ddf9e5d42c128a8e900026aca7568fa83c68cf332e1328066ee8d03a",
"transactionIndex": "0x3a",
"chainId": "0x1",
"gas": "0x1142d",
"to": "0x8c3c0274c33f263f0a55d129cfc8eaa3667a9e8b"
}
```

### Listening with the WebSocket protocol

In the FMZ Quant Trading Platform, we use the ```Dial``` function to create ```WebSocket``` connections, you can check the ```FMZ API``` documentation to learn the ```Dial``` function.

The test code in this section runs in the Ethereum mainnet environment, and it is easier to use the FMZ Quant to test in live trading due to the use of WebSocket protocol communication. The Websocket protocol subscription messages are:

```javascript
{"jsonrpc": "2.0", "id": 1, "method": "eth_subscribe", "params": ["newPendingTransactions"]}
```

In addition to ```newPendingTransactions```, you can also subscribe to ```newHeads```, ```logs```.

Receiving data pushed by ```WebSocket``` connections:

```javascript
{
"jsonrpc": "2.0",
"method": "eth_subscription",
"params": {
"subscription": "0x2c5c087b4aa188e008f4747828ef4e61",
"result": "0x69c4251cecb814e17cfe7a5ee41742a616f9a4d1bbf245c49b186b1006fd14d3"
}
}
```

Then further query ```transaction``` according to which: ```"result": "0x69c4251cecb814e17cfe7a5ee41742a616f9a4d1bbf245c49b186b1006fd14d3"```. For a specific ```transaction```, we use the Ethereum RPC method ```eth_getTransactionByHash``` to query.

```javascript
var ws = null

function main () {
// {"jsonrpc": "2.0", "id": 1, "method": "eth_subscribe", "params": ["xxxxx"]} , "xxxxx" is the specific message to subscribe to
var payload = {"jsonrpc": "2.0", "id": 1, "method": "eth_subscribe", "params": ["newPendingTransactions"]}

// wss://mainnet.infura.io/ws/v3/xxxxx , "xxxxx" is your infura key
var infuraKey = "your key"

ws = Dial("wss://mainnet.infura.io/ws/v3/" + infuraKey + "|reconnect=true&payload=" + JSON.stringify(payload))
if (!ws) {
throw "websocket link infura failed!"
}

// eth_getTransactionByHash call count
var getTransactionCounter = 0

var beginTS = new Date().getTime()

// Loop to get messages
while (true) {
// Receive push messages
var data = ws.read()
if (data) {
var ts = new Date().getTime()

if (ts - beginTS >= 1000) {
getTransactionCounter = 0
beginTS = ts
}

// Check transaction details based on txHash
if (ts - beginTS < 1000 && getTransactionCounter >= 100) {
Sleep(1000)
getTransactionCounter = 0
beginTS = ts
}

var obj = JSON.parse(data)
if (obj["params"] && obj["params"]["result"]) {
var transcationInfo = exchange.IO("api", "eth", "eth_getTransactionByHash", obj["params"]["result"])
Log(obj["params"]["result"], "transcationInfo:", transcationInfo)
}

getTransactionCounter++
}

LogStatus(_D())
}
}

function onexit() {
Log("Disconnect WS connection")
ws.close()
}
```

Create a live trading to run the above code, you can receive the data pushed by the WebSocket connection, the data is pushed constantly, we extract one of them - ```transaction```:

```javascript
{
"maxPriorityFeePerGas": "0x5f5e100",
"nonce": "0x1a9",
"accessList": [],
"blockNumber": "0x10b1c9f",
"from": "0x5888700be02f52c8adf85890886ef84a6b8a7829",
"blockHash": "0x92c3d77ea218cdc0967ab74b6005bb393b92355047f206c7e2d59d41828e7fa9",
"chainId": "0x1",
"gasPrice": "0x34fdbf43d",
"s": "0x7d86ae29a786a61b9e74a7a9e2cc4b39b7913aa3d4c3816ccb07528fed82048a",
"to": "0xfc2068c3d47b575a60f6a4a7bf60dea0ac368e01",
"type": "0x2",
"v": "0x1",
"value": "0x0",
"gas": "0x1aad3",
"hash": "0x2c77c0704aefbb26db460cbb71efdb488df968ad53d2c2b3f1e1172056b40b22",
"input": "0x42842e0e0000000000000000000000005888700be02f52c8adf85890886ef84a6b8a7829000000000000000000000000d2d07e4d1bb0f40ac3e4aa7cc3ad05d348bfd2c3000000000000000000000000000000000000000000000000000000000000180b",
"maxFeePerGas": "0x4712d1273",
"r": "0x8ec58f95f6d9729a6eee075e6976658b6c5346cbc90eb68ac361a40af073b10e",
"transactionIndex": "0xc1"
}
```

Excerpted (partial omission) log data:

```run
2023-06-18 16:20:07 Info Disconnect WS connection
2023-06-18 16:20:07 Info 0xba07ca903f9eafbfa7d494bb26197713034b9ca2dd3c19bc0898af3f35b59343 transcationInfo: {"accessList":[],"from":"0xe2977d60182da068dfd78693f96362ee7a2e9644","nonce":"0xf","value":"0x0","blockHash":"0x92c3d77ea218cdc0967ab74b6005bb393b92355047f206c7e2d59d41828e7fa9","blockNumber":"0x10b1c9f","chainId":"0x1","hash":"0xba07ca903f9eafbfa7d494bb26197713034b9ca2dd3c19bc0898af3f35b59343","maxFeePerGas":"0x530c30b70","r":"0xf28bfdf372a5401a2e00675c6ebe8d5e73f2c955db44b1aa56240b9197d6cbc7","type":"0x2","v":"0x0","gas":"0x21079","gasPrice":"0x367b3783d","input":"0x657bb1130000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000001e0300000000000000000000000033c6eec1723b12c46732f7ab41398de45641fa42000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000041976bd7d021a5b94cbba72b291093b50a0ecf21d1c6cd8193fbfcd685c4723ce068feb249bdcace58c28eb3b6cc647e8c839b0826c84f8dfe4c31d57d1ac1f0111b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000648ebef50000000000000000000000000000000000000000000000000000000000000000","maxPriorityFeePerGas":"0x1dcd6500","s":"0x71d51246bb60e792f963a3c75c46fd8f557921ce6face7224c944e1768a76ca","to":"0x0b51eb9d0e54c562fedc07ceba453f05b70c4b79","transactionIndex":"0x40"}
2023-06-18 16:20:07 Info 0x2c77c0704aefbb26db460cbb71efdb488df968ad53d2c2b3f1e1172056b40b22 transcationInfo: {"maxPriorityFeePerGas":"0x5f5e100","nonce":"0x1a9","accessList":[],"blockNumber":"0x10b1c9f","from":"0x5888700be02f52c8adf85890886ef84a6b8a7829","blockHash":"0x92c3d77ea218cdc0967ab74b6005bb393b92355047f206c7e2d59d41828e7fa9","chainId":"0x1","gasPrice":"0x34fdbf43d","s":"0x7d86ae29a786a61b9e74a7a9e2cc4b39b7913aa3d4c3816ccb07528fed82048a","to":"0xfc2068c3d47b575a60f6a4a7bf60dea0ac368e01","type":"0x2","v":"0x1","value":"0x0","gas":"0x1aad3","hash":"0x2c77c0704aefbb26db460cbb71efdb488df968ad53d2c2b3f1e1172056b40b22","input":"0x42842e0e0000000000000000000000005888700be02f52c8adf85890886ef84a6b8a7829000000000000000000000000d2d07e4d1bb0f40ac3e4aa7cc3ad05d348bfd2c3000000000000000000000000000000000000000000000000000000000000180b","maxFeePerGas":"0x4712d1273","r":"0x8ec58f95f6d9729a6eee075e6976658b6c5346cbc90eb68ac361a40af073b10e","transactionIndex":"0xc1"}
2023-06-18 16:20:07 Info 0xbc42d5db10e5cb2e888c76005c522cb2474a0c0a7325feb867b618f69ff26f2a transcationInfo: {"accessList":[],"blockNumber":"0x10b1c9f","gas":"0x1cc12b","hash":"0xbc42d5db10e5cb2e888c76005c522cb2474a0c0a7325feb867b618f69ff26f2a","maxFeePerGas":"0x6ab262e5c","value":"0x0","v":"0x1","chainId":"0x1","from":"0xc1b634853cb333d3ad8663715b08f41a3aec47cc","input":"0x8f111f3c000000000000000000000000000000000000000000000000000000000003b83700000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000e0fa2000000000000000000000000e64a54e2533fd126c2e452c5fab544d80e2e4eb50000000000000000000000000000000000000000000000000000000004c6ff1c0000000000000000000000000000000000000000000000000000000004c70029000000000000000000000000000000000000000000000000000000000001822d005b1979341221e80ed20b20d832de88a8a4b535fe9990a90c165f3c95ad085ab9445c0a998c70edff76f1c2de3f4263d7e4fe3c3fb73fe7dcfbdede92371842fb883267f5408c8aaf08ba2f6c22463f19da98183d2302735615460d7380d6f9ff5e764e75bcaca9a93946cf644cd4d4448f314c4cf60cd0353f085aa0562d70e16a510b8bc4c2a09b5e7fafcd43f07dc1b5dd1782962af8f6fff7a6965bfc127e11501a72c64913d58e624333f9ec51687c7cb1bb4a9850541f1e03b2790ed4ee508052910dfe22542d900548d5243ca238811427491d49e98cf269ccab5b1724f0f9698120e406c00910c4090c0e84e0400e2706822d2a001a3964a0ca8101700a547342c2c1fff8934a988416f020a0c98f0909c7f529875f8443914e10b58145c79d38914d1fafbc9ee57ebcb377e4ac1cd252bdebe3c59e8e917fea7dbc7bf66dfc1846482a858645b95555b3ecc9ab4f9e2b0e3e78d68379b009e606a1cefe675670a5eabd5f5a2efa5d77a1084288480c98d01c70a3d8c6b854496e2a966dc9051b13b872b7c6c2c5d82676fd8e82c680514333db21db2006d23f42074021de7e61c54d88b01824d40f03d1505eb6ec6d0cb7ccd38deb821517a5e63d0e89f6bf0385f109c81ea36dd00e7a903a100290f5b47a940ed146ae9338ff8bc17a2b5bc457614d0831e743e485c0de84636b034400bf6bd192ff723045cc170e109aabf273dc9de19c9987038515b6613249f471f9ddeb31331cc1643902212d20241c417532ad7e4a9ac742b4b5f68e1019795cf9386dcf36037502c13ff51f50a2202b2c1cac1c0b38a21ec798deff778c9a6b679d16d0521d2df89c439f4f8f9425ed378f4194d03d00
2023-06-18 16:20:06 Info 0xff0945c3d682a37e18ee433d56c8bedbb93d9ac368af968ed8d53b655575e8e5 transcationInfo: {"gas":"0x5208","s":"0x63572e1fa060841b939cea0849154e55781fe0efcbdfe5ce6979b44ce0980e4a","transactionIndex":"0xa7","value":"0x113e9d515e400","blockHash":"0x92c3d77ea218cdc0967ab74b6005bb393b92355047f206c7e2d59d41828e7fa9","hash":"0xff0945c3d682a37e18ee433d56c8bedbb93d9ac368af968ed8d53b655575e8e5","nonce":"0x2","r":"0x698fe26331ad39ba89c4d30985b707792ea4ab09b25205727f8fac2a6120b54a","gasPrice":"0x35458af00","from":"0x228d93af92d03184c07aa9e39b3d2d61b666686d","input":"0x","to":"0x0246177b98a5e42835cdcfaac1c274d3e6c39486","v":"0x26","blockNumber":"0x10b1c9f","type":"0x0","chainId":"0x1"}
...
```

## Decoding Transaction Details

In the previous course, we wrote a monitoring program to monitor pending transactions on Ethereum, get the pushed transaction hash via WebSocket protocol, and then query the specific transaction details based on the transaction hash.

Next we want to do further parsing of the ```input``` field data in the transaction details data. The ```input``` field data looks like a jumble of hexadecimal data, but it actually encodes the content of the transaction: including the functions called, and the parameters entered, etc.

After repeated and extensive testing, we found that the timeliness and quantity of data pushed over by the WebSocket connection has a lot to do with the RPC node currently in use, and the pushed data received by two different RPC node services (e.g., infura, ALCHEMY) when creating a WebSocket connection at the same time is not exactly the same, and since the current scenario generates a large number of requests, we still need to use a more stable and faster RPC service. The WebSocket connection also pushes a lot of transaction hashes that have been Pending for a long time, and when using ```eth_getTransactionByHash``` to query, you often get a null value (tested on FMZ, node.js).

We use the ```alchemy``` RPC node this time: ```wss://eth-mainnet.g.alchemy.com/v2/oKmOQKbneVkxgHZfibs-iFhIlIAl6HDN```. The node supports both WebSocket and REST protocols.

We monitor the ```multicall(uint256,bytes[])``` method of the router smart contract of the Uniswap decentralized exchange, so we need to calculate the function signature hash of the method first.

```
// Take the first 8 characters of the complete hash
// multicall: 0x5ae401dc
var sigHash = "0x" + Encode("keccak256", "string", "hex", "multicall(uint256,bytes[])").slice(0, 8)
```

Based on the example in the previous lesson, we have made some modifications. When receiving messages pushed by the WebSocket connection, the latest data is received using ```var data = ws.read(-2)``` method, and the ```read()``` function parameter is set to -2 to indicate that the latest data is returned immediately. We only care about the ```Transaction``` that contains the ```multicall``` call, using ```if (tx && tx.input.indexOf(sigHash) ! == -1)``` to determine the filter.

2 custom functions need to be designed:

- ```calcAllFuncSigHash()```: Calculate signature hash for all methods based on ABI.
- ```decodeCall()```: Decoding function.

Next, when the ```multicall``` call is detected, the decoding operation can start, and the parameters of the ```multicall``` method are decoded for the first time: ```deadline``` and ```data```. ```deadline``` is a timestamp that is better understood, and ```data``` is another encoded ```calldata```, so you still need to continue to use the ```decodeCall()``` function to decode it.

Example of a complete implementation:

```javascript
var ws = null
var arrLog = []

const ABI_Route = '[{"inputs":[{"internalType":"address","name":"_factoryV2","type":"address"},{"internalType":"address","name":"factoryV3","type":"address"},{"internalType":"address","name":"_positionManager","type":"address"},{"internalType":"address","name":"_WETH9","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"WETH9","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveMax","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveMaxMinusOne","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveZeroThenMax","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"approveZeroThenMaxMinusOne","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"callPositionManager","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"paths","type":"bytes[]"},{"internalType":"uint128[]","name":"amounts","type":"uint128[]"},{"internalType":"uint24","name":"maximumTickDivergence","type":"uint24"},{"internalType":"uint32","name":"secondsAgo","type":"uint32"}],"name":"checkOracleSlippage","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"uint24","name":"maximumTickDivergence","type":"uint24"},{"internalType":"uint32","name":"secondsAgo","type":"uint32"}],"name":"checkOracleSlippage","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactInputParams","name":"params","type":"tuple"}],"name":"exactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMinimum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IV3SwapRouter.ExactInputSingleParams","name":"params","type":"tuple"}],"name":"exactInputSingle","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"}],"internalType":"struct IV3SwapRouter.ExactOutputSingleParams","name":"params","type":"tuple"}],"name":"exactOutputSingle","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getApprovalType","outputs":[{"internalType":"enum IApproveAndCall.ApprovalType","name":"","type":"uint8"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"}],"internalType":"struct IApproveAndCall.IncreaseLiquidityParams","name":"params","type":"tuple"}],"name":"increaseLiquidity","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint24","name":"fee","type":"uint24"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"internalType":"struct IApproveAndCall.MintParams","name":"params","type":"tuple"}],"name":"mint","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"previousBlockhash","type":"bytes32"},{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"positionManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"pull","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"refundETH","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowed","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitAllowedIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"selfPermitIfNecessary","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"swapExactTokensForTokens","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMax","type":"uint256"},{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"address","name":"to","type":"address"}],"name":"swapTokensForExactTokens","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"}],"name":"sweepToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"sweepTokenWithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"sweepTokenWithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"name":"unwrapWETH9","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"}],"name":"unwrapWETH9","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"unwrapWETH9WithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountMinimum","type":"uint256"},{"internalType":"uint256","name":"feeBips","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"}],"name":"unwrapWETH9WithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"wrapETH","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]'

function calcAllFuncSigHash(jsonABI) {
var mapSigHash = {}
for (var i in jsonABI) {
var ele = jsonABI[i]
if (typeof(ele["name"]) != "undefined") {
if (ele["inputs"]) {
var funcName = ele["name"]
if (ele["inputs"].length == 0) {
var methodId = "0x" + Encode("keccak256", "string", "hex", funcName + "()").slice(0, 8)
mapSigHash[methodId] = {"argsTypeList": [], "argsNameList": [], "funcName": funcName}
} else {
var arr = []
var arrName = []
var argPrototype = []
for (var j in ele["inputs"]) {
var inputType = ele["inputs"][j]["type"]
if (inputType == "tuple") {
var components = ele["inputs"][j]["components"]
var tupleType = []
var protoType = []
for (var componentsIdx = 0; componentsIdx < components.length; componentsIdx++) {
tupleType.push(components[componentsIdx]["type"])
protoType.push(components[componentsIdx]["name"] + " " + components[componentsIdx]["type"])
}
arr.push("(" + tupleType.join() + ")")
arrName.push(ele["inputs"][j]["name"])
// Prototype
argPrototype.push("tuple" + "(" + protoType.join() + ")")
} else {
arr.push(inputType)
arrName.push(ele["inputs"][j]["name"])
// Prototype
argPrototype.push(inputType)
}
}
var functionSignature = funcName + "(" + arr.join() + ")"
var methodId = "0x" + Encode("keccak256", "string", "hex", functionSignature).slice(0, 8)
mapSigHash[methodId] = {"argsTypeList": arr, "argsNameList": arrName, "funcName": funcName, "argPrototype": argPrototype}
}
}
}
}
return mapSigHash
}

function decodeCall(input, abi) {
var mapSigHash = calcAllFuncSigHash(JSON.parse(abi))
var methodId = input.slice(0, 10)
var data = input.slice(10)

var decodedArgs = {}
var infoMethod = mapSigHash[methodId]
if (typeof(infoMethod) == "undefined") {
return [methodId, mapSigHash]
}

var arr = []
for (var i = 0; i < infoMethod["argsTypeList"].length; i++) {
if (infoMethod["argsTypeList"][i].startsWith("(")) {
arr.push(infoMethod["argPrototype"][i])
} else {
arr.push(infoMethod["argsTypeList"][i])
}
}

if (arr.length == 0) {
return {"funcName": infoMethod["funcName"], "args": decodedArgs}
}

var args = exchange.IO("decode", arr.join(), data)

if (!Array.isArray(args)) {
args = [args]
}

if (args.length != infoMethod["argsNameList"].length) {
Log("args:", args)
Log("infoMethod:", infoMethod)
throw "The decoded args are not equal to the argsNameList"
}

for (var i = 0; i < infoMethod["argsNameList"].length; i++) {
var key = infoMethod["argsNameList"][i]
var value = args[i]
decodedArgs[key] = value
}

return {"funcName": infoMethod["funcName"], "args": decodedArgs}
}

function main () {
// {"jsonrpc": "2.0", "id": 1, "method": "eth_subscribe", "params": ["xxxxx"]} , "xxxxx" is the specific message of the subscription
var payload = {"jsonrpc": "2.0", "id": 1, "method": "eth_subscribe", "params": ["newPendingTransactions"]}

// Use the alchemy service
ws = Dial("wss://eth-mainnet.g.alchemy.com/v2/oKmOQKbneVkxgHZfibs-iFhIlIAl6HDN" + "|reconnect=true&payload=" + JSON.stringify(payload))
if (!ws) {
throw "websocket link to alchemy failed!"
}

// eth_getTransactionByHash call count
var getTransactionCounter = 0

// Start Timestamp
var beginTS = new Date().getTime()

// Calculate function signature hash
var sigHash = "0x" + Encode("keccak256", "string", "hex", "multicall(uint256,bytes[])").slice(0, 8)
Log("sigHash:", sigHash)

// Loop for messages
while (true) {
var msg = ""
var recv = null
// Receive pushed messages, use the read parameter -2, and return the latest data immediately
var data = ws.read(-2)
if (data && data != "") {
var ts = new Date().getTime()

if (ts - beginTS >= 1000) {
getTransactionCounter = 0
beginTS = ts
}

// Check transaction details based on txHash
if (ts - beginTS < 1000 && getTransactionCounter >= 100) {
Sleep(1000)
getTransactionCounter = 0
beginTS = ts
}

var obj = JSON.parse(data)
if (obj["params"] && obj["params"]["result"]) {
var txHash = obj["params"]["result"]
var tx = exchange.IO("api", "eth", "eth_getTransactionByHash", txHash)

if (tx && tx.input.indexOf(sigHash) !== -1) {
// Decode transaction details
arrLog = []
var decodedInput = decodeCall(tx.input, ABI_Route)

// Log("----------------", txHash, "/", decodedInput["funcName"], "----------------", "#FF0000")
arrLog.push("----------------" + txHash + "/" + decodedInput["funcName"] + "----------------" + "#FF0000")
arrLog.push(tx.from + " -> " + tx.to)

for (var i = 0; i < decodedInput["args"]["data"].length; i++) {
var calldata = "0x" + decodedInput["args"]["data"][i]
var decodedCalldata = decodeCall(calldata, ABI_Route)

// Log("----------------", decodedCalldata["funcName"], "----------------", "#FF0000")
arrLog.push("----------------" + decodedCalldata["funcName"] + "----------------" + "#FF0000")

for (var key in decodedCalldata["args"]) {
// Log(key, decodedCalldata["args"][key])
arrLog.push(key + ": " + JSON.stringify(decodedCalldata["args"][key]))
}
}

// Output logs
for (var logIdx = arrLog.length - 1; logIdx >= 0; logIdx--) {
Log(arrLog[logIdx])
}
}

getTransactionCounter++
}
recv = obj
} else if (data == null) {
msg = "The buffer queue is empty, time:" + _D()
}

LogStatus(_D(), ", msg:", msg, ", recv:", recv)
}
}

function onexit() {
Log("Disconnect WS connection")
ws.close()
}

function onerror() {
Log("Disconnect WS connection")
ws.close()

for (var logIdx = arrLog.length - 1; logIdx >= 0; logIdx--) {
Log(arrLog[logIdx])
}
}
```

Create a live trading to test:

```run
2023-06-20 17:01:00 Info ----------------0x5288a7bd6e0f57162ca763df722de73793e542734d7d2b7af5755664e2e67910/multicall----------------
2023-06-20 17:01:00 Info 0x851b594033d57c98af753bcb3a7d0237a615de32 -> 0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45
2023-06-20 17:01:00 Info ----------------exactInputSingle----------------
2023-06-20 17:01:00 Info params: {"tokenOut":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2","fee":"10000","recipient":"0x0000000000000000000000000000000000000002","amountIn":"8952087000296027130940868","amountOutMinimum":"41638694112306829","sqrtPriceLimitX96":"0","tokenIn":"0xe1283567345349942acdfad3692924a1b16cf3cc"}
2023-06-20 17:01:00 Info ----------------unwrapWETH9----------------
2023-06-20 17:01:00 Info amountMinimum: "41638694112306829"
2023-06-20 17:01:00 Info recipient: "0x851b594033d57c98af753bcb3a7d0237a615de32"
2023-06-20 16:59:03 Info ----------------0x55e0c4a38a17d3aa6e8f558a66c77e9defa9f8f6e347536363ac1b921de9aaf3/multicall----------------
2023-06-20 16:59:03 Info 0x27457ada2dd725c7d0f28e1737bdd0bf583c0f0b -> 0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45
2023-06-20 16:59:03 Info ----------------swapExactTokensForTokens----------------
2023-06-20 16:59:03 Info amountIn: "816769666850161"
2023-06-20 16:59:03 Info amountOutMin: "40404501509302321"
2023-06-20 16:59:03 Info path: ["0x7863e06bca47ded821fcb53ab788eeb371243eda","0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"]
2023-06-20 16:59:03 Info to: "0x27457ada2dd725c7d0f28e1737bdd0bf583c0f0b"
2023-06-20 16:58:25 Info sigHash: 0x5ae401dc
```

Screenshot:
https://stocksharp.com/file/150279
You can see that the Transaction Hash is ```0x5288a7bd6e0f57162ca763df722de73793e542734d7d2b7af5755664e2e67910``` for this transaction, and the input data data contains the call to a ```multicall``` method call. This transaction is sent in the direction: 0x851b594033d57c98af753bcb3a7d0237a615de32 -> 0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45. ```0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45 ``` is Uniswap's router contract address.
https://stocksharp.com/file/150280
The ```multicall``` package is parsed to call the contract's ```exactInputSingle``` and ```unwrapWETH9``` methods and the specific parameters of these methods.

```
----------------exactInputSingle----------------
params: {
"tokenOut":"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"fee":"10000",
"recipient":"0x0000000000000000000000000000000000000002",
"amountIn":"8952087000296027130940868",
"amountOutMinimum":"41638694112306829",
"sqrtPriceLimitX96":"0",
"tokenIn":"0xe1283567345349942acdfad3692924a1b16cf3cc"
}

----------------unwrapWETH9----------------
amountMinimum: "41638694112306829"
recipient: "0x851b594033d57c98af753bcb3a7d0237a615de32"
```

If you are interested, you can modify and extend the example based on it to monitor more transactions and parse these on-chain operations.
From: https://blog.mathquant.c...-ethereum-using-fmz.html

Get Started with web3 Development Easily Based on Ethereum Using FMZ (6)

2024-04-16T03:28:35Z

## Unit conversions

Many of the calculations related to Ethereum have values that exceed the maximum safe integer of the ```JavaScript``` language. Therefore, some methods are needed on the FMZ Quant Trading Platform to handle large values, which we have used specifically in previous courses and have not covered in detail. This section will discuss this aspect in detail.

Print the maximum safe integer defined in the ```JavaScript``` language:

```javascript
function main() {
Log("Number.MAX_SAFE_INTEGER:", Number.MAX_SAFE_INTEGER)
}
```

Running results:

> Number.MAX_SAFE_INTEGER: 9007199254740991

### BigInt
The smallest unit defined in Ethereum is ```1wei```, and the definition ```1Gwei``` is equal to ```1000000000 wei```. ```1Gwei``` is not really a very large number in Ethereum-related calculations, and some data is much larger than it. So these data with very large values can easily exceed ```Number.MAX_SAFE_INTEGER: 9007199254740991```.

At FMZ Quant Trading Platform, we use the platform's ```BigInt``` object to represent these very large integer data. Use the constructor ```BigInt()``` to construct the ```BigInt``` object. You can construct ```BigInt``` objects using numeric, hexadecimal numeric strings as parameters. Use the ```toString()``` method of ```BigInt``` object to output the data represented by the object as a string.

The operations supported by the ```BigInt``` object are:

- Addition: ```+```
- Subtraction: ```-```
- Multiplication: ```*```
- Division: ```/```
- Modulo operations: ```%```
- Power operations: ```*```

Refer to the following code examples:

```javascript
function main() {
// Decimal representation of 1Gwei
var oneGwei = 1000000000

// Decimal to hexadecimal conversion of 1Gwei
var oneGweiForHex = "0x" + oneGwei.toString(16)

Log("oneGwei : ", oneGwei)
Log("oneGweiForHex : ", oneGweiForHex)

// Constructing BigInt objects
Log("1Gwei / 1Gwei : ", (BigInt(oneGwei) / BigInt(oneGweiForHex)).toString(10))
Log("1Gwei * 1Gwei : ", (BigInt(oneGwei) * BigInt(oneGweiForHex)).toString(10))
Log("1Gwei - 1Gwei : ", (BigInt(oneGwei) - BigInt(oneGweiForHex)).toString(10))
Log("1Gwei + 1Gwei : ", (BigInt(oneGwei) + BigInt(oneGweiForHex)).toString(10))
Log("(1Gwei + 1) % 1Gwei : ", (BigInt(oneGwei + 1) % BigInt(oneGweiForHex)).toString(10))
Log("1Gwei ** 2 : ", (BigInt(oneGwei) ** BigInt(2)).toString(10))
Log("The square root of 100 : ", (BigInt(100) ** BigFloat(0.5)).toString(10))

Log("Number.MAX_SAFE_INTEGER : ", BigInt(Number.MAX_SAFE_INTEGER).toString(10))
Log("Number.MAX_SAFE_INTEGER * 2 : ", (BigInt(Number.MAX_SAFE_INTEGER) * BigInt("2")).toString(10))
}
```

Debugging tool testing:

```run
2023-06-08 11:39:50 Info Number.MAX_SAFE_INTEGER * 2 : 18014398509481982
2023-06-08 11:39:50 Info Number.MAX_SAFE_INTEGER : 9007199254740991
2023-06-08 11:39:50 Info The square root of 100 : 10
2023-06-08 11:39:50 Info 1Gwei ** 2 : 1000000000000000000
2023-06-08 11:39:50 Info (1Gwei + 1) % 1Gwei : 1
2023-06-08 11:39:50 Info 1Gwei + 1Gwei : 2000000000
2023-06-08 11:39:50 Info 1Gwei - 1Gwei : 0
2023-06-08 11:39:50 Info 1Gwei * 1Gwei : 1000000000000000000
2023-06-08 11:39:50 Info 1Gwei / 1Gwei : 1
2023-06-08 11:39:50 Info oneGweiForHex : 0x3b9aca00
2023-06-08 11:39:50 Info oneGwei : 1000000000
```

### BigFloat

The ```BigFloat``` object is used similarly to the ```BigInt``` object to represent floating point numbers with larger values, and it also supports addition, subtraction, multiplication and division.
The ```BigFloat``` object supports the ```toFixed()``` method.

Refer to the following code example:

```javascript
function main() {
var pi = 3.14
var oneGwei = "1000000000"
var oneGweiForHex = "0x3b9aca00"

Log("pi + oneGwei : ", (BigFloat(pi) + BigFloat(oneGwei)).toFixed(2))
Log("pi - oneGweiForHex : ", (BigFloat(pi) - BigFloat(oneGweiForHex)).toFixed(2))
Log("pi * 2.0 : ", (BigFloat(pi) * BigFloat(2.0)).toFixed(2))
Log("pi / 2.0 : ", (BigFloat(pi) / BigFloat(2.0)).toFixed(2))
}
```

Debugging tool testing:

```javascript
2023-06-08 13:56:44 Info pi / 2.0 : 1.57
2023-06-08 13:56:44 Info pi * 2.0 : 6.28
2023-06-08 13:56:44 Info pi - oneGweiForHex : -999999996.86
2023-06-08 13:56:44 Info pi + oneGwei : 1000000003.14
```

### BigDecimal

The ```BigDecimal``` object is compatible with integer values and floating point values, and supports initialization with the ```BigInt``` object and the ```BigFloat``` object, and it also supports addition, subtraction, multiplication and division.

Refer to the following code example:

```javascript
function main() {
var pi = 3.1415
var oneGwei = 1000000000
var oneGweiForHex = "0x3b9aca00"

Log("pi : ", BigDecimal(pi).toFixed(2))
Log("oneGwei : ", BigDecimal(oneGwei).toString())
Log("oneGweiForHex : ", BigDecimal(BigInt(oneGweiForHex)).toString())

Log("BigInt(oneGwei) : ", BigDecimal(BigInt(oneGwei)).toString())
Log("BigFloat(pi) : ", BigDecimal(BigFloat(pi)).toFixed(4))

Log("oneGwei + pi : ", (BigDecimal(oneGwei) + BigDecimal(pi)).toString())
Log("oneGwei - pi : ", (BigDecimal(oneGwei) - BigDecimal(pi)).toString())
Log("2.0 * pi : ", (BigDecimal(2.0) * BigDecimal(pi)).toString())
Log("pi / pi : ", (BigDecimal(pi) / BigDecimal(pi)).toString())
}
```

Running in the debugging tool:

```run
2023-06-08 14:52:53 Info pi / pi : 1
2023-06-08 14:52:53 Info 2.0 * pi : 6.283
2023-06-08 14:52:53 Info oneGwei - pi : 999999996.8585
2023-06-08 14:52:53 Info oneGwei + pi : 1000000003.1415
2023-06-08 14:52:53 Info BigFloat(pi) : 3.1415
2023-06-08 14:52:53 Info BigInt(oneGwei) : 1e+9
2023-06-08 14:52:53 Info oneGweiForHex : 1e+9
2023-06-08 14:52:53 Info oneGwei : 1e+9
2023-06-08 14:52:53 Info pi : 3.14
```

### Unit conversions

The following two functions: ```toAmount()```, ```toInnerAmount()``` we have used many times in previous courses, these two functions are mainly used for data precision conversion.

```javascript
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}

function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
```

The ```toAmount()``` function converts (reduces) a variable ```s``` according to the precision parameter ```decimals```. In web3 practical development, it is often necessary to deal with some chained hexadecimal data.
We have often encountered this in our previous courses, for example, the ```data``` field data in the ```Transfer(address,address,uint256)``` event of a smart contract:

```desc
{
"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000",
"topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", "0x0000000000000000000000006b75d8af000000e20b7a7ddf000ba900b4009a80", "0x000000000000000000000000bcb095c1f9c3dc02e834976706c87dee5d0f1fb6"],
"transactionHash": "0x27f9bf5abe3148169b4b85a83e1de32bd50eb81ecc52e5af006157d93353e4c4",
"transactionIndex": "0x0",
"removed": false,
"address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"blockHash": "0x847be24a7b159c292bda030a011dfec89487b70e71eed486969b032d6ef04bad",
"blockNumber": "0x109b1cc",
"logIndex": "0x0"
}
```

When processing data ```"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000"```, we use the ```toAmount()``` function. This processing is designed to do a good job of converting data field data to readable values.

```javascript
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}

function main() {
var data = "0x00000000000000000000000000000000000000000000000001c1a55000000000"
Log(toAmount(data, 18)) // Print out 0.12656402755905127
}
```

1 ETH token, as we know, is ```1e18 wei```, if we get a data ```126564027559051260``` in ```wei```, how to convert it to ETH tokens?
Using the ```toAmount(, 18)``` function is a very simple conversion method. The ```toInnerAmount()``` function is the reverse operation of the ```toAmount()``` function (depending on the precision, zoom in), and it is easy to convert the data using these two functions.

It is important to note the integer value safety range in the JavaScript language, ```Number.MAX_SAFE_INTEGER```, and the following example illustrates a hidden problem when converting data:

```javascript
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
var amount = 0.01
var innerAmount = Number(toInnerAmount(amount, 18))

Log("Number.MAX_SAFE_INTEGER:", Number.MAX_SAFE_INTEGER) // 9007199254740991
Log("innerAmount:", innerAmount) // 10000000000000000

Log("typeof(innerAmount):", typeof(innerAmount), ", innerAmount:", innerAmount)

// Decimal value 10000000000000000 -> Hexadecimal value 0x2386f26fc10000
Log("Convert", innerAmount, "to hexadecimal:", innerAmount.toString(16))
Log("Convert", BigInt(10000000000000000).toString(10), "to hexadecimal:", BigInt(10000000000000000).toString(16))

Log("0x" + BigInt(10000000000000000).toString(16), "Convert to decimal:", toAmount("0x" + BigInt(10000000000000000).toString(16), 0))
}
```

It is possible to run in the debugging tool:

```run
2023-06-15 16:21:40 Info Convert 0x2386f26fc10000 to decimal: 10000000000000000
2023-06-15 16:21:40 Info Convert 10000000000000000 to hexadecimal: 2386f26fc10000
2023-06-15 16:21:40 Info Convert 10000000000000000 to hexadecimal: 10000000000000000
2023-06-15 16:21:40 Info typeof(innerAmount): number , innerAmount: 10000000000000000
2023-06-15 16:21:40 Info innerAmount: 10000000000000000
2023-06-15 16:21:40 Info Number.MAX_SAFE_INTEGER: 9007199254740991
```

Through observation we found that:

```javascript
Log("Convert", innerAmount, "to hexadecimal:", innerAmount.toString(16))
```

This line of code corresponds to the log output: ```Converting 10000000000000000 to hex: 10000000000000000```, which is not converted correctly. The reason is naturally that 10000000000000000 is beyond ```Number.MAX_SAFE_INTEGER```.

But when the decimal value is within the safe range, i.e., less than ```Number.MAX_SAFE_INTEGER```, the ```toString(16)``` function converts it properly again, for example:

```javascript
function main() {
var value = 1000
Log("Convert value to hexadecimal:", "0x" + value.toString(16)) // 0x3e8
Log("Convert 0x3e8 to decimal:", Number("0x3e8")) // 1000
}
```

In blockchain, even ```0.01``` ETH converted to a value of ```10000000000000000``` in ```wei``` will exceed ```Number.MAX_SAFE_INTEGER``, so a safer conversion for such cases is: ```BigInt(10000000000000000).toString(16)```.

## Simulation Calls

Executing transactions and calling the ```Write``` method of smart contracts on Ethereum costs a certain amount of gas and sometimes it fails. It is important to know which transactions are likely to fail before sending them and calling them. There are simulated calls on Ethereum for testing.

### eth_call

Ethereum's RPC method ```eth_call```: it can simulate a transaction and return the result of a possible transaction, but it does not actually execute the transaction on the blockchain.

The ```eth_call``` method has 2 parameters, the first one is a dictionary structure, ```transactionObject```:

```javascript
// transactionObject
{
"from" : ..., // The address from which the transaction is sent
"to" : ..., // The address to which the transaction is addressed
"gas" : ..., // The integer of gas provided for the transaction execution
"gasPrice" : ..., // The integer of gasPrice used for each paid gas encoded as hexadecimal
"value" : ..., // The integer of value sent with this transaction encoded as hexadecimal
"data" : ..., // The hash of the method signature and encoded parameters. For more information, see the Contract ABI description in the Solidity documentation
}
```

The second parameter is ```blockNumber```: you can pass the label ```latest/pending/earliest```, etc:

```javascript
/* blockNumber
The block number in hexadecimal format or the string latest, earliest, pending, safe or
finalized (safe and finalized tags are only supported on Ethereum, Gnosis, Arbitrum,
Arbitrum Nova and Avalanche C-chain), see the default block parameter description in
the official Ethereum documentation
*/
```

Next, we take the smart contract method ```approve``` and ```transfer``` calls of the token ```DAI``` as an example for simulation calls, and the following test environment is the main Ethereum network.

### Simulation call approve

We are all familiar with the ```approve``` method for ERC20 contracts, and we have practiced it in previous courses. Since the ERC20 contract is already built into the FMZ platform ABI, there is no need to register the ABI of the smart contract to be called by the simulation.

```javascript
function main() {
var contractAddressUniswapV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var contractAddress_DAI = "0x6b175474e89094c44da98b954eedeac495271d0f"
var wallet = exchange.IO("address")

// encode approve
var data = exchange.IO("encode", contractAddress_DAI, "approve(address,uint256)",
contractAddressUniswapV3SwapRouterV2, "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
Log("ERC20 token DAI approve encode, data:", data)

var transactionObject = {
"from" : wallet,
"to" : contractAddress_DAI,
// "gasPrice" : "0x" + parseInt("21270894680").toString(16),
// "gas" : "0x" + parseInt("21000").toString(16),
"data" : "0x" + data,
}
var blockNumber = "latest"

var ret = exchange.IO("api", "eth", "eth_call", transactionObject, blockNumber)
Log("ret:", ret)
}
```

The code in the example first encodes the ```approve(address,uint256)``` method and parameters, and the parameter value ```0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff``` of the ```approve``` method indicates the maximum number of authorizations. Authorization is given to the smart contract at address ```0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45``` i.e. the router contract for ```Uniswap V3```. Finally the Ethereum RPC method ```eth_call``` is called for simulation. You can see that the ```gasPrice``` and ```gas``` fields in the ```transactionObject``` parameters can be omitted.

The debugging tool is run and the simulation calls the approve method to authorize successfully (it does not authorize actually):

```run
2023-06-09 11:58:39 Info ret: 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 11:58:39 Info ERC20 token DAI approve encode, data: 095ea7b300000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
```

It is also possible to simulate some failure scenarios, when we adjust the ```gasPrice``` and ```gas``` parameters, if the ETH in the wallet is not enough to pay the gas fee, an error will be reported::

> insufficient funds

When the gas cost is set too low, an error will be reported:

> intrinsic gas too low: have 21000, want 21944 (supplied gas 21000)

### Simulation call transfer

We are familiar with ERC20's ```transfer``` method, which allows you to transfer ERC20 tokens to a certain wallet address, so let's try to simulate a transfer of 1000 DAI to Vitalik Buterin.

```javascript
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
var walletVitalik = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
var contractAddress_DAI = "0x6b175474e89094c44da98b954eedeac495271d0f"
var wallet = exchange.IO("address")

// transfer to Vitalik Buterin
var decimals_DAI = exchange.IO("api", contractAddress_DAI, "decimals")
var transferAmount = toInnerAmount(1000, decimals_DAI)
Log("Transfer amount:", 1000, "DAI, use toInnerAmount convert to:", transferAmount)

// encode transfer
var data = exchange.IO("encode", contractAddress_DAI, "transfer(address,uint256)",
walletVitalik, transferAmount)

var transactionObject = {
"from" : wallet,
"to" : contractAddress_DAI,
"data" : "0x" + data,
}
var blockNumber = "latest"

var ret = exchange.IO("api", "eth", "eth_call", transactionObject, blockNumber)
return ret
}
```

Since I don't have DAI tokens in this test wallet, running it in the debug tool reported the following error unexpectedly:

> execution reverted: Dai/insufficient-balance

Check the wallet address of Vitalik Buterin: ```0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045```, it is clear that this wallet has DAI tokens. So let's adjust the transfer direction of the simulation call and simulate the transfer of 1000 DAI from Vitalik Buterin to us.

Modify the code, where the changes I made comments:

```javascript
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
var walletVitalik = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
var contractAddress_DAI = "0x6b175474e89094c44da98b954eedeac495271d0f"
var wallet = exchange.IO("address")

var decimals_DAI = exchange.IO("api", contractAddress_DAI, "decimals")
var transferAmount = toInnerAmount(1000, decimals_DAI)
Log("Transfer amount:", 1000, "DAI, use toInnerAmount convert to:", transferAmount)

// encode transfer
var data = exchange.IO("encode", contractAddress_DAI, "transfer(address,uint256)",
wallet, transferAmount) // Use the wallet variable as a parameter and change the transfer recipient's address to my own

var transactionObject = {
"from" : walletVitalik, // Use the walletVitalik variable as the value of the from field to simulate that the call was made from the Vitalik Buterin's wallet address
"to" : contractAddress_DAI,
"data" : "0x" + data,
}
var blockNumber = "latest"

var ret = exchange.IO("api", "eth", "eth_call", transactionObject, blockNumber)
Log(ret)
}
```

Debugging tool test:

```javascript
2023-06-09 13:34:31 Info 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 13:34:31 Info Transfer amount: 1000 DAI, use toInnerAmount convert to: 1000000000000000000000
```

Using the FMZ Quant Trading Platform, it is easy to simulate the results of transactions and avoid unnecessary loss of gas fees from sending potentially failed transactions. We used the example code from this chapter of the course to simulate the call to transfer money to Vitalik Buterin's wallet and Vitalik Buterin's wallet to transfer money to us. Of course, there are many more uses for this ```eth_call``` method. Use your imagination, what would you use the ```eth_call``` method for?

## Identify ERC721 Contracts

We know that tokens like ETH and BTC are homogenized tokens, and the token in your wallet is not different from the token in my wallet. But there are many things in the world that are not homogeneous, such as real estate, antiques, virtual artwork, etc. These cannot be represented by homogeneous tokens in abstraction. Therefore, there is the ERC721 standard to abstract non-homogeneous objects, and there is NFT and related concepts.
So among the many smart contracts deployed on Ethereum, how do we identify which smart contracts are ERC721 standard smart contracts?

To identify ERC721, it is important to know the ERC165 standard first.

### ERC165
With the ERC165 standard, a smart contract can declare the interfaces it supports for other contracts to check. An ERC165 interface contract has only one function: ```supportsInterface(bytes4 interfaceId)```, the parameter ```interfaceId``` is the interface Id to be queried. If the contract implements the interfaceId returns a boolean true value, otherwise it returns a false value.

Here we are going to talk about how this ```interfaceId``` is calculated and encoded specifically.

[ERC165 Standard](https://eips.ethereum.org/EIPS/eip-165) shows an example:

```solidity
pragma solidity ^0.4.20;

interface Solidity101 {
function hello() external pure;
function world(int) external pure;
}

contract Selector {
function calculateSelector() public pure returns (bytes4) {
Solidity101 i;
return i.hello.selector ^ i.world.selector;
}
}
```

For the function signature of the interface (consisting of a function name and a list of parameter types) to perform a dissimilarity operation, for an ERC165 interface contract where the contract has only one function:

```solidity
pragma solidity ^0.4.20;

interface ERC165 {
/// @notice Query if a contract implements an interface
/// @param interfaceID The interface identifier, as specified in ERC-165
/// @dev Interface identification is specified in ERC-165. This function
/// uses less than 30,000 gas.
/// @return `true` if the contract implements `interfaceID` and
/// `interfaceID` is not 0xffffffff, `false` otherwise
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
```

> The interface identifier for this interface is 0x01ffc9a7. You can calculate this by running bytes4(keccak256('supportsInterface(bytes4)')); or using the Selector contract above.

Calculate the function signature directly and take its first 4 bytes to arrive at ```interfaceId```.

```javascript
function main() {
var ret = Encode("keccak256", "string", "hex", "supportsInterface(bytes4)")
Log("supportsInterface(bytes4) interfaceId:", "0x" + ret.slice(0, 8))
}
```

Tests can be run in the debug tool at:

```run
2023-06-13 14:53:35 Info supportsInterface(bytes4) interfaceId: 0x01ffc9a7
```

It can be seen that the calculated results are consistent with the description in the [ERC165 Standard](https://eips.ethereum.org/EIPS/eip-165) document.

### ERC721

Next let's look at the interface definition of the ERC721 contract standard:

```solidity
interface ERC721 /* is ERC165 */ {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);

event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);

event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

function balanceOf(address _owner) external view returns (uint256);

function ownerOf(uint256 _tokenId) external view returns (address);

function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;

function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

function approve(address _approved, uint256 _tokenId) external payable;

function setApprovalForAll(address _operator, bool _approved) external;

function getApproved(uint256 _tokenId) external view returns (address);

function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
```

If we want to determine whether a smart contract is an ERC721 contract, first we need to know the ```interfaceId``` of the ERC721 contract before we can try to use the ```supportsInterface(bytes4 interfaceId)``` method to determine it. In previous courses, we have familiarized us with some concepts of the ERC165 standard and the algorithm for calculating the ```interfaceId```, and we write code to calculate directly:

```javascript
function calcSelector(arrSelector) {
var ret = null
if (Array.isArray(arrSelector)) {
if (arrSelector.length == 1) {
ret = Encode("keccak256", "string", "hex", arrSelector[0])
} else if (arrSelector.length == 0) {
throw "Error: the number of elements in the array is 0"
} else {
var viewEncodeData = null
for (var i = 0; i < arrSelector.length; i++) {
if (i == 0) {
ret = new Uint8Array(Encode("keccak256", "string", "raw", arrSelector[i]))
} else {
viewData = new Uint8Array(Encode("keccak256", "string", "raw", arrSelector[i]))

if (viewData.length != ret.length) {
throw "Error: TypeArray view length is different"
}

for (var index = 0; index < ret.length; index++) {
ret[index] ^= viewData[index]
}
}
}
ret = Encode("raw", "raw", "hex", ret.buffer)
}
} else {
throw "Error: The parameter requires an array type."
}

return "0x" + ret.slice(0, 8)
}
function main() {
// supportsInterface(bytes4): 0x01ffc9a7
// var ret = calcSelector(["supportsInterface(bytes4)"])

// ERC721Metadata: 0x5b5e139f
/*
var arrSelector = [
"name()",
"symbol()",
"tokenURI(uint256)"
]
var ret = calcSelector(arrSelector)
*/

// ERC721: 0x80ac58cd
// /*
var arrSelector = [
"balanceOf(address)",
"ownerOf(uint256)",
"safeTransferFrom(address,address,uint256,bytes)",
"safeTransferFrom(address,address,uint256)",
"transferFrom(address,address,uint256)",
"approve(address,uint256)",
"setApprovalForAll(address,bool)",
"getApproved(uint256)",
"isApprovedForAll(address,address)",
]
var ret = calcSelector(arrSelector)
// */

Log(ret)
}
```

The code uses the ```Encode()``` function for function signature calculation (the ```keccak256``` algorithm), and for the calculation in the code example above, specifying the output parameter of the ```Encode()``` function as ```"raw"```, the function returns the ```ArrayBuffer``` type of ```JavaScript``` language.
To perform a ```^``` (iso-or) operation on two ```ArrayBuffer``` objects, you need to create a ```TypedArray``` view based on the ```ArrayBuffer``` object, then iterate through the data in it and perform the iso-or operation one by one.

Run in the debugging tool:

```run
2023-06-13 15:04:09 Info 0x80ac58cd
```

It can be seen that the calculated results are consistent with those described in [eip-721](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md).

```solidity
pragma solidity ^0.4.20;

/// @title ERC-721 Non-Fungible Token Standard/// @dev See https://eips.ethereum.org/EIPS/eip-721/// Note: the ERC-165 identifier for this interface is 0x80ac58cd.interface ERC721 /* is ERC165 */ {
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
...

```

With the ERC721 interface Id, we can determine if a contract is an ERC721 standard contract or not. We use ```BAYC``` to do the test, which is a contract that follows ERC721. First we need to register the ABI, and since we only call the following three methods, we can register these three methods:

- supportsInterface(interfaceId)
- symbol()
- name()

The specific codes are as follows:

```javascript
function main() {
// Contract address for ERC721, BAYC is used here
var testContractAddress = "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"

var testABI = `[{
"inputs": [{
"internalType": "bytes4",
"name": "interfaceId",
"type": "bytes4"
}],
"name": "supportsInterface",
"outputs": [{
"internalType": "bool",
"name": "",
"type": "bool"
}],
"stateMutability": "view",
"type": "function"
}, {
"inputs": [],
"name": "symbol",
"outputs": [{
"internalType": "string",
"name": "",
"type": "string"
}],
"stateMutability": "view",
"type": "function"
}, {
"inputs": [],
"name": "name",
"outputs": [{
"internalType": "string",
"name": "",
"type": "string"
}],
"stateMutability": "view",
"type": "function"
}]`

// ERC721 Interface Id, calculated in the previous course
var interfaceId = "0x80ac58cd"

// Register ABI
exchange.IO("abi", testContractAddress, testABI)

// Call the supportsInterface method
var isErc721 = exchange.IO("api", testContractAddress, "supportsInterface", interfaceId)

// Output Information
Log("Contract address:", testContractAddress)
Log("Contract name:", exchange.IO("api", testContractAddress, "name"))
Log("Contract code:", exchange.IO("api", testContractAddress, "symbol"))
Log("Whether the contract is ERC721 standard:", isErc721)
}
```

Tests can be run in the debugging tool:

```run
2023-06-13 16:32:57 Info Whether the contract is ERC721 standard: true
2023-06-13 16:32:57 Info Contract code: BAYC
2023-06-13 16:32:57 Info Contract name: BoredApeYachtClub
2023-06-13 16:32:57 Info Contract address: 0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d
```

The contract with the address ```0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d``` is determined to be ERC721 standard.

In this part, we introduced how to determine ERC721 contracts, so contracts like ERC20, which do not support the ERC165 standard, will have to be identified in another way. Do you know how to check if a contract is ERC20 standard?

## Encoding calldata

What is ```calldata```? By the author's understanding, a simple layman's description here is:

> The "calldata" is the encoding of a function call or parameter in Ethereum, and the "calldata" is encoded according to the ABI (Application Binary Interface) specification of the contract.

For example, we can encode the ```balanceOf``` and ```transfer``` method calls of the ERC20 contract we studied in the previous course, together with the parameters of the calls, into a ```calldata```. In some application scenarios, such as **interaction between contracts**, this scenario will use ```calldata```, and of course there are many other application scenarios that are not listed here.

How to code a smart contract function call to get ```calldata```?

In the FMZ Quant Trading Platform, you can use ```exchange.IO("encode", ...)``` to encode smart contract function calls, the use of exchange.IO("encode", ...) is very simple. The first parameter of the function is the fixed string ```"encode"```; the second parameter is the address of the smart contract; the third parameter is the name of the smart contract method to be encoded; the rest of the parameters are passed to the specific parameter value of the smart contract method to be encoded.

### eth_sendRawTransaction

When we encode a smart contract method call and generate the corresponding ```calldata``` data, if this smart contract method is a Write method (i.e.: write operation), we need to use the generated ```calldata``` data as the data field of the transaction and then use the Ethereum RPC method ```eth_ sendRawTransaction``` to send a request containing the raw data of that transaction to the Ethereum network.

The ```eth_sendRawTransaction``` method has only one parameter, ```data```:

> data: The signed transaction (typically signed with a library, using your private key)

The ```data``` parameter is a transaction data after the signature calculation, and the transaction data structure of Ethereum has the following main fields:

```javascript
{
"nonce": "0x1", // Number of transactions on the account of the sender of the transaction
"gasPrice": "0x12a05f200", // Traded Gas price
"gasLimit": "0x5208", // Gas limit for trading
"to": "0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2", // Target contract address or recipient address
"value": "0x4563918244F40000", // Number of Ethereum transferred
"data": "0x0123456789ABCDEF", // Data to send to the contract
}
```

How to sign an Ethereum transaction?

In the FMZ Quant Trading Platform, we use the ```Encode()``` function to perform the signature calculation, the specific example we write in the subsequent course "Execute Write method calldata".

To be continued...