উদ্ভাবক সর্বজনীন চুক্তি চুক্তি অ্যাক্সেস উদাহরণ

সম্প্রতি, কিছু ব্যবহারকারী সবসময় সম্পর্কে কথা বলেনAOFEXএই এক্সচেঞ্জ সম্পর্কে, বিবেচনা করে যে চুক্তি এক্সচেঞ্জের REST ইন্টারফেসকে কীভাবে সংযুক্ত করতে হয় সে সম্পর্কে FMZ-এ কোনও উদাহরণ নেই। এই নিবন্ধটি অ্যাক্সেস সম্পর্কেAOFEXউদাহরণ হিসাবে, আমরা ব্যাখ্যা করব কিভাবে চুক্তি বিনিময় অ্যাক্সেস করতে হয়।

FMZ-এ স্পট এক্সচেঞ্জ এবং ফিউচার এক্সচেঞ্জের মধ্যে একটি পার্থক্য রয়েছে। উদাহরণ স্বরূপ, আমরা যে তিনটি প্রধান এক্সচেঞ্জের সাথে পরিচিত তাতে স্পট ট্রেডিং এবং কন্ট্রাক্ট ট্রেডিং উভয়ই অন্তর্ভুক্ত। এই বিভিন্ন বাজারের API ইন্টারফেসগুলিও আলাদা, এবং কিছুতে এমন API সিস্টেম রয়েছে যা সম্পূর্ণ আলাদা এবং স্বাধীন। তাই, FMZ-এ এই এক্সচেঞ্জগুলিকে এনক্যাপসুলেট করার সময়, স্পট এবং ফিউচারগুলিকে আলাদা করা হয়।

এফএমজেড প্ল্যাটফর্ম সম্প্রদায়ে অনেক উদাহরণ রয়েছে এবং স্পট এক্সচেঞ্জকে এনক্যাপসুলেট করার জন্য এফএমজেড-এর সাধারণ প্রোটোকল ব্যবহার করার জন্য নথি রয়েছে, তবে চুক্তি বিনিময়কে এনক্যাপসুলেট করার জন্য কোনও সম্পূর্ণ উদাহরণ নেই। যাইহোক, ইউনিভার্সাল প্রোটোকল প্লাগ-ইন প্রোগ্রাম যা ফিউচার সংস্করণকে এনক্যাপসুলেট করে তা মূলত স্পট সংস্করণের মতোই, আরও কয়েকটি ইন্টারফেস সহ।

FMZ সাধারণ প্রোটোকল নথি: https://www.fmz.com/bbs-topic/1052 নথিটি একটি স্পট এক্সচেঞ্জ সাধারণ প্রোটোকল অ্যাক্সেস ডেমো সহ আসে

ইন্টারফেস যে স্পট এক্সচেঞ্জ বস্তু এবং ফিউচার বিনিময় বস্তু encapsulate প্রয়োজন

স্পট এক্সচেঞ্জ বস্তুর প্রধান ইন্টারফেস

• exchange.GetTicker() টিক মার্কেট ডেটা পেতে, স্পট এবং ফিউচার উভয়ই প্রয়োজন।

• exchange.GetDepth() অর্ডার বুক ডেটা পেতে, স্পট এবং ফিউচার উভয়ই প্রয়োজন।

• exchange.GetTrades() অর্ডার ফ্লো ডেটা (বাজার লেনদেনের রেকর্ড) পেতে, স্পট এবং ফিউচার উভয়ই প্রয়োজন।

• exchange.GetRecords() কে-লাইন ডেটা পেতে, স্পট এবং ফিউচার উভয়ই প্রয়োজন।

• exchange.GetAccount() অ্যাকাউন্ট সম্পদ ডেটা পেতে, স্পট এবং ফিউচার উভয়ই প্রয়োজন।

• exchange.Buy() একটি ক্রয় অর্ডার দেওয়ার জন্য, স্পট এবং ফিউচার উভয়ই প্রয়োজন।

• exchange.Sell() একটি বিক্রয় আদেশ স্থাপন করতে, স্পট এবং ফিউচার উভয়ই প্রয়োজন।

• exchange.GetOrder() স্পট এবং ফিউচার উভয়ই নির্দিষ্ট আইডির অর্ডার ডেটা পান।

• exchange.GetOrders() স্পট এবং ফিউচার উভয়ই বর্তমান সক্রিয় মুলতুবি অর্ডার পান।

• exchange.CancelOrder() স্পট এবং ফিউচার উভয়ের জন্য নির্দিষ্ট আইডি দিয়ে অর্ডার বাতিল করুন।

স্পট এক্সচেঞ্জ অবজেক্টের এই ইন্টারফেসগুলিকে এনক্যাপসুলেট করার পাশাপাশি, ফিউচার এক্সচেঞ্জ অবজেক্টকে ফিউচার দ্বারা ব্যবহৃত ইন্টারফেস ফাংশনগুলিকে অতিরিক্তভাবে এনক্যাপসুলেট করতে হবে।

• exchange.SetMarginLevel() বর্তমান প্রতীকের লিভারেজ মান সেট করুন।

• exchange.SetDirection() বর্তমান পণ্যের ট্রেডিং দিক নির্ধারণ করুন: ওপেন লং পজিশন/ওপেন শর্ট পজিশন/ক্লোজ লং পজিশন/ক্লোজ শর্ট পজিশন।

