sted IP-Adresse ist10.0.3.15 }
#### exchange.SetTimeout(...)
```exchange.SetTimeout(Millisecond)```, in which the parameter **Millisecond** is a millisecond value.
Only for the ```rest``` protocol, it is used to set the time-out period for ```rest``` requests, and it takes effect only by setting it once.
For example: ```exchange.SetTimeout(3000)```, set the timeout time of the ```rest``` request of the exchange object ```exchange```, if it exceeds 3 seconds, timeout will return ```null```.
Note:
* The parameter ```Millisecond``` is millisecond, and 1,000 milliseconds equals 1 second.
* Only need to set once.
* Only for the **rest** protocol.
* ```SetTimeout``` is not a global function, but an exchange object method.
### Special Requirements for C++ Written Strategies
The main difference between ```C++``` written strategy and ```JavaScript``` written strategy is the returned data differences of **FMZ API** interface. For example, the ```exchange.GetTicker()``` function.
- JavaScript
```exchange.GetTicker()``` returns an object if the call succeeds, or returns ```null``` if the call fails (due to the exchange server problems or network problems, etc.).
```javascript
function main() {
var ticker = exchange.GetTicker()
// Determine if the call to "exchange.GetTicker" function failed, and return "null" when it failed
if (ticker){
Log(ticker)
}
}
C++exchange.GetTicker()Wenn der Aufruf fehlschlägt, ist das zurückgegebene Objekt immer noch ein Objekt, das sich durch das Attribut vom normalen zurückgegebenen Objekt unterscheidet.Valid.
void main() {
auto ticker = exchange.GetTicker();
// Determine if the call to "exchange.GetTicker()" function failed and if the "Valid" attribute of the returned object is "false"
if (ticker.Valid) {
Log(ticker);
}
}
Der Unterschied zwischenmain()Funktion imC++Schriftliche Strategiemain()Funktion in der Norm C11:
Der Rücklaufwert derC++Eintrittsfunktion des Programmsmain()in C11 ist vonintIn derC++Schriftliche Strategie auf FMZ-Plattform, die Startfunktion der Strategie ist auch die Funktionmain(), aber diese beiden sind nicht die gleiche Funktion, nur mit dem gleichen Namen.main()Funktion imC++Strategie ist vonvoid type.
void main() {
// Use "Test" function to test
if (!Test("c++")) {
// Show an exception to stop the program
Panic("Please download the latest-versioned docker");
}
// Determine if the return of all objects is valid with "Valid"
LogProfitReset();
LogReset();
Log(_N(9.12345, 2));
Log("use _C", _C(exchange.GetTicker), _C(exchange.GetAccount));
}
Aus Gründen der JavaScript-Sprache (JavaScript-Sprache unterstützt integrierte Zeichenfolgenasciiundutf-16Die Daten werden nur dann zurückgegeben, wenn sie auf eine Zeichenkette stoßen, die nicht verschlüsselt werden kann.ArrayBufferAlle API-Schnittstellen, die Stringparameter übergeben können, unterstützen auch das Übergeben derArrayBuffer type.
Es unterstützt wirklich die Multi-Threading-Funktion desJavaScriptSprachstrategie von der Basis des Systems, einschließlich: gleichzeitige Ausführung von benutzerdefinierten Ausführungsfunktionen; Unterstützung für die Kommunikation zwischen gleichzeitigen Threads, Unterstützung für die Kommunikation zwischen gleichzeitigen Threads und dem Hauptthread; Speicherung, gemeinsame Nutzung von Variablen in der Thread-Umgebung und andere Funktionen.https://www.fmz.com/bbs-topic/9974.
Die__Thread(function, arguments...)Funktion erstellt einen Thread, der gleichzeitig ausgeführt wird. Es unterstützt keine direkte Verweisung auf andere Variablen als die Thread-Ausführungsfunktion (als isolierte Umgebung ausgeführt). Verweise auf externe Variablen werden nicht kompiliert. Verweise auf andere Schließungsfunktionen werden ebenfalls nicht unterstützt. Alle APIs der Plattform können innerhalb des Threads aufgerufen werden, aber andere benutzerdefinierte Funktionen können nicht aufgerufen werden.functionkann eine Funktionsreferenz oder eine anonyme Funktion sein.argumentsist der Parameter derfunctionFunktion (der tatsächlich übermittelte Parameter) undarguments...bedeutet, dass mehrere Parameter eingegeben werden können.
function testFunc(n) {
Log("Execute the function testFunc, parameter n:", n)
}
function main() {
var testThread1 = __Thread(function () {
Log("Executes an anonymous function with no parameters.")
})
var testThread2 = __Thread(testFunc, 10) // parameter n ： 10
__threadJoin(testThread1) // You can use the __threadJoin function to wait for concurrent threads to complete
__threadJoin(testThread2) // If you don't wait for the execution of testThread1 and testThread2 to complete, the main thread will automatically release the concurrent thread after the execution is completed first, and terminate the execution function of the concurrent thread
}
Es unterstützt die Anrufmethode von__Thread([function, arguments...], [function, arguments...], ...), d. h. mehrere Thread-Ausführungsfunktionen werden sequenziell in den erstellten Threads ausgeführt.
function threadTestFuncA(a) {
Log(a)
threadTestFuncC(4)
// The threadTestFuncC function can be called, but the threadTestFuncB function cannot be called
// this.d
Log(d)
}
function threadTestFuncB(b) {
Log(b)
threadTestFuncC(2)
this.d = 5
}
function main() {
// Execute the threadTestFuncB function first, and then execute the threadTestFuncA function
// threadTestFuncC will not be executed automatically, but it can be called by other thread execution functions
var threadId = __Thread([threadTestFuncA, 3], [threadTestFuncB, 1], ["function threadTestFuncC(c) {Log(c)}"])
__threadJoin(threadId)
}
Die gleichzeitige Ausführungsfunktion wurde an die__ThreadDas oben genannte Beispiel verwendet dieLogFunktion zum Drucken1 ~ 5Sie unterstützen die Verwendung von Variablen, die von verschiedenen Thread-Ausführungsfunktionen geteilt werden.this.dDie Variable im obigen Beispiel kann in derthreadTestFuncBFunktion und in derthreadTestFuncAEs unterstützt die Übergabe von Funktionsfolgen, wie"function threadTestFuncC(c) {Log(c)}"in dem obigen Beispiel, mit dem Threads Funktionsanrufe an externe Funktionen und Bibliotheken
Für den Import externer Bibliotheken ist ein spezifisches Anwendungsbeispiel wie folgt:
function ml(input) {
const net = new brain.NeuralNetwork();
net.train([
{ input: [0, 0], output: [0] },
{ input: [0, 1], output: [1] },
{ input: [1, 0], output: [1] },
{ input: [1, 1], output: [0] },
]);
return net.run(input);
}
function main() {
Log(__threadJoin(__Thread([ml, [1, 0]], [HttpQuery("https://unpkg.com/brain.js")])))
}
Die__threadPeekMessage(threadId, timeout)Funktion liest Daten aus dem Thread-Kommunikationskanal, der ParameterthreadIdist die von der__Thread()Funktion, Einstellung des ParametersthreadIdbedeutet, die Daten zu empfangen, die vom Thread gesendet werden, der durch den ThreadId dargestellt wird. Wenn er auf 0 gesetzt ist, bedeutet er, die Daten zu empfangen, die vom Hauptthread gesendet werden, d. h. die aktuelle Hauptfunktion (der Parameter threadId ist auf 0 gesetzt, der nur in gleichzeitigen Thread-Ausführungsfunktionen unterstützt wird).timeoutist eine Timeout-Einstellung, die nach der Anzahl der von diesem Parameter gesetzten Millisekunden blockiert und wartet.timeoutist auf-1, bedeutet es, zu blockieren und zu warten, bis die Daten im Kanal empfangen werden.__threadPeekMessageFunktion wird sofort einen Nullwert zurückgeben.
Wenn Sie Programme schreiben, müssen Sie auf das Problem der Thread-Standstillstand achten.testFuncder erzeugten gleichzeitigen Schleife und dermainFunktion des Hauptfaden und Funktion der Ausführung des FadentestFuncwird zuerst hingerichtet.
function testFunc() {
for(var i = 0 ; i < 5 ; i++) { // 0 ~ 5, after sending to the main thread 5 times, the execution of the thread function is completed, and the __threadPeekMessage function in the main function fetches all the data, it will not block again, and returns a null value immediately
__threadPostMessage(0, i) // Send data to the main thread
var msg = __threadPeekMessage(0, -1) // Listen for data from the main thread
Log("from main msg:", msg)
Sleep(500)
}
Log("testFunc execution is complete")
}
function main() {
var testThread = __Thread(testFunc) // Create a thread with an Id of 1
for (var i = 0 ; i < 10 ; i++) {
__threadPostMessage(1, i) // Send data to the thread whose Id is 1, that is, the thread that executes the testFunc function in this example
var msg = __threadPeekMessage(1, -1) // Listen to the data sent by the thread whose Id is 1, that is, the data sent by the thread that executes the testFunc function in the example
Log("from testFunc msg:", msg)
Sleep(500)
}
}
Die__threadPostMessage(threadId, data)Funktion schreibt Daten in den Thread-Kommunikationskanal, der ParameterthreadIdist die von der__Thread()Funktion, setzen Sie den ParameterthreadIdbedeutet, Daten an den Thread zu senden, der durch den ThreadId dargestellt wird, und wenn er auf 0 gesetzt ist, bedeutet dies, Daten an den Hauptthread zu senden, d. h. die aktuelle Hauptfunktion (der Parameter threadId ist auf 0 gesetzt, der nur in gleichzeitigen Thread-Ausführungsfunktionen unterstützt wird).datakann Werte, Zeichenfolgen, Boolean-Werte, Objekte, Arrays und andere Datentypen übergeben. Diese Funktion gibt keinen Wert zurück.
Wenn die__threadPostMessageWenn eine Funktion in der Ausführungsfunktion eines Threads aufgerufen wird, um Signale und Daten zu senden, wird auch ein Nachrichtenereignis generiert.EventLoop()Funktion zum Empfangen von Nachrichtenbenachrichtigungen.
function testFunc() {
for(var i = 0 ; i < 10 ; i++) {
Log("post msg, i:", i)
__threadPostMessage(0, {msg: "testFunc", i: i})
Sleep(100)
}
}
function main() {
var testThread = __Thread(testFunc)
for (var i = 0 ; i < 10 ; i++) {
var e = EventLoop()
Log("e:", e)
// e: {"Seq":1,"Event":"thread","Index":1,"Nano":1677745512064773600,"Deleted":0,"Symbol":"","Ticker":{"Info":null,"High":0,"Low":0,"Sell":0,"Buy":0,"Last":0,"Volume":0,"OpenInterest":0,"Time":0}}
if (e.Event == "thread") {
var msg = __threadPeekMessage(testThread, -1)
Log("msg:", msg, "#FF0000")
}
Sleep(500)
}
var retThreadJoin = __threadJoin(testThread)
Log("retThreadJoin:", retThreadJoin)
}
Die__threadJoin(threadId, timeout)Die Funktion wird verwendet, um auf den Thread mit der angegebenen ID zu warten, um die Systemressourcen zu verlassen und zurückzufordern.threadIdist die von der__Thread()Funktion und Parametertimeoutist die Timeout-Einstellung für das Warten auf das Ende des Threads, in Millisekunden. Wenn die Timeout nicht eingestellt ist, bedeutet dies, bis zum Ende der Thread-Ausführung zu warten.undefined.
Wertstruktur der Rendite, beispielsweise:
{
"id":1, // Thread Id
"terminated":false, // Whether the thread is terminated forcibly
"elapsed":2504742813, // The running time of the thread (nanoseconds)
"ret": 123 // The return value of the thread function
}
Die__threadTerminatedie Funktion wird verwendet, um den Thread zwangsweise zu beenden und die Hardware-Ressourcen freizugeben, die vom erstellten Thread verwendet werden (der __threadJoin kann nicht mehr verwendet werden, um auf das Ende zu warten).threadIdist die von der__Thread()Funktion. Rückgabewert: Boolean-Wert, der das Ausführungsresultat anzeigt.
function testFunc() {
for(var i = 0 ; i < 10 ; i++) {
Log("i:", i)
Sleep(500)
}
}
function main() {
var testThread = __Thread(testFunc)
var retThreadTerminate = null
for (var i = 0 ; i < 10 ; i++) {
Log("main i:", i)
if (i == 5) {
retThreadTerminate = __threadTerminate(testThread)
}
Sleep(500)
}
Log("retThreadTerminate:", retThreadTerminate)
}
__threadGetData(threadId, key), die Funktion wird verwendet, um auf die Variablen zuzugreifen, die zwischen Threads geteilt werden.__threadJoinFunktion (Wartend auf einen erfolgreichen Ausgang) und hat die__threadTerminateFunktion (endete den Thread gewaltsam).threadIdist die Thread-Id und der Parameterkeyist der Schlüsselname der gespeichertenkey-valueRückgabewert: Gibt den Schlüsselwert zurück, derkeyin derkey-value pair.
threadIdist 0, um den Hauptfaden anzugeben (d. h. den Faden, womainFunktion befindet sich), können Sie__threadId()Funktion, um die ID des aktuellen Threads zu erhalten, setzen Sie den ParameterthreadIdSie können auch die Variablen in der Thread-Umgebung der angegebenen ID lesen.
function main() {
var t1 = __Thread(function() {
Sleep(2000)
var id = __threadId() // Get the Id of the current thread
Log("id:", id, ", in testThread1 print:", __threadGetData(id, "msg")) // Retrieve the key value corresponding to the key name msg in the current thread, i.e. "testThread2"
Log("id:", 2, ", in testThread1 print:", __threadGetData(2, "msg")) // Read the key value corresponding to the key name msg in the thread with thread Id 2, i.e. 99
})
var t2 = __Thread(function(t) {
__threadSetData(t, "msg", "testThread2") // Set a key-value pair to the thread with Id t1 (Id 1), with the key name msg and the key value "testThread2"
__threadSetData(__threadId(), "msg", 99) // Set the key-value pair in the current thread (Id is 2) with the key name msg and the key value 99
__threadSetData(0, "msg", 100) // Set up a key-value pair in the main thread, with the key name msg and the key value 100
}, t1)
__threadJoin(t1) // You can check the __threadJoin(threadId, timeout) function, which is used to wait for the end of thread execution
Log("in main, get msg:", __threadGetData(0, "msg"))
}
__threadSetData(threadId, key, value), die zur Speicherung von Variablen in der Thread-Umgebung verwendet wird.threadIdist die Thread-Id, der Parameterkeyist der Schlüsselname der gespeichertenkey-valuePaar und Parametervalueist der Schlüsselwert. Die Funktion gibt keinen Wert zurück.
threadIdist 0, um den Hauptfaden anzugeben (d. h. den Faden, womainFunktion befindet sich), und Sie können die__threadId()Funktion, um die ID des aktuellen Threads zu erhalten.valuenicht spezifizierte Löschmittelkey. Es unterstützt den gegenseitigen Zugriff auf freigegebene Variablen zwischen Threads. Die Daten sind gültig, wenn der Thread die Variablen nicht ausgeführt hat__threadJoinFunktion (Wartend auf erfolgreichen Ausgang) und hat die__threadTerminateDer Wert des Parametersvaluemuss eine serialisierbare Variable sein.
function testFunc() {
var id = __threadId() // Get the current thread Id
__threadSetData(id, "testFunc", 100) // Stored in the current thread environment
__threadSetData(0, "testFunc", 99) // Stored in the main threaded environment
Log("testFunc execution is complete")
}
function main() {
// threadId is 1, the created thread with threadId 1 will be executed first, as long as the thread resources are not recycled, the variables stored locally in the thread will be valid
var testThread = __Thread(testFunc)
Sleep(1000)
// Output in main, get testFunc: 100
Log("in main, get testFunc:", __threadGetData(testThread, "testFunc"))
// Output in main, get testFunc: 99
Log("in main, get testFunc:", __threadGetData(0, "testFunc"))
// Delete the testFunc key-value pair in the thread environment with Id testThread
__threadSetData(testThread, "testFunc")
// After deleting and reading again, the __threadGetData function returns undefined
Log("in main, get testFunc:", __threadGetData(testThread, "testFunc"))
}
__threadId(), der verwendet wird, um die Id des aktuellen Threads ohne Parameter zu erhalten.threadIdDer aktuelle Faden.
function testFunc() {
Log("in testFunc, __threadId():", __threadId())
}
function main() {
__Thread(testFunc)
// If the execution of the main thread is completed, the created child thread will stop executing, so here Sleep(1000), wait for 1 second
Sleep(1000)
Log("in main, __threadId():", __threadId())
}
In derJavaScriptIn diesem Fall kann der Hex-Code der wasm-Datei geladen, instanziert und der Code darin ausgeführt werden.JavaScriptCode, es hat einen gewissen Geschwindigkeitsvorteil.
wasm.parseModule(data), das ein Hex-String-Modell analysiert.dataParameter ist die wasm-Codierung, die in eine hex-String umgewandelt wurde.Strategiebeispiel.
Beispielsweise kann der folgende C++-Funktionscode in wasm-Code kompiliert und dann in eine Hex-String umgewandelt werden, die als diedataParameter derwasm.parseModule(data) function.
// Recursive Algorithm for Fibonacci Numbers
int fib(int f) {
if (f < 2) return f;
return fib(f - 1) + fib(f - 2);
}
wasm.buildInstance(module, opt), die eine Wasm-Modell-Instanz erstellt.moduleDas Parameter ist das Wasm-Modell, und dasoptParameter ist die Konfigurationsinformation, die verwendet wird, um den dem wasm-Instanzprogramm zugewiesenen Stack-Raum festzulegen.
optBeispiel für die Parameterstellung:
{
stack_size: 65*1024*1024,
}
callFunction(funcName, param1, ...), eine Methode der wasm-Modell-Instanz, die zur Ausführung der Funktion in der wasm-Modell-Instanz verwendet wird.funcNameParameter ist der Name der auszuführenden Funktion und dieparam1Parameter ist der Parameter, der bei der Ausführung der Funktion eingegeben wird (gegeben durch den ParameterfuncName).
Die FMZ Quant Trading-Plattform ist offiziell zugänglich, um den interaktiven Aufruf derweb3Vertrag über die Kette, die Zugang zu dendefileicht austauschen.
Auf der FMZ Quant Trading-Plattform schreiben Sie Strategiecode, um den Methodenanruf von Smart Contract auf der Ethereum-Kette durch dieexchange.IOFunktion. Zuerst konfigurieren Sie den Zugangsknoten auf der FMZ Quant Trading Plattform. Die Zugangsknoten können selbst aufgebaute Knoten sein oder Dienste von Drittanbietern verwenden, wieinfura.
Auf der Seite vonWeb3. KonfigurierenRpc Address(Dienstadresse des Zugangsknotenpunkts) undPrivate KeyEs unterstützt die lokalisierte Bereitstellung privater Schlüssel, sieheSchlüssel zur Sicherheit].
Ein Vertrag, der ein Standard istERC20Für die Anrufung anderer Methoden als des Standardvertrags ist die Registrierung des ABI-Inhalts erforderlich:exchange.IO("abi", tokenAddress, abiContent). Um den ABI-Inhalt eines Vertrages zu erhalten, können Sie die folgende URL verwenden, um ihn zu erhalten, wobei nur das Ergebnisfeld verwendet wird.
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
Wenn der zweite Parameter derexchange.IOFunktion ist"eth", können Sie die RPC-Methoden anrufen, die dem Knotenserver direkt zur Verfügung stehen, zum Beispiel:
Abfrage des ETH-Guthabenes in der Brieftasche
function main() {
// "owner" needs to be replaced with a specific wallet address
// "latest" parameter labels for string position: 'latest', 'earliest' or 'pending', please refer to https://eth.wiki/json-rpc/API#the-default-block-parameter
// The return value ethBalance is a hexadecimal string: 0x9b19ce56113070
var ethBalance = exchange.IO("api", "eth", "eth_getBalance", "owner", "latest")
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Because of the JavaScript language precision, it is necessary to use the system underlying encapsulated function BigInt, BigDecimal to process.
// Convert ethBalance to readable quantity, 0x9b19ce56113070 to 0.043656995388076145.
Log(Number((BigDecimal(BigInt(ethBalance))/BigDecimal(Math.pow(10, ethDecimal))).toString()))
}
ETH-Überweisung
function mian() {
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Number of transfers, readable quantity e.g. 0.01 ETH
var sendAmount = 0.01
// Because of the JavaScript language precision, it is necessary to use the system underlying encapsulated function BigInt, BigDecimal to process, and converts readable quantities into data for processing on the chain.
var toAmount = (BigDecimal(sendAmount)*BigDecimal(Math.pow(10, ethDecimal))).toFixed(0)
// "toAddress" is the address of the recipient's ETH wallet at the time of the transfer, which needs to be filled in specifically, and toAmount is the number of transfers.
exchange.IO("api", "eth", "send", "toAddress", toAmount)
}
Gaspreis abfragen
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0)) // 5000000000 , in wei (5 gwei)
}
Abfrage eth_estimateGas
function toAmount(s, decimals) {
// The toAmount function can convert the hex-encoded value to a decimal value
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// Encoding the call to the approve method
var data = exchange.IO("encode", "0x111111111117dC0aa78b770fA6A738034120C302", "approve", "0xe592427a0aece92de3edee1f18e0157c05861564", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
Log("data:", data)
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0))
var obj = {
"from" : "0x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // walletAddress
"to" : "0x111111111117dC0aa78b770fA6A738034120C302",
"gasPrice" : gasPrice,
"value" : "0x0",
"data" : "0x" + data,
}
var gasLimit = exchange.IO("api", "eth", "eth_estimateGas", obj)
Log("gasLimit:", toAmount(gasLimit, 0))
Log("gas fee", toAmount(gasLimit, 0) * toAmount(gasPrice, 0) / 1e18)
}
Die Funktionexchange.IOdieencodeMethode, die die Funktionsanruf-Codierung zurückgeben kannhexSie können sich auf die öffentlich zugänglichen Plattformen beziehenunwrapWETH9Die Methode wird hier als Beispiel verwendet:
function main() {
// Main network address of ContractV3SwapRouterV2: 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
// To call the unwrapWETH9 method, you need to register the ABI first, omit the registration here.
// "owner" represents the wallet address, it needs to fill in the specific, 1 represents the number of unwrapping, unwrap a WETH into ETH
var data = exchange.IO("encode", "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", "unwrapWETH9(uint256,address)", 1, "owner")
Log(data)
}
Bei Anrufen derexchange.IO("encode",...)Funktion, wenn der zweite Parameter (String-Typ) mit0x, bedeutet der Anruf der Methode auf dem codierten (encode) ein Smart Contract.0xDie Funktion ist die gleiche wie bei derabi.encodein dersolidity. Verweisen Sie auf das folgende Beispiel.
function main() {
var x = 10
var address = "0x02a5fBb259d20A3Ad2Fdf9CCADeF86F6C1c1Ccc9"
var str = "Hello World"
var array = [1, 2, 3]
var ret = exchange.IO("encode", "uint256,address,string,uint256[]", x, address, str, array) // uint i.e. uint256 , the type length needs to be specified on FMZ
Log("ret:", ret)
/*
000000000000000000000000000000000000000000000000000000000000000a // x
00000000000000000000000002a5fbb259d20a3ad2fdf9ccadef86f6c1c1ccc9 // address
0000000000000000000000000000000000000000000000000000000000000080 // offset of str
00000000000000000000000000000000000000000000000000000000000000c0 // offset of array
000000000000000000000000000000000000000000000000000000000000000b // the length of str
48656c6c6f20576f726c64000000000000000000000000000000000000000000 // str data
0000000000000000000000000000000000000000000000000000000000000003 // the length of the array
0000000000000000000000000000000000000000000000000000000000000001 // array the first data
0000000000000000000000000000000000000000000000000000000000000002 // array the second data
0000000000000000000000000000000000000000000000000000000000000003 // array the third data
*/
}
Unterstützung der sequentiellen Kodierung von Tupeln oder Typen mit Tupeln:
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
}
Diese Typordnung besteht austupleundbytes, also müssen zwei Parameter eingegeben werden, wenn sie aufgerufen werdenexchange.IOzuencode:
tuple:{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Die eingegebenen Parameter müssen auch mit der Struktur und dem Typ dertuple, wie sie in dertypesParameter:tuple(a uint256, b uint8, c address).
bytes:"0011"
Unterstützung der sequentiellen Kodierung von Arrays oder Arraytypen, die Arrays enthalten:
function main() {
var path = ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"] // ETH address, USDT address
var ret = exchange.IO("encode", "address[]", path)
Log("encode: ", ret)
}
Zum Beispiel, wenn die DEX-Methode vonUniswap V3, müssen Sie in den Parametern, wie den Austausch Pfad, so müssen Sie dieencodePackagedBetrieb:
function main() {
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
var tokenOutAddress = "0x6b175474e89094c44da98b954eedeac495271d0f"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
}
Die Datenverarbeitung unterstützt nicht nur die Codierung (encode), aber auch die Entschlüsselung (decode) Verwendenexchange.IO("decode", types, rawData)Funktion zur Durchführung derdecode operation.
function main() {
// register SwapRouter02 abi
var walletAddress = "0x398a93ca23CBdd2642a07445bCD2b8435e0a373f"
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"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"}]`
exchange.IO("abi", routerAddress, abi) // abi only uses the contents of the local exactOutput method, the full abi can be searched on the Internet
// encode path
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
var tokenOutAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
var dataTuple = {
"path" : path,
"recipient" : walletAddress,
"amountOut" : 1000,
"amountInMaximum" : 1,
}
// encode SwapRouter02 exactOutput
var rawData = exchange.IO("encode", routerAddress, "exactOutput", dataTuple)
Log("method hash:", rawData.slice(0, 8)) // 09b81346
Log("params hash:", rawData.slice(8))
// decode exactOutput params
var decodeRaw = exchange.IO("decode", "tuple(path bytes,recipient address,amountOut uint256,amountInMaximum uint256)", rawData.slice(8))
Log("decodeRaw:", decodeRaw)
}
Das Beispiel führt dieencodePackedErstmals während derpathParameterverarbeitung, weil dieexactOutputMethodenanruf, der später codiert werden muss, benötigt diepathAls Parameter.encodeVerfahren derexactOutputRouting-Vertrag hat nur einen Parameter und der Parametertyp isttuple. Die MethodeexactOutputName ist als0x09b81346, das das Ergebnis entschlüsseltdecodeRawvonexchange.IO ("decode",...)Methode, und es stimmt mit der VariablendataTuple.
Es unterstützt das Wechseln von privaten Schlüsseln, um mehrere Wallet-Adressen zu betreiben, zum Beispiel:
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Der erste Parameter derexchange.IOFunktion ist:"api"Der zweite Parameter desexchange.IOFunktion ist die Adresse des zu aufrufenden Smart Contracts.
Wenn die aufgerufene Methode diepayableSie müssen einen Transfer-ETH-Wert nach dem Methodennamen hinzufügen (der vierte Parameter desexchange.IOFunktion), die von numerischem Typ sein kann oder einen Wert in Zeichenfolgeform übermittelt, z. B. diemulticallVerfahren derUniswap V3Die folgenden Inhalte sind Beispiele für einige Aufrufe von Smart Contract-Methoden:
Dezimalstellen
DiedecimalsMethode ist eineconstantVerfahren derERC20die nicht erzeugtgasDie Daten sind in der Lage, die Präzisionsdaten eines bestimmtentoken. DiedecimalsRückgabewert: die Präzisionsdaten vontoken.
function main(){
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302" // The contract address of the token, in the example the token is 1INCH
Log(exchange.IO("api", tokenAddress, "decimals")) // Query, print 1INCH tokens with precision index of 18
}
Zulage
DieallowanceMethode ist eineconstantVerfahren derERC20die nicht erzeugtgasDie Verbraucher können sich über die Anzahl dertokenDieallowanceDie Methode muss in 2 Parametern übergeben werden, die erste ist die Wallet-Adresse und die zweite ist die autorisierte Adresse.token.
function main(){
// The contract address of the token, in the example the token is 1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// For example, the query yields 10000000000000000000000, divided by the precision unit of the token 1e18, the current exchange object bound to the wallet to the spender address authorized 1 1INCH.
Log(exchange.IO("api", tokenAddress, "allowance", "owner", "spender"))
}
owner: Die Wallet-Adresse wird in dem Beispiel durch die Zeichenfolge spender: Die autorisierte Vertragsadresse wird im Beispiel durch die Zeichenfolge Uniswap V3 router v1.
genehmigen
DieapproveDie Methode ist nichtconstantVerfahren derERC20Das erzeugtgasVerbrauch, der verwendet wird, um einetokenDieapproveDie Methode muss in 2 Parametern übergeben werden, die erste ist die Adresse, die autorisiert werden soll, und die zweite ist der autorisierte Betrag.txid.
function main(){
// The contract address of the token, in the example the token is 1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// The hexadecimal string of the authorization amount: 0xde0b6b3a7640000 , the corresponding decimal string: 1e18 , 1e18 divided by the precision unit of the token, i.e. 1 token amount, so this refers to the authorization of one token.
Log(exchange.IO("api", tokenAddress, "approve", "spender", "0xde0b6b3a7640000"))
}
spender: Die Adresse des genehmigten Auftrags, das Beispiel wird durch die Zeichenfolge Uniswap V3 router v1 address.
0xde0b6b3a7640000: Die Zahl der Genehmigungen, hier mit einer hexadezimalen Zeichenfolge dargestellt, entspricht einem Dezimalwert von1e18, geteilt durch dietokenPräzisionseinheit im Beispiel (d. h. 1e18), die 1 ergibttoken authorized.
Der dritte Parameter derexchange.IOFunktion wird übergeben, Methodenameapprove, die auch in Form vonmethodId, z. B.:
mehrfachgerufen
DiemulticallMethode ist eine nicht konstante Methode derUniswap V3, diegasDie Anwendungen werden für den Austausch von Token auf vielfältige Weise verwendet.multicallMethode kann mehrere Methoden zur Übermittlung von Parametern haben. Sie können die ABI abfragen, die die Methode enthält, um Details zu erhalten. Sie müssen die ABI registrieren, bevor Sie die Methode aufrufen.txid.
Für konkrete BeispielemulticallMethodenanrufe, bitte beziehen Sie sich auf die Öffentlichkeit
Pseudocode wird hier verwendet, um einige Details zu beschreiben:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: Router-V2-Adresse von Uniswap V3.value: Der übertragene ETH-Betrag wird auf 0 gesetzt, wenn dietokenInDas Token für den Austausch ist nicht ETH.deadline: Es kann auf(new Date().getTime() / 1000) + 3600, was bedeutet, dass es eine Stunde gültig ist.data: Die Daten der zu durchführenden Verpackung.
Es ist auch möglich, diegasLimit/gasPrice/nonceWir verwenden Pseudocode, um wieder zu beschreiben:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
Sie können Parameter festlegen{gasPrice: 11, gasLimit: 111, nonce: 111}Nach Ihren spezifischen Bedürfnissen wird der Parameter auf den letzten Parameter desexchange.IOSie können dienonceund verwenden Sie die Systemeinstellungen, oder nicht setzengasLimit/gasPrice/nonceund verwenden Sie alle System-Standardwerte.
Es ist zu beachten, daß im Beispiel das AttributstateMutabilityinmulticall(uint256,bytes[])Methode istpayable, und dievalueDas Attribut vonstateMutability":"payable"Sie können von derABI. Dieexchange.IODiese Funktion wird die erforderlichen Parameter entsprechend derstateMutabilityAttribut in derABISiehe auchstateMutabilityAttribut istnonpayable, der Parametervaluenicht eingereicht werden muss.
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object.
}
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switch to BSC chain
}
Wenn Sie die Indikatorfunktionen aufrufen, müssen Sie hinzufügenTA.odertalib.als Präfix
Beispiele für den Aufruf der Indikatorfunktionen intalibBibliothek undTABibliothek:
function main(){
var records = exchange.GetRecords()
var macd = TA.MACD(records)
var atr = TA.ATR(records, 14)
// Print the last row of indicator values
Log(macd[0][records.length-1], macd[1][records.length-1], macd[2][records.length-1])
Log(atr[atr.length-1])
// Print all indicator data, and JavaScript written strategies have integrated a talib library on FMZ Quant Trading platform
Log(talib.MACD(records))
Log(talib.MACD(records, 12, 26, 9))
Log(talib.OBV(records))
// The talib library can also be passed in an array of numbers, which can be passed in order. For example: OBV (Records [Close], Records [Volume]) requires the parameters of the two arrays, including "Close" and "Volume"
Log(talib.OBV([1,2,3], [7.1, 6.2, 3, 3]))
// You can also directly pass in the "records" array containing the "Close" and "Volume" attribute
Log(talib.OBV(records))
Log(TA.Highest(records, 30, 'High'))
Log(TA.Highest([1,2,3,4], 0))
}
# Python needs to install the talib library separately
import talib
def main():
r = exchange.GetRecords()
macd = TA.MACD(r)
atr = TA.ATR(r, 14)
Log(macd[0][-1], macd[1][-1], macd[2][-1])
Log(atr[-1])
# For Python, the system extends the attributes of the array returned by GetRecords, and adds "Open", "High", "Low", "Close" and "Volume" to facilitate the call of the functions in the talib library
Log(talib.MACD(r.Close))
Log(talib.MACD(r.Close, 12, 26, 9))
Log(talib.OBV(r.Close, r.Volume))
Log(TA.Highest(r, 30, "High"))
Log(TA.Highest([1, 2, 3, 4], 0))
void main() {
auto r = exchange.GetRecords();
auto macd = TA.MACD(r);
auto atr = TA.ATR(r, 14);
Log(macd[0][macd[0].size() - 1], macd[1][macd[1].size() - 1], macd[2][macd[2].size() - 1]);
Log(atr[atr.size() - 1]);
Log(talib.MACD(r));
Log(talib.MACD(r, 12, 26, 9));
Log(talib.OBV(r));
Log(TA.Highest(r.Close(), 30));
}
Die Daten in den folgenden Parametern sind alle Daten, die durch die Funktion ermittelt werden.exchange.GetRecords(Period)- Ich weiß.
Achten Sie auf die Länge derrecords, wenn die Länge nicht den Parameterberechnungsanforderungen der Indikatorfunktion entspricht, wird ein ungültiger Wert zurückgegeben.
DieTADie Indikatorbibliothek der FMZ Quant Trading-Plattform hat die häufig verwendeten Indikator-Algorithmen optimiert, um den Aufruf von Strategien inJavaScript, Pythonundcpp Open-Source-TA-Bibliothekscode.
TA.MACD(data, fast period, slow period, signal period), mit den Standard-Periodenparametern von (12, 26, 9) gibt die zweidimensionalen Arrays zurück, die[DIF, DEA, MACD] respectively.
function main(){
// You can fill in different k-line periods, such as PERIOD_M1, PERIOD_M30 and PERIOD_H1...
var records = exchange.GetRecords(PERIOD_M15)
var macd = TA.MACD(records, 12, 26, 9)
// You can see from the log that three arrays are returned, corresponding to DIF, DEA, MACD
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
macd = TA.MACD(r, 12, 26, 9)
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
void main() {
auto r = exchange.GetRecords(PERIOD_M15);
auto macd = TA.MACD(r, 12, 26, 9);
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2]);
}
TA.KDJ(data, period 1, period 2, period 3), mit den Standard-Periodenparametern von (9, 3, 3) gibt die zweidimensionalen Arrays zurück, die(K, D, J) respectively.
function main(){
var records = exchange.GetRecords(PERIOD_M15)
var kdj = TA.KDJ(records, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
kdj = TA.KDJ(r, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
void main() {
auto r = exchange.GetRecords();
auto kdj = TA.KDJ(r, 9, 3, 3);
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2]);
}
TA.RSI(data, period), mit dem Standard-Periode-Parameter 14, gibt ein einmaliges Array zurück.
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var rsi = TA.RSI(records, 14)
Log(rsi)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
rsi = TA.RSI(r, 14)
Log(rsi)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto rsi = TA.RSI(r, 14);
Log(rsi);
}
TA.ATR(data, period); ATR(Daten, Periode), mit dem Standard-Periode-Parameter 14, gibt ein einmaliges Array zurück.
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var atr = TA.ATR(records, 14)
Log(atr)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
atr = TA.ATR(r, 14)
Log(atr)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto atr = TA.ATR(r, 14);
Log(atr);
}
TA.OBV(data)Gibt ein einmaliges Array zurück.
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var obv = TA.OBV(records)
Log(obv)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
obv = TA.OBV(r)
Log(obv)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto obv = TA.OBV(r);
Log(obv);
}
TA.MA(data, period); MA ((daten, Periode), mit dem Standard-Periode-Parameter 9, gibt ein einmaliges Array zurück.
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var ma = TA.MA(records, 14)
Log(ma)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
ma = TA.MA(r, 14)
Log(ma)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto ma = TA.MA(r, 14);
Log(ma);
}
TA.EMA(data, period)ist ein exponentieller Durchschnittsindikator mit dem Standard-Periodenparameter 9, gibt ein einmaliges Array zurück.
function main(){
var records = exchange.GetRecords()
// Determine if the number of K-line bars meets the requirement of the indicator calculation period
if (records && records.length > 9) {
var ema = TA.EMA(records, 9)
Log(ema)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 9:
ema = TA.EMA(r, 9)
Log(ema)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 9) {
auto ema = TA.EMA(r, 9);
Log(ema);
}
}
TA.BOLL(data, period, multiplier); BOLL(Daten, Periode, Multiplikator) ist ein Bollinger-Band-Indikator mit den Standardparametern (20, 2) und gibt ein zweidimensionales Array zurück, nämlich[Upline, Midline, Downline].
function main() {
var records = exchange.GetRecords()
if(records && records.length > 20) {
var boll = TA.BOLL(records, 20, 2)
var upLine = boll[0]
var midLine = boll[1]
var downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 20:
boll = TA.BOLL(r, 20, 2)
upLine = boll[0]
midLine = boll[1]
downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 20) {
auto boll = TA.BOLL(r, 20, 2);
auto upLine = boll[0];
auto midLine = boll[1];
auto downLine = boll[2];
Log(upLine);
Log(midLine);
Log(downLine);
}
}
TA.Alligator(data, mandible period, tooth period, upper lip period); Alligator ((Daten, Kieferperiode, Zahnperiode, Oberlippeperiode) ist Alligator-Indikator mit den Standardparametern (13,8,5) und gibt ein zweidimensionelles Array zurück, nämlich[Mandible, Teeth, Upper Lip].
TA.CMF(data, period); CMF ((Daten, Periode) ist Chaikin Geldfluss Indikator, mit dem Standard-Periode-Parameter von 20, gibt ein einmaliges Array zurück.
TA.Highest(data, period, attribute), gibt den maximalen Wert für den letzten Zeitraum (ohne den aktuellen Bar) zurück, z. B.TA.Highest(records, 30, 'High'). Wenn dieperiodist 0, bedeutet es alle Bars. Wenn dieattributeist nicht angegeben, werden die Daten als gewöhnliches Array betrachtet und geben einen Preis (Werttyp) zurück.
TA.Lowest(data, period, attribute), gibt den Mindestwert für den letzten Zeitraum (ohne den aktuellen Bar) zurück, z. B.TA.Highest(records, 30, 'Low'). Wenn dieperiodist 0, bedeutet dies alle Balken. Wenn das Attribut nicht angegeben ist, werden die Daten als gewöhnliches Array betrachtet und ein Preis (Werttyp) zurückgegeben.
Die Anwendung vonTA.Highest(...)undTA.Lowest(...)in derC++Strategie sollte beachtet werden, dassHighestundLowestFunktionen haben nur 2 Parameter, und der erste Parameter ist nicht der Rückgabewert vonauto r = exchange.GetRecords()Funktion, also müssen Sie die Methode vonrzur Übermittlung bestimmter Attributdaten, z. B.: passr.Close()Die Call-Methode derClose, High, Low, Open, Volumeist genau wier.Close().
C++Beispiele:
void main() {
Records r;
r.Valid = true;
for (auto i = 0; i < 10; i++) {
Record ele;
ele.Time = i * 100000;
ele.High = i * 10000;
ele.Low = i * 1000;
ele.Close = i * 100;
ele.Open = i * 10;
ele.Volume = i * 1;
r.push_back(ele);
}
for(int j = 0; j < r.size(); j++){
Log(r[j]);
}
// Note: if the first parameter passed in is not r, you need to call "r.Close()"
auto highest = TA.Highest(r.Close(), 8);
Log(highest);
}
JavaScriptBibliothekhttp://mathjs.org/
function main() {
Log(math.round(math.e, 3)) // 2.718
Log(math.atan2(3, -3) / math.pi) // 0.75
Log(math.log(10000, 10)) // 4
Log(math.sqrt(-4)) // {"mathjs":"Complex","re":0,"im":2}
}
http://mikemcl.github.io/decimal.js/
function main() {
var x = -1.2
var a = Decimal.abs(x)
var b = new Decimal(x).abs()
Log(a.equals(b)) // true
var y = 2.2
var sum = Decimal.add(x, y)
Log(sum.equals(new Decimal(x).plus(y)))