// -------------------------------------------------------------------------------

// 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

// -------------------------------------------------------------------------------

package ccxt

func (this *coinmate) PublicGetOrderBook (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetOrderBook", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PublicGetTicker (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetTicker", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PublicGetTickerAll (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetTickerAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PublicGetProducts (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetProducts", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PublicGetTransactions (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetTransactions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PublicGetTradingPairs (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("publicGetTradingPairs", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBalances (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBalances", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBitcoinCashWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBitcoinCashWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBitcoinCashDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBitcoinCashDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBitcoinDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBitcoinDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBitcoinWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBitcoinWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBitcoinWithdrawalFees (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBitcoinWithdrawalFees", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBuyInstant (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBuyInstant", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostBuyLimit (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostBuyLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostCancelOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostCancelOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostCancelOrderWithInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostCancelOrderWithInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostCreateVoucher (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostCreateVoucher", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostDashDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostDashDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostDashWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostDashWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostEthereumWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostEthereumWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostEthereumDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostEthereumDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostLitecoinWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostLitecoinWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostLitecoinDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostLitecoinDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostOpenOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostOrderHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostOrderHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostOrderById (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostOrderById", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostPusherAuth (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostPusherAuth", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostRedeemVoucher (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostRedeemVoucher", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostReplaceByBuyLimit (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostReplaceByBuyLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostReplaceByBuyInstant (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostReplaceByBuyInstant", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostReplaceBySellLimit (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostReplaceBySellLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostReplaceBySellInstant (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostReplaceBySellInstant", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostRippleDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostRippleDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostRippleWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostRippleWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostSellInstant (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSellInstant", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostSellLimit (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSellLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostTransactionHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostTransactionHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostTraderFees (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostTraderFees", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostTradeHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostTradeHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostTransfer (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostTransfer", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostTransferHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostTransferHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedBitcoinDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedBitcoinDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedBitcoinCashDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedBitcoinCashDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedDashDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedDashDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedEthereumDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedEthereumDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedLitecoinDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedLitecoinDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedRippleDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedRippleDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostCancelAllOpenOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostCancelAllOpenOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostWithdrawVirtualCurrency (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostWithdrawVirtualCurrency", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostVirtualCurrencyDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostVirtualCurrencyDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedVirtualCurrencyDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedVirtualCurrencyDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostAdaWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAdaWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostAdaDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostAdaDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedAdaDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedAdaDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostSolWithdrawal (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSolWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostSolDepositAddresses (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostSolDepositAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *coinmate) PrivatePostUnconfirmedSolDeposits (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("privatePostUnconfirmedSolDeposits", parameters))
       PanicOnError(ch)
   }()
   return ch
}