• exchange.SetContractType() বর্তমান চুক্তি কোড সেট করুন। কারণ ফিউচারের চিরস্থায়ী চুক্তি আছে (swap), বিতরণ চুক্তি (quarterত্রৈমাসিক), ইত্যাদি, FMZ-এ প্রতিটির নিজস্ব চুক্তি কোড রয়েছে বিশদ বিবরণের জন্য, আপনি FMZ API ডকুমেন্টেশন পরীক্ষা করতে পারেন। এনক্যাপসুলেট করার সময় এই সেটিংসগুলিও অনুসরণ করা প্রয়োজন, অন্যথায় বিদ্যমান পুরানো কৌশলগুলি সঠিকভাবে কাজ নাও করতে পারে।

• exchange.GetPosition() বর্তমান বিভিন্ন অবস্থানের তথ্য পান। এটি এখানে দেখা যায় যে স্পট অবস্থানের কোন ধারণা নেই শুধুমাত্র অ্যাকাউন্ট পরিবর্তনের সাথে তুলনা করে যুক্তিযুক্তভাবে গণনা করা যেতে পারে। কিন্তু ভবিষ্যৎ ক্ষেত্রে খোলা পদ আছে।

কৌশলে ফিউচার-নির্দিষ্ট ইন্টারফেস কল করার সময় সাধারণ প্রোটোকল প্লাগ-ইন-এ অভিভাবক কর্তৃক প্রেরিত অনুরোধের বডি ডেটা

AOFEX এক্সচেঞ্জকে উদাহরণ হিসেবে নিলে, আপনি যদি FMZ-এ সাধারণ প্রোটোকলের এক্সচেঞ্জ অবজেক্ট কনফিগার করেন, তাহলে API KEY পূরণ করা হয়:

• accessKey : 212f54a1-1c88-1bf5-54a1-f7bf52b3256c
• secretKey : 7RJPKpBJMBkUL87RJPKpkULJPSUpsaKpUL83ysDs

FMZ সাধারণ প্রোটোকল কনফিগারেশন পৃষ্ঠায় আছেaccessKeyএবংsecretKeyইনপুট বক্স, ইউনিভার্সাল প্রোটোকল এক্সচেঞ্জ অবজেক্ট কনফিগার করার পরে, ইউনিভার্সাল প্রোটোকল প্লাগ-ইন প্রোগ্রাম চলাকালীন প্রাপ্ত অনুরোধে বডির JSON ফর্ম্যাট ডেটাaccessKeyক্ষেত্রটির মান হল212f54a1-1c88-1bf5-54a1-f7bf52b3256c，secret_keyক্ষেত্রটির মান হল7RJPKpBJMBkUL87RJPKpkULJPSUpsaKpUL83ysDs。

যখন নিম্নলিখিত ইন্টারফেসটি কল করা হয়, তখন হোস্ট সর্বজনীন প্রোটোকল প্লাগ-ইন প্রোগ্রামে নিম্নরূপ একটি RPC অনুরোধ জারি করবে:

• কৌশলে ডাকলেexchange.SetMarginLevel(10)কখন, অনুরোধ করা বডিতে ডেটা হল:

  {
      "access_key":"212f54a1-1c88-1bf5-54a1-f7bf52b3256c",
      "method":"io",
      "nonce":1631858961289247000,
      "params":{"args":[10],"code":0},   
      "secret_key":"7RJPKpBJMBkUL87RJPKpkULJPSUpsaKpUL83ysDs"
  }

কলিং এক্সচেঞ্জ।সেটমার্জিন লেভেল(10), প্যারামিটারটি 10-এ পাস হয়।

• কৌশলে ডাকলেexchange.SetDirection("buy")কখন, অনুরোধ করা বডিতে ডেটা হল:

  {
      "access_key":"212f54a1-1c88-1bf5-54a1-f7bf52b3256c",
      "method":"io",
      "nonce":1631860438946922000,
      "params":{"args":["buy"],"code":1},  
      "secret_key":"7RJPKpBJMBkUL87RJPKpkULJPSUpsaKpUL83ysDs"
  }

কল exchange.SetDirection(“buy”), প্যারামিটার হিসাবে “buy” পাস করে।

• কৌশলে ডাকলেexchange.SetContractType("swap")কখন, অনুরোধ করা বডিতে ডেটা হল:

  {
      "access_key":"212f54a1-1c88-1bf5-54a1-f7bf52b3256c",
      "method":"io",
      "nonce":1631860847525039000,
      "params":{"args":["swap"],"code":2},   
      "secret_key":"7RJPKpBJMBkUL87RJPKpkULJPSUpsaKpUL83ysDs"
  }

কল exchange.SetContractType(“swap”), প্যারামিটার হিসাবে “swap” এ পাস করে।

• কৌশলে ডাকলেexchange.GetPosition()কখন, অনুরোধ করা বডিতে ডেটা হল:

  {
      "access_key":"212f54a1-1c88-1bf5-54a1-f7bf52b3256c",
      "method":"io",
      "nonce":1631860996119505000,
      "params":{"args":[],"code":3},  
      "secret_key":"7RJPKpBJMBkUL87RJPKpkULJPSUpsaKpUL83ysDs"
  }

Exchange.GetPosition() কল করার সময়, কোন প্যারামিটার পাস করা হয় না।

উপরের অনুরোধের বডিতে JSON ডেটা পর্যবেক্ষণ করে আমরা পেয়েছি:

• যখন ফিউচার এক্সচেঞ্জ অবজেক্টের জন্য নির্দিষ্ট ফাংশন কল করা হয়, অনুরোধ করা বডিmethodক্ষেত্রের মানগুলি হলio。
• এই ফাংশন পার্থক্য প্রয়োজনparamsমাঠেcodeরায়, অর্থাৎ:
  • codeজন্য0হ্যাঁSetMarginLevel。
  • codeজন্য1হ্যাঁSetDirection。
  • codeজন্য2হ্যাঁSetContractType。
  • codeজন্য3হ্যাঁGetPosition。
