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 btcalpha struct {
    Exchange

}

func NewBtcalphaCore() btcalpha {
   p := btcalpha{}
   setDefaults(&p)
   return p
}

func  (this *btcalpha) Describe() interface{}  {
    return this.DeepExtend(this.Exchange.Describe(), map[string]interface{} {
        "id": "btcalpha",
        "name": "BTC-Alpha",
        "countries": []interface{}{"US"},
        "version": "v1",
        "has": map[string]interface{} {
            "CORS": nil,
            "spot": true,
            "margin": false,
            "swap": false,
            "future": false,
            "option": false,
            "addMargin": false,
            "cancelOrder": true,
            "closeAllPositions": false,
            "closePosition": false,
            "createDepositAddress": false,
            "createOrder": true,
            "createReduceOnlyOrder": false,
            "createStopLimitOrder": false,
            "createStopMarketOrder": false,
            "createStopOrder": false,
            "fetchBalance": true,
            "fetchBorrowRateHistories": false,
            "fetchBorrowRateHistory": false,
            "fetchClosedOrders": true,
            "fetchCrossBorrowRate": false,
            "fetchCrossBorrowRates": false,
            "fetchDeposit": false,
            "fetchDepositAddress": false,
            "fetchDepositAddresses": false,
            "fetchDepositAddressesByNetwork": false,
            "fetchDeposits": true,
            "fetchFundingHistory": false,
            "fetchFundingRate": false,
            "fetchFundingRateHistory": false,
            "fetchFundingRates": false,
            "fetchIndexOHLCV": false,
            "fetchIsolatedBorrowRate": false,
            "fetchIsolatedBorrowRates": false,
            "fetchL2OrderBook": true,
            "fetchLeverage": false,
            "fetchMarginMode": false,
            "fetchMarkets": true,
            "fetchMarkOHLCV": false,
            "fetchMyTrades": true,
            "fetchOHLCV": true,
            "fetchOpenInterestHistory": false,
            "fetchOpenOrders": true,
            "fetchOrder": true,
            "fetchOrderBook": true,
            "fetchOrders": true,
            "fetchPosition": false,
            "fetchPositionHistory": false,
            "fetchPositionMode": false,
            "fetchPositions": false,
            "fetchPositionsForSymbol": false,
            "fetchPositionsHistory": false,
            "fetchPositionsRisk": false,
            "fetchPremiumIndexOHLCV": false,
            "fetchTicker": true,
            "fetchTickers": true,
            "fetchTrades": true,
            "fetchTradingFee": false,
            "fetchTradingFees": false,
            "fetchTransfer": false,
            "fetchTransfers": false,
            "fetchWithdrawal": false,
            "fetchWithdrawals": true,
            "reduceMargin": false,
            "setLeverage": false,
            "setMarginMode": false,
            "setPositionMode": false,
            "transfer": false,
            "withdraw": false,
        },
        "timeframes": map[string]interface{} {
            "5m": "5",
            "15m": "15",
            "30m": "30",
            "1h": "60",
            "4h": "240",
            "1d": "D",
        },
        "urls": map[string]interface{} {
            "logo": "https://github.com/user-attachments/assets/dce49f3a-61e5-4ba0-a2fe-41d192fd0e5d",
            "api": map[string]interface{} {
                "rest": "https://btc-alpha.com/api",
            },
            "www": "https://btc-alpha.com",
            "doc": "https://btc-alpha.github.io/api-docs",
            "fees": "https://btc-alpha.com/fees/",
            "referral": "https://btc-alpha.com/?r=123788",
        },
        "api": map[string]interface{} {
            "public": map[string]interface{} {
                "get": []interface{}{"currencies/", "pairs/", "orderbook/{pair_name}", "exchanges/", "charts/{pair}/{type}/chart/", "ticker/"},
            },
            "private": map[string]interface{} {
                "get": []interface{}{"wallets/", "orders/own/", "order/{id}/", "exchanges/own/", "deposits/", "withdraws/"},
                "post": []interface{}{"order/", "order-cancel/"},
            },
        },
        "fees": map[string]interface{} {
            "trading": map[string]interface{} {
                "maker": this.ParseNumber("0.002"),
                "taker": this.ParseNumber("0.002"),
            },
            "funding": map[string]interface{} {
                "withdraw": map[string]interface{} {},
            },
        },
        "commonCurrencies": map[string]interface{} {
            "CBC": "Cashbery",
        },
        "features": map[string]interface{} {
            "spot": map[string]interface{} {
                "sandbox": false,
                "createOrder": map[string]interface{} {
                    "marginMode": false,
                    "triggerPrice": false,
                    "triggerPriceType": nil,
                    "triggerDirection": false,
                    "stopLossPrice": false,
                    "takeProfitPrice": false,
                    "attachedStopLossTakeProfit": nil,
                    "timeInForce": map[string]interface{} {
                        "IOC": false,
                        "FOK": false,
                        "PO": false,
                        "GTD": false,
                    },
                    "hedged": false,
                    "leverage": false,
                    "marketBuyRequiresPrice": false,
                    "marketBuyByCost": false,
                    "selfTradePrevention": false,
                    "trailing": false,
                    "iceberg": false,
                },
                "createOrders": nil,
                "fetchMyTrades": map[string]interface{} {
                    "marginMode": false,
                    "limit": 100,
                    "daysBack": nil,
                    "untilDays": nil,
                    "symbolRequired": false,
                },
                "fetchOrder": map[string]interface{} {
                    "marginMode": false,
                    "trigger": false,
                    "trailing": false,
                    "symbolRequired": false,
                },
                "fetchOpenOrders": map[string]interface{} {
                    "marginMode": false,
                    "limit": 2000,
                    "trigger": false,
                    "trailing": false,
                    "symbolRequired": false,
                },
                "fetchOrders": map[string]interface{} {
                    "marginMode": false,
                    "limit": 2000,
                    "daysBack": nil,
                    "untilDays": nil,
                    "trigger": false,
                    "trailing": false,
                    "symbolRequired": false,
                },
                "fetchClosedOrders": map[string]interface{} {
                    "marginMode": false,
                    "limit": 2000,
                    "daysBack": nil,
                    "daysBackCanceled": nil,
                    "untilDays": nil,
                    "trigger": false,
                    "trailing": false,
                    "symbolRequired": false,
                },
                "fetchOHLCV": map[string]interface{} {
                    "max": 720,
                },
            },
            "swap": map[string]interface{} {
                "linear": nil,
                "inverse": nil,
            },
            "future": map[string]interface{} {
                "linear": nil,
                "inverse": nil,
            },
        },
        "precisionMode": TICK_SIZE,
        "exceptions": map[string]interface{} {
            "exact": map[string]interface{} {},
            "broad": map[string]interface{} {
                "Out of balance": InsufficientFunds,
            },
        },
    })
}
/**
 * @method
 * @name btcalpha#fetchMarkets
 * @description retrieves data on all markets for btcalpha
 * @see https://btc-alpha.github.io/api-docs/#list-all-currencies
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} an array of objects representing market data
 */
