Withdraw additional functionality (validation/submission/tracking) (#409)

* reworked request struct and exchange response started work on validation system

* removed import cycle until work around

* Added intial withdraw support via CLI added

* Added Crypto command to gctcli

* moved var declartion to single line

* Test updates for binance and anx

* All exchange tests have been updated test coverage added to validate

* First pass at adding withdrawl select from database

* started adding basic lru cache system

* Added basic LRU cache including Add Get Remove Contains ContainsOrAdd Clear

* wording changes on comments

* removed exported var's in strut as they are not required

* Added README

* README updates

* corrected ID on commands

* rm line :D

* merged in origin/cache

* linter fixes (gofmt)

* Added basic cache lookup to events

* swapped to mutex over rwmutex updated comments

* unexported getNewest & getOldest

* unexported getNewest & getOldest

* Updated comments and cited references in source

* updated comments

* WIP

* Migrated exchange WithdrawFiat wrapper to new struct response

* Migrated exchange WithdrawFiat wrapper to new struct response

* started work on bank management

* Added exchange level banking details back with migration to banking package

* Removed broken tests for now

* Added validation to bank accounts

* removed duplicate bank details from withdraw struct

* Test coverage increased

* gofmt

* merged upstream/master with clean up

* First pass at adding command line linking to gctcli

* added validation for crypto address, added gctcli support to retreive previous withdrawal requests

* general cleanup

* general cleanup

* reordered imports

* Increased test coverage moved to database sublogger

* Pass incorrect currency no longer return error from c.CheckBankAccountConfig

* remove TestMain() for now as other tests in this package will need to be reworked

* Happy little race car

* Reverted to upstream tests

* Added test covarege for validation method, corrected response on cli protobuf

* query clean up and removal of duplicated code

* cleaned up queries into singlem ethod increased test coverage

* Migrated international fund withdraw to new exchange response and added cache size override

* Migrated international fund withdraw to new exchange response and added cache size override

* Extended gctcli commands

* lowered default cache to 25

* small code clean up

* added get by date method

* add returned error

* cli commands cleaing return error on nil results to fix out of bounds

* merged write & read helpers into one for test coverage and increased engine/withdraw test coverage

* gofmt

* Added test coverage for valid ID

* removed unused param

* converted to use timestamp package from protobuf

* gofmt

* use built in RFC3339 timestamp

* remove setting of CreatedAt & UpdatedAt and allow ORm to take care of it

* also use ptype on byid

* code flow improvements

* remove inverse conditional check and linters run

* removed test data

* removed comment

* removed comment

* also write failures to database for auditing

* converted to use default time for start & end

* Default to time.Now() minus 30 days

* Default to time.Now() minus 30 days

* small code clean up

* fixed missing semicolon on migrations, code clean up

* updated sqlite migrations

* Added additonal check for exchange level bank account if global is not found

* case sensativity fix for currency names

* use correct compare

* test coverage fixed

* removed space

* return pointer to banking.Account

* return pointer to banking.Account

* added else check back to validate()

* Added empty string as default to migration over NULL due to retrivial of data
This commit is contained in:
Andrew
2020-02-26 15:45:13 +11:00
committed by GitHub
parent def3cdf226
commit b26ec86d43
122 changed files with 18066 additions and 2029 deletions

File diff suppressed because it is too large Load Diff

View File

@@ -1069,42 +1069,8 @@ func local_request_GoCryptoTrader_GetCryptocurrencyDepositAddress_0(ctx context.
}
func request_GoCryptoTrader_WithdrawCryptocurrencyFunds_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawCurrencyRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.WithdrawCryptocurrencyFunds(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_GoCryptoTrader_WithdrawCryptocurrencyFunds_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawCurrencyRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.WithdrawCryptocurrencyFunds(ctx, &protoReq)
return msg, metadata, err
}
func request_GoCryptoTrader_WithdrawFiatFunds_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawCurrencyRequest
var protoReq WithdrawFiatRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
@@ -1121,7 +1087,7 @@ func request_GoCryptoTrader_WithdrawFiatFunds_0(ctx context.Context, marshaler r
}
func local_request_GoCryptoTrader_WithdrawFiatFunds_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawCurrencyRequest
var protoReq WithdrawFiatRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
@@ -1137,6 +1103,142 @@ func local_request_GoCryptoTrader_WithdrawFiatFunds_0(ctx context.Context, marsh
}
func request_GoCryptoTrader_WithdrawCryptocurrencyFunds_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawCryptoRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.WithdrawCryptocurrencyFunds(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_GoCryptoTrader_WithdrawCryptocurrencyFunds_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawCryptoRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.WithdrawCryptocurrencyFunds(ctx, &protoReq)
return msg, metadata, err
}
func request_GoCryptoTrader_WithdrawalEventByID_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawalEventByIDRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.WithdrawalEventByID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_GoCryptoTrader_WithdrawalEventByID_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawalEventByIDRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.WithdrawalEventByID(ctx, &protoReq)
return msg, metadata, err
}
func request_GoCryptoTrader_WithdrawalEventsByExchange_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawalEventsByExchangeRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.WithdrawalEventsByExchange(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_GoCryptoTrader_WithdrawalEventsByExchange_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawalEventsByExchangeRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.WithdrawalEventsByExchange(ctx, &protoReq)
return msg, metadata, err
}
func request_GoCryptoTrader_WithdrawalEventsByDate_0(ctx context.Context, marshaler runtime.Marshaler, client GoCryptoTraderClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawalEventsByDateRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.WithdrawalEventsByDate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_GoCryptoTrader_WithdrawalEventsByDate_0(ctx context.Context, marshaler runtime.Marshaler, server GoCryptoTraderServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq WithdrawalEventsByDateRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.WithdrawalEventsByDate(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_GoCryptoTrader_GetLoggerDetails_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
@@ -2504,6 +2606,26 @@ func RegisterGoCryptoTraderHandlerServer(ctx context.Context, mux *runtime.Serve
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawFiatFunds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_GoCryptoTrader_WithdrawFiatFunds_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawFiatFunds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawCryptocurrencyFunds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@@ -2524,7 +2646,7 @@ func RegisterGoCryptoTraderHandlerServer(ctx context.Context, mux *runtime.Serve
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawFiatFunds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawalEventByID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
@@ -2533,14 +2655,54 @@ func RegisterGoCryptoTraderHandlerServer(ctx context.Context, mux *runtime.Serve
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_GoCryptoTrader_WithdrawFiatFunds_0(rctx, inboundMarshaler, server, req, pathParams)
resp, md, err := local_request_GoCryptoTrader_WithdrawalEventByID_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawFiatFunds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
forward_GoCryptoTrader_WithdrawalEventByID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawalEventsByExchange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_GoCryptoTrader_WithdrawalEventsByExchange_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawalEventsByExchange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawalEventsByDate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_GoCryptoTrader_WithdrawalEventsByDate_0(rctx, inboundMarshaler, server, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawalEventsByDate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
@@ -3673,6 +3835,26 @@ func RegisterGoCryptoTraderHandlerClient(ctx context.Context, mux *runtime.Serve
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawFiatFunds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_GoCryptoTrader_WithdrawFiatFunds_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawFiatFunds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawCryptocurrencyFunds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@@ -3693,7 +3875,7 @@ func RegisterGoCryptoTraderHandlerClient(ctx context.Context, mux *runtime.Serve
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawFiatFunds_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawalEventByID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
@@ -3702,14 +3884,54 @@ func RegisterGoCryptoTraderHandlerClient(ctx context.Context, mux *runtime.Serve
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_GoCryptoTrader_WithdrawFiatFunds_0(rctx, inboundMarshaler, client, req, pathParams)
resp, md, err := request_GoCryptoTrader_WithdrawalEventByID_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawFiatFunds_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
forward_GoCryptoTrader_WithdrawalEventByID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawalEventsByExchange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_GoCryptoTrader_WithdrawalEventsByExchange_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawalEventsByExchange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_GoCryptoTrader_WithdrawalEventsByDate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_GoCryptoTrader_WithdrawalEventsByDate_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_GoCryptoTrader_WithdrawalEventsByDate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
@@ -4191,10 +4413,16 @@ var (
pattern_GoCryptoTrader_GetCryptocurrencyDepositAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getcryptodepositaddress"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_WithdrawCryptocurrencyFunds_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "withdrawcryptofunds"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_WithdrawFiatFunds_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "withdrawfiatfunds"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_WithdrawCryptocurrencyFunds_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "withdrawithdrawcryptofundswfiatfunds"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_WithdrawalEventByID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "withdrawaleventbyid"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_WithdrawalEventsByExchange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "withdrawaleventbyid"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_WithdrawalEventsByDate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "withdrawaleventbydate"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_GetLoggerDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "getloggerdetails"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_GoCryptoTrader_SetLoggerDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "setloggerdetails"}, "", runtime.AssumeColonVerbOpt(true)))
@@ -4311,9 +4539,15 @@ var (
forward_GoCryptoTrader_GetCryptocurrencyDepositAddress_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_WithdrawFiatFunds_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_WithdrawCryptocurrencyFunds_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_WithdrawFiatFunds_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_WithdrawalEventByID_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_WithdrawalEventsByExchange_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_WithdrawalEventsByDate_0 = runtime.ForwardResponseMessage
forward_GoCryptoTrader_GetLoggerDetails_0 = runtime.ForwardResponseMessage

View File

@@ -1,6 +1,7 @@
syntax = "proto3";
import "google/api/annotations.proto";
import "google/protobuf/timestamp.proto";
package gctrpc;
@@ -244,6 +245,8 @@ message AddPortfolioAddressRequest {
string coin_type = 2;
string description = 3;
double balance = 4;
string supported_exchanges = 5;
bool cold_storage = 6;
}
message AddPortfolioAddressResponse {}
@@ -434,28 +437,90 @@ message GetCryptocurrencyDepositAddressResponse {
string address = 1;
}
message WithdrawCurrencyRequest {
message WithdrawFiatRequest {
string exchange = 1;
string description = 2;
string one_time_password = 3;
string account_id = 4;
int64 pin = 5;
string trade_password = 6;
string currency = 7;
string address = 8;
string address_tag = 9;
double amount = 10;
double fee_amount = 11;
string bank_name = 12;
string bank_address = 13;
string bank_city = 14;
string bank_country = 15;
string swife_code = 16;
string wire_currency = 17;
string currency = 2;
double amount = 3;
string description = 4;
string bank_account_id = 5;
}
message WithdrawCryptoRequest {
string exchange = 1;
string address = 2;
string address_tag = 3;
string currency = 4;
double amount = 5;
double fee = 6;
string description = 7;
}
message WithdrawResponse {
string result = 1;
string id = 1;
string status = 2;
}
message WithdrawalEventByIDRequest {
string id = 1;
}
message WithdrawalEventByIDResponse {
WithdrawalEventResponse event = 2;
}
message WithdrawalEventsByExchangeRequest {
string exchange = 1;
string id = 2;
int32 limit = 3;
}
message WithdrawalEventsByDateRequest {
string exchange = 1;
string start = 2;
string end = 3;
int32 limit = 4;
}
message WithdrawalEventsByExchangeResponse {
repeated WithdrawalEventResponse event = 2;
}
message WithdrawalEventResponse {
string id = 2;
WithdrawlExchangeEvent exchange = 3;
WithdrawalRequestEvent request = 4;
google.protobuf.Timestamp created_at = 5;
google.protobuf.Timestamp updated_at = 6;
}
message WithdrawlExchangeEvent {
string name = 1;
string id = 2;
string status = 3;
}
message WithdrawalRequestEvent {
string currency = 2;
string description = 3;
double amount = 4;
int32 type = 5;
FiatWithdrawalEvent fiat = 6;
CryptoWithdrawalEvent crypto = 7;
}
message FiatWithdrawalEvent {
string bank_name = 1;
string account_name = 2;
string account_number = 3;
string bsb = 4;
string swift = 5;
string iban = 6;
}
message CryptoWithdrawalEvent {
string address = 1;
string address_tag = 2;
double fee = 3;
}
message GetLoggerDetailsRequest {
@@ -845,16 +910,38 @@ service GoCryptoTrader {
};
}
rpc WithdrawCryptocurrencyFunds(WithdrawCurrencyRequest) returns (WithdrawResponse) {
rpc WithdrawFiatFunds(WithdrawFiatRequest) returns (WithdrawResponse) {
option (google.api.http) = {
post: "/v1/withdrawcryptofunds"
post: "/v1/withdrawfiatfunds"
body: "*"
};
}
rpc WithdrawFiatFunds(WithdrawCurrencyRequest) returns (WithdrawResponse) {
rpc WithdrawCryptocurrencyFunds(WithdrawCryptoRequest) returns (WithdrawResponse) {
option (google.api.http) = {
post: "/v1/withdrawfiatfunds"
post: "/v1/withdrawithdrawcryptofundswfiatfunds"
body: "*"
};
}
rpc WithdrawalEventByID(WithdrawalEventByIDRequest) returns (WithdrawalEventByIDResponse) {
option (google.api.http) = {
post: "/v1/withdrawaleventbyid"
body: "*"
};
}
rpc WithdrawalEventsByExchange(WithdrawalEventsByExchangeRequest) returns (WithdrawalEventsByExchangeResponse) {
option (google.api.http) = {
post: "/v1/withdrawaleventbyid"
body: "*"
};rpcse
}
rpc WithdrawalEventsByDate(WithdrawalEventsByDateRequest) returns (WithdrawalEventsByExchangeResponse) {
option (google.api.http) = {
post: "/v1/withdrawaleventbydate"
body: "*"
};
}

View File

@@ -502,16 +502,7 @@
"200": {
"description": "A successful response.(streaming responses)",
"schema": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcGetAccountInfoResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcGetAccountInfoResponse"
"$ref": "#/x-stream-definitions/gctrpcGetAccountInfoResponse"
}
}
},
@@ -709,16 +700,7 @@
"200": {
"description": "A successful response.(streaming responses)",
"schema": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcOrderbookResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcOrderbookResponse"
"$ref": "#/x-stream-definitions/gctrpcOrderbookResponse"
}
}
},
@@ -833,16 +815,7 @@
"200": {
"description": "A successful response.(streaming responses)",
"schema": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcTickerResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcTickerResponse"
"$ref": "#/x-stream-definitions/gctrpcTickerResponse"
}
}
},
@@ -1062,16 +1035,7 @@
"200": {
"description": "A successful response.(streaming responses)",
"schema": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcOrderbookResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcOrderbookResponse"
"$ref": "#/x-stream-definitions/gctrpcOrderbookResponse"
}
}
},
@@ -1251,16 +1215,7 @@
"200": {
"description": "A successful response.(streaming responses)",
"schema": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcTickerResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcTickerResponse"
"$ref": "#/x-stream-definitions/gctrpcTickerResponse"
}
}
},
@@ -1457,14 +1412,14 @@
]
}
},
"/v1/withdrawcryptofunds": {
"/v1/withdrawaleventbydate": {
"post": {
"operationId": "WithdrawCryptocurrencyFunds",
"operationId": "WithdrawalEventsByDate",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/gctrpcWithdrawResponse"
"$ref": "#/definitions/gctrpcWithdrawalEventsByExchangeResponse"
}
}
},
@@ -1474,7 +1429,33 @@
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/gctrpcWithdrawCurrencyRequest"
"$ref": "#/definitions/gctrpcWithdrawalEventsByDateRequest"
}
}
],
"tags": [
"GoCryptoTrader"
]
}
},
"/v1/withdrawaleventbyid": {
"post": {
"operationId": "WithdrawalEventsByExchange",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/gctrpcWithdrawalEventsByExchangeResponse"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/gctrpcWithdrawalEventsByExchangeRequest"
}
}
],
@@ -1500,7 +1481,33 @@
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/gctrpcWithdrawCurrencyRequest"
"$ref": "#/definitions/gctrpcWithdrawFiatRequest"
}
}
],
"tags": [
"GoCryptoTrader"
]
}
},
"/v1/withdrawithdrawcryptofundswfiatfunds": {
"post": {
"operationId": "WithdrawCryptocurrencyFunds",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/gctrpcWithdrawResponse"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/gctrpcWithdrawCryptoRequest"
}
}
],
@@ -1602,6 +1609,13 @@
"balance": {
"type": "number",
"format": "double"
},
"supported_exchanges": {
"type": "string"
},
"cold_storage": {
"type": "boolean",
"format": "boolean"
}
}
},
@@ -1758,6 +1772,21 @@
}
}
},
"gctrpcCryptoWithdrawalEvent": {
"type": "object",
"properties": {
"address": {
"type": "string"
},
"address_tag": {
"type": "string"
},
"fee": {
"type": "number",
"format": "double"
}
}
},
"gctrpcCurrencyPair": {
"type": "object",
"properties": {
@@ -1786,6 +1815,29 @@
}
}
},
"gctrpcFiatWithdrawalEvent": {
"type": "object",
"properties": {
"bank_name": {
"type": "string"
},
"account_name": {
"type": "string"
},
"account_number": {
"type": "string"
},
"bsb": {
"type": "string"
},
"swift": {
"type": "string"
},
"iban": {
"type": "string"
}
}
},
"gctrpcForexProvider": {
"type": "object",
"properties": {
@@ -2809,61 +2861,51 @@
}
}
},
"gctrpcWithdrawCurrencyRequest": {
"gctrpcWithdrawCryptoRequest": {
"type": "object",
"properties": {
"exchange": {
"type": "string"
},
"description": {
"type": "string"
},
"one_time_password": {
"type": "string"
},
"account_id": {
"type": "string"
},
"pin": {
"type": "string",
"format": "int64"
},
"trade_password": {
"type": "string"
},
"currency": {
"type": "string"
},
"address": {
"type": "string"
},
"address_tag": {
"type": "string"
},
"currency": {
"type": "string"
},
"amount": {
"type": "number",
"format": "double"
},
"fee_amount": {
"fee": {
"type": "number",
"format": "double"
},
"bank_name": {
"description": {
"type": "string"
}
}
},
"gctrpcWithdrawFiatRequest": {
"type": "object",
"properties": {
"exchange": {
"type": "string"
},
"bank_address": {
"currency": {
"type": "string"
},
"bank_city": {
"amount": {
"type": "number",
"format": "double"
},
"description": {
"type": "string"
},
"bank_country": {
"type": "string"
},
"swife_code": {
"type": "string"
},
"wire_currency": {
"bank_account_id": {
"type": "string"
}
}
@@ -2871,7 +2913,131 @@
"gctrpcWithdrawResponse": {
"type": "object",
"properties": {
"result": {
"id": {
"type": "string"
},
"status": {
"type": "string"
}
}
},
"gctrpcWithdrawalEventByIDRequest": {
"type": "object",
"properties": {
"id": {
"type": "string"
}
}
},
"gctrpcWithdrawalEventByIDResponse": {
"type": "object",
"properties": {
"event": {
"$ref": "#/definitions/gctrpcWithdrawalEventResponse"
}
}
},
"gctrpcWithdrawalEventResponse": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"exchange": {
"$ref": "#/definitions/gctrpcWithdrawlExchangeEvent"
},
"request": {
"$ref": "#/definitions/gctrpcWithdrawalRequestEvent"
},
"created_at": {
"type": "string",
"format": "date-time"
},
"updated_at": {
"type": "string",
"format": "date-time"
}
}
},
"gctrpcWithdrawalEventsByDateRequest": {
"type": "object",
"properties": {
"exchange": {
"type": "string"
},
"start": {
"type": "string"
},
"end": {
"type": "string"
},
"limit": {
"type": "integer",
"format": "int32"
}
}
},
"gctrpcWithdrawalEventsByExchangeRequest": {
"type": "object",
"properties": {
"exchange": {
"type": "string"
},
"id": {
"type": "string"
},
"limit": {
"type": "integer",
"format": "int32"
}
}
},
"gctrpcWithdrawalEventsByExchangeResponse": {
"type": "object",
"properties": {
"event": {
"type": "array",
"items": {
"$ref": "#/definitions/gctrpcWithdrawalEventResponse"
}
}
}
},
"gctrpcWithdrawalRequestEvent": {
"type": "object",
"properties": {
"currency": {
"type": "string"
},
"description": {
"type": "string"
},
"amount": {
"type": "number",
"format": "double"
},
"type": {
"type": "integer",
"format": "int32"
},
"fiat": {
"$ref": "#/definitions/gctrpcFiatWithdrawalEvent"
},
"crypto": {
"$ref": "#/definitions/gctrpcCryptoWithdrawalEvent"
}
}
},
"gctrpcWithdrawlExchangeEvent": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"id": {
"type": "string"
},
"status": {
"type": "string"
}
}
@@ -2913,5 +3079,43 @@
}
}
}
},
"x-stream-definitions": {
"gctrpcGetAccountInfoResponse": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcGetAccountInfoResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcGetAccountInfoResponse"
},
"gctrpcOrderbookResponse": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcOrderbookResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcOrderbookResponse"
},
"gctrpcTickerResponse": {
"type": "object",
"properties": {
"result": {
"$ref": "#/definitions/gctrpcTickerResponse"
},
"error": {
"$ref": "#/definitions/runtimeStreamError"
}
},
"title": "Stream result of gctrpcTickerResponse"
}
}
}