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

// 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 *wavesexchange) MatcherGetMatcher (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 ("matcherGetMatcher", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherSettings (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 ("matcherGetMatcherSettings", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherSettingsRates (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 ("matcherGetMatcherSettingsRates", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherBalanceReservedPublicKey (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 ("matcherGetMatcherBalanceReservedPublicKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugAllSnashotOffsets (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 ("matcherGetMatcherDebugAllSnashotOffsets", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugCurrentOffset (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 ("matcherGetMatcherDebugCurrentOffset", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugLastOffset (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 ("matcherGetMatcherDebugLastOffset", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugOldestSnapshotOffset (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 ("matcherGetMatcherDebugOldestSnapshotOffset", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugConfig (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 ("matcherGetMatcherDebugConfig", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugAddressAddress (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 ("matcherGetMatcherDebugAddressAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugStatus (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 ("matcherGetMatcherDebugStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherDebugAddressAddressCheck (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 ("matcherGetMatcherDebugAddressAddressCheck", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbook (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 ("matcherGetMatcherOrderbook", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookBaseIdQuoteId (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 ("matcherGetMatcherOrderbookBaseIdQuoteId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookBaseIdQuoteIdPublicKeyPublicKey (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 ("matcherGetMatcherOrderbookBaseIdQuoteIdPublicKeyPublicKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookBaseIdQuoteIdOrderId (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 ("matcherGetMatcherOrderbookBaseIdQuoteIdOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookBaseIdQuoteIdInfo (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 ("matcherGetMatcherOrderbookBaseIdQuoteIdInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookBaseIdQuoteIdStatus (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 ("matcherGetMatcherOrderbookBaseIdQuoteIdStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookBaseIdQuoteIdTradableBalanceAddress (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 ("matcherGetMatcherOrderbookBaseIdQuoteIdTradableBalanceAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookPublicKey (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 ("matcherGetMatcherOrderbookPublicKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrderbookPublicKeyOrderId (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 ("matcherGetMatcherOrderbookPublicKeyOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrdersAddress (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 ("matcherGetMatcherOrdersAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherOrdersAddressOrderId (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 ("matcherGetMatcherOrdersAddressOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetMatcherTransactionsOrderId (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 ("matcherGetMatcherTransactionsOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherGetApiV1OrderbookBaseIdQuoteId (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 ("matcherGetApiV1OrderbookBaseIdQuoteId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrderbook (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 ("matcherPostMatcherOrderbook", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrderbookMarket (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 ("matcherPostMatcherOrderbookMarket", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrderbookCancel (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 ("matcherPostMatcherOrderbookCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrderbookBaseIdQuoteIdCancel (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 ("matcherPostMatcherOrderbookBaseIdQuoteIdCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrderbookBaseIdQuoteIdCalculateFee (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 ("matcherPostMatcherOrderbookBaseIdQuoteIdCalculateFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrderbookBaseIdQuoteIdDelete (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 ("matcherPostMatcherOrderbookBaseIdQuoteIdDelete", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrderbookBaseIdQuoteIdCancelAll (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 ("matcherPostMatcherOrderbookBaseIdQuoteIdCancelAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherDebugSaveSnapshots (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 ("matcherPostMatcherDebugSaveSnapshots", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrdersAddressCancel (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 ("matcherPostMatcherOrdersAddressCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrdersCancelOrderId (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 ("matcherPostMatcherOrdersCancelOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPostMatcherOrdersSerialize (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 ("matcherPostMatcherOrdersSerialize", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherDeleteMatcherOrderbookBaseIdQuoteId (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 ("matcherDeleteMatcherOrderbookBaseIdQuoteId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherDeleteMatcherSettingsRatesAssetId (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 ("matcherDeleteMatcherSettingsRatesAssetId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MatcherPutMatcherSettingsRatesAssetId (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 ("matcherPutMatcherSettingsRatesAssetId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddresses (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 ("nodeGetAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesBalanceAddress (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 ("nodeGetAddressesBalanceAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesBalanceAddressConfirmations (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 ("nodeGetAddressesBalanceAddressConfirmations", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesBalanceDetailsAddress (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 ("nodeGetAddressesBalanceDetailsAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesDataAddress (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 ("nodeGetAddressesDataAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesDataAddressKey (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 ("nodeGetAddressesDataAddressKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesEffectiveBalanceAddress (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 ("nodeGetAddressesEffectiveBalanceAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesEffectiveBalanceAddressConfirmations (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 ("nodeGetAddressesEffectiveBalanceAddressConfirmations", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesPublicKeyPublicKey (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 ("nodeGetAddressesPublicKeyPublicKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesScriptInfoAddress (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 ("nodeGetAddressesScriptInfoAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesScriptInfoAddressMeta (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 ("nodeGetAddressesScriptInfoAddressMeta", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesSeedAddress (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 ("nodeGetAddressesSeedAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesSeqFromTo (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 ("nodeGetAddressesSeqFromTo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAddressesValidateAddress (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 ("nodeGetAddressesValidateAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAliasByAddressAddress (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 ("nodeGetAliasByAddressAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAliasByAliasAlias (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 ("nodeGetAliasByAliasAlias", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAssetsAssetIdDistributionHeightLimit (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 ("nodeGetAssetsAssetIdDistributionHeightLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAssetsBalanceAddress (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 ("nodeGetAssetsBalanceAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAssetsBalanceAddressAssetId (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 ("nodeGetAssetsBalanceAddressAssetId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAssetsDetailsAssetId (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 ("nodeGetAssetsDetailsAssetId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetAssetsNftAddressLimitLimit (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 ("nodeGetAssetsNftAddressLimitLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlockchainRewards (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 ("nodeGetBlockchainRewards", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlockchainRewardsHeight (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 ("nodeGetBlockchainRewardsHeight", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksAddressAddressFromTo (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 ("nodeGetBlocksAddressAddressFromTo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksAtHeight (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 ("nodeGetBlocksAtHeight", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksDelaySignatureBlockNum (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 ("nodeGetBlocksDelaySignatureBlockNum", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksFirst (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 ("nodeGetBlocksFirst", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksHeadersLast (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 ("nodeGetBlocksHeadersLast", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksHeadersSeqFromTo (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 ("nodeGetBlocksHeadersSeqFromTo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksHeight (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 ("nodeGetBlocksHeight", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksHeightSignature (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 ("nodeGetBlocksHeightSignature", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksLast (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 ("nodeGetBlocksLast", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksSeqFromTo (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 ("nodeGetBlocksSeqFromTo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetBlocksSignatureSignature (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 ("nodeGetBlocksSignatureSignature", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetConsensusAlgo (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 ("nodeGetConsensusAlgo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetConsensusBasetarget (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 ("nodeGetConsensusBasetarget", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetConsensusBasetargetBlockId (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 ("nodeGetConsensusBasetargetBlockId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetConsensusGeneratingbalanceAddress (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 ("nodeGetConsensusGeneratingbalanceAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetConsensusGenerationsignature (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 ("nodeGetConsensusGenerationsignature", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetConsensusGenerationsignatureBlockId (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 ("nodeGetConsensusGenerationsignatureBlockId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugBalancesHistoryAddress (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 ("nodeGetDebugBalancesHistoryAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugBlocksHowMany (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 ("nodeGetDebugBlocksHowMany", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugConfigInfo (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 ("nodeGetDebugConfigInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugHistoryInfo (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 ("nodeGetDebugHistoryInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugInfo (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 ("nodeGetDebugInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugMinerInfo (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 ("nodeGetDebugMinerInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugPortfoliosAddress (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 ("nodeGetDebugPortfoliosAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugState (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 ("nodeGetDebugState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugStateChangesAddressAddress (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 ("nodeGetDebugStateChangesAddressAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugStateChangesInfoId (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 ("nodeGetDebugStateChangesInfoId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetDebugStateWavesHeight (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 ("nodeGetDebugStateWavesHeight", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetLeasingActiveAddress (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 ("nodeGetLeasingActiveAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetNodeState (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 ("nodeGetNodeState", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetNodeVersion (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 ("nodeGetNodeVersion", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetPeersAll (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 ("nodeGetPeersAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetPeersBlacklisted (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 ("nodeGetPeersBlacklisted", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetPeersConnected (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 ("nodeGetPeersConnected", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetPeersSuspended (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 ("nodeGetPeersSuspended", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetTransactionsAddressAddressLimitLimit (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 ("nodeGetTransactionsAddressAddressLimitLimit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetTransactionsInfoId (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 ("nodeGetTransactionsInfoId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetTransactionsStatus (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 ("nodeGetTransactionsStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetTransactionsUnconfirmed (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 ("nodeGetTransactionsUnconfirmed", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetTransactionsUnconfirmedInfoId (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 ("nodeGetTransactionsUnconfirmedInfoId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetTransactionsUnconfirmedSize (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 ("nodeGetTransactionsUnconfirmedSize", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetUtilsSeed (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 ("nodeGetUtilsSeed", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetUtilsSeedLength (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 ("nodeGetUtilsSeedLength", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetUtilsTime (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 ("nodeGetUtilsTime", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeGetWalletSeed (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 ("nodeGetWalletSeed", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostAddresses (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 ("nodePostAddresses", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostAddressesDataAddress (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 ("nodePostAddressesDataAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostAddressesSignAddress (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 ("nodePostAddressesSignAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostAddressesSignTextAddress (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 ("nodePostAddressesSignTextAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostAddressesVerifyAddress (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 ("nodePostAddressesVerifyAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostAddressesVerifyTextAddress (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 ("nodePostAddressesVerifyTextAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostDebugBlacklist (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 ("nodePostDebugBlacklist", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostDebugPrint (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 ("nodePostDebugPrint", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostDebugRollback (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 ("nodePostDebugRollback", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostDebugValidate (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 ("nodePostDebugValidate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostNodeStop (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 ("nodePostNodeStop", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostPeersClearblacklist (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 ("nodePostPeersClearblacklist", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostPeersConnect (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 ("nodePostPeersConnect", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostTransactionsBroadcast (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 ("nodePostTransactionsBroadcast", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostTransactionsCalculateFee (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 ("nodePostTransactionsCalculateFee", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostTranasctionsSign (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 ("nodePostTranasctionsSign", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostTransactionsSignSignerAddress (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 ("nodePostTransactionsSignSignerAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostTranasctionsStatus (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 ("nodePostTranasctionsStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsHashFast (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 ("nodePostUtilsHashFast", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsHashSecure (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 ("nodePostUtilsHashSecure", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsScriptCompileCode (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 ("nodePostUtilsScriptCompileCode", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsScriptCompileWithImports (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 ("nodePostUtilsScriptCompileWithImports", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsScriptDecompile (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 ("nodePostUtilsScriptDecompile", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsScriptEstimate (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 ("nodePostUtilsScriptEstimate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsSignPrivateKey (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 ("nodePostUtilsSignPrivateKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodePostUtilsTransactionsSerialize (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 ("nodePostUtilsTransactionsSerialize", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeDeleteAddressesAddress (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 ("nodeDeleteAddressesAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) NodeDeleteDebugRollbackToSignature (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 ("nodeDeleteDebugRollbackToSignature", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PublicGetAssets (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 ("publicGetAssets", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PublicGetPairs (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 ("publicGetPairs", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PublicGetCandlesBaseIdQuoteId (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 ("publicGetCandlesBaseIdQuoteId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PublicGetTransactionsExchange (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 ("publicGetTransactionsExchange", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PrivateGetDepositAddressesCurrency (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 ("privateGetDepositAddressesCurrency", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PrivateGetDepositAddressesCurrencyPlatform (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 ("privateGetDepositAddressesCurrencyPlatform", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PrivateGetPlatforms (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 ("privateGetPlatforms", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PrivateGetDepositCurrencies (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 ("privateGetDepositCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PrivateGetWithdrawCurrencies (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 ("privateGetWithdrawCurrencies", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PrivateGetWithdrawAddressesCurrencyAddress (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 ("privateGetWithdrawAddressesCurrencyAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) PrivatePostOauth2Token (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 ("privatePostOauth2Token", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) ForwardGetMatcherOrdersAddress (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 ("forwardGetMatcherOrdersAddress", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) ForwardGetMatcherOrdersAddressOrderId (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 ("forwardGetMatcherOrdersAddressOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) ForwardPostMatcherOrdersWavesAddressCancel (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 ("forwardPostMatcherOrdersWavesAddressCancel", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *wavesexchange) MarketGetTickers (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 ("marketGetTickers", parameters))
       PanicOnError(ch)
   }()
   return ch
}