func  (this *btcalpha) 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.PublicGetPairs(params))
            PanicOnError(response)
        
                //
            //    [
            //        {
            //            "name": "1INCH_USDT",
            //            "currency1": "1INCH",
            //            "currency2": "USDT",
            //            "price_precision": 4,
            //            "amount_precision": 2,
            //            "minimum_order_size": "0.01000000",
            //            "maximum_order_size": "900000.00000000",
            //            "minimum_order_value": "10.00000000",
            //            "liquidity_type": 10
            //        },
            //    ]
            //
        ch <- this.ParseMarkets(response)
            return nil
        
            }()
            return ch
        }
func  (this *btcalpha) ParseMarket(market interface{}) interface{}  {
    var id interface{} = this.SafeString(market, "name")
    var baseId interface{} = this.SafeString(market, "currency1")
    var quoteId interface{} = this.SafeString(market, "currency2")
    var base interface{} = this.SafeCurrencyCode(baseId)
    var quote interface{} = this.SafeCurrencyCode(quoteId)
    var pricePrecision interface{} = this.SafeString(market, "price_precision")
    var priceLimit interface{} = this.ParsePrecision(pricePrecision)
    var amountLimit interface{} = this.SafeString(market, "minimum_order_size")
    return map[string]interface{} {
        "id": id,
        "symbol": Add(Add(base, "/"), quote),
        "base": base,
        "quote": quote,
        "settle": nil,
        "baseId": baseId,
        "quoteId": quoteId,
        "settleId": nil,
        "type": "spot",
        "spot": true,
        "margin": false,
        "swap": false,
        "future": false,
        "option": false,
        "active": true,
        "contract": false,
        "linear": nil,
        "inverse": nil,
        "contractSize": nil,
        "expiry": nil,
        "expiryDatetime": nil,
        "strike": nil,
        "optionType": nil,
        "precision": map[string]interface{} {
            "amount": this.ParseNumber(this.ParsePrecision(this.SafeString(market, "amount_precision"))),
            "price": this.ParseNumber(this.ParsePrecision((pricePrecision))),
        },
        "limits": map[string]interface{} {
            "leverage": map[string]interface{} {
                "min": nil,
                "max": nil,
            },
            "amount": map[string]interface{} {
                "min": this.ParseNumber(amountLimit),
                "max": this.SafeNumber(market, "maximum_order_size"),
            },
            "price": map[string]interface{} {
                "min": this.ParseNumber(priceLimit),
                "max": nil,
            },
            "cost": map[string]interface{} {
                "min": this.ParseNumber(Precise.StringMul(priceLimit, amountLimit)),
                "max": nil,
            },
        },
        "created": nil,
        "info": market,
    }
}
/**
 * @method
 * @name btcalpha#fetchTickers
 * @see https://btc-alpha.github.io/api-docs/#tickers
 * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
 * @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 *btcalpha) 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
        
            retRes3368 := (<-this.LoadMarkets())
            PanicOnError(retRes3368)
        
            response:= (<-this.PublicGetTicker(params))
            PanicOnError(response)
        
                //
            //    [
            //        {
            //            "timestamp": "1674658.445272",
            //            "pair": "BTC_USDT",
            //            "last": "22476.85",
            //            "diff": "458.96",
            //            "vol": "6660.847784",
            //            "high": "23106.08",
            //            "low": "22348.29",
            //            "buy": "22508.46",
            //            "sell": "22521.11"
            //        },
            //        ...
            //    ]
            //
        ch <- this.ParseTickers(response, symbols)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchTicker
 * @see https://btc-alpha.github.io/api-docs/#tickers
 * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
 * @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 *btcalpha) 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
        
            retRes3678 := (<-this.LoadMarkets())
            PanicOnError(retRes3678)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "pair": GetValue(market, "id"),
            }
        
            response:= (<-this.PublicGetTicker(this.Extend(request, params)))
            PanicOnError(response)
        
                //
            //    {
            //        "timestamp": "1674658.445272",
            //        "pair": "BTC_USDT",
            //        "last": "22476.85",
            //        "diff": "458.96",
            //        "vol": "6660.847784",
            //        "high": "23106.08",
            //        "low": "22348.29",
            //        "buy": "22508.46",
            //        "sell": "22521.11"
            //    }
            //
        ch <- this.ParseTicker(response, market)
            return nil
        
            }()
            return ch
        }
func  (this *btcalpha) ParseTicker(ticker interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //    {
    //        "timestamp": "1674658.445272",
    //        "pair": "BTC_USDT",
    //        "last": "22476.85",
    //        "diff": "458.96",
    //        "vol": "6660.847784",
    //        "high": "23106.08",
    //        "low": "22348.29",
    //        "buy": "22508.46",
    //        "sell": "22521.11"
    //    }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var timestampStr interface{} = this.SafeString(ticker, "timestamp")
    var timestamp interface{} = ParseInt(Precise.StringMul(timestampStr, "1000000"))
    var marketId interface{} = this.SafeString(ticker, "pair")
    market = this.SafeMarket(marketId, market, "_")
    var last interface{} = this.SafeString(ticker, "last")
    return this.SafeTicker(map[string]interface{} {
        "info": ticker,
        "symbol": GetValue(market, "symbol"),
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "high": this.SafeString(ticker, "high"),
        "low": this.SafeString(ticker, "low"),
        "bid": this.SafeString(ticker, "buy"),
        "bidVolume": nil,
        "ask": this.SafeString(ticker, "sell"),
        "askVolume": nil,
        "vwap": nil,
        "open": nil,
        "close": last,
        "last": last,
        "previousClose": nil,
        "change": this.SafeString(ticker, "diff"),
        "percentage": nil,
        "average": nil,
        "baseVolume": nil,
        "quoteVolume": this.SafeString(ticker, "vol"),
    }, market)
}
/**
 * @method
 * @name btcalpha#fetchOrderBook
 * @see https://btc-alpha.github.io/api-docs/#get-orderbook
 * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
 * @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 *btcalpha) 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
        
            retRes4438 := (<-this.LoadMarkets())
            PanicOnError(retRes4438)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "pair_name": GetValue(market, "id"),
            }
            if IsTrue(limit) {
                AddElementToObject(request, "limit_sell", limit)
                AddElementToObject(request, "limit_buy", limit)
            }
        
            response:= (<-this.PublicGetOrderbookPairName(this.Extend(request, params)))
            PanicOnError(response)
        
            ch <- this.ParseOrderBook(response, GetValue(market, "symbol"), nil, "buy", "sell", "price", "amount")
            return nil
        
            }()
            return ch
        }
func  (this *btcalpha) ParseBidsAsks(bidasks interface{}, optionalArgs ...interface{}) interface{}  {
    priceKey := GetArg(optionalArgs, 0, 0)
    _ = priceKey
    amountKey := GetArg(optionalArgs, 1, 1)
    _ = amountKey
    countOrIdKey := GetArg(optionalArgs, 2, 2)
    _ = countOrIdKey
    var result interface{} = []interface{}{}
    for i := 0; IsLessThan(i, GetArrayLength(bidasks)); i++ {
        var bidask interface{} = GetValue(bidasks, i)
        if IsTrue(bidask) {
            AppendToArray(&result,this.ParseBidAsk(bidask, priceKey, amountKey))
        }
    }
    return result
}
func  (this *btcalpha) ParseTrade(trade interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // fetchTrades (public)
    //
    //      {
    //          "id": "202203440",
    //          "timestamp": "1637856276.264215",
    //          "pair": "AAVE_USDT",
    //          "price": "320.79900000",
    //          "amount": "0.05000000",
    //          "type": "buy"
    //      }
    //
    // fetchMyTrades (private)
    //
    //      {
    //          "id": "202203440",
    //          "timestamp": "1637856276.264215",
    //          "pair": "AAVE_USDT",
    //          "price": "320.79900000",
    //          "amount": "0.05000000",
    //          "type": "buy",
    //          "my_side": "buy"
    //      }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var marketId interface{} = this.SafeString(trade, "pair")
    market = this.SafeMarket(marketId, market, "_")
    var timestampRaw interface{} = this.SafeString(trade, "timestamp")
    var timestamp interface{} = this.ParseToInt(Precise.StringMul(timestampRaw, "1000000"))
    var priceString interface{} = this.SafeString(trade, "price")
    var amountString interface{} = this.SafeString(trade, "amount")
    var id interface{} = this.SafeString(trade, "id")
    var side interface{} = this.SafeString2(trade, "my_side", "type")
    return this.SafeTrade(map[string]interface{} {
        "id": id,
        "info": trade,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "symbol": GetValue(market, "symbol"),
        "order": id,
        "type": "limit",
        "side": side,
        "takerOrMaker": nil,
        "price": priceString,
        "amount": amountString,
        "cost": nil,
        "fee": nil,
    }, market)
}
/**
 * @method
 * @name btcalpha#fetchTrades
 * @description get the list of most recent trades for a particular symbol
 * @see https://btc-alpha.github.io/api-docs/#list-all-exchanges
 * @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 *btcalpha) 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
        
            retRes5298 := (<-this.LoadMarkets())
            PanicOnError(retRes5298)
            var market interface{} = nil
            var request interface{} = map[string]interface{} {}
            if IsTrue(!IsEqual(symbol, nil)) {
                market = this.Market(symbol)
                AddElementToObject(request, "pair", GetValue(market, "id"))
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "limit", limit)
            }
        
            trades:= (<-this.PublicGetExchanges(this.Extend(request, params)))
            PanicOnError(trades)
        
            ch <- this.ParseTrades(trades, market, since, limit)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchDeposits
 * @description fetch all deposits made to an account
 * @see https://btc-alpha.github.io/api-docs/#list-own-deposits
 * @param {string} code unified currency code
 * @param {int} [since] the earliest time in ms to fetch deposits for
 * @param {int} [limit] the maximum number of deposits structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
 */
