package ccxt

// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

type delta struct {
    Exchange

}

func NewDeltaCore() delta {
   p := delta{}
   setDefaults(&p)
   return p
}

func  (this *delta) Describe() interface{}  {
    return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
        "id": "delta",
        "name": "Delta Exchange",
        "countries": []interface{}{"VC"},
        "rateLimit": 300,
        "version": "v2",
        "has": map[string]interface{} {
            "CORS": nil,
            "spot": true,
            "margin": false,
            "swap": true,
            "future": false,
            "option": true,
            "addMargin": true,
            "cancelAllOrders": true,
            "cancelOrder": true,
            "closeAllPositions": true,
            "closePosition": false,
            "createOrder": true,
            "createReduceOnlyOrder": true,
            "editOrder": true,
            "fetchBalance": true,
            "fetchClosedOrders": true,
            "fetchCurrencies": true,
            "fetchDeposit": nil,
            "fetchDepositAddress": true,
            "fetchDepositAddresses": false,
            "fetchDepositAddressesByNetwork": false,
            "fetchDeposits": nil,
            "fetchFundingHistory": false,
            "fetchFundingRate": true,
            "fetchFundingRateHistory": false,
            "fetchFundingRates": true,
            "fetchGreeks": true,
            "fetchIndexOHLCV": true,
            "fetchLedger": true,
            "fetchLeverage": true,
            "fetchLeverageTiers": false,
            "fetchMarginMode": true,
            "fetchMarginModes": false,
            "fetchMarketLeverageTiers": false,
            "fetchMarkets": true,
            "fetchMarkOHLCV": true,
            "fetchMySettlementHistory": false,
            "fetchMyTrades": true,
            "fetchOHLCV": true,
            "fetchOpenInterest": true,
            "fetchOpenOrders": true,
            "fetchOption": true,
            "fetchOptionChain": false,
            "fetchOrderBook": true,
            "fetchPosition": true,
            "fetchPositionMode": false,
            "fetchPositions": true,
            "fetchPremiumIndexOHLCV": false,
            "fetchSettlementHistory": true,
            "fetchStatus": true,
            "fetchTicker": true,
            "fetchTickers": true,
            "fetchTime": true,
            "fetchTrades": true,
            "fetchTransfer": nil,
            "fetchTransfers": nil,
            "fetchUnderlyingAssets": false,
            "fetchVolatilityHistory": false,
            "fetchWithdrawal": nil,
            "fetchWithdrawals": nil,
            "reduceMargin": true,
            "setLeverage": true,
            "setMargin": false,
            "setMarginMode": false,
            "setPositionMode": false,
            "transfer": false,
            "withdraw": false,
        },
        "timeframes": map[string]interface{} {
            "1m": "1m",
            "3m": "3m",
            "5m": "5m",
            "15m": "15m",
            "30m": "30m",
            "1h": "1h",
            "2h": "2h",
            "4h": "4h",
            "6h": "6h",
            "1d": "1d",
            "7d": "7d",
            "1w": "1w",
            "2w": "2w",
            "1M": "30d",
        },
        "urls": map[string]interface{} {
            "logo": "https://user-images.githubusercontent.com/1294454/99450025-3be60a00-2931-11eb-9302-f4fd8d8589aa.jpg",
            "test": map[string]interface{} {
                "public": "https://testnet-api.delta.exchange",
                "private": "https://testnet-api.delta.exchange",
            },
            "api": map[string]interface{} {
                "public": "https://api.delta.exchange",
                "private": "https://api.delta.exchange",
            },
            "www": "https://www.delta.exchange",
            "doc": []interface{}{"https://docs.delta.exchange"},
            "fees": "https://www.delta.exchange/fees",
            "referral": "https://www.delta.exchange/app/signup/?code=IULYNB",
        },
        "api": map[string]interface{} {
            "public": map[string]interface{} {
                "get": []interface{}{"assets", "indices", "products", "products/{symbol}", "tickers", "tickers/{symbol}", "l2orderbook/{symbol}", "trades/{symbol}", "stats", "history/candles", "history/sparklines", "settings"},
            },
            "private": map[string]interface{} {
                "get": []interface{}{"orders", "products/{product_id}/orders/leverage", "positions/margined", "positions", "orders/history", "fills", "fills/history/download/csv", "wallet/balances", "wallet/transactions", "wallet/transactions/download", "wallets/sub_accounts_transfer_history", "users/trading_preferences", "sub_accounts", "profile", "deposits/address", "orders/leverage"},
                "post": []interface{}{"orders", "orders/bracket", "orders/batch", "products/{product_id}/orders/leverage", "positions/change_margin", "positions/close_all", "wallets/sub_account_balance_transfer", "orders/cancel_after", "orders/leverage"},
                "put": []interface{}{"orders", "orders/bracket", "orders/batch", "positions/auto_topup", "users/update_mmp", "users/reset_mmp"},
                "delete": []interface{}{"orders", "orders/all", "orders/batch"},
            },
        },
        "fees": map[string]interface{} {
            "trading": map[string]interface{} {
                "tierBased": true,
                "percentage": true,
                "taker": this.ParseNumber("0.0015"),
                "maker": this.ParseNumber("0.0010"),
                "tiers": map[string]interface{} {
                    "taker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.0015")}, []interface{}{this.ParseNumber("100"), this.ParseNumber("0.0013")}, []interface{}{this.ParseNumber("250"), this.ParseNumber("0.0013")}, []interface{}{this.ParseNumber("1000"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("5000"), this.ParseNumber("0.0009")}, []interface{}{this.ParseNumber("10000"), this.ParseNumber("0.00075")}, []interface{}{this.ParseNumber("20000"), this.ParseNumber("0.00065")}},
                    "maker": []interface{}{[]interface{}{this.ParseNumber("0"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("100"), this.ParseNumber("0.001")}, []interface{}{this.ParseNumber("250"), this.ParseNumber("0.0009")}, []interface{}{this.ParseNumber("1000"), this.ParseNumber("0.00075")}, []interface{}{this.ParseNumber("5000"), this.ParseNumber("0.0006")}, []interface{}{this.ParseNumber("10000"), this.ParseNumber("0.0005")}, []interface{}{this.ParseNumber("20000"), this.ParseNumber("0.0005")}},
                },
            },
        },
        "options": map[string]interface{} {
            "networks": map[string]interface{} {
                "TRC20": "TRC20(TRON)",
                "BEP20": "BEP20(BSC)",
            },
        },
        "features": map[string]interface{} {
            "default": map[string]interface{} {
                "sandbox": true,
                "createOrder": map[string]interface{} {
                    "marginMode": false,
                    "triggerPrice": true,
                    "triggerPriceType": map[string]interface{} {
                        "last": true,
                        "mark": true,
                        "index": true,
                    },
                    "triggerDirection": false,
                    "stopLossPrice": false,
                    "takeProfitPrice": false,
                    "attachedStopLossTakeProfit": map[string]interface{} {
                        "triggerPriceType": nil,
                        "price": true,
                    },
                    "timeInForce": map[string]interface{} {
                        "IOC": true,
                        "FOK": true,
                        "PO": true,
                        "GTD": false,
                    },
                    "hedged": false,
                    "selfTradePrevention": false,
                    "trailing": false,
                    "iceberg": false,
                    "leverage": false,
                    "marketBuyByCost": false,
                    "marketBuyRequiresPrice": false,
                },
                "createOrders": nil,
                "fetchMyTrades": map[string]interface{} {
                    "marginMode": false,
                    "limit": 100,
                    "daysBack": 100000,
                    "untilDays": 100000,
                    "symbolRequired": false,
                },
                "fetchOrder": nil,
                "fetchOpenOrders": map[string]interface{} {
                    "marginMode": false,
                    "limit": 100,
                    "trigger": false,
                    "trailing": false,
                    "symbolRequired": false,
                },
                "fetchOrders": nil,
                "fetchClosedOrders": map[string]interface{} {
                    "marginMode": false,
                    "limit": 500,
                    "daysBack": 100000,
                    "daysBackCanceled": 1,
                    "untilDays": 100000,
                    "trigger": false,
                    "trailing": false,
                    "symbolRequired": false,
                },
                "fetchOHLCV": map[string]interface{} {
                    "limit": 2000,
                },
            },
            "spot": map[string]interface{} {
                "extends": "default",
            },
            "swap": map[string]interface{} {
                "linear": map[string]interface{} {
                    "extends": "default",
                },
                "inverse": map[string]interface{} {
                    "extends": "default",
                },
            },
            "future": map[string]interface{} {
                "linear": map[string]interface{} {
                    "extends": "default",
                },
                "inverse": map[string]interface{} {
                    "extends": "default",
                },
            },
        },
        "precisionMode": TICK_SIZE,
        "requiredCredentials": map[string]interface{} {
            "apiKey": true,
            "secret": true,
        },
        "exceptions": map[string]interface{} {
            "exact": map[string]interface{} {
                "insufficient_margin": InsufficientFunds,
                "order_size_exceed_available": InvalidOrder,
                "risk_limits_breached": BadRequest,
                "invalid_contract": BadSymbol,
                "immediate_liquidation": InvalidOrder,
                "out_of_bankruptcy": InvalidOrder,
                "self_matching_disrupted_post_only": InvalidOrder,
                "immediate_execution_post_only": InvalidOrder,
                "bad_schema": BadRequest,
                "invalid_api_key": AuthenticationError,
                "invalid_signature": AuthenticationError,
                "open_order_not_found": OrderNotFound,
                "unavailable": ExchangeNotAvailable,
            },
            "broad": map[string]interface{} {},
        },
    })
}
func  (this *delta) CreateExpiredOptionMarket(symbol interface{}) interface{}  {
    // support expired option contracts
    var quote interface{} = "USDT"
    var optionParts interface{} = Split(symbol, "-")
    var symbolBase interface{} = Split(symbol, "/")
    var base interface{} = nil
    var expiry interface{} = nil
    var optionType interface{} = nil
    if IsTrue(IsGreaterThan(GetIndexOf(symbol, "/"), OpNeg(1))) {
        base = this.SafeString(symbolBase, 0)
        expiry = this.SafeString(optionParts, 1)
        optionType = this.SafeString(optionParts, 3)
    } else {
        base = this.SafeString(optionParts, 1)
        expiry = this.SafeString(optionParts, 3)
        optionType = this.SafeString(optionParts, 0)
    }
    var settle interface{} = quote
    var strike interface{} = this.SafeString(optionParts, 2)
    var datetime interface{} = this.ConvertExpireDate(expiry)
    var timestamp interface{} = this.Parse8601(datetime)
    return map[string]interface{} {
        "id": Add(Add(Add(Add(Add(Add(optionType, "-"), base), "-"), strike), "-"), expiry),
        "symbol": Add(Add(Add(Add(Add(Add(Add(Add(Add(Add(base, "/"), quote), ":"), settle), "-"), expiry), "-"), strike), "-"), optionType),
        "base": base,
        "quote": quote,
        "settle": settle,
        "baseId": base,
        "quoteId": quote,
        "settleId": settle,
        "active": false,
        "type": "option",
        "linear": nil,
        "inverse": nil,
        "spot": false,
        "swap": false,
        "future": false,
        "option": true,
        "margin": false,
        "contract": true,
        "contractSize": this.ParseNumber("1"),
        "expiry": timestamp,
        "expiryDatetime": datetime,
        "optionType": Ternary(IsTrue((IsEqual(optionType, "C"))), "call", "put"),
        "strike": this.ParseNumber(strike),
        "precision": map[string]interface{} {
            "amount": nil,
            "price": nil,
        },
        "limits": map[string]interface{} {
            "amount": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "price": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "cost": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
        },
        "info": nil,
    }
}
func  (this *delta) SafeMarket(optionalArgs ...interface{}) interface{}  {
    marketId := GetArg(optionalArgs, 0, nil)
    _ = marketId
    market := GetArg(optionalArgs, 1, nil)
    _ = market
    delimiter := GetArg(optionalArgs, 2, nil)
    _ = delimiter
    marketType := GetArg(optionalArgs, 3, nil)
    _ = marketType
    var isOption interface{} = IsTrue((!IsEqual(marketId, nil))) && IsTrue((IsTrue(IsTrue(IsTrue((EndsWith(marketId, "-C"))) || IsTrue((EndsWith(marketId, "-P")))) || IsTrue((StartsWith(marketId, "C-")))) || IsTrue((StartsWith(marketId, "P-")))))
    if IsTrue(IsTrue(isOption) && !IsTrue((InOp(this.Markets_by_id, marketId)))) {
        // handle expired option contracts
        return this.CreateExpiredOptionMarket(marketId)
    }
    return this.Exchange.SafeMarket(marketId, market, delimiter, marketType)
}
/**
 * @method
 * @name delta#fetchTime
 * @description fetches the current integer timestamp in milliseconds from the exchange server
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {int} the current integer timestamp in milliseconds from the exchange server
 */
func  (this *delta) FetchTime(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            response:= (<-this.PublicGetSettings(params))
            PanicOnError(response)
            // full response sample under `fetchStatus`
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.SafeIntegerProduct(result, "server_time", 0.001)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchStatus
 * @description the latest known information on the availability of the exchange API
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [status structure]{@link https://docs.ccxt.com/#/?id=exchange-status-structure}
 */
func  (this *delta) FetchStatus(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            response:= (<-this.PublicGetSettings(params))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //           "deto_liquidity_mining_daily_reward": "40775",
            //           "deto_msp": "1.0",
            //           "deto_staking_daily_reward": "23764.08",
            //           "enabled_wallets": [
            //             "BTC",
            //             ...
            //           ],
            //           "portfolio_margin_params": {
            //             "enabled_portfolios": {
            //               ".DEAVAXUSDT": {
            //                 "asset_id": 5,
            //                 "futures_contingency_margin_percent": "1",
            //                 "interest_rate": "0",
            //                 "maintenance_margin_multiplier": "0.8",
            //                 "max_price_shock": "20",
            //                 "max_short_notional_limit": "2000",
            //                 "options_contingency_margin_percent": "1",
            //                 "options_discount_range": "10",
            //                 "options_liq_band_range_percentage": "25",
            //                 "settling_asset": "USDT",
            //                 "sort_priority": 5,
            //                 "underlying_asset": "AVAX",
            //                 "volatility_down_shock": "30",
            //                 "volatility_up_shock": "45"
            //               },
            //               ...
            //             },
            //             "portfolio_enabled_contracts": [
            //               "futures",
            //               "perpetual_futures",
            //               "call_options",
            //               "put_options"
            //             ]
            //           },
            //           "server_time": 1650640673500273,
            //           "trade_farming_daily_reward": "100000",
            //           "circulating_supply": "140000000",
            //           "circulating_supply_update_time": "1636752800",
            //           "deto_referral_mining_daily_reward": "0",
            //           "deto_total_reward_pool": "100000000",
            //           "deto_trade_mining_daily_reward": "0",
            //           "kyc_deposit_limit": "20",
            //           "kyc_withdrawal_limit": "10000",
            //           "maintenance_start_time": "1650387600000000",
            //           "msp_deto_commission_percent": "25",
            //           "under_maintenance": "false"
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
            var underMaintenance interface{} = this.SafeString(result, "under_maintenance")
            var status interface{} = Ternary(IsTrue((IsEqual(underMaintenance, "true"))), "maintenance", "ok")
            var updated interface{} = this.SafeIntegerProduct(result, "server_time", 0.001, this.Milliseconds())
        
            ch <- map[string]interface{} {
                "status": status,
                "updated": updated,
                "eta": nil,
                "url": nil,
                "info": response,
            }
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchCurrencies
 * @description fetches all available currencies on an exchange
 * @see https://docs.delta.exchange/#get-list-of-all-assets
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} an associative dictionary of currencies
 */
func  (this *delta) FetchCurrencies(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            response:= (<-this.PublicGetAssets(params))
            PanicOnError(response)
            //
            //     {
            //         "result":[
            //             {
            //                 "base_withdrawal_fee":"0.0005",
            //                 "deposit_status":"enabled",
            //                 "id":2,
            //                 "interest_credit":true,
            //                 "interest_slabs":[
            //                     {"limit":"0.1","rate":"0"},
            //                     {"limit":"1","rate":"0.05"},
            //                     {"limit":"5","rate":"0.075"},
            //                     {"limit":"10","rate":"0.1"},
            //                     {"limit":"9999999999999999","rate":"0"}
            //                 ],
            //                 "kyc_deposit_limit":"10",
            //                 "kyc_withdrawal_limit":"2",
            //                 "min_withdrawal_amount":"0.001",
            //                 "minimum_precision":4,
            //                 "name":"Bitcoin",
            //                 "precision":8,
            //                 "sort_priority":1,
            //                 "symbol":"BTC",
            //                 "variable_withdrawal_fee":"0",
            //                 "withdrawal_status":"enabled"
            //             },
            //         ],
            //         "success":true
            //     }
            //
            var currencies interface{} = this.SafeList(response, "result", []interface{}{})
            var result interface{} = map[string]interface{} {}
            for i := 0; IsLessThan(i, GetArrayLength(currencies)); i++ {
                var currency interface{} = GetValue(currencies, i)
                var id interface{} = this.SafeString(currency, "symbol")
                var numericId interface{} = this.SafeInteger(currency, "id")
                var code interface{} = this.SafeCurrencyCode(id)
                var depositStatus interface{} = this.SafeString(currency, "deposit_status")
                var withdrawalStatus interface{} = this.SafeString(currency, "withdrawal_status")
                var depositsEnabled interface{} =         (IsEqual(depositStatus, "enabled"))
                var withdrawalsEnabled interface{} =         (IsEqual(withdrawalStatus, "enabled"))
                var active interface{} = IsTrue(depositsEnabled) && IsTrue(withdrawalsEnabled)
                AddElementToObject(result, code, map[string]interface{} {
            "id": id,
            "numericId": numericId,
            "code": code,
            "name": this.SafeString(currency, "name"),
            "info": currency,
            "active": active,
            "deposit": depositsEnabled,
            "withdraw": withdrawalsEnabled,
            "fee": this.SafeNumber(currency, "base_withdrawal_fee"),
            "precision": this.ParseNumber(this.ParsePrecision(this.SafeString(currency, "precision"))),
            "limits": map[string]interface{} {
                "amount": map[string]interface{} {
                    "min": nil,
                    "max": nil,
                },
                "withdraw": map[string]interface{} {
                    "min": this.SafeNumber(currency, "min_withdrawal_amount"),
                    "max": nil,
                },
            },
            "networks": map[string]interface{} {},
        })
            }
        
            ch <- result
            return nil
        
            }()
            return ch
        }
func  (this *delta) LoadMarkets(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    reload := GetArg(optionalArgs, 0, false)
            _ = reload
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
        
            markets:= (<-this.Exchange.LoadMarkets(reload, params))
            PanicOnError(markets)
            var currenciesByNumericId interface{} = this.SafeDict(this.Options, "currenciesByNumericId")
            if IsTrue(IsTrue((IsEqual(currenciesByNumericId, nil))) || IsTrue(reload)) {
                AddElementToObject(this.Options, "currenciesByNumericId", this.IndexByStringifiedNumericId(this.Currencies))
            }
            var marketsByNumericId interface{} = this.SafeDict(this.Options, "marketsByNumericId")
            if IsTrue(IsTrue((IsEqual(marketsByNumericId, nil))) || IsTrue(reload)) {
                AddElementToObject(this.Options, "marketsByNumericId", this.IndexByStringifiedNumericId(this.Markets))
            }
        
            ch <- markets
            return nil
        
            }()
            return ch
        }