• যখন ফিউচার এক্সচেঞ্জ অবজেক্টগুলির জন্য নির্দিষ্ট এই ফাংশনগুলিকে কল করা হয়, তখন পাস করা প্যারামিটারগুলি সমস্ত বডিতে অনুরোধ করা হয়।paramsক্ষেত্রargsমধ্যম

গো ল্যাঙ্গুয়েজ প্লাগ-ইন উদাহরণের স্পট সংস্করণের সাথে তুলনা করে, আপনাকে এটি করতে হবেOnPostফাংশনে কিছু সম্প্রসারণ করুন: “এর জন্য নীচের কোডটি দেখুনফিউচার এক্সচেঞ্জ অবজেক্ট প্রসারিত করার জন্য প্রয়োজনীয় ফাংশন“টীকাটির অবস্থান।

func OnPost(w http.ResponseWriter, r *http.Request) {
    var ret interface{}
    defer func() {
        if e := recover(); e != nil {
            if ee, ok := e.(error); ok {
                e = ee.Error()
            }
            ret = map[string]string{"error": fmt.Sprintf("%v", e)}
        }
        b, _ := json.Marshal(ret)
        w.Write(b)
    }()

    b, err := ioutil.ReadAll(r.Body)
    if err != nil {
        panic(err)
    }

    var request RpcRequest
    err = json.Unmarshal(b, &request)
    if err != nil {
        panic(err)
    }
    e := newZG(request.AccessKey, request.SecretKey)

    var symbol string 
    if _, ok := request.Params["symbol"]; ok {
        symbol = strings.ToUpper(request.Params["symbol"].(string))
    }

    var data interface{}
    switch request.Method {
    case "ticker":
        data, err = e.GetTicker(symbol, "GET")                                        
    case "depth":
        data, err = e.GetDepth(symbol, "GET")
    case "trades":
        data, err = e.GetTrades(symbol, "GET")
    case "records":
        data, err = e.GetRecords(toInt64(request.Params["period"]), symbol, "GET")    
    case "accounts":
        data, err = e.GetAccount(symbol, "GET")
    case "trade":
        side := request.Params["type"].(string)
        if side == "buy" {
            side = "BUY"
        } else {
            side = "SELL"
        }
        price := toFloat(request.Params["price"])
        amount := toFloat(request.Params["amount"])
        data, err = e.Trade(side, price, amount, symbol, "POST")
    case "orders":
        data, err = e.GetOrders(symbol, "POST")
    case "order":
        data, err = e.GetOrder(toString(request.Params["id"]), symbol, "POST")
    case "cancel":
        data, err = e.CancelOrder(toString(request.Params["id"]), symbol, "POST")
    default:
        if strings.HasPrefix(request.Method, "__api_") {
            params := map[string]interface{}{}
            for k, v := range request.Params {
                params[k] = toString(v)
            }
            data, err = e.tapiCall(request.Method[6:], params, "GET")
        } else if request.Method == "io" {              // 扩展期货交易所对象需要的函数
            code := toString(request.Params["code"])
            if code == "0" {            
                // 处理SetMarginLevel
                // ...
            } else if code == "1" {
                // 处理SetDirection
                // ...
            } else if code == "2" {     
                // 处理SetContractType
                // ...
            } else if code == "3" {     
                // 处理GetPosition
                // ...
            } else {
                panic(errors.New(request.Method + " not support"))    
            }
        } else {
            panic(errors.New(request.Method + " not support"))
        }
    }
    if err != nil {
        panic(err)
    }
    ret = map[string]interface{}{
        "data": data,
    }
    return
}

SetMarginLevel/SetDirection/SetContractTypeআক্ষরিক অর্থ থেকে, বর্তমান ট্রেডিং বৈচিত্র্যের প্রাসঙ্গিক কনফিগারেশন সেট করতে তিনটি ফাংশন ব্যবহার করা যেতে পারে। মধ্যেSetDirection/SetContractTypeডিজাইনের দৃষ্টিকোণ থেকে, একটি স্থানীয় ভেরিয়েবল বর্তমান অর্ডারের দিকনির্দেশ রেকর্ড করার জন্য সেট করা হয়েছে (অর্থাৎ, অর্ডার দেওয়ার সময়, অর্ডারটি কোন দিকে দেওয়া হবে তা জানতে আপনাকে এই সেটিংটি পড়তে হবে। কারণ হল দুটি দিকনির্দেশ রয়েছে ফিউচার ক্রয়ের জন্য: দীর্ঘ এবং সংক্ষিপ্ত অতএব, এটি আলাদা করা প্রয়োজন) এবং বর্তমান চুক্তি কোড (যে চুক্তিটি বাজার মূল্য, আদেশ ইত্যাদি পাওয়ার সময় স্পষ্টভাবে জিজ্ঞাসা করা হয়)।

SetMarginLevelএক্সচেঞ্জের লিভারেজ মেকানিজম অনুসারে এটি বিশেষভাবে ডিজাইন করা প্রয়োজন (1. লিভারেজ প্যারামিটারগুলি অর্ডার ইন্টারফেসে প্যারামিটার হিসাবে পাস করা হয়। 2. এক্সচেঞ্জের একটি লিভারেজ ইন্টারফেস রয়েছে)।

GetPositionএটি পণ্যের বর্তমান অবস্থান প্রাপ্ত করার একটি ফাংশন। যখন সাধারণ প্রোটোকল প্লাগ-ইন এক্সচেঞ্জ পজিশন ইন্টারফেস দ্বারা ফেরত পাঠানো ডেটা গ্রহণ করে, তখন এটি সরাসরি FMZ-এ পজিশন ফাংশন তৈরি করে।positionশুধু একই তথ্য গঠন.