func  (this *btcalpha) FetchDeposits(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
        
            retRes5558 := (<-this.LoadMarkets())
            PanicOnError(retRes5558)
            var currency interface{} = nil
            if IsTrue(!IsEqual(code, nil)) {
                currency = this.Currency(code)
            }
        
            response:= (<-this.PrivateGetDeposits(params))
            PanicOnError(response)
        
                //
            //     [
            //         {
            //             "timestamp": 1485363039.18359,
            //             "id": 317,
            //             "currency": "BTC",
            //             "amount": 530.00000000
            //         }
            //     ]
            //
        ch <- this.ParseTransactions(response, currency, since, limit, map[string]interface{} {
                "type": "deposit",
            })
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchWithdrawals
 * @description fetch all withdrawals made from an account
 * @see https://btc-alpha.github.io/api-docs/#list-own-made-withdraws
 * @param {string} code unified currency code
 * @param {int} [since] the earliest time in ms to fetch withdrawals for
 * @param {int} [limit] the maximum number of withdrawals structures to retrieve
 * @param {object} [params] extra parameters specific to the exchange API endpoint
 * @returns {object[]} a list of [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
 */
func  (this *btcalpha) FetchWithdrawals(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
        
            retRes5868 := (<-this.LoadMarkets())
            PanicOnError(retRes5868)
            var currency interface{} = nil
            var request interface{} = map[string]interface{} {}
            if IsTrue(!IsEqual(code, nil)) {
                currency = this.Currency(code)
                AddElementToObject(request, "currency_id", GetValue(currency, "id"))
            }
        
            response:= (<-this.PrivateGetWithdraws(this.Extend(request, params)))
            PanicOnError(response)
        
                //
            //     [
            //         {
            //             "id": 403,
            //             "timestamp": 1485363466.868539,
            //             "currency": "BTC",
            //             "amount": 0.53000000,
            //             "status": 20
            //         }
            //     ]
            //
        ch <- this.ParseTransactions(response, currency, since, limit, map[string]interface{} {
                "type": "withdrawal",
            })
            return nil
        
            }()
            return ch
        }
func  (this *btcalpha) ParseTransaction(transaction interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //  deposit
    //      {
    //          "timestamp": 1485363039.18359,
    //          "id": 317,
    //          "currency": "BTC",
    //          "amount": 530.00000000
    //      }
    //
    //  withdrawal
    //      {
    //          "id": 403,
    //          "timestamp": 1485363466.868539,
    //          "currency": "BTC",
    //          "amount": 0.53000000,
    //          "status": 20
    //      }
    //
    currency := GetArg(optionalArgs, 0, nil)
    _ = currency
    var timestamp interface{} = this.SafeTimestamp(transaction, "timestamp")
    var currencyId interface{} = this.SafeString(transaction, "currency")
    var statusId interface{} = this.SafeString(transaction, "status")
    return map[string]interface{} {
        "id": this.SafeString(transaction, "id"),
        "info": transaction,
        "timestamp": timestamp,
        "datetime": this.Iso8601(timestamp),
        "network": nil,
        "address": nil,
        "addressTo": nil,
        "addressFrom": nil,
        "tag": nil,
        "tagTo": nil,
        "tagFrom": nil,
        "currency": this.SafeCurrencyCode(currencyId, currency),
        "amount": this.SafeNumber(transaction, "amount"),
        "txid": nil,
        "type": nil,
        "status": this.ParseTransactionStatus(statusId),
        "comment": nil,
        "internal": nil,
        "fee": nil,
        "updated": nil,
    }
}
func  (this *btcalpha) ParseTransactionStatus(status interface{}) interface{}  {
    var statuses interface{} = map[string]interface{} {
        "10": "pending",
        "20": "pending",
        "30": "ok",
        "40": "failed",
        "50": "canceled",
    }
    return this.SafeString(statuses, status, status)
}
func  (this *btcalpha) ParseOHLCV(ohlcv interface{}, optionalArgs ...interface{}) interface{}  {
    //
    //     {
    //         "time":1591296000,
    //         "open":0.024746,
    //         "close":0.024728,
    //         "low":0.024728,
    //         "high":0.024753,
    //         "volume":16.624
    //     }
    //
    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 btcalpha#fetchOHLCV
 * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 * @see https://btc-alpha.github.io/api-docs/#charts
 * @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
 * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
 */
func  (this *btcalpha) FetchOHLCV(symbol interface{}, optionalArgs ...interface{}) <- chan interface{} {
            ch := make(chan interface{})
            go func() interface{} {
                defer close(ch)
                defer ReturnPanicError(ch)
                    timeframe := GetArg(optionalArgs, 0, "5m")
            _ = timeframe
            since := GetArg(optionalArgs, 1, nil)
            _ = since
            limit := GetArg(optionalArgs, 2, nil)
            _ = limit
            params := GetArg(optionalArgs, 3, map[string]interface{} {})
            _ = params
        
            retRes6998 := (<-this.LoadMarkets())
            PanicOnError(retRes6998)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "pair": GetValue(market, "id"),
                "type": this.SafeString(this.Timeframes, timeframe, timeframe),
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "limit", limit)
            }
            if IsTrue(!IsEqual(since, nil)) {
                AddElementToObject(request, "since", this.ParseToInt(Divide(since, 1000)))
            }
        
            response:= (<-this.PublicGetChartsPairTypeChart(this.Extend(request, params)))
            PanicOnError(response)
        
                //
            //     [
            //         {"time":1591296000,"open":0.024746,"close":0.024728,"low":0.024728,"high":0.024753,"volume":16.624},
            //         {"time":1591295700,"open":0.024718,"close":0.02475,"low":0.024711,"high":0.02475,"volume":31.645},
            //         {"time":1591295400,"open":0.024721,"close":0.024717,"low":0.024711,"high":0.02473,"volume":65.071}
            //     ]
            //
        ch <- this.ParseOHLCVs(response, market, timeframe, since, limit)
            return nil
        
            }()
            return ch
        }