func  (this *delta) IndexByStringifiedNumericId(input interface{}) interface{}  {
    var result interface{} = map[string]interface{} {}
    if IsTrue(IsEqual(input, nil)) {
        return nil
    }
    var keys interface{} = ObjectKeys(input)
    for i := 0; IsLessThan(i, GetArrayLength(keys)); i++ {
        var key interface{} = GetValue(keys, i)
        var item interface{} = GetValue(input, key)
        var numericIdString interface{} = this.SafeString(item, "numericId")
        if IsTrue(IsEqual(numericIdString, nil)) {
            continue
        }
        AddElementToObject(result, numericIdString, item)
    }
    return result
}
/**
 * @method
 * @name delta#fetchMarkets
 * @description retrieves data on all markets for delta
 * @see https://docs.delta.exchange/#get-list-of-products
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} an array of objects representing market data
 */
func  (this *delta) FetchMarkets(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            response:= (<-this.PublicGetProducts(params))
            PanicOnError(response)
            //
            //     {
            //         "meta":{ "after":null, "before":null, "limit":100, "total_count":81 },
            //         "result":[
            //             // the below response represents item from perpetual market
            //             {
            //                 "annualized_funding":"5.475000000000000000",
            //                 "is_quanto":false,
            //                 "ui_config":{
            //                     "default_trading_view_candle":"15",
            //                     "leverage_slider_values":[1,3,5,10,25,50],
            //                     "price_clubbing_values":[0.001,0.005,0.05,0.1,0.5,1,5],
            //                     "show_bracket_orders":false,
            //                     "sort_priority":29,
            //                     "tags":[]
            //                 },
            //                 "basis_factor_max_limit":"0.15",
            //                 "symbol":"P-LINK-D-151120",
            //                 "id":1584,
            //                 "default_leverage":"5.000000000000000000",
            //                 "maker_commission_rate":"0.0005",
            //                 "contract_unit_currency":"LINK",
            //                 "strike_price":"12.507948",
            //                 "settling_asset":{
            //                     // asset structure
            //                 },
            //                 "auction_start_time":null,
            //                 "auction_finish_time":null,
            //                 "settlement_time":"2020-11-15T12:00:00Z",
            //                 "launch_time":"2020-11-14T11:55:05Z",
            //                 "spot_index":{
            //                     // index structure
            //                 },
            //                 "trading_status":"operational",
            //                 "tick_size":"0.001",
            //                 "position_size_limit":100000,
            //                 "notional_type":"vanilla", // vanilla, inverse
            //                 "price_band":"0.4",
            //                 "barrier_price":null,
            //                 "description":"Daily LINK PUT options quoted in USDT and settled in USDT",
            //                 "insurance_fund_margin_contribution":"1",
            //                 "quoting_asset":{
            //                     // asset structure
            //                 },
            //                 "liquidation_penalty_factor":"0.2",
            //                 "product_specs":{"max_volatility":3,"min_volatility":0.3,"spot_price_band":"0.40"},
            //                 "initial_margin_scaling_factor":"0.0001",
            //                 "underlying_asset":{
            //                     // asset structure
            //                 },
            //                 "state":"live",
            //                 "contract_value":"1",
            //                 "initial_margin":"2",
            //                 "impact_size":5000,
            //                 "settlement_price":null,
            //                 "contract_type":"put_options", // put_options, call_options, move_options, perpetual_futures, interest_rate_swaps, futures, spreads
            //                 "taker_commission_rate":"0.0005",
            //                 "maintenance_margin":"1",
            //                 "short_description":"LINK Daily PUT Options",
            //                 "maintenance_margin_scaling_factor":"0.00005",
            //                 "funding_method":"mark_price",
            //                 "max_leverage_notional":"20000"
            //             },
            //             // the below response represents item from spot market
            //             {
            //                 "position_size_limit": 10000000,
            //                 "settlement_price": null,
            //                 "funding_method": "mark_price",
            //                 "settling_asset": null,
            //                 "impact_size": 10,
            //                 "id": 32258,
            //                 "auction_finish_time": null,
            //                 "description": "Solana tether spot market",
            //                 "trading_status": "operational",
            //                 "tick_size": "0.01",
            //                 "liquidation_penalty_factor": "1",
            //                 "spot_index": {
            //                     "config": { "quoting_asset": "USDT", "service_id": 8, "underlying_asset": "SOL" },
            //                     "constituent_exchanges": [
            //                         { "exchange": "binance", "health_interval": 60, "health_priority": 1, "weight": 1 },
            //                         { "exchange": "huobi", "health_interval": 60, "health_priority": 2, "weight": 1 }
            //                     ],
            //                     "constituent_indices": null,
            //                     "description": "Solana index from binance and huobi",
            //                     "health_interval": 300,
            //                     "id": 105,
            //                     "impact_size": "40.000000000000000000",
            //                     "index_type": "spot_pair",
            //                     "is_composite": false,
            //                     "price_method": "ltp",
            //                     "quoting_asset_id": 5,
            //                     "symbol": ".DESOLUSDT",
            //                     "tick_size": "0.000100000000000000",
            //                     "underlying_asset_id": 66
            //                 },
            //                 "contract_type": "spot",
            //                 "launch_time": "2022-02-03T10:18:11Z",
            //                 "symbol": "SOL_USDT",
            //                 "disruption_reason": null,
            //                 "settlement_time": null,
            //                 "insurance_fund_margin_contribution": "1",
            //                 "is_quanto": false,
            //                 "maintenance_margin": "5",
            //                 "taker_commission_rate": "0.0005",
            //                 "auction_start_time": null,
            //                 "max_leverage_notional": "10000000",
            //                 "state": "live",
            //                 "annualized_funding": "0",
            //                 "notional_type": "vanilla",
            //                 "price_band": "100",
            //                 "product_specs": { "kyc_required": false, "max_order_size": 2000, "min_order_size": 0.01, "quoting_precision": 4, "underlying_precision": 2 },
            //                 "default_leverage": "1.000000000000000000",
            //                 "initial_margin": "10",
            //                 "maintenance_margin_scaling_factor": "1",
            //                 "ui_config": {
            //                     "default_trading_view_candle": "1d",
            //                     "leverage_slider_values": [],
            //                     "price_clubbing_values": [ 0.01, 0.05, 0.1, 0.5, 1, 2.5, 5 ],
            //                     "show_bracket_orders": false,
            //                     "sort_priority": 2,
            //                     "tags": []
            //                 },
            //                 "basis_factor_max_limit": "10000",
            //                 "contract_unit_currency": "SOL",
            //                 "strike_price": null,
            //                 "quoting_asset": {
            //                     "base_withdrawal_fee": "10.000000000000000000",
            //                     "deposit_status": "enabled",
            //                     "id": 5,
            //                     "interest_credit": false,
            //                     "interest_slabs": null,
            //                     "kyc_deposit_limit": "100000.000000000000000000",
            //                     "kyc_withdrawal_limit": "10000.000000000000000000",
            //                     "min_withdrawal_amount": "30.000000000000000000",
            //                     "minimum_precision": 2,
            //                     "name": "Tether",
            //                     "networks": [
            //                         { "base_withdrawal_fee": "25", "deposit_status": "enabled", "memo_required": false, "network": "ERC20", "variable_withdrawal_fee": "0", "withdrawal_status": "enabled" },
            //                         { "base_withdrawal_fee": "1", "deposit_status": "enabled", "memo_required": false, "network": "BEP20(BSC)", "variable_withdrawal_fee": "0", "withdrawal_status": "enabled" },
            //                         { "base_withdrawal_fee": "1", "deposit_status": "disabled", "memo_required": false, "network": "TRC20(TRON)", "variable_withdrawal_fee": "0", "withdrawal_status": "disabled" }
            //                     ],
            //                     "precision": 8,
            //                     "sort_priority": 1,
            //                     "symbol": "USDT",
            //                     "variable_withdrawal_fee": "0.000000000000000000",
            //                     "withdrawal_status": "enabled"
            //                 },
            //                 "maker_commission_rate": "0.0005",
            //                 "initial_margin_scaling_factor": "2",
            //                 "underlying_asset": {
            //                     "base_withdrawal_fee": "0.000000000000000000",
            //                     "deposit_status": "enabled",
            //                     "id": 66,
            //                     "interest_credit": false,
            //                     "interest_slabs": null,
            //                     "kyc_deposit_limit": "0.000000000000000000",
            //                     "kyc_withdrawal_limit": "0.000000000000000000",
            //                     "min_withdrawal_amount": "0.020000000000000000",
            //                     "minimum_precision": 4,
            //                     "name": "Solana",
            //                     "networks": [
            //                         { "base_withdrawal_fee": "0.01", "deposit_status": "enabled", "memo_required": false, "network": "SOLANA", "variable_withdrawal_fee": "0", "withdrawal_status": "enabled" },
            //                         { "base_withdrawal_fee": "0.01", "deposit_status": "enabled", "memo_required": false, "network": "BEP20(BSC)", "variable_withdrawal_fee": "0", "withdrawal_status": "enabled" }
            //                     ],
            //                     "precision": 8,
            //                     "sort_priority": 7,
            //                     "symbol": "SOL",
            //                     "variable_withdrawal_fee": "0.000000000000000000",
            //                     "withdrawal_status": "enabled"
            //                 },
            //                 "barrier_price": null,
            //                 "contract_value": "1",
            //                 "short_description": "SOL-USDT spot market"
            //             },
            //         ],
            //         "success":true
            //     }
            //
            var markets interface{} = this.SafeList(response, "result", []interface{}{})
            var result interface{} = []interface{}{}
            for i := 0; IsLessThan(i, GetArrayLength(markets)); i++ {
                var market interface{} = GetValue(markets, i)
                var typeVar interface{} = this.SafeString(market, "contract_type")
                if IsTrue(IsEqual(typeVar, "options_combos")) {
                    continue
                }
                // const settlingAsset = this.safeValue (market, 'settling_asset', {});
                var quotingAsset interface{} = this.SafeDict(market, "quoting_asset", map[string]interface{} {})
                var underlyingAsset interface{} = this.SafeDict(market, "underlying_asset", map[string]interface{} {})
                var settlingAsset interface{} = this.SafeDict(market, "settling_asset")
                var productSpecs interface{} = this.SafeDict(market, "product_specs", map[string]interface{} {})
                var baseId interface{} = this.SafeString(underlyingAsset, "symbol")
                var quoteId interface{} = this.SafeString(quotingAsset, "symbol")
                var settleId interface{} = this.SafeString(settlingAsset, "symbol")
                var id interface{} = this.SafeString(market, "symbol")
                var numericId interface{} = this.SafeInteger(market, "id")
                var base interface{} = this.SafeCurrencyCode(baseId)
                var quote interface{} = this.SafeCurrencyCode(quoteId)
                var settle interface{} = this.SafeCurrencyCode(settleId)
                var callOptions interface{} =         (IsEqual(typeVar, "call_options"))
                var putOptions interface{} =         (IsEqual(typeVar, "put_options"))
                var moveOptions interface{} =         (IsEqual(typeVar, "move_options"))
                var spot interface{} =         (IsEqual(typeVar, "spot"))
                var swap interface{} =         (IsEqual(typeVar, "perpetual_futures"))
                var future interface{} =         (IsEqual(typeVar, "futures"))
                var option interface{} =         (IsTrue(IsTrue(callOptions) || IsTrue(putOptions)) || IsTrue(moveOptions))
                var strike interface{} = this.SafeString(market, "strike_price")
                var expiryDatetime interface{} = this.SafeString(market, "settlement_time")
                var expiry interface{} = this.Parse8601(expiryDatetime)
                var contractSize interface{} = this.SafeNumber(market, "contract_value")
                var amountPrecision interface{} = nil
                if IsTrue(spot) {
                    amountPrecision = this.ParseNumber(this.ParsePrecision(this.SafeString(productSpecs, "underlying_precision"))) // seems inverse of 'impact_size'
                } else {
                    // other markets (swap, futures, move, spread, irs) seem to use the step of '1' contract
                    amountPrecision = this.ParseNumber("1")
                }
                var linear interface{} =         (IsEqual(settle, quote))
                var optionType interface{} = nil
                var symbol interface{} = Add(Add(base, "/"), quote)
                if IsTrue(IsTrue(IsTrue(swap) || IsTrue(future)) || IsTrue(option)) {
                    symbol = Add(Add(symbol, ":"), settle)
                    if IsTrue(IsTrue(future) || IsTrue(option)) {
                        symbol = Add(Add(symbol, "-"), this.Yymmdd(expiry))
                        if IsTrue(option) {
                            typeVar = "option"
                            var letter interface{} = "C"
                            optionType = "call"
                            if IsTrue(putOptions) {
                                letter = "P"
                                optionType = "put"
                            } else if IsTrue(moveOptions) {
                                letter = "M"
                                optionType = "move"
                            }
                            symbol = Add(Add(Add(Add(symbol, "-"), strike), "-"), letter)
                        } else {
                            typeVar = "future"
                        }
                    } else {
                        typeVar = "swap"
                    }
                }
                var state interface{} = this.SafeString(market, "state")
                AppendToArray(&result,map[string]interface{} {
                    "id": id,
                    "numericId": numericId,
                    "symbol": symbol,
                    "base": base,
                    "quote": quote,
                    "settle": settle,
                    "baseId": baseId,
                    "quoteId": quoteId,
                    "settleId": settleId,
                    "type": typeVar,
                    "spot": spot,
                    "margin": Ternary(IsTrue(spot), nil, false),
                    "swap": swap,
                    "future": future,
                    "option": option,
                    "active": (IsEqual(state, "live")),
                    "contract": !IsTrue(spot),
                    "linear": Ternary(IsTrue(spot), nil, linear),
                    "inverse": Ternary(IsTrue(spot), nil, !IsTrue(linear)),
                    "taker": this.SafeNumber(market, "taker_commission_rate"),
                    "maker": this.SafeNumber(market, "maker_commission_rate"),
                    "contractSize": contractSize,
                    "expiry": expiry,
                    "expiryDatetime": expiryDatetime,
                    "strike": this.ParseNumber(strike),
                    "optionType": optionType,
                    "precision": map[string]interface{} {
                        "amount": amountPrecision,
                        "price": this.SafeNumber(market, "tick_size"),
                    },
                    "limits": map[string]interface{} {
                        "leverage": map[string]interface{} {
                            "min": nil,
                            "max": nil,
                        },
                        "amount": map[string]interface{} {
                            "min": this.ParseNumber("1"),
                            "max": this.SafeNumber(market, "position_size_limit"),
                        },
                        "price": map[string]interface{} {
                            "min": nil,
                            "max": nil,
                        },
                        "cost": map[string]interface{} {
                            "min": this.SafeNumber(market, "min_size"),
                            "max": nil,
                        },
                    },
                    "created": this.Parse8601(this.SafeString(market, "launch_time")),
                    "info": market,
                })
            }
        
            ch <- result
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // spot: fetchTicker, fetchTickers
    //
    //     {
    //         "close": 30634.0,
    //         "contract_type": "spot",
    //         "greeks": null,
    //         "high": 30780.0,
    //         "low": 30340.5,
    //         "mark_price": "48000",
    //         "oi": "0.0000",
    //         "oi_change_usd_6h": "0.0000",
    //         "oi_contracts": "0",
    //         "oi_value": "0.0000",
    //         "oi_value_symbol": "BTC",
    //         "oi_value_usd": "0.0000",
    //         "open": 30464.0,
    //         "price_band": null,
    //         "product_id": 8320,
    //         "quotes": {},
    //         "size": 2.6816639999999996,
    //         "spot_price": "30637.91465121",
    //         "symbol": "BTC_USDT",
    //         "timestamp": 1689139767621299,
    //         "turnover": 2.6816639999999996,
    //         "turnover_symbol": "BTC",
    //         "turnover_usd": 81896.45613400004,
    //         "volume": 2.6816639999999996
    //     }
    //
    // swap: fetchTicker, fetchTickers
    //
    //     {
    //         "close": 30600.5,
    //         "contract_type": "perpetual_futures",
    //         "funding_rate": "0.00602961",
    //         "greeks": null,
    //         "high": 30803.0,
    //         "low": 30265.5,
    //         "mark_basis": "-0.45601594",
    //         "mark_price": "30600.10481568",
    //         "oi": "469.9190",
    //         "oi_change_usd_6h": "2226314.9900",
    //         "oi_contracts": "469919",
    //         "oi_value": "469.9190",
    //         "oi_value_symbol": "BTC",
    //         "oi_value_usd": "14385640.6802",
    //         "open": 30458.5,
    //         "price_band": {
    //             "lower_limit": "29067.08312627",
    //             "upper_limit": "32126.77608693"
    //         },
    //         "product_id": 139,
    //         "quotes": {
    //             "ask_iv": null,
    //             "ask_size": "965",
    //             "best_ask": "30600.5",
    //             "best_bid": "30599.5",
    //             "bid_iv": null,
    //             "bid_size": "196",
    //             "impact_mid_price": null,
    //             "mark_iv": "-0.44931641"
    //         },
    //         "size": 1226303,
    //         "spot_price": "30612.85362773",
    //         "symbol": "BTCUSDT",
    //         "timestamp": 1689136597460456,
    //         "turnover": 37392218.45999999,
    //         "turnover_symbol": "USDT",
    //         "turnover_usd": 37392218.45999999,
    //         "volume": 1226.3029999999485
    //     }
    //
    // option: fetchTicker, fetchTickers
    //
    //     {
    //         "contract_type": "call_options",
    //         "greeks": {
    //             "delta": "0.60873994",
    //             "gamma": "0.00014854",
    //             "rho": "7.71808010",
    //             "spot": "30598.49040622",
    //             "theta": "-30.44743017",
    //             "vega": "24.83508248"
    //         },
    //         "mark_price": "1347.74819696",
    //         "mark_vol": "0.39966303",
    //         "oi": "2.7810",
    //         "oi_change_usd_6h": "0.0000",
    //         "oi_contracts": "2781",
    //         "oi_value": "2.7810",
    //         "oi_value_symbol": "BTC",
    //         "oi_value_usd": "85127.4337",
    //         "price_band": {
    //             "lower_limit": "91.27423497",
    //             "upper_limit": "7846.19454697"
    //         },
    //         "product_id": 107150,
    //         "quotes": {
    //             "ask_iv": "0.41023239",
    //             "ask_size": "2397",
    //             "best_ask": "1374",
    //             "best_bid": "1322",
    //             "bid_iv": "0.38929375",
    //             "bid_size": "3995",
    //             "impact_mid_price": null,
    //             "mark_iv": "0.39965618"
    //         },
    //         "spot_price": "30598.43379314",
    //         "strike_price": "30000",
    //         "symbol": "C-BTC-30000-280723",
    //         "timestamp": 1689136932893181,
    //         "turnover_symbol": "USDT"
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var timestamp interface{} = this.SafeIntegerProduct(ticker, "timestamp", 0.001)
    var marketId interface{} = this.SafeString(ticker, "symbol")
    var symbol interface{} = this.SafeSymbol(marketId, market)
    var last interface{} = this.SafeString(ticker, "close")
    var quotes interface{} = this.SafeDict(ticker, "quotes", map[string]interface{} {})
    return this.SafeTicker(map[string]interface{} {
        "symbol": symbol,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "high": this.SafeNumber(ticker, "high"),
        "low": this.SafeNumber(ticker, "low"),
        "bid": this.SafeNumber(quotes, "best_bid"),
        "bidVolume": this.SafeNumber(quotes, "bid_size"),
        "ask": this.SafeNumber(quotes, "best_ask"),
        "askVolume": this.SafeNumber(quotes, "ask_size"),
        "vwap": nil,
        "open": this.SafeString(ticker, "open"),
        "close": last,
        "last": last,
        "previousClose": nil,
        "change": nil,
        "percentage": nil,
        "average": nil,
        "baseVolume": this.SafeNumber(ticker, "volume"),
        "quoteVolume": this.SafeNumber(ticker, "turnover"),
        "markPrice": this.SafeNumber(ticker, "mark_price"),
        "indexPrice": this.SafeNumber(ticker, "spot_price"),
        "info": ticker,
    }, market)
}
/**
 * @method
 * @name delta#fetchTicker
 * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @see https://docs.delta.exchange/#get-ticker-for-a-product-by-symbol
 * @param {string} symbol unified symbol of the market to fetch the ticker for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
 */