সম্পূর্ণ AOFEX ফিউচার ইউনিভার্সাল প্রোটোকল প্লাগ-ইন উদাহরণ:

ভাষা যান

”`go /* CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build xxx.go */

package main

import ( “bytes” “encoding/hex” “crypto/sha1” “encoding/json” “errors” “flag” “fmt” “io/ioutil” “log” “net/http” “net/url” “sort” “strconv” “strings” “time” // proxy “golang.org/x/net/proxy” “crypto/tls” “math/rand” )

var isUsedProxy bool = false
var ct string = “”
var direction string = “buy”
var marginLevel float64 = 10
var currSymbol string = “”

func toFloat(s interface{}) float64 { var ret float64 switch v := s.(type) { case float64: ret = v case float32: ret = float64(v) case int64: ret = float64(v) case int: ret = float64(v) case int32: ret = float64(v) case string: ret, _ = strconv.ParseFloat(strings.TrimSpace(v), 64) } return ret }

func float2str(i float64) string { return strconv.FormatFloat(i, ‘f’, -1, 64) }

func toInt64(s interface{}) int64 { var ret int64 switch v := s.(type) { case int: ret = int64(v) case float64: ret = int64(v) case bool: if v { ret = 1 } else { ret = 0 } case int64: ret = v case string: ret, _ = strconv.ParseInt(strings.TrimSpace(v), 10, 64) } return ret }

func toString(s interface{}) string { var ret string switch v := s.(type) { case string: ret = v case int64: ret = strconv.FormatInt(v, 10) case float64: ret = strconv.FormatFloat(v, ‘f’, -1, 64) case bool: ret = strconv.FormatBool(v) default: ret = fmt.Sprintf(“%v”, s) } return ret }

type Json struct { data interface{} }

func NewJson(body []byte) (*Json, error) { j := new(Json) err := j.UnmarshalJSON(body) if err != nil { return nil, err } return j, nil }

func (j *Json) UnmarshalJSON(p []byte) error { return json.Unmarshal(p, &j.data) }

func (j *Json) Get(key string) *Json { m, err := j.Map() if err == nil { if val, ok := m[key]; ok { return &Json{val} } } return &Json{nil} }

func (j *Json) CheckGet(key string) (*Json, bool) { m, err := j.Map() if err == nil { if val, ok := m[key]; ok { return &Json{val}, true } } return nil, false }

func (j *Json) Map() (map[string]interface{}, error) { if m, ok := (j.data).(map[string]interface{}); ok { return m, nil } return nil, errors.New(“type assertion to map[string]interface{} failed”) }

func (j *Json) Array() ([]interface{}, error) { if a, ok := (j.data).([]interface{}); ok { return a, nil } return nil, errors.New(“type assertion to []interface{} failed”) }

func (j *Json) Bool() (bool, error) { if s, ok := (j.data).(bool); ok { return s, nil } return false, errors.New(“type assertion to bool failed”) }

func (j *Json) String() (string, error) { if s, ok := (j.data).(string); ok { return s, nil } return “”, errors.New(“type assertion to string failed”) }

func (j *Json) Bytes() ([]byte, error) { if s, ok := (j.data).(string); ok { return []byte(s), nil } return nil, errors.New(“type assertion to []byte failed”) }

func (j *Json) Int() (int, error) { if f, ok := (j.data).(float64); ok { return int(f), nil }

return -1, errors.New("type assertion to float64 failed")

}

func (j *Json) MustArray(args …[]interface{}) []interface{} { var def []interface{}

switch len(args) {
case 0:
case 1:
    def = args[0]
default:
    log.Panicf("MustArray() received too many arguments %d", len(args))
}

a, err := j.Array()
if err == nil {
    return a
}

return def

}

func (j *Json) MustMap(args …map[string]interface{}) map[string]interface{} { var def map[string]interface{}

switch len(args) {
case 0:
case 1:
    def = args[0]
default:
    log.Panicf("MustMap() received too many arguments %d", len(args))
}

a, err := j.Map()
if err == nil {
    return a
}

return def

}

func (j *Json) MustString(args …string) string { var def string

switch len(args) {
case 0:
case 1:
    def = args[0]
default:
    log.Panicf("MustString() received too many arguments %d", len(args))
}

s, err := j.String()
if err == nil {
    return s
}

return def

}

func (j *Json) MustInt64() int64 { var ret int64 var err error switch v := j.data.(type) { case int: ret = int64(v) case int64: ret = v case float64: ret = int64(v) case string: if ret, err = strconv.ParseInt(v, 10, 64); err != nil { panic(err) } default: ret = 0 } return ret }

func (j *Json) MustFloat64() float64 { var ret float64 var err error switch v := j.data.(type) { case int: ret = float64(v) case int64: ret = float64(v) case float64: ret = v case string: v = strings.Replace(v, “,”, “”, -1) if ret, err = strconv.ParseFloat(v, 64); err != nil { panic(err) } default: ret = 0 } return ret }

type headerTuple struct { name string value string }

type Request struct { headers []headerTuple Proxy string Method string Uri string Body interface{} QueryString interface{} Timeout time.Duration ContentType string Accept string Host string UserAgent string }

func (r *Request) AddHeader(name string, value string) { if r.headers == nil { r.headers = []headerTuple{} } r.headers = append(r.headers, headerTuple{name: name, value: value}) }

type iAOFEX struct { accessKey string secretKey string clientID string currency string opCurrency string baseCurrency string quoteCurrency string apiBase string timeout time.Duration timeLocation *time.Location

// ext
contractTypes []string

}

type MapSorter []Item

type Item struct { Key string Val string }

func NewMapSorter(m map[string]string) MapSorter { ms := make(MapSorter, 0, len(m))

for k, v := range m {
    if strings.HasPrefix(k, "!") {
        k = strings.Replace(k, "!", "", -1)
    }
    ms = append(ms, Item{k, v})
}

return ms

}

func (ms MapSorter) Len() int { return len(ms) }

func (ms MapSorter) Less(i, j int) bool { return ms[i].Key < ms[j].Key
}

func (ms MapSorter) Swap(i, j int) { ms[i], ms[j] = ms[j], ms[i] }

func encodeParams(params map[string]string, escape bool) string { ms := NewMapSorter(params) sort.Sort(ms)

v := url.Values{}
for _, item := range ms {
    v.Add(item.Key, item.Val)
}
if escape {
    return v.Encode()
}
var buf bytes.Buffer
keys := make([]string, 0, len(v))
for k := range v {
    keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
    vs := v[k]
    prefix := k + "="
    for _, v := range vs {
        if buf.Len() > 0 {
            buf.WriteByte('&')
        }
        buf.WriteString(prefix)
        buf.WriteString(v)
    }
}
return buf.String()

}

func newiAOFEX(accessKey, secretKey string) *iAOFEX { s := new(iAOFEX) s.accessKey = accessKey s.secretKey = secretKey s.apiBase = “https://openapi-contract.aofex.info” s.timeout = 20 * time.Second s.timeLocation = time.FixedZone(“Asia/Shanghai”, 8*60*60) s.contractTypes = []string{“swap”} return s }

func (p *iAOFEX) isValidContractType(contractType string) bool { for _, t := range p.contractTypes { if contractType == t { return true } } return false }

func (p *iAOFEX) calcContractTypeMap(currency string) (contractTypeMap map[string]string, err error) { var baseCurrency, quoteCurrency string contractTypeMap = map[string]string{} if arr := strings.SplitN(currency, “_”, 2); len(arr) == 2 { baseCurrency = arr[0] quoteCurrency = arr[1] } else { err = errors.New(“symbol error!”) return } contractTypeMap[“swap”] = fmt.Sprintf(“%s-%s”, strings.ToUpper(baseCurrency), strings.ToUpper(quoteCurrency)) return }

func (p *iAOFEX) apiCall(method string) (*Json, error) { req, err := http.NewRequest(“GET”, fmt.Sprintf(“%s%s”, p.apiBase, method), nil) if err != nil { return nil, err }

fmt.Printf("\n %c[1;44;32m%s%c[0m\n", 0x1B, "apiCall GET create req:" + fmt.Sprintf("%s%s", p.apiBase, method), 0x1B)
fmt.Println("req:", req)                                                        
req.Header.Set("Content-Type", "application/json;utf-8")

// proxy
strProxy := ""
client := http.DefaultClient
if isUsedProxy {
    var auth *proxy.Auth
    proxyAddr := strings.Split(strProxy, "//")[1]
    if strings.Contains(proxyAddr, "@") {
        arr := strings.SplitN(proxyAddr, "@", 2)
        arrAuth := strings.SplitN(arr[0], ":", 2)
        proxyAddr = arr[1]
        auth = &proxy.Auth{}
        auth.User = arrAuth[0]
        if len(arrAuth) == 2 {
            auth.Password = arrAuth[1]
        }
    }
    var dialer proxy.Dialer
    if dialer, err = proxy.SOCKS5("tcp", proxyAddr, auth, proxy.Direct); err == nil {
        client = &http.Client{
            Transport: &http.Transport{
                Dial:                  dialer.Dial,
                MaxIdleConnsPerHost:   5,
                TLSClientConfig:       &tls.Config{InsecureSkipVerify: true},
                ResponseHeaderTimeout: 20 * time.Second,
            },
            Timeout: 20 * time.Second,
        }
    } else {
        return nil, err
    }
}


resp, err := client.Do(req)
if err != nil {
    return nil, err
}
defer resp.Body.Close()
b, err := ioutil.ReadAll(resp.Body)
if err != nil {
    return nil, err
}

var js *Json
js, err = NewJson(b)
if err != nil {
    return nil, err
}

// fault tolerant 
if _, ok := js.data.(map[string]interface{}); ok {
    if code, ok := js.MustMap()["code"]; ok {
        if toString(code) != "0" {
            err = errors.New(fmt.Sprintf("%v", js.data))
        }
    }
}    

return js, err 

}

func (p *iAOFEX) GetTicker(symbol string) (ticker interface{}, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

var js *Json
js, err = p.apiCall(fmt.Sprintf("/openApi/contract/market?symbol=%s", realCt))
if err != nil {
    return
}

depth, errDepth := p.GetDepth(symbol)
if errDepth != nil {
    err = errDepth
    return 
}

ask1 := depth.(map[string]interface{})["asks"].([][2]float64)[0][0]
bid1 := depth.(map[string]interface{})["bids"].([][2]float64)[0][0]
mp := js.Get("result").MustMap()
ticker = map[string]interface{}{
    "time": time.Now().UnixNano() / 1e6,
    "buy":  toFloat(bid1),
    "sell": toFloat(ask1),
    "last": toFloat(mp["close"]),
    "high": toFloat(mp["high"]),
    "low":  toFloat(mp["low"]),
    "vol":  toFloat(mp["vol"]),
}
return

}

func (p *iAOFEX) GetDepth(symbol string) (depth interface{}, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

var js *Json
js, err = p.apiCall(fmt.Sprintf("/openApi/contract/depth?symbol=%s", realCt))
if err != nil {
    return
}

asks := [][2]float64{}
bids := [][2]float64{}
for _, pair := range js.Get("result").Get("asks").MustArray() {                            
    arr := pair.([]interface{})
    asks = append(asks, [2]float64{toFloat(arr[0]), toFloat(arr[1])})
}
for _, pair := range js.Get("result").Get("bids").MustArray() {                            
    arr := pair.([]interface{})
    bids = append(bids, [2]float64{toFloat(arr[0]), toFloat(arr[1])})
}
depth = map[string]interface{}{
    "time": js.Get("result").Get("ts").MustInt64(),
    "asks": asks,
    "bids": bids,
}
return

}

func (p *iAOFEX) GetTrades(symbol string) (trades interface{}, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

var js *Json
js, err = p.apiCall(fmt.Sprintf("/openApi/contract/trade?symbol=%s", realCt))
if err != nil {
    return
}

items := []map[string]interface{}{}
for _, pair := range js.Get("result").Get("data").MustArray() {
    item := map[string]interface{}{}
    mp := pair.(map[string]interface{})
    item["id"] = toString(mp["id"])
    item["price"] = toFloat(mp["price"])
    item["amount"] = toFloat(mp["amount"])
    item["time"] = toInt64(mp["ts"])
    if toString(mp["direction"]) == "buy" {
        item["type"] = "buy"
    } else {
        item["type"] = "sell"
    }
    items = append(items, item)
}

for i := 0; i < len(items); i++ {
    for j := 0; j < len(items)-i-1; j++ {
        if toInt64(items[j]["time"]) > toInt64(items[j+1]["time"]) {
            items[j], items[j+1] = items[j+1], items[j]
        }
    }
}

trades = items
return

}

func (p *iAOFEX) GetRecords(step int64, symbol string) (records interface{}, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

var periodDict map[int64]string = map[int64]string{
    1 : "1min",
    5 : "5min",
    15 : "15min",
    30 : "30min",
    60 : "1hour",
    1440 : "1day",
}
period, okPeriod := periodDict[step]
if !okPeriod {
    err = errors.New("period not support")
    return 
}

var js *Json
js, err = p.apiCall(fmt.Sprintf("/openApi/contract/kline?symbol=%s&period=%s&size=500", realCt, period))
if err != nil {
    return
}

items := []interface{}{}
recordsData := js.Get("result").Get("data").MustArray()
for i := len(recordsData) - 1 ; i >= 0 ; i-- {
    mp := recordsData[i].(map[string]interface{})
    item := [6]interface{}{}
    item[0] = toInt64(mp["id"])          // time
    item[1] = toFloat(mp["open"])        // open
    item[2] = toFloat(mp["high"])        // high
    item[3] = toFloat(mp["low"])         // low
    item[4] = toFloat(mp["close"])       // close
    item[5] = toFloat(mp["vol"])         // vol
    items = append(items, item)
}
records = items
return

}

func JSON_Encode(d interface{}) string { buffer := &bytes.Buffer{} encoder := json.NewEncoder(buffer) encoder.SetEscapeHTML(false) encoder.Encode(d) return buffer.String() }

func (p *iAOFEX) tapiCall(httpMethod string, method string, params map[string]string) (js *Json, err error) { if params == nil { params = map[string]string{} }

nonce := toString(time.Now().UnixNano() / 1e9)
strLetter := "124567890abcdefghijklmnopqrstuvwxyz"
for i := 0 ; i < 5 ; i++ {
    rand.Seed(time.Now().UnixNano())
    nonce += string(strLetter[rand.Intn(len(strLetter))])
}

arrParams := []string{}
arrParams = append(arrParams, p.accessKey)
arrParams = append(arrParams, p.secretKey)
arrParams = append(arrParams, nonce)

for k, v := range params {
    arrParams = append(arrParams, fmt.Sprintf("%s=%s", k, v))
}

sort.Strings(arrParams)
strSign := ""
for _, ele := range arrParams {
    strSign += toString(ele)
}
h := sha1.New()
h.Write([]byte(strSign))
signature := hex.EncodeToString(h.Sum(nil))

strUrl := fmt.Sprintf("%s%s", p.apiBase, method)
if len(params) > 0 {
    strUrl = fmt.Sprintf("%s%s?%s", p.apiBase, method, encodeParams(params, false))
}

req, err := http.NewRequest(httpMethod, strUrl, nil)
if err != nil {
    return nil, err
}
req.Header.Add("Nonce", nonce)
req.Header.Add("Token", p.accessKey)
req.Header.Add("Signature", signature)

strProxy := ""
client := http.DefaultClient
if isUsedProxy {
    var auth *proxy.Auth
    proxyAddr := strings.Split(strProxy, "//")[1]
    if strings.Contains(proxyAddr, "@") {
        arr := strings.SplitN(proxyAddr, "@", 2)
        arrAuth := strings.SplitN(arr[0], ":", 2)
        proxyAddr = arr[1]
        auth = &proxy.Auth{}
        auth.User = arrAuth[0]
        if len(arrAuth) == 2 {
            auth.Password = arrAuth[1]
        }
    }
    var dialer proxy.Dialer
    if dialer, err = proxy.SOCKS5("tcp", proxyAddr, auth, proxy.Direct); err == nil {
        client = &http.Client{
            Transport: &http.Transport{
                Dial:                  dialer.Dial,
                MaxIdleConnsPerHost:   5,
                TLSClientConfig:       &tls.Config{InsecureSkipVerify: true},
                ResponseHeaderTimeout: 20 * time.Second,
            },
            Timeout: 20 * time.Second,
        }
    } else {
        return nil, err
    }
}

fmt.Printf("\n %c[1;44;32m%s%c[0m\n", 0x1B, "apiCall GET create req:" + fmt.Sprintf("%s%s", p.apiBase, method), 0x1B)
fmt.Println("tapiCall req:", req)  

resp, err := client.Do(req)

if err != nil {
    return nil, err
}
defer resp.Body.Close()
b, err := ioutil.ReadAll(resp.Body)
if err != nil {
    return nil, err
}

js, err = NewJson(b)
if err != nil {
    return nil, err
}

// fault tolerant 
if mp, ok := js.data.(map[string]interface{}); ok {
    if errno, ok := mp["errno"]; !ok || toString(errno) != "0" {
        err = errors.New(fmt.Sprintf("%v", js.data))    
    }
} else {
    err = errors.New(fmt.Sprintf("%v", js.data))
}

return js, err

}

func (p *iAOFEX) GetAccount(symbol string) (account interface{}, err error) { symbol = currSymbol mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

var js *Json
js, err = p.tapiCall("GET", "/openApi/contract/walletList", nil)
if err != nil {
    return
}

assets := map[string]map[string]interface{}{}
for _, ele := range js.Get("result").MustArray() {
    dic := ele.(map[string]interface{})
    if realCt != toString(dic["symbol"]) {
        continue
    }
    arr := strings.SplitN(toString(dic["symbol"]), "-", 2)
    if arr[1] == "USDT" {
        if _, ok := assets[arr[1]]; !ok {
            assets[arr[1]] = map[string]interface{}{}
        }
        assets[arr[1]]["currency"] = arr[1]
        assets[arr[1]]["Info"] = dic
        assets[arr[1]]["free"] = toFloat(dic["avail"])
        assets[arr[1]]["frozen"] = toFloat(dic["frozen"])
    }
}

accounts := []map[string]interface{}{}
for _, pair := range assets {
    accounts = append(accounts, pair)
}

account = accounts
return

}

func (p *iAOFEX) Trade(side string, price, amount float64, symbol string) (orderId interface{}, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

params := map[string]string{}

if direction == "buy" {
    params["contract_type"] = "open"
} else if direction == "sell" {
    params["contract_type"] = "open"
} else if direction == "closebuy" {
    params["contract_type"] = "close" 
} else if direction == "closesell" { 
    params["contract_type"] = "close"
} else {
    err = errors.New("invalid direction!")
    return 
}

if (side == "buy-limit" || side == "buy-market") && (direction == "sell" || direction == "closebuy") {
    err = errors.New("invalid direction!")
    return 
} else if (side == "sell-limit" || side == "sell-market") && (direction == "buy" || direction == "closesell") {
    err = errors.New("invalid direction!")
    return 
}

params["type"] = side
params["lever_rate"] = toString(marginLevel)
params["amount"] = toString(amount)
params["symbol"] = realCt
if price > 0 {
    params["price"] = toString(price)
}

var js *Json
js, err = p.tapiCall("POST", "/openApi/contract/add", params)
if err != nil {
    return
}

orderId = map[string]string{"id": toString(js.MustMap()["result"])}
return

}

func (p *iAOFEX) GetOrders(symbol string) (orders interface{}, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

from := ""
limit := 100
items := []map[string]interface{}{}
for {
    params := map[string]string{
        "symbol" : realCt, 
        "limit" : toString(limit),             
    }
    if from != "" {
        params["from"] = toString(from)
    }

    var js *Json
    js, err = p.tapiCall("GET", "/openApi/contract/currentList", params)
    if err != nil {
        return
    }

    arr := js.Get("result").MustArray()
    for _, ele := range arr {
        mp := ele.(map[string]interface{})
        item := map[string]interface{}{}
        item["id"] = toString(mp["order_id"])
        item["amount"] = toFloat(mp["amount"])
        item["price"] = toFloat(mp["price"])
        item["deal_amount"] = toFloat(mp["deal_amount"])
        item["avg_price"] = toFloat(mp["price_avg"])        
        if toString(mp["type"]) == "buy-limit" || toString(mp["type"]) == "buy-market" || toString(mp["type"]) == "buy-tactics" || toString(mp["type"]) == "buy-market-tactic" || toString(mp["type"]) == "buy-plan" || toString(mp["type"]) == "buy-market-plan" {
            item["type"] = "buy"
        } else {
            item["type"] = "sell"
        }
        item["status"] = "open"
        item["contract_type"] = ct
        items = append(items, item)
        from = toString(mp["order_id"])
    }

    if len(arr) < limit {
        break
    }
}
return items, nil

}

func (p *iAOFEX) GetOrder(orderId string, symbol string) (order interface{}, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

var js *Json
js, err = p.tapiCall("GET", "/openApi/contract/historyList", map[string]string{
    "from" : toString(orderId),
    "symbol" : realCt, 
    "limit" : "1",
})
if err != nil {
    return
}

item := map[string]interface{}{}
for _, ele := range js.Get("result").MustArray() {
    mp := ele.(map[string]interface{})
    if realCt != toString(mp["symbol"]) || toString(mp["order_id"]) != toString(orderId) {
        continue
    }
    item["id"] = toString(mp["order_id"])
    item["amount"] = toFloat(mp["amount"])
    item["price"] = toFloat(mp["price"])
    item["deal_amount"] = toFloat(mp["deal_amount"])
    item["avg_price"] = toFloat(mp["price_avg"])
    item["contract_type"] = ct
    if toString(mp["type"]) == "buy-limit" || toString(mp["type"]) == "buy-market" || toString(mp["type"]) == "buy-tactics" || toString(mp["type"]) == "buy-market-tactic" || toString(mp["type"]) == "buy-plan" || toString(mp["type"]) == "buy-market-plan" {
        item["type"] = "buy"
    } else {
        item["type"] = "sell"
    }    

    switch toString(mp["status"]) {
    case "1", "2":
        item["status"] = "open"
    case "3":
        item["status"] = "closed"
    case "4", "5", "6":
        item["status"] = "cancelled"
    }
    return item, nil
}

err = errors.New("order not found")
return 

}

func (p *iAOFEX) CancelOrder(orderId string, symbol string) (ret bool, err error) { mpCt, mpCtErr := p.calcContractTypeMap(symbol) if mpCtErr != nil { err = mpCtErr return } realCt, ok := mpCt[ct] if !ok { err = errors.New(“invalid contractType!”) return }

_, err = p.tapiCall("POST", "/openApi/contract/cancel", map[string]string{
    "order_ids" : toString(orderId), 
    "symbol" : realCt, 
})
if err != nil {
    return
}

ret = true
return

}

type RpcRequest struct {
AccessKey string json:"access_key" SecretKey string json:"secret_key" Nonce int64 json:"nonce" Method string json:"method" Params map[string]interface{} json:"params" }

func OnPost(w http.ResponseWriter, r *http.Request) { var ret interface{} defer func() { if e := recover(); e != nil { if ee, ok := e.(error); ok { e = ee.Error() } ret = map[string]string{“error”: fmt.Sprintf(“%v”, e)} } b, _ := json.Marshal(ret) w.Write(b) }()

b, err := ioutil.ReadAll(r.Body)
if err != nil {
    panic(err)
}
var request RpcRequest
err = json.Unmarshal(b, &request)
if err != nil {
    panic(err)
}

e := newiAOFEX(request.AccessKey, request.SecretKey)
symbol := strings.ToUpper(toString(request.Params["symbol"]))
if _, ok := request.Params["symbol"]; ok {        
    currSymbol = symbol        
}

var data interface{}
switch request.Method {
case "ticker":
    data, err = e.GetTicker(symbol)
case "depth":
    data, err = e.GetDepth(symbol)
case "trades":
    data, err = e.GetTrades(symbol)
case "records":
    data, err = e.GetRecords(toInt64(request.Params["period"]), symbol)
case "accounts":
    data, err = e.GetAccount(symbol)
case "trade":
    side := toString(request.Params["type"])
    if side == "buy" {
        side = "buy-limit"
        if toFloat(request.Params["price"]) <= 0 {
            side = "buy-market"
        }
    } else {
        side = "sell-limit"
        if toFloat(request.Params["price"]) <= 0 {
            side = "sell-market"
        }
    }
    price := toFloat(request.Params["price"])
    amount := toFloat(request.Params["amount"])
    data, err = e.Trade(side, price, amount, symbol)
case "orders":
    data, err = e.GetOrders(symbol)
case "order":
    data, err = e.GetOrder(toString(request.Params["id"]), symbol)
case "cancel":
    data, err = e.CancelOrder(toString(request.Params["id"]), symbol)
default:
    if strings.HasPrefix(request.Method, "__api_") {  
        params := map[string]string{}
        for k, v := range request.Params {
            params[k] = toString(v)
        }
        data, err = e.tapiCall("GET", request.Method[6:], params)
    } else if request.Method == "io" {
        code := toString(request.Params["code"])
        if code == "0" {            
            if args, ok := request.Params["args"].([]interface{}); ok && len(args) == 1 {
                marginLevel = toFloat(args[0])
            } else {
                err = errors.New(fmt.Sprintf("%v", request.Params))
            }
        } else if code == "1" {
            if args, ok := request.Params["args"].([]interface{}); ok && len(args) == 1 {
                orderDirection := toString(args[0])
                if orderDirection == "buy" || orderDirection == "sell" || orderDirection == "closebuy" || orderDirection == "closesell" {
                    direction = orderDirection
                    data = orderDirection
                } else {
                    err = errors.New(fmt.Sprintf("not support orderDirection: %s", orderDirection))
                }
            } else {
                err = errors.New(fmt.Sprintf("%v", request.Params))
            }
        } else if code == "2" {     
            if args, ok := request.Params["args"].([]interface{}); ok && len(args) == 1 {
                contractType := toString(args[0])
                if e.isValidContractType(contractType) {
                    ct = contractType
                    data = contractType
                } else {
                    err = errors.New(fmt.Sprintf("not support contractType: %s", contractType))
                }
            } else {
                err = errors.New(fmt.Sprintf("%v", request.Params))
            }
        } else if code == "3" {     
            symbol := currSymbol
            mpCt, mpCtErr := e.calcContractTypeMap(symbol)
            if mpCtErr != nil {
                panic(mpCtErr)
            }
            realCt, ok := mpCt[ct]
            if !ok {
                err = errors.New("invalid contractType!")
                panic(err)
            }
            var js *Json
            js, err = e.tapiCall("GET", "/openApi/contract/position", map[string]string{
                "symbol" : realCt, 
            })
            if err != nil {
                panic(err)
            }

            items := []map[string]interface{}{}
            for _, ele := range js.Get("result").MustArray() {
                mp := ele.(map[string]interface{})
                item := map[string]interface{}{}
                item["MarginLevel"] = toFloat(mp["lever_rate"])
                item["Amount"] = toFloat(mp["amount"])
                item["FrozenAmount"] = toFloat(mp["contract_frozen"])
                item["Price"] = toFloat(mp["open_price_avg"])
                item["Profit"] = toFloat(mp["un_profit"])
                if toString(mp["type"]) == "1" {
                    item["Type"] = 0
                } else {
                    item["Type"] = 1
                }
                item["ContractType"] = ct
                item["Margin"] = toFloat(mp["bood"])
                items = append(items,