func  (this *btcalpha) ParseBalance(response interface{}) interface{}  {
    var result interface{} = map[string]interface{} {
        "info": response,
    }
    for i := 0; IsLessThan(i, GetArrayLength(response)); i++ {
        var balance interface{} = GetValue(response, i)
        var currencyId interface{} = this.SafeString(balance, "currency")
        var code interface{} = this.SafeCurrencyCode(currencyId)
        var account interface{} = this.Account()
        AddElementToObject(account, "used", this.SafeString(balance, "reserve"))
        AddElementToObject(account, "total", this.SafeString(balance, "balance"))
        AddElementToObject(result, code, account)
    }
    return this.SafeBalance(result)
}
/**
 * @method
 * @name btcalpha#fetchBalance
 * @description query for balance and get the amount of funds available for trading or funds locked in orders
 * @see https://btc-alpha.github.io/api-docs/#list-own-wallets
 * @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 *btcalpha) 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
        
            retRes7458 := (<-this.LoadMarkets())
            PanicOnError(retRes7458)
        
            response:= (<-this.PrivateGetWallets(params))
            PanicOnError(response)
        
            ch <- this.ParseBalance(response)
            return nil
        
            }()
            return ch
        }
func  (this *btcalpha) ParseOrderStatus(status interface{}) interface{}  {
    var statuses interface{} = map[string]interface{} {
        "1": "open",
        "2": "canceled",
        "3": "closed",
    }
    return this.SafeString(statuses, status, status)
}
func  (this *btcalpha) ParseOrder(order interface{}, optionalArgs ...interface{}) interface{}  {
    //
    // fetchClosedOrders / fetchOrder
    //     {
    //       "id": "923763073",
    //       "date": "1635451090368",
    //       "type": "sell",
    //       "pair": "XRP_USDT",
    //       "price": "1.00000000",
    //       "amount": "0.00000000",
    //       "status": "3",
    //       "amount_filled": "10.00000000",
    //       "amount_original": "10.0"
    //       "trades": [],
    //     }
    //
    // createOrder
    //     {
    //       "success": true,
    //       "date": "1635451754.497541",
    //       "type": "sell",
    //       "oid": "923776755",
    //       "price": "1.0",
    //       "amount": "10.0",
    //       "amount_filled": "0.0",
    //       "amount_original": "10.0",
    //       "trades": []
    //     }
    //
    market := GetArg(optionalArgs, 0, nil)
    _ = market
    var marketId interface{} = this.SafeString(order, "pair")
    market = this.SafeMarket(marketId, market, "_")
    var symbol interface{} = GetValue(market, "symbol")
    var success interface{} = this.SafeBool(order, "success", false)
    var timestamp interface{} = nil
    if IsTrue(success) {
        timestamp = this.SafeTimestamp(order, "date")
    } else {
        timestamp = this.SafeInteger(order, "date")
    }
    var price interface{} = this.SafeString(order, "price")
    var remaining interface{} = this.SafeString(order, "amount")
    var filled interface{} = this.SafeString(order, "amount_filled")
    var amount interface{} = this.SafeString(order, "amount_original")
    var status interface{} = this.ParseOrderStatus(this.SafeString(order, "status"))
    var id interface{} = this.SafeStringN(order, []interface{}{"oid", "id", "order"})
    var trades interface{} = this.SafeValue(order, "trades")
    var side interface{} = this.SafeString2(order, "my_side", "type")
    return this.SafeOrder(map[string]interface{} {
        "id": id,
        "clientOrderId": nil,
        "datetime": this.Iso8601(timestamp),
        "timestamp": timestamp,
        "status": status,
        "symbol": symbol,
        "type": "limit",
        "timeInForce": nil,
        "postOnly": nil,
        "side": side,
        "price": price,
        "triggerPrice": nil,
        "cost": nil,
        "amount": amount,
        "filled": filled,
        "remaining": remaining,
        "trades": trades,
        "fee": nil,
        "info": order,
        "lastTradeTimestamp": nil,
        "average": nil,
    }, market)
}
/**
 * @method
 * @name btcalpha#createOrder
 * @see https://btc-alpha.github.io/api-docs/#create-order
 * @description create a trade order
 * @param {string} symbol unified symbol of the market to create an order in
 * @param {string} type '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
 * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
 */