func  (this *delta) FetchTicker(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes10758 := (<-this.LoadMarkets())
            PanicOnError(retRes10758)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "symbol": GetValue(market, "id"),
            }
        
            response:= (<-this.PublicGetTickersSymbol(this.Extend(request, params)))
            PanicOnError(response)
            //
            // spot
            //
            //     {
            //         "result": {
            //             "close": 30634.0,
            //             "contract_type": "spot",
            //             "greeks": null,
            //             "high": 30780.0,
            //             "low": 30340.5,
            //             "mark_price": "48000",
            //             "oi": "0.0000",
            //             "oi_change_usd_6h": "0.0000",
            //             "oi_contracts": "0",
            //             "oi_value": "0.0000",
            //             "oi_value_symbol": "BTC",
            //             "oi_value_usd": "0.0000",
            //             "open": 30464.0,
            //             "price_band": null,
            //             "product_id": 8320,
            //             "quotes": {},
            //             "size": 2.6816639999999996,
            //             "spot_price": "30637.91465121",
            //             "symbol": "BTC_USDT",
            //             "timestamp": 1689139767621299,
            //             "turnover": 2.6816639999999996,
            //             "turnover_symbol": "BTC",
            //             "turnover_usd": 81896.45613400004,
            //             "volume": 2.6816639999999996
            //         },
            //         "success": true
            //     }
            //
            // swap
            //
            //     {
            //         "result": {
            //             "close": 30600.5,
            //             "contract_type": "perpetual_futures",
            //             "funding_rate": "0.00602961",
            //             "greeks": null,
            //             "high": 30803.0,
            //             "low": 30265.5,
            //             "mark_basis": "-0.45601594",
            //             "mark_price": "30600.10481568",
            //             "oi": "469.9190",
            //             "oi_change_usd_6h": "2226314.9900",
            //             "oi_contracts": "469919",
            //             "oi_value": "469.9190",
            //             "oi_value_symbol": "BTC",
            //             "oi_value_usd": "14385640.6802",
            //             "open": 30458.5,
            //             "price_band": {
            //                 "lower_limit": "29067.08312627",
            //                 "upper_limit": "32126.77608693"
            //             },
            //             "product_id": 139,
            //             "quotes": {
            //                 "ask_iv": null,
            //                 "ask_size": "965",
            //                 "best_ask": "30600.5",
            //                 "best_bid": "30599.5",
            //                 "bid_iv": null,
            //                 "bid_size": "196",
            //                 "impact_mid_price": null,
            //                 "mark_iv": "-0.44931641"
            //             },
            //             "size": 1226303,
            //             "spot_price": "30612.85362773",
            //             "symbol": "BTCUSDT",
            //             "timestamp": 1689136597460456,
            //             "turnover": 37392218.45999999,
            //             "turnover_symbol": "USDT",
            //             "turnover_usd": 37392218.45999999,
            //             "volume": 1226.3029999999485
            //         },
            //         "success": true
            //     }
            //
            // option
            //
            //     {
            //         "result": {
            //             "contract_type": "call_options",
            //             "greeks": {
            //                 "delta": "0.60873994",
            //                 "gamma": "0.00014854",
            //                 "rho": "7.71808010",
            //                 "spot": "30598.49040622",
            //                 "theta": "-30.44743017",
            //                 "vega": "24.83508248"
            //             },
            //             "mark_price": "1347.74819696",
            //             "mark_vol": "0.39966303",
            //             "oi": "2.7810",
            //             "oi_change_usd_6h": "0.0000",
            //             "oi_contracts": "2781",
            //             "oi_value": "2.7810",
            //             "oi_value_symbol": "BTC",
            //             "oi_value_usd": "85127.4337",
            //             "price_band": {
            //                 "lower_limit": "91.27423497",
            //                 "upper_limit": "7846.19454697"
            //             },
            //             "product_id": 107150,
            //             "quotes": {
            //                 "ask_iv": "0.41023239",
            //                 "ask_size": "2397",
            //                 "best_ask": "1374",
            //                 "best_bid": "1322",
            //                 "bid_iv": "0.38929375",
            //                 "bid_size": "3995",
            //                 "impact_mid_price": null,
            //                 "mark_iv": "0.39965618"
            //             },
            //             "spot_price": "30598.43379314",
            //             "strike_price": "30000",
            //             "symbol": "C-BTC-30000-280723",
            //             "timestamp": 1689136932893181,
            //             "turnover_symbol": "USDT"
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseTicker(result, market)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchTickers
 * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
 * @see https://docs.delta.exchange/#get-tickers-for-products
 * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
 */