func  (this *btcalpha) 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
            if IsTrue(IsEqual(typeVar, "market")) {
                panic(InvalidOrder(Add(this.Id, " only limits orders are supported")))
            }
        
            retRes8488 := (<-this.LoadMarkets())
            PanicOnError(retRes8488)
            var market interface{} = this.Market(symbol)
            var request interface{} = map[string]interface{} {
                "pair": GetValue(market, "id"),
                "type": side,
                "amount": amount,
                "price": this.PriceToPrecision(symbol, price),
            }
        
            response:= (<-this.PrivatePostOrder(this.Extend(request, params)))
            PanicOnError(response)
            if !IsTrue(GetValue(response, "success")) {
                panic(InvalidOrder(Add(Add(this.Id, " "), this.Json(response))))
            }
            var order interface{} = this.ParseOrder(response, market)
            var orderAmount interface{} = ToString(GetValue(order, "amount"))
            amount = Ternary(IsTrue(Precise.StringGt(orderAmount, "0")), GetValue(order, "amount"), amount)
            AddElementToObject(order, "amount", this.ParseNumber(amount))
        
            ch <- order
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#cancelOrder
 * @see https://btc-alpha.github.io/api-docs/#cancel-order
 * @description cancels an open 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 *btcalpha) 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
            var request interface{} = map[string]interface{} {
                "order": id,
            }
        
            response:= (<-this.PrivatePostOrderCancel(this.Extend(request, params)))
            PanicOnError(response)
        
                //
            //    {
            //        "order": 63568
            //    }
            //
        ch <- this.ParseOrder(response)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchOrder
 * @see https://btc-alpha.github.io/api-docs/#retrieve-single-order
 * @description fetches information on an order made by the user
 * @param {string} id the order id
 * @param {string} symbol not used by btcalpha fetchOrder
 * @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 *btcalpha) FetchOrder(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
        
            retRes9018 := (<-this.LoadMarkets())
            PanicOnError(retRes9018)
            var request interface{} = map[string]interface{} {
                "id": id,
            }
        
            order:= (<-this.PrivateGetOrderId(this.Extend(request, params)))
            PanicOnError(order)
        
            ch <- this.ParseOrder(order)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchOrders
 * @see https://btc-alpha.github.io/api-docs/#list-own-orders
 * @description fetches information on multiple orders made by the user
 * @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 *btcalpha) FetchOrders(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
        
            retRes9218 := (<-this.LoadMarkets())
            PanicOnError(retRes9218)
            var request interface{} = map[string]interface{} {}
            var market interface{} = nil
            if IsTrue(!IsEqual(symbol, nil)) {
                market = this.Market(symbol)
                AddElementToObject(request, "pair", GetValue(market, "id"))
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "limit", limit)
            }
        
            orders:= (<-this.PrivateGetOrdersOwn(this.Extend(request, params)))
            PanicOnError(orders)
        
            ch <- this.ParseOrders(orders, market, since, limit)
            return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchOpenOrders
 * @description fetch all unfilled currently open orders
 * @see https://btc-alpha.github.io/api-docs/#list-own-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 orders 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 *btcalpha) 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
            var request interface{} = map[string]interface{} {
                "status": "1",
            }
        
                retRes95015 :=  (<-this.FetchOrders(symbol, since, limit, this.Extend(request, params)))
                PanicOnError(retRes95015)
                ch <- retRes95015
                return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchClosedOrders
 * @description fetches information on multiple closed orders made by the user
 * @see https://btc-alpha.github.io/api-docs/#list-own-orders
 * @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 *btcalpha) 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
            var request interface{} = map[string]interface{} {
                "status": "3",
            }
        
                retRes96815 :=  (<-this.FetchOrders(symbol, since, limit, this.Extend(request, params)))
                PanicOnError(retRes96815)
                ch <- retRes96815
                return nil
        
            }()
            return ch
        }
/**
 * @method
 * @name btcalpha#fetchMyTrades
 * @description fetch all trades made by the user
 * @see https://btc-alpha.github.io/api-docs/#list-own-exchanges
 * @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 *btcalpha) 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
        
            retRes9838 := (<-this.LoadMarkets())
            PanicOnError(retRes9838)
            var request interface{} = map[string]interface{} {}
            if IsTrue(!IsEqual(symbol, nil)) {
                var market interface{} = this.Market(symbol)
                AddElementToObject(request, "pair", GetValue(market, "id"))
            }
            if IsTrue(!IsEqual(limit, nil)) {
                AddElementToObject(request, "limit", limit)
            }
        
            trades:= (<-this.PrivateGetExchangesOwn(this.Extend(request, params)))
            PanicOnError(trades)
        
            ch <- this.ParseTrades(trades, nil, since, limit)
            return nil
        
            }()
            return ch
        }
func  (this *btcalpha) Nonce() interface{}  {
    return this.Milliseconds()
}
func  (this *btcalpha) 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 query interface{} = this.Urlencode(this.Keysort(this.Omit(params, this.ExtractParams(path))))
    var url interface{} = Add(GetValue(GetValue(this.Urls, "api"), "rest"), "/")
    if IsTrue(!IsEqual(path, "charts/{pair}/{type}/chart/")) {
        url = Add(url, "v1/")
    }
    url = Add(url, this.ImplodeParams(path, params))
    headers = map[string]interface{} {
        "Accept": "application/json",
    }
    if IsTrue(IsEqual(api, "public")) {
        if IsTrue(GetArrayLength(query)) {
            url = Add(url, Add("?", query))
        }
    } else {
        this.CheckRequiredCredentials()
        var payload interface{} = this.ApiKey
        if IsTrue(IsEqual(method, "POST")) {
            AddElementToObject(headers, "Content-Type", "application/x-www-form-urlencoded")
            body = query
            payload = Add(payload, body)
        } else if IsTrue(GetArrayLength(query)) {
            url = Add(url, Add("?", query))
        }
        AddElementToObject(headers, "X-KEY", this.ApiKey)
        AddElementToObject(headers, "X-SIGN", this.Hmac(this.Encode(payload), this.Encode(this.Secret), sha256))
        AddElementToObject(headers, "X-NONCE", ToString(this.Nonce()))
    }
    return map[string]interface{} {
        "url": url,
        "method": method,
        "body": body,
        "headers": headers,
    }
}
func  (this *btcalpha) 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  // fallback to default error handler
    }
    //
    //     {"date":1570599531.4814300537,"error":"Out of balance -9.99243661 BTC"}
    //
    var error interface{} = this.SafeString(response, "error")
    if IsTrue(!IsEqual(error, nil)) {
        var feedback interface{} = Add(Add(this.Id, " "), body)
        this.ThrowExactlyMatchedException(GetValue(this.Exceptions, "exact"), error, feedback)
        this.ThrowBroadlyMatchedException(GetValue(this.Exceptions, "broad"), error, feedback)
        panic(ExchangeError(feedback))
    }
    return nil
}


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