func  (this *delta) FetchTickers(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
        
            retRes12198 := (<-this.LoadMarkets())
            PanicOnError(retRes12198)
            symbols = this.MarketSymbols(symbols)
        
            response:= (<-this.PublicGetTickers(params))
            PanicOnError(response)
            //
            // spot
            //
            //     {
            //         "result": [
            //             {
            //                 "close": 30634.0,
            //                 "contract_type": "spot",
            //                 "greeks": null,
            //                 "high": 30780.0,
            //                 "low": 30340.5,
            //                 "mark_price": "48000",
            //                 "oi": "0.0000",
            //                 "oi_change_usd_6h": "0.0000",
            //                 "oi_contracts": "0",
            //                 "oi_value": "0.0000",
            //                 "oi_value_symbol": "BTC",
            //                 "oi_value_usd": "0.0000",
            //                 "open": 30464.0,
            //                 "price_band": null,
            //                 "product_id": 8320,
            //                 "quotes": {},
            //                 "size": 2.6816639999999996,
            //                 "spot_price": "30637.91465121",
            //                 "symbol": "BTC_USDT",
            //                 "timestamp": 1689139767621299,
            //                 "turnover": 2.6816639999999996,
            //                 "turnover_symbol": "BTC",
            //                 "turnover_usd": 81896.45613400004,
            //                 "volume": 2.6816639999999996
            //             },
            //         ],
            //         "success":true
            //     }
            //
            // swap
            //
            //     {
            //         "result": [
            //             {
            //                 "close": 30600.5,
            //                 "contract_type": "perpetual_futures",
            //                 "funding_rate": "0.00602961",
            //                 "greeks": null,
            //                 "high": 30803.0,
            //                 "low": 30265.5,
            //                 "mark_basis": "-0.45601594",
            //                 "mark_price": "30600.10481568",
            //                 "oi": "469.9190",
            //                 "oi_change_usd_6h": "2226314.9900",
            //                 "oi_contracts": "469919",
            //                 "oi_value": "469.9190",
            //                 "oi_value_symbol": "BTC",
            //                 "oi_value_usd": "14385640.6802",
            //                 "open": 30458.5,
            //                 "price_band": {
            //                     "lower_limit": "29067.08312627",
            //                     "upper_limit": "32126.77608693"
            //                 },
            //                 "product_id": 139,
            //                 "quotes": {
            //                     "ask_iv": null,
            //                     "ask_size": "965",
            //                     "best_ask": "30600.5",
            //                     "best_bid": "30599.5",
            //                     "bid_iv": null,
            //                     "bid_size": "196",
            //                     "impact_mid_price": null,
            //                     "mark_iv": "-0.44931641"
            //                 },
            //                 "size": 1226303,
            //                 "spot_price": "30612.85362773",
            //                 "symbol": "BTCUSDT",
            //                 "timestamp": 1689136597460456,
            //                 "turnover": 37392218.45999999,
            //                 "turnover_symbol": "USDT",
            //                 "turnover_usd": 37392218.45999999,
            //                 "volume": 1226.3029999999485
            //             },
            //         ],
            //         "success":true
            //     }
            //
            // option
            //
            //     {
            //         "result": [
            //             {
            //                 "contract_type": "call_options",
            //                 "greeks": {
            //                     "delta": "0.60873994",
            //                     "gamma": "0.00014854",
            //                     "rho": "7.71808010",
            //                     "spot": "30598.49040622",
            //                     "theta": "-30.44743017",
            //                     "vega": "24.83508248"
            //                 },
            //                 "mark_price": "1347.74819696",
            //                 "mark_vol": "0.39966303",
            //                 "oi": "2.7810",
            //                 "oi_change_usd_6h": "0.0000",
            //                 "oi_contracts": "2781",
            //                 "oi_value": "2.7810",
            //                 "oi_value_symbol": "BTC",
            //                 "oi_value_usd": "85127.4337",
            //                 "price_band": {
            //                     "lower_limit": "91.27423497",
            //                     "upper_limit": "7846.19454697"
            //                 },
            //                 "product_id": 107150,
            //                 "quotes": {
            //                     "ask_iv": "0.41023239",
            //                     "ask_size": "2397",
            //                     "best_ask": "1374",
            //                     "best_bid": "1322",
            //                     "bid_iv": "0.38929375",
            //                     "bid_size": "3995",
            //                     "impact_mid_price": null,
            //                     "mark_iv": "0.39965618"
            //                 },
            //                 "spot_price": "30598.43379314",
            //                 "strike_price": "30000",
            //                 "symbol": "C-BTC-30000-280723",
            //                 "timestamp": 1689136932893181,
            //                 "turnover_symbol": "USDT"
            //             },
            //         ],
            //         "success":true
            //     }
            //
            var tickers interface{} = this.SafeList(response, "result", []interface{}{})
            var result interface{} = map[string]interface{} {}
            for i := 0; IsLessThan(i, GetArrayLength(tickers)); i++ {
                var ticker interface{} = this.ParseTicker(GetValue(tickers, i))
                var symbol interface{} = GetValue(ticker, "symbol")
                AddElementToObject(result, symbol, ticker)
            }
        
            ch <- this.FilterByArrayTickers(result, "symbol", symbols)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchOrderBook
 * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @see https://docs.delta.exchange/#get-l2-orderbook
 * @param {string} symbol unified symbol of the market to fetch the order book for
 * @param {int} [limit] the maximum amount of order book entries to return
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
 */
func  (this *delta) FetchOrderBook(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    limit := GetArg(optionalArgs, 0, nil)
            _ = limit
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
        
            retRes13738 := (<-this.LoadMarkets())
            PanicOnError(retRes13738)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "symbol": GetValue(market, "id"),
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "depth", limit)
            }
        
            response:= (<-this.PublicGetL2orderbookSymbol(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result":{
            //             "buy":[
            //                 {"price":"15814.0","size":912},
            //                 {"price":"15813.5","size":1279},
            //                 {"price":"15813.0","size":1634},
            //             ],
            //             "sell":[
            //                 {"price":"15814.5","size":625},
            //                 {"price":"15815.0","size":982},
            //                 {"price":"15815.5","size":1328},
            //             ],
            //             "symbol":"BTCUSDT"
            //         },
            //         "success":true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseOrderBook(result, GetValue(market, "symbol"), nil, "buy", "sell", "price", "size")
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // public fetchTrades
    //
    //     {
    //         "buyer_role":"maker",
    //         "price":"15896.5",
    //         "seller_role":"taker",
    //         "size":241,
    //         "symbol":"BTCUSDT",
    //         "timestamp":1605376684714595
    //     }
    //
    // private fetchMyTrades
    //
    //     {
    //         "commission":"0.008335000000000000",
    //         "created_at":"2020-11-16T19:07:19Z",
    //         "fill_type":"normal",
    //         "id":"e7ff05c233a74245b72381f8dd91d1ce",
    //         "meta_data":{
    //             "effective_commission_rate":"0.0005",
    //             "order_price":"16249",
    //             "order_size":1,
    //             "order_type":"market_order",
    //             "order_unfilled_size":0,
    //             "trading_fee_credits_used":"0"
    //         },
    //         "order_id":"152999629",
    //         "price":"16669",
    //         "product":{
    //             "contract_type":"perpetual_futures",
    //             "contract_unit_currency":"BTC",
    //             "contract_value":"0.001",
    //             "id":139,
    //             "notional_type":"vanilla",
    //             "quoting_asset":{"minimum_precision":2,"precision":6,"symbol":"USDT"},
    //             "settling_asset":{"minimum_precision":2,"precision":6,"symbol":"USDT"},
    //             "symbol":"BTCUSDT",
    //             "tick_size":"0.5",
    //             "underlying_asset":{"minimum_precision":4,"precision":8,"symbol":"BTC"}
    //         },
    //         "product_id":139,
    //         "role":"taker",
    //         "side":"sell",
    //         "size":1
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var id interface{} = this.SafeString(trade, "id")
    var orderId interface{} = this.SafeString(trade, "order_id")
    var timestamp interface{} = this.Parse8601(this.SafeString(trade, "created_at"))
    timestamp = this.SafeIntegerProduct(trade, "timestamp", 0.001, timestamp)
    var priceString interface{} = this.SafeString(trade, "price")
    var amountString interface{} = this.SafeString(trade, "size")
    var product interface{} = this.SafeDict(trade, "product", map[string]interface{} {})
    var marketId interface{} = this.SafeString(product, "symbol")
    var symbol interface{} = this.SafeSymbol(marketId, market)
    var sellerRole interface{} = this.SafeString(trade, "seller_role")
    var side interface{} = this.SafeString(trade, "side")
    if IsTrue(IsEqual(side, nil)) {
        if IsTrue(IsEqual(sellerRole, "taker")) {
            side = "sell"
        } else if IsTrue(IsEqual(sellerRole, "maker")) {
            side = "buy"
        }
    }
    var takerOrMaker interface{} = this.SafeString(trade, "role")
    var metaData interface{} = this.SafeDict(trade, "meta_data", map[string]interface{} {})
    var typeVar interface{} = this.SafeString(metaData, "order_type")
    if IsTrue(!IsEqual(typeVar, nil)) {
        typeVar = Replace(typeVar, "_order", "")
    }
    var feeCostString interface{} = this.SafeString(trade, "commission")
    var fee interface{} = nil
    if IsTrue(!IsEqual(feeCostString, nil)) {
        var settlingAsset interface{} = this.SafeDict(product, "settling_asset", map[string]interface{} {})
        var feeCurrencyId interface{} = this.SafeString(settlingAsset, "symbol")
        var feeCurrencyCode interface{} = this.SafeCurrencyCode(feeCurrencyId)
        fee = map[string]interface{} {
            "cost": feeCostString,
            "currency": feeCurrencyCode,
        }
    }
    return this.SafeTrade(map[string]interface{} {
        "id": id,
        "order": orderId,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "symbol": symbol,
        "type": typeVar,
        "side": side,
        "price": priceString,
        "amount": amountString,
        "cost": nil,
        "takerOrMaker": takerOrMaker,
        "fee": fee,
        "info": trade,
    }, market)
}
/**
 * @method
 * @name delta#fetchTrades
 * @description get the list of most recent trades for a particular symbol
 * @see https://docs.delta.exchange/#get-public-trades
 * @param {string} symbol unified symbol of the market to fetch trades for
 * @param {int} [since] timestamp in ms of the earliest trade to fetch
 * @param {int} [limit] the maximum amount of trades to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
 */
func  (this *delta) FetchTrades(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    since := GetArg(optionalArgs, 0, nil)
            _ = since
            limit := GetArg(optionalArgs, 1, nil)
            _ = limit
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
        
            retRes15168 := (<-this.LoadMarkets())
            PanicOnError(retRes15168)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "symbol": GetValue(market, "id"),
            }
        
            response:= (<-this.PublicGetTradesSymbol(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result":[
            //             {
            //                 "buyer_role":"maker",
            //                 "price":"15896.5",
            //                 "seller_role":"taker",
            //                 "size":241,
            //                 "symbol":"BTCUSDT",
            //                 "timestamp":1605376684714595
            //             }
            //         ],
            //         "success":true
            //     }
            //
            var result interface{} = this.SafeList(response, "result", []interface{}{})
        
            ch <- this.ParseTrades(result, market, since, limit)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "time":1605393120,
    //         "open":15989,
    //         "high":15989,
    //         "low":15987.5,
    //         "close":15987.5,
    //         "volume":565
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    return []interface{}{this.SafeTimestamp(ohlcv, "time"), this.SafeNumber(ohlcv, "open"), this.SafeNumber(ohlcv, "high"), this.SafeNumber(ohlcv, "low"), this.SafeNumber(ohlcv, "close"), this.SafeNumber(ohlcv, "volume")}
}
/**
 * @method
 * @name delta#fetchOHLCV
 * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://docs.delta.exchange/#delta-exchange-api-v2-historical-ohlc-candles-sparklines
 * @param {string} symbol unified symbol of the market to fetch OHLCV data for
 * @param {string} timeframe the length of time each candle represents
 * @param {int} [since] timestamp in ms of the earliest candle to fetch
 * @param {int} [limit] the maximum amount of candles to fetch
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.until] timestamp in ms of the latest candle to fetch
 * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
 */
func  (this *delta) FetchOHLCV(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    timeframe := GetArg(optionalArgs, 0, "1m")
            _ = timeframe
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
            retRes15768 := (<-this.LoadMarkets())
            PanicOnError(retRes15768)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "resolution": this.SafeString(this.Timeframes, timeframe, timeframe),
            }
            var duration interface{} = this.ParseTimeframe(timeframe)
            limit = Ternary(IsTrue(limit), limit, 2000) // max 2000
            var until interface{} = this.SafeIntegerProduct(params, "until", 0.001)
            var untilIsDefined interface{} =     (!IsEqual(until, nil))
            if IsTrue(untilIsDefined) {
                until = this.ParseToInt(until)
            }
            if IsTrue(IsEqual(since, nil)) {
                var end interface{} = Ternary(IsTrue(untilIsDefined), until, this.Seconds())
                AddElementToObject(request, "end", end)
                AddElementToObject(request, "start", Subtract(end, Multiply(limit, duration)))
            } else {
                var start interface{} = this.ParseToInt(Divide(since, 1000))
                AddElementToObject(request, "start", start)
                AddElementToObject(request, "end", Ternary(IsTrue(untilIsDefined), until, this.Sum(start, Multiply(limit, duration))))
            }
            var price interface{} = this.SafeString(params, "price")
            if IsTrue(IsEqual(price, "mark")) {
                AddElementToObject(request, "symbol", Add("MARK:", GetValue(market, "id")))
            } else if IsTrue(IsEqual(price, "index")) {
                AddElementToObject(request, "symbol", GetValue(GetValue(GetValue(market, "info"), "spot_index"), "symbol"))
            } else {
                AddElementToObject(request, "symbol", GetValue(market, "id"))
            }
            params = this.Omit(params, []interface{}{"price", "until"})
        
            response:= (<-this.PublicGetHistoryCandles(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "success":true,
            //         "result":[
            //             {"time":1605393120,"open":15989,"high":15989,"low":15987.5,"close":15987.5,"volume":565},
            //             {"time":1605393180,"open":15966,"high":15966,"low":15959,"close":15959,"volume":24},
            //             {"time":1605393300,"open":15973,"high":15973,"low":15973,"close":15973,"volume":1288},
            //         ]
            //     }
            //
            var result interface{} = this.SafeList(response, "result", []interface{}{})
        
            ch <- this.ParseOHLCVs(result, market, timeframe, since, limit)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseBalance(response interface{}) interface{}  {
    var balances interface{} = this.SafeList(response, "result", []interface{}{})
    var result interface{} = map[string]interface{} {
        "info": response,
    }
    var currenciesByNumericId interface{} = this.SafeDict(this.Options, "currenciesByNumericId", map[string]interface{} {})
    for i := 0; IsLessThan(i, GetArrayLength(balances)); i++ {
        var balance interface{} = GetValue(balances, i)
        var currencyId interface{} = this.SafeString(balance, "asset_id")
        var currency interface{} = this.SafeDict(currenciesByNumericId, currencyId)
        var code interface{} = Ternary(IsTrue((IsEqual(currency, nil))), currencyId, GetValue(currency, "code"))
        var account interface{} = this.Account()
        AddElementToObject(account, "total", this.SafeString(balance, "balance"))
        AddElementToObject(account, "free", this.SafeString(balance, "available_balance"))
        AddElementToObject(result, code, account)
    }
    return this.SafeBalance(result)
}
/**
 * @method
 * @name delta#fetchBalance
 * @description query for balance and get the amount of funds available for trading or funds locked in orders
 * @see https://docs.delta.exchange/#get-wallet-balances
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
 */
func  (this *delta) FetchBalance(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes16478 := (<-this.LoadMarkets())
            PanicOnError(retRes16478)
        
            response:= (<-this.PrivateGetWalletBalances(params))
            PanicOnError(response)
        
                //
            //     {
            //         "result":[
            //             {
            //                 "asset_id":1,
            //                 "available_balance":"0",
            //                 "balance":"0",
            //                 "commission":"0",
            //                 "id":154883,
            //                 "interest_credit":"0",
            //                 "order_margin":"0",
            //                 "pending_referral_bonus":"0",
            //                 "pending_trading_fee_credit":"0",
            //                 "position_margin":"0",
            //                 "trading_fee_credit":"0",
            //                 "user_id":22142
            //             },
            //         ],
            //         "success":true
            //     }
            //
        ch <- this.ParseBalance(response)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchPosition
 * @description fetch data on a single open contract trade position
 * @see https://docs.delta.exchange/#get-position
 * @param {string} symbol unified market symbol of the market the position is held in, default is undefined
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
 */
func  (this *delta) FetchPosition(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes16838 := (<-this.LoadMarkets())
            PanicOnError(retRes16838)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "product_id": GetValue(market, "numericId"),
            }
        
            response:= (<-this.PrivateGetPositions(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result":{
            //             "entry_price":null,
            //             "size":0,
            //             "timestamp":1605454074268079
            //         },
            //         "success":true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParsePosition(result, market)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchPositions
 * @description fetch all open positions
 * @see https://docs.delta.exchange/#get-margined-positions
 * @param {string[]|undefined} symbols list of unified market symbols
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
 */
func  (this *delta) FetchPositions(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
        
            retRes17138 := (<-this.LoadMarkets())
            PanicOnError(retRes17138)
        
            response:= (<-this.PrivateGetPositionsMargined(params))
            PanicOnError(response)
            //
            //     {
            //         "success": true,
            //         "result": [
            //           {
            //             "user_id": 0,
            //             "size": 0,
            //             "entry_price": "string",
            //             "margin": "string",
            //             "liquidation_price": "string",
            //             "bankruptcy_price": "string",
            //             "adl_level": 0,
            //             "product_id": 0,
            //             "product_symbol": "string",
            //             "commission": "string",
            //             "realized_pnl": "string",
            //             "realized_funding": "string"
            //           }
            //         ]
            //     }
            //
            var result interface{} = this.SafeList(response, "result", []interface{}{})
        
            ch <- this.ParsePositions(result, symbols)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParsePosition(position interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // fetchPosition
    //
    //     {
    //         "entry_price":null,
    //         "size":0,
    //         "timestamp":1605454074268079
    //     }
    //
    //
    // fetchPositions
    //
    //     {
    //         "user_id": 0,
    //         "size": 0,
    //         "entry_price": "string",
    //         "margin": "string",
    //         "liquidation_price": "string",
    //         "bankruptcy_price": "string",
    //         "adl_level": 0,
    //         "product_id": 0,
    //         "product_symbol": "string",
    //         "commission": "string",
    //         "realized_pnl": "string",
    //         "realized_funding": "string"
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var marketId interface{} = this.SafeString(position, "product_symbol")
    market = this.SafeMarket(marketId, market)
    var symbol interface{} = GetValue(market, "symbol")
    var timestamp interface{} = this.SafeIntegerProduct(position, "timestamp", 0.001)
    var sizeString interface{} = this.SafeString(position, "size")
    var side interface{} = nil
    if IsTrue(!IsEqual(sizeString, nil)) {
        if IsTrue(Precise.StringGt(sizeString, "0")) {
            side = "buy"
        } else if IsTrue(Precise.StringLt(sizeString, "0")) {
            side = "sell"
        }
    }
    return this.SafePosition(map[string]interface{} {
        "info": position,
        "id": nil,
        "symbol": symbol,
        "notional": nil,
        "marginMode": nil,
        "liquidationPrice": this.SafeNumber(position, "liquidation_price"),
        "entryPrice": this.SafeNumber(position, "entry_price"),
        "unrealizedPnl": nil,
        "percentage": nil,
        "contracts": this.ParseNumber(sizeString),
        "contractSize": this.SafeNumber(market, "contractSize"),
        "markPrice": nil,
        "side": side,
        "hedged": nil,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "maintenanceMargin": nil,
        "maintenanceMarginPercentage": nil,
        "collateral": nil,
        "initialMargin": nil,
        "initialMarginPercentage": nil,
        "leverage": nil,
        "marginRatio": nil,
        "stopLossPrice": nil,
        "takeProfitPrice": nil,
    })
}
func  (this *delta) ParseOrderStatus(status interface{}) interface{}  {
    var statuses interface{} = map[string]interface{} {
        "open": "open",
        "pending": "open",
        "closed": "closed",
        "cancelled": "canceled",
    }
    return this.SafeString(statuses, status, status)
}
func  (this *delta) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // createOrder, cancelOrder, editOrder, fetchOpenOrders, fetchClosedOrders
    //
    //     {
    //         "average_fill_price":null,
    //         "bracket_order":null,
    //         "bracket_stop_loss_limit_price":null,
    //         "bracket_stop_loss_price":null,
    //         "bracket_take_profit_limit_price":null,
    //         "bracket_take_profit_price":null,
    //         "bracket_trail_amount":null,
    //         "cancellation_reason":null,
    //         "client_order_id":null,
    //         "close_on_trigger":"false",
    //         "commission":"0",
    //         "created_at":"2020-11-16T02:38:26Z",
    //         "id":152870626,
    //         "limit_price":"10000",
    //         "meta_data":{"source":"api"},
    //         "order_type":"limit_order",
    //         "paid_commission":"0",
    //         "product_id":139,
    //         "reduce_only":false,
    //         "side":"buy",
    //         "size":0,
    //         "state":"open",
    //         "stop_order_type":null,
    //         "stop_price":null,
    //         "stop_trigger_method":"mark_price",
    //         "time_in_force":"gtc",
    //         "trail_amount":null,
    //         "unfilled_size":0,
    //         "user_id":22142
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var id interface{} = this.SafeString(order, "id")
    var clientOrderId interface{} = this.SafeString(order, "client_order_id")
    var timestamp interface{} = this.Parse8601(this.SafeString(order, "created_at"))
    var marketId interface{} = this.SafeString(order, "product_id")
    var marketsByNumericId interface{} = this.SafeDict(this.Options, "marketsByNumericId", map[string]interface{} {})
    market = this.SafeValue(marketsByNumericId, marketId, market)
    var symbol interface{} = Ternary(IsTrue((IsEqual(market, nil))), marketId, GetValue(market, "symbol"))
    var status interface{} = this.ParseOrderStatus(this.SafeString(order, "state"))
    var side interface{} = this.SafeString(order, "side")
    var typeVar interface{} = this.SafeString(order, "order_type")
    typeVar = Replace(typeVar, "_order", "")
    var price interface{} = this.SafeString(order, "limit_price")
    var amount interface{} = this.SafeString(order, "size")
    var remaining interface{} = this.SafeString(order, "unfilled_size")
    var average interface{} = this.SafeString(order, "average_fill_price")
    var fee interface{} = nil
    var feeCostString interface{} = this.SafeString(order, "paid_commission")
    if IsTrue(!IsEqual(feeCostString, nil)) {
        var feeCurrencyCode interface{} = nil
        if IsTrue(!IsEqual(market, nil)) {
            var settlingAsset interface{} = this.SafeDict(GetValue(market, "info"), "settling_asset", map[string]interface{} {})
            var feeCurrencyId interface{} = this.SafeString(settlingAsset, "symbol")
            feeCurrencyCode = this.SafeCurrencyCode(feeCurrencyId)
        }
        fee = map[string]interface{} {
            "cost": feeCostString,
            "currency": feeCurrencyCode,
        }
    }
    return this.SafeOrder(map[string]interface{} {
        "info": order,
        "id": id,
        "clientOrderId": clientOrderId,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "lastTradeTimestamp": nil,
        "symbol": symbol,
        "type": typeVar,
        "side": side,
        "price": price,
        "amount": amount,
        "cost": nil,
        "average": average,
        "filled": nil,
        "remaining": remaining,
        "status": status,
        "fee": fee,
        "trades": nil,
    }, market)
}
/**
 * @method
 * @name delta#createOrder
 * @description create a trade order
 * @see https://docs.delta.exchange/#place-order
 * @param {string} symbol unified symbol of the market to create an order in
 * @param {string} type 'market' or 'limit'
 * @param {string} side 'buy' or 'sell'
 * @param {float} amount how much of currency you want to trade in units of base currency
 * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {bool} [params.reduceOnly] *contract only* indicates if this order is to reduce the size of a position
 * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
func  (this *delta) CreateOrder(symbol interface{}, typeVar interface{}, side interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    price := GetArg(optionalArgs, 0, nil)
            _ = price
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
        
            retRes19228 := (<-this.LoadMarkets())
            PanicOnError(retRes19228)
            var orderType interface{} = Add(typeVar, "_order")
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "product_id": GetValue(market, "numericId"),
                "size": this.AmountToPrecision(GetValue(market, "symbol"), amount),
                "side": side,
                "order_type": orderType,
            }
            if IsTrue(IsEqual(typeVar, "limit")) {
                AddElementToObject(request, "limit_price", this.PriceToPrecision(GetValue(market, "symbol"), price))
            }
            var clientOrderId interface{} = this.SafeString2(params, "clientOrderId", "client_order_id")
            params = this.Omit(params, []interface{}{"clientOrderId", "client_order_id"})
            if IsTrue(!IsEqual(clientOrderId, nil)) {
                AddElementToObject(request, "client_order_id", clientOrderId)
            }
            var reduceOnly interface{} = this.SafeBool(params, "reduceOnly")
            if IsTrue(reduceOnly) {
                AddElementToObject(request, "reduce_only", reduceOnly)
                params = this.Omit(params, "reduceOnly")
            }
        
            response:= (<-this.PrivatePostOrders(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result":{
            //             "average_fill_price":null,
            //             "bracket_order":null,
            //             "bracket_stop_loss_limit_price":null,
            //             "bracket_stop_loss_price":null,
            //             "bracket_take_profit_limit_price":null,
            //             "bracket_take_profit_price":null,
            //             "bracket_trail_amount":null,
            //             "cancellation_reason":null,
            //             "client_order_id":null,
            //             "close_on_trigger":"false",
            //             "commission":"0",
            //             "created_at":"2020-11-16T02:38:26Z",
            //             "id":152870626,
            //             "limit_price":"10000",
            //             "meta_data":{"source":"api"},
            //             "order_type":"limit_order",
            //             "paid_commission":"0",
            //             "product_id":139,
            //             "reduce_only":false,
            //             "side":"buy",
            //             "size":0,
            //             "state":"open",
            //             "stop_order_type":null,
            //             "stop_price":null,
            //             "stop_trigger_method":"mark_price",
            //             "time_in_force":"gtc",
            //             "trail_amount":null,
            //             "unfilled_size":0,
            //             "user_id":22142
            //         },
            //         "success":true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseOrder(result, market)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#editOrder
 * @description edit a trade order
 * @see https://docs.delta.exchange/#edit-order
 * @param {string} id order id
 * @param {string} symbol unified symbol of the market to create an order in
 * @param {string} type 'market' or 'limit'
 * @param {string} side 'buy' or 'sell'
 * @param {float} amount how much of the currency you want to trade in units of the base currency
 * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
func  (this *delta) EditOrder(id interface{}, symbol interface{}, typeVar interface{}, side interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    amount := GetArg(optionalArgs, 0, nil)
            _ = amount
            price := GetArg(optionalArgs, 1, nil)
            _ = price
            params := GetArg(optionalArgs, 2, map[string]interface{} {})
            _ = params
        
            retRes20058 := (<-this.LoadMarkets())
            PanicOnError(retRes20058)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "id": ParseInt(id),
                "product_id": GetValue(market, "numericId"),
            }
            if IsTrue(!IsEqual(amount, nil)) {
                AddElementToObject(request, "size", ParseInt(this.AmountToPrecision(symbol, amount)))
            }
            if IsTrue(!IsEqual(price, nil)) {
                AddElementToObject(request, "limit_price", this.PriceToPrecision(symbol, price))
            }
        
            response:= (<-this.PrivatePutOrders(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "success": true,
            //         "result": {
            //             "id": "ashb1212",
            //             "product_id": 27,
            //             "limit_price": "9200",
            //             "side": "buy",
            //             "size": 100,
            //             "unfilled_size": 50,
            //             "user_id": 1,
            //             "order_type": "limit_order",
            //             "state": "open",
            //             "created_at": "..."
            //         }
            //     }
            //
            var result interface{} = this.SafeDict(response, "result")
        
            ch <- this.ParseOrder(result, market)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#cancelOrder
 * @description cancels an open order
 * @see https://docs.delta.exchange/#cancel-order
 * @param {string} id order id
 * @param {string} symbol unified symbol of the market the order was made in
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
func  (this *delta) CancelOrder(id interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(symbol, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " cancelOrder() requires a symbol argument")))
            }
        
            retRes20558 := (<-this.LoadMarkets())
            PanicOnError(retRes20558)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "id": ParseInt(id),
                "product_id": GetValue(market, "numericId"),
            }
        
            response:= (<-this.PrivateDeleteOrders(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result":{
            //             "average_fill_price":null,
            //             "bracket_order":null,
            //             "bracket_stop_loss_limit_price":null,
            //             "bracket_stop_loss_price":null,
            //             "bracket_take_profit_limit_price":null,
            //             "bracket_take_profit_price":null,
            //             "bracket_trail_amount":null,
            //             "cancellation_reason":"cancelled_by_user",
            //             "client_order_id":null,
            //             "close_on_trigger":"false",
            //             "commission":"0",
            //             "created_at":"2020-11-16T02:38:26Z",
            //             "id":152870626,
            //             "limit_price":"10000",
            //             "meta_data":{"source":"api"},
            //             "order_type":"limit_order",
            //             "paid_commission":"0",
            //             "product_id":139,
            //             "reduce_only":false,
            //             "side":"buy",
            //             "size":0,
            //             "state":"cancelled",
            //             "stop_order_type":null,
            //             "stop_price":null,
            //             "stop_trigger_method":"mark_price",
            //             "time_in_force":"gtc",
            //             "trail_amount":null,
            //             "unfilled_size":0,
            //             "user_id":22142
            //         },
            //         "success":true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result")
        
            ch <- this.ParseOrder(result, market)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#cancelAllOrders
 * @description cancel all open orders in a market
 * @see https://docs.delta.exchange/#cancel-all-open-orders
 * @param {string} symbol unified market symbol of the market to cancel orders in
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
func  (this *delta) CancelAllOrders(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(symbol, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " cancelAllOrders() requires a symbol argument")))
            }
        
            retRes21158 := (<-this.LoadMarkets())
            PanicOnError(retRes21158)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "product_id": GetValue(market, "numericId"),
            }
            var response interface{} = this.PrivateDeleteOrdersAll(this.Extend(request, params))
        
                //
            //     {
            //         "result":{},
            //         "success":true
            //     }
            //
        ch <- []interface{}{this.SafeOrder(map[string]interface{} {
            "info": response,
        })}
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchOpenOrders
 * @description fetch all unfilled currently open orders
 * @see https://docs.delta.exchange/#get-active-orders
 * @param {string} symbol unified market symbol
 * @param {int} [since] the earliest time in ms to fetch open orders for
 * @param {int} [limit] the maximum number of open order structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
func  (this *delta) FetchOpenOrders(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
                retRes214815 :=  (<-this.FetchOrdersWithMethod("privateGetOrders", symbol, since, limit, params))
                PanicOnError(retRes214815)
                ch <- retRes214815
                return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchClosedOrders
 * @description fetches information on multiple closed orders made by the user
 * @see https://docs.delta.exchange/#get-order-history-cancelled-and-closed
 * @param {string} symbol unified market symbol of the market orders were made in
 * @param {int} [since] the earliest time in ms to fetch orders for
 * @param {int} [limit] the maximum number of order structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
func  (this *delta) FetchClosedOrders(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
                retRes216315 :=  (<-this.FetchOrdersWithMethod("privateGetOrdersHistory", symbol, since, limit, params))
                PanicOnError(retRes216315)
                ch <- retRes216315
                return nil
        
            }()
            return ch
        }
func  (this *delta) FetchOrdersWithMethod(method interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
            retRes21678 := (<-this.LoadMarkets())
            PanicOnError(retRes21678)
            var request interface{} = map[string]interface{} {}
            var market interface{} = nil
            if IsTrue(!IsEqual(symbol, nil)) {
                market = this.Market(symbol)
                AddElementToObject(request, "product_ids", GetValue(market, "numericId")) // accepts a comma-separated list of ids
            }
            if IsTrue(!IsEqual(since, nil)) {
                AddElementToObject(request, "start_time", Add(ToString(since), "000"))
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "page_size", limit)
            }
            var response interface{} = nil
            if IsTrue(IsEqual(method, "privateGetOrders")) {
                
        response = (<-this.PrivateGetOrders(this.Extend(request, params)))
                PanicOnError(response)
            } else if IsTrue(IsEqual(method, "privateGetOrdersHistory")) {
                
        response = (<-this.PrivateGetOrdersHistory(this.Extend(request, params)))
                PanicOnError(response)
            }
            //
            //     {
            //         "success": true,
            //         "result": [
            //             {
            //                 "id": "ashb1212",
            //                 "product_id": 27,
            //                 "limit_price": "9200",
            //                 "side": "buy",
            //                 "size": 100,
            //                 "unfilled_size": 50,
            //                 "user_id": 1,
            //                 "order_type": "limit_order",
            //                 "state": "open",
            //                 "created_at": "..."
            //             }
            //         ],
            //         "meta": {
            //             "after": "string",
            //             "before": "string"
            //         }
            //     }
            //
            var result interface{} = this.SafeList(response, "result", []interface{}{})
        
            ch <- this.ParseOrders(result, market, since, limit)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchMyTrades
 * @description fetch all trades made by the user
 * @see https://docs.delta.exchange/#get-user-fills-by-filters
 * @param {string} symbol unified market symbol
 * @param {int} [since] the earliest time in ms to fetch trades for
 * @param {int} [limit] the maximum number of trades structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
 */
func  (this *delta) FetchMyTrades(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
            retRes22348 := (<-this.LoadMarkets())
            PanicOnError(retRes22348)
            var request interface{} = map[string]interface{} {}
            var market interface{} = nil
            if IsTrue(!IsEqual(symbol, nil)) {
                market = this.Market(symbol)
                AddElementToObject(request, "product_ids", GetValue(market, "numericId")) // accepts a comma-separated list of ids
            }
            if IsTrue(!IsEqual(since, nil)) {
                AddElementToObject(request, "start_time", Add(ToString(since), "000"))
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "page_size", limit)
            }
        
            response:= (<-this.PrivateGetFills(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "meta":{
            //             "after":null,
            //             "before":null,
            //             "limit":10,
            //             "total_count":2
            //         },
            //         "result":[
            //             {
            //                 "commission":"0.008335000000000000",
            //                 "created_at":"2020-11-16T19:07:19Z",
            //                 "fill_type":"normal",
            //                 "id":"e7ff05c233a74245b72381f8dd91d1ce",
            //                 "meta_data":{
            //                     "effective_commission_rate":"0.0005",
            //                     "order_price":"16249",
            //                     "order_size":1,
            //                     "order_type":"market_order",
            //                     "order_unfilled_size":0,
            //                     "trading_fee_credits_used":"0"
            //                 },
            //                 "order_id":"152999629",
            //                 "price":"16669",
            //                 "product":{
            //                     "contract_type":"perpetual_futures",
            //                     "contract_unit_currency":"BTC",
            //                     "contract_value":"0.001",
            //                     "id":139,
            //                     "notional_type":"vanilla",
            //                     "quoting_asset":{"minimum_precision":2,"precision":6,"symbol":"USDT"},
            //                     "settling_asset":{"minimum_precision":2,"precision":6,"symbol":"USDT"},
            //                     "symbol":"BTCUSDT",
            //                     "tick_size":"0.5",
            //                     "underlying_asset":{"minimum_precision":4,"precision":8,"symbol":"BTC"}
            //                 },
            //                 "product_id":139,
            //                 "role":"taker",
            //                 "side":"sell",
            //                 "size":1
            //             }
            //         ],
            //         "success":true
            //     }
            //
            var result interface{} = this.SafeList(response, "result", []interface{}{})
        
            ch <- this.ParseTrades(result, market, since, limit)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchLedger
 * @description fetch the history of changes, actions done by the user or operations that altered the balance of the user
 * @see https://docs.delta.exchange/#get-wallet-transactions
 * @param {string} [code] unified currency code, default is undefined
 * @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
 * @param {int} [limit] max number of ledger entries to return, default is undefined
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger}
 */
func  (this *delta) FetchLedger(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    code := GetArg(optionalArgs, 0, nil)
            _ = code
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
            retRes23178 := (<-this.LoadMarkets())
            PanicOnError(retRes23178)
            var request interface{} = map[string]interface{} {}
            var currency interface{} = nil
            if IsTrue(!IsEqual(code, nil)) {
                currency = this.Currency(code)
                AddElementToObject(request, "asset_id", GetValue(currency, "numericId"))
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "page_size", limit)
            }
        
            response:= (<-this.PrivateGetWalletTransactions(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "meta":{"after":null,"before":null,"limit":10,"total_count":1},
            //         "result":[
            //             {
            //                 "amount":"29.889184",
            //                 "asset_id":5,
            //                 "balance":"29.889184",
            //                 "created_at":"2020-11-15T21:25:01Z",
            //                 "meta_data":{
            //                     "deposit_id":3884,
            //                     "transaction_id":"0x41a60174849828530abb5008e98fc63c9b598288743ec4ba9620bcce900a3b8d"
            //                 },
            //                 "transaction_type":"deposit",
            //                 "user_id":22142,
            //                 "uuid":"70bb5679da3c4637884e2dc63efaa846"
            //             }
            //         ],
            //         "success":true
            //     }
            //
            var result interface{} = this.SafeList(response, "result", []interface{}{})
        
            ch <- this.ParseLedger(result, currency, since, limit)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseLedgerEntryType(typeVar interface{}) interface{}  {
    var types interface{} = map[string]interface{} {
        "pnl": "pnl",
        "deposit": "transaction",
        "withdrawal": "transaction",
        "commission": "fee",
        "conversion": "trade",
        "referral_bonus": "referral",
        "commission_rebate": "rebate",
    }
    return this.SafeString(types, typeVar, typeVar)
}
func  (this *delta) ParseLedgerEntry(item interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "amount":"29.889184",
    //         "asset_id":5,
    //         "balance":"29.889184",
    //         "created_at":"2020-11-15T21:25:01Z",
    //         "meta_data":{
    //             "deposit_id":3884,
    //             "transaction_id":"0x41a60174849828530abb5008e98fc63c9b598288743ec4ba9620bcce900a3b8d"
    //         },
    //         "transaction_type":"deposit",
    //         "user_id":22142,
    //         "uuid":"70bb5679da3c4637884e2dc63efaa846"
    //     }
    //
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    var id interface{} = this.SafeString(item, "uuid")
    var direction interface{} = nil
    var account interface{} = nil
    var metaData interface{} = this.SafeDict(item, "meta_data", map[string]interface{} {})
    var referenceId interface{} = this.SafeString(metaData, "transaction_id")
    var referenceAccount interface{} = nil
    var typeVar interface{} = this.SafeString(item, "transaction_type")
    if IsTrue(IsTrue(IsTrue(IsTrue(IsTrue(IsTrue((IsEqual(typeVar, "deposit"))) || IsTrue((IsEqual(typeVar, "commission_rebate")))) || IsTrue((IsEqual(typeVar, "referral_bonus")))) || IsTrue((IsEqual(typeVar, "pnl")))) || IsTrue((IsEqual(typeVar, "withdrawal_cancellation")))) || IsTrue((IsEqual(typeVar, "promo_credit")))) {
        direction = "in"
    } else if IsTrue(IsTrue(IsTrue(IsTrue((IsEqual(typeVar, "withdrawal"))) || IsTrue((IsEqual(typeVar, "commission")))) || IsTrue((IsEqual(typeVar, "conversion")))) || IsTrue((IsEqual(typeVar, "perpetual_futures_funding")))) {
        direction = "out"
    }
    typeVar = this.ParseLedgerEntryType(typeVar)
    var currencyId interface{} = this.SafeString(item, "asset_id")
    var currenciesByNumericId interface{} = this.SafeDict(this.Options, "currenciesByNumericId")
    currency = this.SafeValue(currenciesByNumericId, currencyId, currency)
    var code interface{} = Ternary(IsTrue((IsEqual(currency, nil))), nil, GetValue(currency, "code"))
    var amount interface{} = this.SafeString(item, "amount")
    var timestamp interface{} = this.Parse8601(this.SafeString(item, "created_at"))
    var after interface{} = this.SafeString(item, "balance")
    var before interface{} = Precise.StringMax("0", Precise.StringSub(after, amount))
    var status interface{} = "ok"
    return this.SafeLedgerEntry(map[string]interface{} {
        "info": item,
        "id": id,
        "direction": direction,
        "account": account,
        "referenceId": referenceId,
        "referenceAccount": referenceAccount,
        "type": typeVar,
        "currency": code,
        "amount": this.ParseNumber(amount),
        "before": this.ParseNumber(before),
        "after": this.ParseNumber(after),
        "status": status,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "fee": nil,
    }, currency)
}
/**
 * @method
 * @name delta#fetchDepositAddress
 * @description fetch the deposit address for a currency associated with this account
 * @param {string} code unified currency code
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {string} [params.network] unified network code
 * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
 */
func  (this *delta) FetchDepositAddress(code interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes24428 := (<-this.LoadMarkets())
            PanicOnError(retRes24428)
            var currency interface{} = this.Currency(code)
            var request interface{} = map[string]interface{} {
                "asset_symbol": GetValue(currency, "id"),
            }
            var networkCode interface{} = this.SafeStringUpper(params, "network")
            if IsTrue(!IsEqual(networkCode, nil)) {
                AddElementToObject(request, "network", this.NetworkCodeToId(networkCode, code))
                params = this.Omit(params, "network")
            }
        
            response:= (<-this.PrivateGetDepositsAddress(this.Extend(request, params)))
            PanicOnError(response)
            //
            //    {
            //        "success": true,
            //        "result": {
            //            "id": 1915615,
            //            "user_id": 27854758,
            //            "address": "TXYB4GdKsXKEWbeSNPsmGZu4ZVCkhVh1Zz",
            //            "memo": "",
            //            "status": "active",
            //            "updated_at": "2023-01-12T06:03:46.000Z",
            //            "created_at": "2023-01-12T06:03:46.000Z",
            //            "asset_symbol": "USDT",
            //            "network": "TRC20(TRON)",
            //            "custodian": "fireblocks"
            //        }
            //    }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseDepositAddress(result, currency)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseDepositAddress(depositAddress interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //    {
    //        "id": 1915615,
    //        "user_id": 27854758,
    //        "address": "TXYB4GdKsXKEWbeSNPsmGZu4ZVCkhVh1Zz",
    //        "memo": "",
    //        "status": "active",
    //        "updated_at": "2023-01-12T06:03:46.000Z",
    //        "created_at": "2023-01-12T06:03:46.000Z",
    //        "asset_symbol": "USDT",
    //        "network": "TRC20(TRON)",
    //        "custodian": "fireblocks"
    //    }
    //
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    var address interface{} = this.SafeString(depositAddress, "address")
    var marketId interface{} = this.SafeString(depositAddress, "asset_symbol")
    var networkId interface{} = this.SafeString(depositAddress, "network")
    this.CheckAddress(address)
    return map[string]interface{} {
        "info": depositAddress,
        "currency": this.SafeCurrencyCode(marketId, currency),
        "network": this.NetworkIdToCode(networkId),
        "address": address,
        "tag": this.SafeString(depositAddress, "memo"),
    }
}
/**
 * @method
 * @name delta#fetchFundingRate
 * @description fetch the current funding rate
 * @see https://docs.delta.exchange/#get-ticker-for-a-product-by-symbol
 * @param {string} symbol unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
 */
func  (this *delta) FetchFundingRate(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes25128 := (<-this.LoadMarkets())
            PanicOnError(retRes25128)
            var market interface{} = this.Market(symbol)
            if !IsTrue(GetValue(market, "swap")) {
                panic(BadSymbol(Add(this.Id, " fetchFundingRate() supports swap contracts only")))
            }
            var request interface{} = map[string]interface{} {
                "symbol": GetValue(market, "id"),
            }
        
            response:= (<-this.PublicGetTickersSymbol(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //             "close": 30600.5,
            //             "contract_type": "perpetual_futures",
            //             "funding_rate": "0.00602961",
            //             "greeks": null,
            //             "high": 30803.0,
            //             "low": 30265.5,
            //             "mark_basis": "-0.45601594",
            //             "mark_price": "30600.10481568",
            //             "oi": "469.9190",
            //             "oi_change_usd_6h": "2226314.9900",
            //             "oi_contracts": "469919",
            //             "oi_value": "469.9190",
            //             "oi_value_symbol": "BTC",
            //             "oi_value_usd": "14385640.6802",
            //             "open": 30458.5,
            //             "price_band": {
            //                 "lower_limit": "29067.08312627",
            //                 "upper_limit": "32126.77608693"
            //             },
            //             "product_id": 139,
            //             "quotes": {
            //                 "ask_iv": null,
            //                 "ask_size": "965",
            //                 "best_ask": "30600.5",
            //                 "best_bid": "30599.5",
            //                 "bid_iv": null,
            //                 "bid_size": "196",
            //                 "impact_mid_price": null,
            //                 "mark_iv": "-0.44931641"
            //             },
            //             "size": 1226303,
            //             "spot_price": "30612.85362773",
            //             "symbol": "BTCUSDT",
            //             "timestamp": 1689136597460456,
            //             "turnover": 37392218.45999999,
            //             "turnover_symbol": "USDT",
            //             "turnover_usd": 37392218.45999999,
            //             "volume": 1226.3029999999485
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseFundingRate(result, market)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchFundingRates
 * @description fetch the funding rate for multiple markets
 * @see https://docs.delta.exchange/#get-tickers-for-products
 * @param {string[]|undefined} symbols list of unified market symbols
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rates-structure}, indexed by market symbols
 */
func  (this *delta) FetchFundingRates(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbols := GetArg(optionalArgs, 0, nil)
            _ = symbols
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
        
            retRes25808 := (<-this.LoadMarkets())
            PanicOnError(retRes25808)
            symbols = this.MarketSymbols(symbols)
            var request interface{} = map[string]interface{} {
                "contract_types": "perpetual_futures",
            }
        
            response:= (<-this.PublicGetTickers(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": [
            //             {
            //                 "close": 30600.5,
            //                 "contract_type": "perpetual_futures",
            //                 "funding_rate": "0.00602961",
            //                 "greeks": null,
            //                 "high": 30803.0,
            //                 "low": 30265.5,
            //                 "mark_basis": "-0.45601594",
            //                 "mark_price": "30600.10481568",
            //                 "oi": "469.9190",
            //                 "oi_change_usd_6h": "2226314.9900",
            //                 "oi_contracts": "469919",
            //                 "oi_value": "469.9190",
            //                 "oi_value_symbol": "BTC",
            //                 "oi_value_usd": "14385640.6802",
            //                 "open": 30458.5,
            //                 "price_band": {
            //                     "lower_limit": "29067.08312627",
            //                     "upper_limit": "32126.77608693"
            //                 },
            //                 "product_id": 139,
            //                 "quotes": {
            //                     "ask_iv": null,
            //                     "ask_size": "965",
            //                     "best_ask": "30600.5",
            //                     "best_bid": "30599.5",
            //                     "bid_iv": null,
            //                     "bid_size": "196",
            //                     "impact_mid_price": null,
            //                     "mark_iv": "-0.44931641"
            //                 },
            //                 "size": 1226303,
            //                 "spot_price": "30612.85362773",
            //                 "symbol": "BTCUSDT",
            //                 "timestamp": 1689136597460456,
            //                 "turnover": 37392218.45999999,
            //                 "turnover_symbol": "USDT",
            //                 "turnover_usd": 37392218.45999999,
            //                 "volume": 1226.3029999999485
            //             },
            //         ],
            //         "success":true
            //     }
            //
            var rates interface{} = this.SafeList(response, "result", []interface{}{})
        
            ch <- this.ParseFundingRates(rates, symbols)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseFundingRate(contract interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "close": 30600.5,
    //         "contract_type": "perpetual_futures",
    //         "funding_rate": "0.00602961",
    //         "greeks": null,
    //         "high": 30803.0,
    //         "low": 30265.5,
    //         "mark_basis": "-0.45601594",
    //         "mark_price": "30600.10481568",
    //         "oi": "469.9190",
    //         "oi_change_usd_6h": "2226314.9900",
    //         "oi_contracts": "469919",
    //         "oi_value": "469.9190",
    //         "oi_value_symbol": "BTC",
    //         "oi_value_usd": "14385640.6802",
    //         "open": 30458.5,
    //         "price_band": {
    //             "lower_limit": "29067.08312627",
    //             "upper_limit": "32126.77608693"
    //         },
    //         "product_id": 139,
    //         "quotes": {
    //             "ask_iv": null,
    //             "ask_size": "965",
    //             "best_ask": "30600.5",
    //             "best_bid": "30599.5",
    //             "bid_iv": null,
    //             "bid_size": "196",
    //             "impact_mid_price": null,
    //             "mark_iv": "-0.44931641"
    //         },
    //         "size": 1226303,
    //         "spot_price": "30612.85362773",
    //         "symbol": "BTCUSDT",
    //         "timestamp": 1689136597460456,
    //         "turnover": 37392218.45999999,
    //         "turnover_symbol": "USDT",
    //         "turnover_usd": 37392218.45999999,
    //         "volume": 1226.3029999999485
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var timestamp interface{} = this.SafeIntegerProduct(contract, "timestamp", 0.001)
    var marketId interface{} = this.SafeString(contract, "symbol")
    var fundingRateString interface{} = this.SafeString(contract, "funding_rate")
    var fundingRate interface{} = Precise.StringDiv(fundingRateString, "100")
    return map[string]interface{} {
        "info": contract,
        "symbol": this.SafeSymbol(marketId, market),
        "markPrice": this.SafeNumber(contract, "mark_price"),
        "indexPrice": this.SafeNumber(contract, "spot_price"),
        "interestRate": nil,
        "estimatedSettlePrice": nil,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "fundingRate": this.ParseNumber(fundingRate),
        "fundingTimestamp": nil,
        "fundingDatetime": nil,
        "nextFundingRate": nil,
        "nextFundingTimestamp": nil,
        "nextFundingDatetime": nil,
        "previousFundingRate": nil,
        "previousFundingTimestamp": nil,
        "previousFundingDatetime": nil,
        "interval": nil,
    }
}
/**
 * @method
 * @name delta#addMargin
 * @description add margin
 * @see https://docs.delta.exchange/#add-remove-position-margin
 * @param {string} symbol unified market symbol
 * @param {float} amount amount of margin to add
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [margin structure]{@link https://docs.ccxt.com/#/?id=add-margin-structure}
 */
func  (this *delta) AddMargin(symbol interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
                retRes271715 :=  (<-this.ModifyMarginHelper(symbol, amount, "add", params))
                PanicOnError(retRes271715)
                ch <- retRes271715
                return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#reduceMargin
 * @description remove margin from a position
 * @see https://docs.delta.exchange/#add-remove-position-margin
 * @param {string} symbol unified market symbol
 * @param {float} amount the amount of margin to remove
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [margin structure]{@link https://docs.ccxt.com/#/?id=reduce-margin-structure}
 */
func  (this *delta) ReduceMargin(symbol interface{}, amount interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
                retRes273115 :=  (<-this.ModifyMarginHelper(symbol, amount, "reduce", params))
                PanicOnError(retRes273115)
                ch <- retRes273115
                return nil
        
            }()
            return ch
        }
func  (this *delta) ModifyMarginHelper(symbol interface{}, amount interface{}, typeVar interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes27358 := (<-this.LoadMarkets())
            PanicOnError(retRes27358)
            var market interface{} = this.Market(symbol)
            amount = ToString(amount)
            if IsTrue(IsEqual(typeVar, "reduce")) {
                amount = Precise.StringMul(amount, "-1")
            }
            var request interface{} = map[string]interface{} {
                "product_id": GetValue(market, "numericId"),
                "delta_margin": amount,
            }
        
            response:= (<-this.PrivatePostPositionsChangeMargin(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //             "auto_topup": false,
            //             "bankruptcy_price": "24934.12",
            //             "commission": "0.01197072",
            //             "created_at": "2023-07-20T03:49:09.159401Z",
            //             "entry_price": "29926.8",
            //             "liquidation_price": "25083.754",
            //             "margin": "4.99268",
            //             "margin_mode": "isolated",
            //             "product_id": 84,
            //             "product_symbol": "BTCUSDT",
            //             "realized_cashflow": "0",
            //             "realized_funding": "0",
            //             "realized_pnl": "0",
            //             "size": 1,
            //             "updated_at": "2023-07-20T03:49:09.159401Z",
            //             "user_id": 30084879
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseMarginModification(result, market)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseMarginModification(data interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "auto_topup": false,
    //         "bankruptcy_price": "24934.12",
    //         "commission": "0.01197072",
    //         "created_at": "2023-07-20T03:49:09.159401Z",
    //         "entry_price": "29926.8",
    //         "liquidation_price": "25083.754",
    //         "margin": "4.99268",
    //         "margin_mode": "isolated",
    //         "product_id": 84,
    //         "product_symbol": "BTCUSDT",
    //         "realized_cashflow": "0",
    //         "realized_funding": "0",
    //         "realized_pnl": "0",
    //         "size": 1,
    //         "updated_at": "2023-07-20T03:49:09.159401Z",
    //         "user_id": 30084879
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var marketId interface{} = this.SafeString(data, "product_symbol")
    market = this.SafeMarket(marketId, market)
    return map[string]interface{} {
        "info": data,
        "symbol": GetValue(market, "symbol"),
        "type": nil,
        "marginMode": "isolated",
        "amount": nil,
        "total": this.SafeNumber(data, "margin"),
        "code": nil,
        "status": nil,
        "timestamp": nil,
        "datetime": nil,
    }
}
/**
 * @method
 * @name delta#fetchOpenInterest
 * @description retrieves the open interest of a derivative market
 * @see https://docs.delta.exchange/#get-ticker-for-a-product-by-symbol
 * @param {string} symbol unified market symbol
 * @param {object} [params] exchange specific parameters
 * @returns {object} an open interest structure{@link https://docs.ccxt.com/#/?id=open-interest-structure}
 */
func  (this *delta) FetchOpenInterest(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes28208 := (<-this.LoadMarkets())
            PanicOnError(retRes28208)
            var market interface{} = this.Market(symbol)
            if !IsTrue(GetValue(market, "contract")) {
                panic(BadRequest(Add(this.Id, " fetchOpenInterest() supports contract markets only")))
            }
            var request interface{} = map[string]interface{} {
                "symbol": GetValue(market, "id"),
            }
        
            response:= (<-this.PublicGetTickersSymbol(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //             "close": 894.0,
            //             "contract_type": "call_options",
            //             "greeks": {
            //                 "delta": "0.67324861",
            //                 "gamma": "0.00022178",
            //                 "rho": "4.34638266",
            //                 "spot": "30178.53195697",
            //                 "theta": "-35.64972577",
            //                 "vega": "16.34381277"
            //             },
            //             "high": 946.0,
            //             "low": 893.0,
            //             "mark_price": "1037.07582681",
            //             "mark_vol": "0.35899491",
            //             "oi": "0.0910",
            //             "oi_change_usd_6h": "-90.5500",
            //             "oi_contracts": "91",
            //             "oi_value": "0.0910",
            //             "oi_value_symbol": "BTC",
            //             "oi_value_usd": "2746.3549",
            //             "open": 946.0,
            //             "price_band": {
            //                 "lower_limit": "133.37794509",
            //                 "upper_limit": "5663.66930164"
            //             },
            //             "product_id": 116171,
            //             "quotes": {
            //                 "ask_iv": "0.36932389",
            //                 "ask_size": "1321",
            //                 "best_ask": "1054",
            //                 "best_bid": "1020",
            //                 "bid_iv": "0.34851914",
            //                 "bid_size": "2202",
            //                 "impact_mid_price": null,
            //                 "mark_iv": "0.35896335"
            //             },
            //             "size": 152,
            //             "spot_price": "30178.53195697",
            //             "strike_price": "29500",
            //             "symbol": "C-BTC-29500-280723",
            //             "timestamp": 1689834695286094,
            //             "turnover": 4546.601744940001,
            //             "turnover_symbol": "USDT",
            //             "turnover_usd": 4546.601744940001,
            //             "volume": 0.15200000000000002
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseOpenInterest(result, market)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseOpenInterest(interest interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "close": 894.0,
    //         "contract_type": "call_options",
    //         "greeks": {
    //             "delta": "0.67324861",
    //             "gamma": "0.00022178",
    //             "rho": "4.34638266",
    //             "spot": "30178.53195697",
    //             "theta": "-35.64972577",
    //             "vega": "16.34381277"
    //         },
    //         "high": 946.0,
    //         "low": 893.0,
    //         "mark_price": "1037.07582681",
    //         "mark_vol": "0.35899491",
    //         "oi": "0.0910",
    //         "oi_change_usd_6h": "-90.5500",
    //         "oi_contracts": "91",
    //         "oi_value": "0.0910",
    //         "oi_value_symbol": "BTC",
    //         "oi_value_usd": "2746.3549",
    //         "open": 946.0,
    //         "price_band": {
    //             "lower_limit": "133.37794509",
    //             "upper_limit": "5663.66930164"
    //         },
    //         "product_id": 116171,
    //         "quotes": {
    //             "ask_iv": "0.36932389",
    //             "ask_size": "1321",
    //             "best_ask": "1054",
    //             "best_bid": "1020",
    //             "bid_iv": "0.34851914",
    //             "bid_size": "2202",
    //             "impact_mid_price": null,
    //             "mark_iv": "0.35896335"
    //         },
    //         "size": 152,
    //         "spot_price": "30178.53195697",
    //         "strike_price": "29500",
    //         "symbol": "C-BTC-29500-280723",
    //         "timestamp": 1689834695286094,
    //         "turnover": 4546.601744940001,
    //         "turnover_symbol": "USDT",
    //         "turnover_usd": 4546.601744940001,
    //         "volume": 0.15200000000000002
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var timestamp interface{} = this.SafeIntegerProduct(interest, "timestamp", 0.001)
    var marketId interface{} = this.SafeString(interest, "symbol")
    return this.SafeOpenInterest(map[string]interface{} {
        "symbol": this.SafeSymbol(marketId, market),
        "baseVolume": this.SafeNumber(interest, "oi_value"),
        "quoteVolume": this.SafeNumber(interest, "oi_value_usd"),
        "openInterestAmount": this.SafeNumber(interest, "oi_contracts"),
        "openInterestValue": this.SafeNumber(interest, "oi"),
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "info": interest,
    }, market)
}
/**
 * @method
 * @name delta#fetchLeverage
 * @description fetch the set leverage for a market
 * @see https://docs.delta.exchange/#get-order-leverage
 * @param {string} symbol unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
 */
func  (this *delta) FetchLeverage(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes29598 := (<-this.LoadMarkets())
            PanicOnError(retRes29598)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "product_id": GetValue(market, "numericId"),
            }
        
            response:= (<-this.PrivateGetProductsProductIdOrdersLeverage(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //             "index_symbol": null,
            //             "leverage": "10",
            //             "margin_mode": "isolated",
            //             "order_margin": "0",
            //             "product_id": 84,
            //             "user_id": 30084879
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseLeverage(result, market)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseLeverage(leverage interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var marketId interface{} = this.SafeString(leverage, "index_symbol")
    var leverageValue interface{} = this.SafeInteger(leverage, "leverage")
    return map[string]interface{} {
        "info": leverage,
        "symbol": this.SafeSymbol(marketId, market),
        "marginMode": this.SafeStringLower(leverage, "margin_mode"),
        "longLeverage": leverageValue,
        "shortLeverage": leverageValue,
    }
}
/**
 * @method
 * @name delta#setLeverage
 * @description set the level of leverage for a market
 * @see https://docs.delta.exchange/#change-order-leverage
 * @param {float} leverage the rate of leverage
 * @param {string} symbol unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} response from the exchange
 */
func  (this *delta) SetLeverage(leverage interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            params := GetArg(optionalArgs, 1, map[string]interface{} {})
            _ = params
            if IsTrue(IsEqual(symbol, nil)) {
                panic(ArgumentsRequired(Add(this.Id, " setLeverage() requires a symbol argument")))
            }
        
            retRes30088 := (<-this.LoadMarkets())
            PanicOnError(retRes30088)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "product_id": GetValue(market, "numericId"),
                "leverage": leverage,
            }
        
                retRes302515 :=  (<-this.PrivatePostProductsProductIdOrdersLeverage(this.Extend(request, params)))
                PanicOnError(retRes302515)
                    //
            //     {
            //         "result": {
            //             "leverage": "20",
            //             "margin_mode": "isolated",
            //             "order_margin": "0",
            //             "product_id": 84
            //         },
            //         "success": true
            //     }
            //
        ch <- retRes302515
                return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchSettlementHistory
 * @description fetches historical settlement records
 * @see https://docs.delta.exchange/#get-product-settlement-prices
 * @param {string} symbol unified market symbol of the settlement history
 * @param {int} [since] timestamp in ms
 * @param {int} [limit] number of records
 * @param {object} [params] exchange specific params
 * @returns {object[]} a list of [settlement history objects]{@link https://docs.ccxt.com/#/?id=settlement-history-structure}
 */
func  (this *delta) FetchSettlementHistory(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    symbol := GetArg(optionalArgs, 0, nil)
            _ = symbol
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
            retRes30408 := (<-this.LoadMarkets())
            PanicOnError(retRes30408)
            var market interface{} = nil
            if IsTrue(!IsEqual(symbol, nil)) {
                market = this.Market(symbol)
            }
            var request interface{} = map[string]interface{} {
                "states": "expired",
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "page_size", limit)
            }
        
            response:= (<-this.PublicGetProducts(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": [
            //             {
            //                 "contract_value": "0.001",
            //                 "basis_factor_max_limit": "10.95",
            //                 "maker_commission_rate": "0.0003",
            //                 "launch_time": "2023-07-19T04:30:03Z",
            //                 "trading_status": "operational",
            //                 "product_specs": {
            //                     "backup_vol_expiry_time": 31536000,
            //                     "max_deviation_from_external_vol": 0.75,
            //                     "max_lower_deviation_from_external_vol": 0.75,
            //                     "max_upper_deviation_from_external_vol": 0.5,
            //                     "max_volatility": 3,
            //                     "min_volatility": 0.1,
            //                     "premium_commission_rate": 0.1,
            //                     "settlement_index_price": "29993.536675710806",
            //                     "vol_calculation_method": "orderbook",
            //                     "vol_expiry_time": 31536000
            //                 },
            //                 "description": "BTC call option expiring on 19-7-2023",
            //                 "settlement_price": "0",
            //                 "disruption_reason": null,
            //                 "settling_asset": {},
            //                 "initial_margin": "1",
            //                 "tick_size": "0.1",
            //                 "maintenance_margin": "0.5",
            //                 "id": 117542,
            //                 "notional_type": "vanilla",
            //                 "ui_config": {},
            //                 "contract_unit_currency": "BTC",
            //                 "symbol": "C-BTC-30900-190723",
            //                 "insurance_fund_margin_contribution": "1",
            //                 "price_band": "2",
            //                 "annualized_funding": "10.95",
            //                 "impact_size": 200,
            //                 "contract_type": "call_options",
            //                 "position_size_limit": 255633,
            //                 "max_leverage_notional": "200000",
            //                 "initial_margin_scaling_factor": "0.000002",
            //                 "strike_price": "30900",
            //                 "is_quanto": false,
            //                 "settlement_time": "2023-07-19T12:00:00Z",
            //                 "liquidation_penalty_factor": "0.5",
            //                 "funding_method": "mark_price",
            //                 "taker_commission_rate": "0.0003",
            //                 "default_leverage": "100.000000000000000000",
            //                 "state": "expired",
            //                 "auction_start_time": null,
            //                 "short_description": "BTC  Call",
            //                 "quoting_asset": {},
            //                 "maintenance_margin_scaling_factor":"0.000002"
            //             }
            //         ],
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeList(response, "result", []interface{}{})
            var settlements interface{} = this.ParseSettlements(result, market)
            var sorted interface{} = this.SortBy(settlements, "timestamp")
        
            ch <- this.FilterBySymbolSinceLimit(sorted, GetValue(market, "symbol"), since, limit)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseSettlement(settlement interface{}, market interface{}) interface{}  {
    //
    //     {
    //         "contract_value": "0.001",
    //         "basis_factor_max_limit": "10.95",
    //         "maker_commission_rate": "0.0003",
    //         "launch_time": "2023-07-19T04:30:03Z",
    //         "trading_status": "operational",
    //         "product_specs": {
    //             "backup_vol_expiry_time": 31536000,
    //             "max_deviation_from_external_vol": 0.75,
    //             "max_lower_deviation_from_external_vol": 0.75,
    //             "max_upper_deviation_from_external_vol": 0.5,
    //             "max_volatility": 3,
    //             "min_volatility": 0.1,
    //             "premium_commission_rate": 0.1,
    //             "settlement_index_price": "29993.536675710806",
    //             "vol_calculation_method": "orderbook",
    //             "vol_expiry_time": 31536000
    //         },
    //         "description": "BTC call option expiring on 19-7-2023",
    //         "settlement_price": "0",
    //         "disruption_reason": null,
    //         "settling_asset": {},
    //         "initial_margin": "1",
    //         "tick_size": "0.1",
    //         "maintenance_margin": "0.5",
    //         "id": 117542,
    //         "notional_type": "vanilla",
    //         "ui_config": {},
    //         "contract_unit_currency": "BTC",
    //         "symbol": "C-BTC-30900-190723",
    //         "insurance_fund_margin_contribution": "1",
    //         "price_band": "2",
    //         "annualized_funding": "10.95",
    //         "impact_size": 200,
    //         "contract_type": "call_options",
    //         "position_size_limit": 255633,
    //         "max_leverage_notional": "200000",
    //         "initial_margin_scaling_factor": "0.000002",
    //         "strike_price": "30900",
    //         "is_quanto": false,
    //         "settlement_time": "2023-07-19T12:00:00Z",
    //         "liquidation_penalty_factor": "0.5",
    //         "funding_method": "mark_price",
    //         "taker_commission_rate": "0.0003",
    //         "default_leverage": "100.000000000000000000",
    //         "state": "expired",
    //         "auction_start_time": null,
    //         "short_description": "BTC  Call",
    //         "quoting_asset": {},
    //         "maintenance_margin_scaling_factor":"0.000002"
    //     }
    //
    var datetime interface{} = this.SafeString(settlement, "settlement_time")
    var marketId interface{} = this.SafeString(settlement, "symbol")
    return map[string]interface{} {
        "info": settlement,
        "symbol": this.SafeSymbol(marketId, market),
        "price": this.SafeNumber(settlement, "settlement_price"),
        "timestamp": this.Parse8601(datetime),
        "datetime": datetime,
    }
}
func  (this *delta) ParseSettlements(settlements interface{}, market interface{}) interface{}  {
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(settlements)); i++ {
        AppendToArray(&result,this.ParseSettlement(GetValue(settlements, i), market))
    }
    return result
}
/**
 * @method
 * @name delta#fetchGreeks
 * @description fetches an option contracts greeks, financial metrics used to measure the factors that affect the price of an options contract
 * @see https://docs.delta.exchange/#get-ticker-for-a-product-by-symbol
 * @param {string} symbol unified symbol of the market to fetch greeks for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [greeks structure]{@link https://docs.ccxt.com/#/?id=greeks-structure}
 */
func  (this *delta) FetchGreeks(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes31998 := (<-this.LoadMarkets())
            PanicOnError(retRes31998)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "symbol": GetValue(market, "id"),
            }
        
            response:= (<-this.PublicGetTickersSymbol(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //             "close": 6793.0,
            //             "contract_type": "call_options",
            //             "greeks": {
            //                 "delta": "0.94739174",
            //                 "gamma": "0.00002206",
            //                 "rho": "11.00890725",
            //                 "spot": "36839.58124652",
            //                 "theta": "-18.18365310",
            //                 "vega": "7.85209698"
            //             },
            //             "high": 7556.0,
            //             "low": 6793.0,
            //             "mark_price": "6955.70698909",
            //             "mark_vol": "0.66916863",
            //             "oi": "1.8980",
            //             "oi_change_usd_6h": "110.4600",
            //             "oi_contracts": "1898",
            //             "oi_value": "1.8980",
            //             "oi_value_symbol": "BTC",
            //             "oi_value_usd": "69940.7319",
            //             "open": 7.2e3,
            //             "price_band": {
            //                 "lower_limit": "5533.89814767",
            //                 "upper_limit": "11691.37688371"
            //             },
            //             "product_id": 129508,
            //             "quotes": {
            //                 "ask_iv": "0.90180438",
            //                 "ask_size": "1898",
            //                 "best_ask": "7210",
            //                 "best_bid": "6913",
            //                 "bid_iv": "0.60881706",
            //                 "bid_size": "3163",
            //                 "impact_mid_price": null,
            //                 "mark_iv": "0.66973549"
            //             },
            //             "size": 5,
            //             "spot_price": "36839.58153868",
            //             "strike_price": "30000",
            //             "symbol": "C-BTC-30000-241123",
            //             "timestamp": 1699584998504530,
            //             "turnover": 184.41206804,
            //             "turnover_symbol": "USDT",
            //             "turnover_usd": 184.41206804,
            //             "volume": 0.005
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseGreeks(result, market)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseGreeks(greeks interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "close": 6793.0,
    //         "contract_type": "call_options",
    //         "greeks": {
    //             "delta": "0.94739174",
    //             "gamma": "0.00002206",
    //             "rho": "11.00890725",
    //             "spot": "36839.58124652",
    //             "theta": "-18.18365310",
    //             "vega": "7.85209698"
    //         },
    //         "high": 7556.0,
    //         "low": 6793.0,
    //         "mark_price": "6955.70698909",
    //         "mark_vol": "0.66916863",
    //         "oi": "1.8980",
    //         "oi_change_usd_6h": "110.4600",
    //         "oi_contracts": "1898",
    //         "oi_value": "1.8980",
    //         "oi_value_symbol": "BTC",
    //         "oi_value_usd": "69940.7319",
    //         "open": 7.2e3,
    //         "price_band": {
    //             "lower_limit": "5533.89814767",
    //             "upper_limit": "11691.37688371"
    //         },
    //         "product_id": 129508,
    //         "quotes": {
    //             "ask_iv": "0.90180438",
    //             "ask_size": "1898",
    //             "best_ask": "7210",
    //             "best_bid": "6913",
    //             "bid_iv": "0.60881706",
    //             "bid_size": "3163",
    //             "impact_mid_price": null,
    //             "mark_iv": "0.66973549"
    //         },
    //         "size": 5,
    //         "spot_price": "36839.58153868",
    //         "strike_price": "30000",
    //         "symbol": "C-BTC-30000-241123",
    //         "timestamp": 1699584998504530,
    //         "turnover": 184.41206804,
    //         "turnover_symbol": "USDT",
    //         "turnover_usd": 184.41206804,
    //         "volume": 0.005
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var timestamp interface{} = this.SafeIntegerProduct(greeks, "timestamp", 0.001)
    var marketId interface{} = this.SafeString(greeks, "symbol")
    var symbol interface{} = this.SafeSymbol(marketId, market)
    var stats interface{} = this.SafeDict(greeks, "greeks", map[string]interface{} {})
    var quotes interface{} = this.SafeDict(greeks, "quotes", map[string]interface{} {})
    return map[string]interface{} {
        "symbol": symbol,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "delta": this.SafeNumber(stats, "delta"),
        "gamma": this.SafeNumber(stats, "gamma"),
        "theta": this.SafeNumber(stats, "theta"),
        "vega": this.SafeNumber(stats, "vega"),
        "rho": this.SafeNumber(stats, "rho"),
        "bidSize": this.SafeNumber(quotes, "bid_size"),
        "askSize": this.SafeNumber(quotes, "ask_size"),
        "bidImpliedVolatility": this.SafeNumber(quotes, "bid_iv"),
        "askImpliedVolatility": this.SafeNumber(quotes, "ask_iv"),
        "markImpliedVolatility": this.SafeNumber(quotes, "mark_iv"),
        "bidPrice": this.SafeNumber(quotes, "best_bid"),
        "askPrice": this.SafeNumber(quotes, "best_ask"),
        "markPrice": this.SafeNumber(greeks, "mark_price"),
        "lastPrice": nil,
        "underlyingPrice": this.SafeNumber(greeks, "spot_price"),
        "info": greeks,
    }
}
/**
 * @method
 * @name delta#closeAllPositions
 * @description closes all open positions for a market type
 * @see https://docs.delta.exchange/#close-all-positions
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @param {int} [params.user_id] the users id
 * @returns {object[]} A list of [position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
 */
func  (this *delta) CloseAllPositions(optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes33498 := (<-this.LoadMarkets())
            PanicOnError(retRes33498)
            var request interface{} = map[string]interface{} {
                "close_all_portfolio": true,
                "close_all_isolated": true,
            }
        
            response:= (<-this.PrivatePostPositionsCloseAll(this.Extend(request, params)))
            PanicOnError(response)
            //
            // {"result":{},"success":true}
            //
            var position interface{} = this.ParsePosition(this.SafeDict(response, "result", map[string]interface{} {}))
        
            ch <- []interface{}{position}
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name delta#fetchMarginMode
 * @description fetches the margin mode of a trading pair
 * @see https://docs.delta.exchange/#get-user
 * @param {string} symbol unified symbol of the market to fetch the margin mode for
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} a [margin mode structure]{@link https://docs.ccxt.com/#/?id=margin-mode-structure}
 */
func  (this *delta) FetchMarginMode(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes33738 := (<-this.LoadMarkets())
            PanicOnError(retRes33738)
            var market interface{} = nil
            if IsTrue(!IsEqual(symbol, nil)) {
                market = this.Market(symbol)
            }
        
            response:= (<-this.PrivateGetProfile(params))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //             "is_password_set": true,
            //             "kyc_expiry_date": null,
            //             "phishing_code": "12345",
            //             "preferences": {
            //                 "favorites": []
            //             },
            //             "is_kyc_provisioned": false,
            //             "country": "Canada",
            //             "margin_mode": "isolated",
            //             "mfa_updated_at": "2023-07-19T01:04:43Z",
            //             "last_name": "",
            //             "oauth_apple_active": false,
            //             "pf_index_symbol": null,
            //             "proof_of_identity_status": "approved",
            //             "dob": null,
            //             "email": "abc_123@gmail.com",
            //             "force_change_password": false,
            //             "nick_name": "still-breeze-123",
            //             "oauth_google_active": false,
            //             "phone_verification_status": "verified",
            //             "id": 12345678,
            //             "last_seen": null,
            //             "is_withdrawal_enabled": true,
            //             "force_change_mfa": false,
            //             "enable_bots": false,
            //             "kyc_verified_on": null,
            //             "created_at": "2023-07-19T01:02:32Z",
            //             "withdrawal_blocked_till": null,
            //             "proof_of_address_status": "approved",
            //             "is_password_change_blocked": false,
            //             "is_mfa_enabled": true,
            //             "is_kyc_done": true,
            //             "oauth": null,
            //             "account_name": "Main",
            //             "sub_account_permissions": null,
            //             "phone_number": null,
            //             "tracking_info": {
            //                 "ga_cid": "1234.4321",
            //                 "is_kyc_gtm_tracked": true,
            //                 "sub_account_config": {
            //                     "cross": 2,
            //                     "isolated": 2,
            //                     "portfolio": 2
            //                 }
            //             },
            //             "first_name": "",
            //             "phone_verified_on": null,
            //             "seen_intro": false,
            //             "password_updated_at": null,
            //             "is_login_enabled": true,
            //             "registration_date": "2023-07-19T01:02:32Z",
            //             "permissions": {},
            //             "max_sub_accounts_limit": 2,
            //             "country_calling_code": null,
            //             "is_sub_account": false,
            //             "is_kyc_refresh_required": false
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseMarginMode(result, market)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseMarginMode(marginMode interface{}, optionalArgs ...interface{}) interface{}  {
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var symbol interface{} = nil
    if IsTrue(!IsEqual(market, nil)) {
        symbol = GetValue(market, "symbol")
    }
    return map[string]interface{} {
        "info": marginMode,
        "symbol": symbol,
        "marginMode": this.SafeString(marginMode, "margin_mode"),
    }
}
/**
 * @method
 * @name delta#fetchOption
 * @description fetches option data that is commonly found in an option chain
 * @see https://docs.delta.exchange/#get-ticker-for-a-product-by-symbol
 * @param {string} symbol unified market symbol
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object} an [option chain structure]{@link https://docs.ccxt.com/#/?id=option-chain-structure}
 */
func  (this *delta) FetchOption(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    params := GetArg(optionalArgs, 0, map[string]interface{} {})
            _ = params
        
            retRes34688 := (<-this.LoadMarkets())
            PanicOnError(retRes34688)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "symbol": GetValue(market, "id"),
            }
        
            response:= (<-this.PublicGetTickersSymbol(this.Extend(request, params)))
            PanicOnError(response)
            //
            //     {
            //         "result": {
            //             "close": 6793.0,
            //             "contract_type": "call_options",
            //             "greeks": {
            //                 "delta": "0.94739174",
            //                 "gamma": "0.00002206",
            //                 "rho": "11.00890725",
            //                 "spot": "36839.58124652",
            //                 "theta": "-18.18365310",
            //                 "vega": "7.85209698"
            //             },
            //             "high": 7556.0,
            //             "low": 6793.0,
            //             "mark_price": "6955.70698909",
            //             "mark_vol": "0.66916863",
            //             "oi": "1.8980",
            //             "oi_change_usd_6h": "110.4600",
            //             "oi_contracts": "1898",
            //             "oi_value": "1.8980",
            //             "oi_value_symbol": "BTC",
            //             "oi_value_usd": "69940.7319",
            //             "open": 7.2e3,
            //             "price_band": {
            //                 "lower_limit": "5533.89814767",
            //                 "upper_limit": "11691.37688371"
            //             },
            //             "product_id": 129508,
            //             "quotes": {
            //                 "ask_iv": "0.90180438",
            //                 "ask_size": "1898",
            //                 "best_ask": "7210",
            //                 "best_bid": "6913",
            //                 "bid_iv": "0.60881706",
            //                 "bid_size": "3163",
            //                 "impact_mid_price": null,
            //                 "mark_iv": "0.66973549"
            //             },
            //             "size": 5,
            //             "spot_price": "36839.58153868",
            //             "strike_price": "30000",
            //             "symbol": "C-BTC-30000-241123",
            //             "timestamp": 1699584998504530,
            //             "turnover": 184.41206804,
            //             "turnover_symbol": "USDT",
            //             "turnover_usd": 184.41206804,
            //             "volume": 0.005
            //         },
            //         "success": true
            //     }
            //
            var result interface{} = this.SafeDict(response, "result", map[string]interface{} {})
        
            ch <- this.ParseOption(result, nil, market)
            return nil
        
            }()
            return ch
        }
func  (this *delta) ParseOption(chain interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "close": 6793.0,
    //         "contract_type": "call_options",
    //         "greeks": {
    //             "delta": "0.94739174",
    //             "gamma": "0.00002206",
    //             "rho": "11.00890725",
    //             "spot": "36839.58124652",
    //             "theta": "-18.18365310",
    //             "vega": "7.85209698"
    //         },
    //         "high": 7556.0,
    //         "low": 6793.0,
    //         "mark_price": "6955.70698909",
    //         "mark_vol": "0.66916863",
    //         "oi": "1.8980",
    //         "oi_change_usd_6h": "110.4600",
    //         "oi_contracts": "1898",
    //         "oi_value": "1.8980",
    //         "oi_value_symbol": "BTC",
    //         "oi_value_usd": "69940.7319",
    //         "open": 7.2e3,
    //         "price_band": {
    //             "lower_limit": "5533.89814767",
    //             "upper_limit": "11691.37688371"
    //         },
    //         "product_id": 129508,
    //         "quotes": {
    //             "ask_iv": "0.90180438",
    //             "ask_size": "1898",
    //             "best_ask": "7210",
    //             "best_bid": "6913",
    //             "bid_iv": "0.60881706",
    //             "bid_size": "3163",
    //             "impact_mid_price": null,
    //             "mark_iv": "0.66973549"
    //         },
    //         "size": 5,
    //         "spot_price": "36839.58153868",
    //         "strike_price": "30000",
    //         "symbol": "C-BTC-30000-241123",
    //         "timestamp": 1699584998504530,
    //         "turnover": 184.41206804,
    //         "turnover_symbol": "USDT",
    //         "turnover_usd": 184.41206804,
    //         "volume": 0.005
    //     }
    //
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    market := GetArg(optionalArgs, 1, nil)
    _ = market
    var marketId interface{} = this.SafeString(chain, "symbol")
    market = this.SafeMarket(marketId, market)
    var quotes interface{} = this.SafeDict(chain, "quotes", map[string]interface{} {})
    var timestamp interface{} = this.SafeIntegerProduct(chain, "timestamp", 0.001)
    return map[string]interface{} {
        "info": chain,
        "currency": nil,
        "symbol": GetValue(market, "symbol"),
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "impliedVolatility": this.SafeNumber(quotes, "mark_iv"),
        "openInterest": this.SafeNumber(chain, "oi"),
        "bidPrice": this.SafeNumber(quotes, "best_bid"),
        "askPrice": this.SafeNumber(quotes, "best_ask"),
        "midPrice": this.SafeNumber(quotes, "impact_mid_price"),
        "markPrice": this.SafeNumber(chain, "mark_price"),
        "lastPrice": nil,
        "underlyingPrice": this.SafeNumber(chain, "spot_price"),
        "change": nil,
        "percentage": nil,
        "baseVolume": this.SafeNumber(chain, "volume"),
        "quoteVolume": nil,
    }
}
func  (this *delta) Sign(path interface{}, optionalArgs ...interface{}) interface{}  {
    api := GetArg(optionalArgs, 0, "public")
    _ = api
    method := GetArg(optionalArgs, 1, "GET")
    _ = method
    params := GetArg(optionalArgs, 2, map[string]interface{} {})
    _ = params
    headers := GetArg(optionalArgs, 3, nil)
    _ = headers
    body := GetArg(optionalArgs, 4, nil)
    _ = body
    var requestPath interface{} = Add(Add(Add("/", this.Version), "/"), this.ImplodeParams(path, params))
    var url interface{} = Add(GetValue(GetValue(this.Urls, "api"), api), requestPath)
    var query interface{} = this.Omit(params, this.ExtractParams(path))
    if IsTrue(IsEqual(api, "public")) {
        if IsTrue(GetArrayLength(ObjectKeys(query))) {
            url = Add(url, Add("?", this.Urlencode(query)))
        }
    } else if IsTrue(IsEqual(api, "private")) {
        this.CheckRequiredCredentials()
        var timestamp interface{} = ToString(this.Seconds())
        headers = map[string]interface{} {
            "api-key": this.ApiKey,
            "timestamp": timestamp,
        }
        var auth interface{} = Add(Add(method, timestamp), requestPath)
        if IsTrue(IsEqual(method, "GET")) {
            if IsTrue(GetArrayLength(ObjectKeys(query))) {
                var queryString interface{} = Add("?", this.Urlencode(query))
                auth = Add(auth, queryString)
                url = Add(url, queryString)
            }
        } else {
            body = this.Json(query)
            auth = Add(auth, body)
            AddElementToObject(headers, "Content-Type", "application/json")
        }
        var signature interface{} = this.Hmac(this.Encode(auth), this.Encode(this.Secret), sha256)
        AddElementToObject(headers, "signature", signature)
    }
    return map[string]interface{} {
        "url": url,
        "method": method,
        "body": body,
        "headers": headers,
    }
}
func  (this *delta) HandleErrors(code interface{}, reason interface{}, url interface{}, method interface{}, headers interface{}, body interface{}, response interface{}, requestHeaders interface{}, requestBody interface{}) interface{}  {
    if IsTrue(IsEqual(response, nil)) {
        return nil
    }
    //
    // {"error":{"code":"insufficient_margin","context":{"available_balance":"0.000000000000000000","required_additional_balance":"1.618626000000000000000000000"}},"success":false}
    //
    var error interface{} = this.SafeDict(response, "error", map[string]interface{} {})
    var errorCode interface{} = this.SafeString(error, "code")
    if IsTrue(!IsEqual(errorCode, nil)) {
        var feedback interface{} = Add(Add(this.Id, " "), body)
        this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), errorCode, feedback)
        this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), errorCode, feedback)
        panic(ExchangeError(feedback))
    }
    return nil
}


func (this *delta) Init(userConfig map[string]interface{}) {
    this.Exchange = Exchange{}
    this.Exchange.InitParent(userConfig, this.Describe().(map[string]interface{}), this)
    this.Exchange.DerivedExchange = this
}