aljaz/ark
1
0
Fork 0
mirror of https://github.com/aljazceru/ark.git synced 2025-12-18 12:44:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add admin APIs to manage wallet (#226)

Browse Source 
* Add admin rpcs to manage wallet

* Fix

* Fixes

* Add sleeping time

* Increase sleeping time
This commit is contained in:
Pietralberto Mazza
2024-08-07 00:36:51 +02:00
committed by GitHub
parent fb8a127f4f
commit 1c67c56d9d
28 changed files with 3680 additions and 1721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
docker-compose.clark.regtest.yml
View File

@@ -14,7 +14,6 @@ services:
- ARK_MIN_RELAY_FEE=200
- ARK_NEUTRINO_PEER=bitcoin:18444
- ARK_ESPLORA_URL=http://chopsticks:3000
- ARK_WALLET_PASSWORD=password
ports:
- "6000:6000"

3
docker-compose.regtest.yml
View File

@@ -30,8 +30,9 @@ services:
- ARK_ROUND_LIFETIME=512
- ARK_DB_TYPE=sqlite
- ARK_TX_BUILDER_TYPE=covenant
- ARK_PORT=8080
ports:
- "8080:6000"
- "8080:8080"
volumes:
oceand:

110
server/api-spec/openapi/swagger/ark/v1/admin.swagger.json
View File

@@ -16,50 +16,6 @@
"application/json"
],
"paths": {
"/v1/admin/address": {
"get": {
"operationId": "AdminService_GetWalletAddress",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1GetWalletAddressResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"AdminService"
]
}
},
"/v1/admin/balance": {
"get": {
"operationId": "AdminService_GetBalance",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1GetBalanceResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"AdminService"
]
}
},
"/v1/admin/round/{roundId}": {
"get": {
"operationId": "AdminService_GetRoundDetails",
@@ -122,28 +78,6 @@
]
}
},
"/v1/admin/status": {
"get": {
"operationId": "AdminService_GetWalletStatus",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1GetWalletStatusResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"AdminService"
]
}
},
"/v1/admin/sweeps": {
"get": {
"operationId": "AdminService_GetScheduledSweep",
@@ -196,28 +130,6 @@
}
}
},
"v1Balance": {
"type": "object",
"properties": {
"locked": {
"type": "string"
},
"available": {
"type": "string"
}
}
},
"v1GetBalanceResponse": {
"type": "object",
"properties": {
"mainAccount": {
"$ref": "#/definitions/v1Balance"
},
"connectorsAccount": {
"$ref": "#/definitions/v1Balance"
}
}
},
"v1GetRoundDetailsResponse": {
"type": "object",
"properties": {
@@ -295,28 +207,6 @@
}
}
},
"v1GetWalletAddressResponse": {
"type": "object",
"properties": {
"address": {
"type": "string"
}
}
},
"v1GetWalletStatusResponse": {
"type": "object",
"properties": {
"initialized": {
"type": "boolean"
},
"unlocked": {
"type": "boolean"
},
"synced": {
"type": "boolean"
}
}
},
"v1ScheduledSweep": {
"type": "object",
"properties": {

368
server/api-spec/openapi/swagger/ark/v1/wallet.swagger.json Normal file
View File

@@ -0,0 +1,368 @@
{
"swagger": "2.0",
"info": {
"title": "ark/v1/wallet.proto",
"version": "version not set"
},
"tags": [
{
"name": "WalletService"
}
],
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"paths": {
"/v1/admin/wallet/address": {
"get": {
"operationId": "WalletService_DeriveAddress",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1DeriveAddressResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"WalletService"
]
}
},
"/v1/admin/wallet/balance": {
"get": {
"operationId": "WalletService_GetBalance",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1GetBalanceResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"WalletService"
]
}
},
"/v1/admin/wallet/create": {
"post": {
"operationId": "WalletService_Create",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1CreateResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v1CreateRequest"
}
}
],
"tags": [
"WalletService"
]
}
},
"/v1/admin/wallet/lock": {
"post": {
"operationId": "WalletService_Lock",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1LockResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v1LockRequest"
}
}
],
"tags": [
"WalletService"
]
}
},
"/v1/admin/wallet/restore": {
"post": {
"operationId": "WalletService_Restore",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1RestoreResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v1RestoreRequest"
}
}
],
"tags": [
"WalletService"
]
}
},
"/v1/admin/wallet/seed": {
"get": {
"operationId": "WalletService_GenSeed",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1GenSeedResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"WalletService"
]
}
},
"/v1/admin/wallet/status": {
"get": {
"operationId": "WalletService_GetStatus",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1GetStatusResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"tags": [
"WalletService"
]
}
},
"/v1/admin/wallet/unlock": {
"post": {
"operationId": "WalletService_Unlock",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/v1UnlockResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/v1UnlockRequest"
}
}
],
"tags": [
"WalletService"
]
}
}
},
"definitions": {
"protobufAny": {
"type": "object",
"properties": {
"@type": {
"type": "string"
}
},
"additionalProperties": {}
},
"rpcStatus": {
"type": "object",
"properties": {
"code": {
"type": "integer",
"format": "int32"
},
"message": {
"type": "string"
},
"details": {
"type": "array",
"items": {
"type": "object",
"$ref": "#/definitions/protobufAny"
}
}
}
},
"v1Balance": {
"type": "object",
"properties": {
"locked": {
"type": "string"
},
"available": {
"type": "string"
}
}
},
"v1CreateRequest": {
"type": "object",
"properties": {
"seed": {
"type": "string"
},
"password": {
"type": "string"
}
}
},
"v1CreateResponse": {
"type": "object"
},
"v1DeriveAddressResponse": {
"type": "object",
"properties": {
"address": {
"type": "string"
}
}
},
"v1GenSeedResponse": {
"type": "object",
"properties": {
"seed": {
"type": "string"
}
}
},
"v1GetBalanceResponse": {
"type": "object",
"properties": {
"mainAccount": {
"$ref": "#/definitions/v1Balance"
},
"connectorsAccount": {
"$ref": "#/definitions/v1Balance"
}
}
},
"v1GetStatusResponse": {
"type": "object",
"properties": {
"initialized": {
"type": "boolean"
},
"unlocked": {
"type": "boolean"
},
"synced": {
"type": "boolean"
}
}
},
"v1LockRequest": {
"type": "object",
"properties": {
"password": {
"type": "string"
}
}
},
"v1LockResponse": {
"type": "object"
},
"v1RestoreRequest": {
"type": "object",
"properties": {
"seed": {
"type": "string"
},
"password": {
"type": "string"
}
}
},
"v1RestoreResponse": {
"type": "object"
},
"v1UnlockRequest": {
"type": "object",
"properties": {
"password": {
"type": "string"
}
}
},
"v1UnlockResponse": {
"type": "object"
}
}
}

53
server/api-spec/protobuf/ark/v1/admin.proto
View File

@@ -5,11 +5,6 @@ package ark.v1;
import "google/api/annotations.proto";
service AdminService {
rpc GetBalance(GetBalanceRequest) returns (GetBalanceResponse) {
option (google.api.http) = {
get: "/v1/admin/balance"
};
}
rpc GetScheduledSweep(GetScheduledSweepRequest) returns (GetScheduledSweepResponse) {
option (google.api.http) = {
get: "/v1/admin/sweeps"
@@ -25,32 +20,13 @@ service AdminService {
post: "/v1/admin/rounds"
body: "*"
};
}
rpc GetWalletAddress(GetWalletAddressRequest) returns (GetWalletAddressResponse) {
option (google.api.http) = {
get: "/v1/admin/address"
};
}
rpc GetWalletStatus(GetWalletStatusRequest) returns (GetWalletStatusResponse) {
option (google.api.http) = {
get: "/v1/admin/status"
};
}
}
message GetBalanceRequest {}
message Balance {
string locked = 1;
string available = 2;
}
message GetBalanceResponse {
Balance main_account = 1;
Balance connectors_account = 2;
}
}
message GetScheduledSweepRequest {}
message GetScheduledSweepResponse {
repeated ScheduledSweep sweeps = 1;
}
message SweepableOutput {
string txid = 1;
@@ -64,10 +40,6 @@ message ScheduledSweep {
repeated SweepableOutput outputs = 2;
}
message GetScheduledSweepResponse {
repeated ScheduledSweep sweeps = 1;
}
message GetRoundDetailsRequest {
string round_id = 1;
}
@@ -91,21 +63,4 @@ message GetRoundsRequest {
message GetRoundsResponse {
repeated string rounds = 1;
}
message GetWalletAddressRequest {}
message GetWalletAddressResponse {
string address = 1;
}
message GetWalletBalanceRequest {}
message GetWalletBalanceResponse {
uint64 balance = 1;
}
message GetWalletStatusRequest {}
message GetWalletStatusResponse {
bool initialized = 1;
bool unlocked = 2;
bool synced = 3;
}

103
server/api-spec/protobuf/ark/v1/wallet.proto Normal file
View File

@@ -0,0 +1,103 @@
syntax = "proto3";
package ark.v1;
import "google/api/annotations.proto";
service WalletService {
rpc GenSeed(GenSeedRequest) returns (GenSeedResponse) {
option (google.api.http) = {
get: "/v1/admin/wallet/seed"
};
}
rpc Create(CreateRequest) returns (CreateResponse) {
option (google.api.http) = {
post: "/v1/admin/wallet/create"
body: "*"
};
}
rpc Restore(RestoreRequest) returns (RestoreResponse) {
option (google.api.http) = {
post: "/v1/admin/wallet/restore"
body: "*"
};
}
rpc Unlock(UnlockRequest) returns (UnlockResponse) {
option (google.api.http) = {
post: "/v1/admin/wallet/unlock"
body: "*"
};
}
rpc Lock(LockRequest) returns (LockResponse) {
option (google.api.http) = {
post: "/v1/admin/wallet/lock"
body: "*"
};
}
rpc GetStatus(GetStatusRequest) returns (GetStatusResponse) {
option (google.api.http) = {
get: "/v1/admin/wallet/status"
};
}
rpc DeriveAddress(DeriveAddressRequest) returns (DeriveAddressResponse) {
option (google.api.http) = {
get: "/v1/admin/wallet/address"
};
}
rpc GetBalance(GetBalanceRequest) returns (GetBalanceResponse) {
option (google.api.http) = {
get: "/v1/admin/wallet/balance"
};
}
}
message GenSeedRequest {}
message GenSeedResponse {
string seed = 1;
}
message CreateRequest {
string seed = 1;
string password = 2;
}
message CreateResponse {}
message RestoreRequest {
string seed = 1;
string password = 2;
}
message RestoreResponse {}
message UnlockRequest {
string password = 1;
}
message UnlockResponse {}
message LockRequest {
string password = 1;
}
message LockResponse {}
message GetStatusRequest {}
message GetStatusResponse {
bool initialized = 1;
bool unlocked = 2;
bool synced = 3;
}
message DeriveAddressRequest {}
message DeriveAddressResponse {
string address = 1;
}
message GetBalanceRequest {}
message Balance {
string locked = 1;
string available = 2;
}
message GetBalanceResponse {
Balance main_account = 1;
Balance connectors_account = 2;
}

1003
server/api-spec/protobuf/gen/ark/v1/admin.pb.go
View File

File diff suppressed because it is too large Load Diff

207
server/api-spec/protobuf/gen/ark/v1/admin.pb.gw.go
View File

@@ -31,24 +31,6 @@ var _ = runtime.String
var _ = utilities.NewDoubleArray
var _ = metadata.Join
func request_AdminService_GetBalance_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBalanceRequest
var metadata runtime.ServerMetadata
msg, err := client.GetBalance(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_AdminService_GetBalance_0(ctx context.Context, marshaler runtime.Marshaler, server AdminServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBalanceRequest
var metadata runtime.ServerMetadata
msg, err := server.GetBalance(ctx, &protoReq)
return msg, metadata, err
}
func request_AdminService_GetScheduledSweep_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetScheduledSweepRequest
var metadata runtime.ServerMetadata
@@ -145,73 +127,12 @@ func local_request_AdminService_GetRounds_0(ctx context.Context, marshaler runti
}
func request_AdminService_GetWalletAddress_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetWalletAddressRequest
var metadata runtime.ServerMetadata
msg, err := client.GetWalletAddress(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_AdminService_GetWalletAddress_0(ctx context.Context, marshaler runtime.Marshaler, server AdminServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetWalletAddressRequest
var metadata runtime.ServerMetadata
msg, err := server.GetWalletAddress(ctx, &protoReq)
return msg, metadata, err
}
func request_AdminService_GetWalletStatus_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetWalletStatusRequest
var metadata runtime.ServerMetadata
msg, err := client.GetWalletStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_AdminService_GetWalletStatus_0(ctx context.Context, marshaler runtime.Marshaler, server AdminServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetWalletStatusRequest
var metadata runtime.ServerMetadata
msg, err := server.GetWalletStatus(ctx, &protoReq)
return msg, metadata, err
}
// RegisterAdminServiceHandlerServer registers the http handlers for service AdminService to "mux".
// UnaryRPC :call AdminServiceServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAdminServiceHandlerFromEndpoint instead.
func RegisterAdminServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AdminServiceServer) error {
mux.Handle("GET", pattern_AdminService_GetBalance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.AdminService/GetBalance", runtime.WithHTTPPathPattern("/v1/admin/balance"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_AdminService_GetBalance_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_AdminService_GetBalance_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_AdminService_GetScheduledSweep_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@@ -287,56 +208,6 @@ func RegisterAdminServiceHandlerServer(ctx context.Context, mux *runtime.ServeMu
})
mux.Handle("GET", pattern_AdminService_GetWalletAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.AdminService/GetWalletAddress", runtime.WithHTTPPathPattern("/v1/admin/address"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_AdminService_GetWalletAddress_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_AdminService_GetWalletAddress_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_AdminService_GetWalletStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.AdminService/GetWalletStatus", runtime.WithHTTPPathPattern("/v1/admin/status"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_AdminService_GetWalletStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_AdminService_GetWalletStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@@ -378,28 +249,6 @@ func RegisterAdminServiceHandler(ctx context.Context, mux *runtime.ServeMux, con
// "AdminServiceClient" to call the correct interceptors.
func RegisterAdminServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AdminServiceClient) error {
mux.Handle("GET", pattern_AdminService_GetBalance_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.AdminService/GetBalance", runtime.WithHTTPPathPattern("/v1/admin/balance"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_AdminService_GetBalance_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_AdminService_GetBalance_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_AdminService_GetScheduledSweep_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@@ -466,77 +315,21 @@ func RegisterAdminServiceHandlerClient(ctx context.Context, mux *runtime.ServeMu
})
mux.Handle("GET", pattern_AdminService_GetWalletAddress_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.AdminService/GetWalletAddress", runtime.WithHTTPPathPattern("/v1/admin/address"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_AdminService_GetWalletAddress_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_AdminService_GetWalletAddress_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_AdminService_GetWalletStatus_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.AdminService/GetWalletStatus", runtime.WithHTTPPathPattern("/v1/admin/status"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_AdminService_GetWalletStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_AdminService_GetWalletStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
var (
pattern_AdminService_GetBalance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "balance"}, ""))
pattern_AdminService_GetScheduledSweep_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "sweeps"}, ""))
pattern_AdminService_GetRoundDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "admin", "round", "round_id"}, ""))
pattern_AdminService_GetRounds_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "rounds"}, ""))
pattern_AdminService_GetWalletAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "address"}, ""))
pattern_AdminService_GetWalletStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "status"}, ""))
)
var (
forward_AdminService_GetBalance_0 = runtime.ForwardResponseMessage
forward_AdminService_GetScheduledSweep_0 = runtime.ForwardResponseMessage
forward_AdminService_GetRoundDetails_0 = runtime.ForwardResponseMessage
forward_AdminService_GetRounds_0 = runtime.ForwardResponseMessage
forward_AdminService_GetWalletAddress_0 = runtime.ForwardResponseMessage
forward_AdminService_GetWalletStatus_0 = runtime.ForwardResponseMessage
)

108
server/api-spec/protobuf/gen/ark/v1/admin_grpc.pb.go
View File

@@ -18,12 +18,9 @@ const _ = grpc.SupportPackageIsVersion7
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AdminServiceClient interface {
GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error)
GetScheduledSweep(ctx context.Context, in *GetScheduledSweepRequest, opts ...grpc.CallOption) (*GetScheduledSweepResponse, error)
GetRoundDetails(ctx context.Context, in *GetRoundDetailsRequest, opts ...grpc.CallOption) (*GetRoundDetailsResponse, error)
GetRounds(ctx context.Context, in *GetRoundsRequest, opts ...grpc.CallOption) (*GetRoundsResponse, error)
GetWalletAddress(ctx context.Context, in *GetWalletAddressRequest, opts ...grpc.CallOption) (*GetWalletAddressResponse, error)
GetWalletStatus(ctx context.Context, in *GetWalletStatusRequest, opts ...grpc.CallOption) (*GetWalletStatusResponse, error)
}
type adminServiceClient struct {
@@ -34,15 +31,6 @@ func NewAdminServiceClient(cc grpc.ClientConnInterface) AdminServiceClient {
return &adminServiceClient{cc}
}
func (c *adminServiceClient) GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error) {
out := new(GetBalanceResponse)
err := c.cc.Invoke(ctx, "/ark.v1.AdminService/GetBalance", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *adminServiceClient) GetScheduledSweep(ctx context.Context, in *GetScheduledSweepRequest, opts ...grpc.CallOption) (*GetScheduledSweepResponse, error) {
out := new(GetScheduledSweepResponse)
err := c.cc.Invoke(ctx, "/ark.v1.AdminService/GetScheduledSweep", in, out, opts...)
@@ -70,43 +58,19 @@ func (c *adminServiceClient) GetRounds(ctx context.Context, in *GetRoundsRequest
return out, nil
}
func (c *adminServiceClient) GetWalletAddress(ctx context.Context, in *GetWalletAddressRequest, opts ...grpc.CallOption) (*GetWalletAddressResponse, error) {
out := new(GetWalletAddressResponse)
err := c.cc.Invoke(ctx, "/ark.v1.AdminService/GetWalletAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *adminServiceClient) GetWalletStatus(ctx context.Context, in *GetWalletStatusRequest, opts ...grpc.CallOption) (*GetWalletStatusResponse, error) {
out := new(GetWalletStatusResponse)
err := c.cc.Invoke(ctx, "/ark.v1.AdminService/GetWalletStatus", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// AdminServiceServer is the server API for AdminService service.
// All implementations should embed UnimplementedAdminServiceServer
// for forward compatibility
type AdminServiceServer interface {
GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error)
GetScheduledSweep(context.Context, *GetScheduledSweepRequest) (*GetScheduledSweepResponse, error)
GetRoundDetails(context.Context, *GetRoundDetailsRequest) (*GetRoundDetailsResponse, error)
GetRounds(context.Context, *GetRoundsRequest) (*GetRoundsResponse, error)
GetWalletAddress(context.Context, *GetWalletAddressRequest) (*GetWalletAddressResponse, error)
GetWalletStatus(context.Context, *GetWalletStatusRequest) (*GetWalletStatusResponse, error)
}
// UnimplementedAdminServiceServer should be embedded to have forward compatible implementations.
type UnimplementedAdminServiceServer struct {
}
func (UnimplementedAdminServiceServer) GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetBalance not implemented")
}
func (UnimplementedAdminServiceServer) GetScheduledSweep(context.Context, *GetScheduledSweepRequest) (*GetScheduledSweepResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetScheduledSweep not implemented")
}
@@ -116,12 +80,6 @@ func (UnimplementedAdminServiceServer) GetRoundDetails(context.Context, *GetRoun
func (UnimplementedAdminServiceServer) GetRounds(context.Context, *GetRoundsRequest) (*GetRoundsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetRounds not implemented")
}
func (UnimplementedAdminServiceServer) GetWalletAddress(context.Context, *GetWalletAddressRequest) (*GetWalletAddressResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetWalletAddress not implemented")
}
func (UnimplementedAdminServiceServer) GetWalletStatus(context.Context, *GetWalletStatusRequest) (*GetWalletStatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetWalletStatus not implemented")
}
// UnsafeAdminServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AdminServiceServer will
@@ -134,24 +92,6 @@ func RegisterAdminServiceServer(s grpc.ServiceRegistrar, srv AdminServiceServer)
s.RegisterService(&AdminService_ServiceDesc, srv)
}
func _AdminService_GetBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBalanceRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AdminServiceServer).GetBalance(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.AdminService/GetBalance",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AdminServiceServer).GetBalance(ctx, req.(*GetBalanceRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AdminService_GetScheduledSweep_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetScheduledSweepRequest)
if err := dec(in); err != nil {
@@ -206,42 +146,6 @@ func _AdminService_GetRounds_Handler(srv interface{}, ctx context.Context, dec f
return interceptor(ctx, in, info, handler)
}
func _AdminService_GetWalletAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetWalletAddressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AdminServiceServer).GetWalletAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.AdminService/GetWalletAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AdminServiceServer).GetWalletAddress(ctx, req.(*GetWalletAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AdminService_GetWalletStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetWalletStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AdminServiceServer).GetWalletStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.AdminService/GetWalletStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AdminServiceServer).GetWalletStatus(ctx, req.(*GetWalletStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
// AdminService_ServiceDesc is the grpc.ServiceDesc for AdminService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
@@ -249,10 +153,6 @@ var AdminService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "ark.v1.AdminService",
HandlerType: (*AdminServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetBalance",
Handler: _AdminService_GetBalance_Handler,
},
{
MethodName: "GetScheduledSweep",
Handler: _AdminService_GetScheduledSweep_Handler,
@@ -265,14 +165,6 @@ var AdminService_ServiceDesc = grpc.ServiceDesc{
MethodName: "GetRounds",
Handler: _AdminService_GetRounds_Handler,
},
{
MethodName: "GetWalletAddress",
Handler: _AdminService_GetWalletAddress_Handler,
},
{
MethodName: "GetWalletStatus",
Handler: _AdminService_GetWalletStatus_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "ark/v1/admin.proto",

1203
server/api-spec/protobuf/gen/ark/v1/wallet.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

670
server/api-spec/protobuf/gen/ark/v1/wallet.pb.gw.go Normal file
View File

@@ -0,0 +1,670 @@
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
// source: ark/v1/wallet.proto
/*
Package arkv1 is a reverse proxy.
It translates gRPC into RESTful JSON APIs.
*/
package arkv1
import (
"context"
"io"
"net/http"
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/proto"
)
// Suppress "imported and not used" errors
var _ codes.Code
var _ io.Reader
var _ status.Status
var _ = runtime.String
var _ = utilities.NewDoubleArray
var _ = metadata.Join
func request_WalletService_GenSeed_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GenSeedRequest
var metadata runtime.ServerMetadata
msg, err := client.GenSeed(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_GenSeed_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GenSeedRequest
var metadata runtime.ServerMetadata
msg, err := server.GenSeed(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletService_Create_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq CreateRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.Create(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_Create_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq CreateRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.Create(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletService_Restore_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq RestoreRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.Restore(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_Restore_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq RestoreRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.Restore(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletService_Unlock_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq UnlockRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.Unlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_Unlock_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq UnlockRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.Unlock(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletService_Lock_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq LockRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.Lock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_Lock_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq LockRequest
var metadata runtime.ServerMetadata
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.Lock(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletService_GetStatus_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetStatusRequest
var metadata runtime.ServerMetadata
msg, err := client.GetStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_GetStatus_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetStatusRequest
var metadata runtime.ServerMetadata
msg, err := server.GetStatus(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletService_DeriveAddress_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq DeriveAddressRequest
var metadata runtime.ServerMetadata
msg, err := client.DeriveAddress(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_DeriveAddress_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq DeriveAddressRequest
var metadata runtime.ServerMetadata
msg, err := server.DeriveAddress(ctx, &protoReq)
return msg, metadata, err
}
func request_WalletService_GetBalance_0(ctx context.Context, marshaler runtime.Marshaler, client WalletServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBalanceRequest
var metadata runtime.ServerMetadata
msg, err := client.GetBalance(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_WalletService_GetBalance_0(ctx context.Context, marshaler runtime.Marshaler, server WalletServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetBalanceRequest
var metadata runtime.ServerMetadata
msg, err := server.GetBalance(ctx, &protoReq)
return msg, metadata, err
}
// RegisterWalletServiceHandlerServer registers the http handlers for service WalletService to "mux".
// UnaryRPC :call WalletServiceServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterWalletServiceHandlerFromEndpoint instead.
func RegisterWalletServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server WalletServiceServer) error {
mux.Handle("GET", pattern_WalletService_GenSeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/GenSeed", runtime.WithHTTPPathPattern("/v1/admin/wallet/seed"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_GenSeed_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_GenSeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Create_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/Create", runtime.WithHTTPPathPattern("/v1/admin/wallet/create"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_Create_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Restore_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/Restore", runtime.WithHTTPPathPattern("/v1/admin/wallet/restore"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_Restore_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Restore_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Unlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/Unlock", runtime.WithHTTPPathPattern("/v1/admin/wallet/unlock"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_Unlock_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Unlock_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Lock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/Lock", runtime.WithHTTPPathPattern("/v1/admin/wallet/lock"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_Lock_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Lock_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_WalletService_GetStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/GetStatus", runtime.WithHTTPPathPattern("/v1/admin/wallet/status"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_GetStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_GetStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_WalletService_DeriveAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/DeriveAddress", runtime.WithHTTPPathPattern("/v1/admin/wallet/address"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_DeriveAddress_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_DeriveAddress_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_WalletService_GetBalance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/ark.v1.WalletService/GetBalance", runtime.WithHTTPPathPattern("/v1/admin/wallet/balance"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_WalletService_GetBalance_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_GetBalance_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
// RegisterWalletServiceHandlerFromEndpoint is same as RegisterWalletServiceHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterWalletServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
conn, err := grpc.NewClient(endpoint, opts...)
if err != nil {
return err
}
defer func() {
if err != nil {
if cerr := conn.Close(); cerr != nil {
grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
}
return
}
go func() {
<-ctx.Done()
if cerr := conn.Close(); cerr != nil {
grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
}
}()
}()
return RegisterWalletServiceHandler(ctx, mux, conn)
}
// RegisterWalletServiceHandler registers the http handlers for service WalletService to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterWalletServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterWalletServiceHandlerClient(ctx, mux, NewWalletServiceClient(conn))
}
// RegisterWalletServiceHandlerClient registers the http handlers for service WalletService
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "WalletServiceClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WalletServiceClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "WalletServiceClient" to call the correct interceptors.
func RegisterWalletServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client WalletServiceClient) error {
mux.Handle("GET", pattern_WalletService_GenSeed_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/GenSeed", runtime.WithHTTPPathPattern("/v1/admin/wallet/seed"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_GenSeed_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_GenSeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Create_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/Create", runtime.WithHTTPPathPattern("/v1/admin/wallet/create"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_Create_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Create_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Restore_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/Restore", runtime.WithHTTPPathPattern("/v1/admin/wallet/restore"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_Restore_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Restore_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Unlock_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/Unlock", runtime.WithHTTPPathPattern("/v1/admin/wallet/unlock"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_Unlock_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Unlock_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("POST", pattern_WalletService_Lock_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/Lock", runtime.WithHTTPPathPattern("/v1/admin/wallet/lock"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_Lock_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_Lock_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_WalletService_GetStatus_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/GetStatus", runtime.WithHTTPPathPattern("/v1/admin/wallet/status"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_GetStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_GetStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_WalletService_DeriveAddress_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/DeriveAddress", runtime.WithHTTPPathPattern("/v1/admin/wallet/address"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_DeriveAddress_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_DeriveAddress_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_WalletService_GetBalance_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)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/ark.v1.WalletService/GetBalance", runtime.WithHTTPPathPattern("/v1/admin/wallet/balance"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_WalletService_GetBalance_0(annotatedContext, inboundMarshaler, client, req, pathParams)
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_WalletService_GetBalance_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
var (
pattern_WalletService_GenSeed_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "seed"}, ""))
pattern_WalletService_Create_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "create"}, ""))
pattern_WalletService_Restore_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "restore"}, ""))
pattern_WalletService_Unlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "unlock"}, ""))
pattern_WalletService_Lock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "lock"}, ""))
pattern_WalletService_GetStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "status"}, ""))
pattern_WalletService_DeriveAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "address"}, ""))
pattern_WalletService_GetBalance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "wallet", "balance"}, ""))
)
var (
forward_WalletService_GenSeed_0 = runtime.ForwardResponseMessage
forward_WalletService_Create_0 = runtime.ForwardResponseMessage
forward_WalletService_Restore_0 = runtime.ForwardResponseMessage
forward_WalletService_Unlock_0 = runtime.ForwardResponseMessage
forward_WalletService_Lock_0 = runtime.ForwardResponseMessage
forward_WalletService_GetStatus_0 = runtime.ForwardResponseMessage
forward_WalletService_DeriveAddress_0 = runtime.ForwardResponseMessage
forward_WalletService_GetBalance_0 = runtime.ForwardResponseMessage
)

351
server/api-spec/protobuf/gen/ark/v1/wallet_grpc.pb.go Normal file
View File

@@ -0,0 +1,351 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package arkv1
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// WalletServiceClient is the client API for WalletService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type WalletServiceClient interface {
GenSeed(ctx context.Context, in *GenSeedRequest, opts ...grpc.CallOption) (*GenSeedResponse, error)
Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error)
Restore(ctx context.Context, in *RestoreRequest, opts ...grpc.CallOption) (*RestoreResponse, error)
Unlock(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error)
Lock(ctx context.Context, in *LockRequest, opts ...grpc.CallOption) (*LockResponse, error)
GetStatus(ctx context.Context, in *GetStatusRequest, opts ...grpc.CallOption) (*GetStatusResponse, error)
DeriveAddress(ctx context.Context, in *DeriveAddressRequest, opts ...grpc.CallOption) (*DeriveAddressResponse, error)
GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error)
}
type walletServiceClient struct {
cc grpc.ClientConnInterface
}
func NewWalletServiceClient(cc grpc.ClientConnInterface) WalletServiceClient {
return &walletServiceClient{cc}
}
func (c *walletServiceClient) GenSeed(ctx context.Context, in *GenSeedRequest, opts ...grpc.CallOption) (*GenSeedResponse, error) {
out := new(GenSeedResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/GenSeed", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
out := new(CreateResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletServiceClient) Restore(ctx context.Context, in *RestoreRequest, opts ...grpc.CallOption) (*RestoreResponse, error) {
out := new(RestoreResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/Restore", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletServiceClient) Unlock(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error) {
out := new(UnlockResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/Unlock", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletServiceClient) Lock(ctx context.Context, in *LockRequest, opts ...grpc.CallOption) (*LockResponse, error) {
out := new(LockResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/Lock", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletServiceClient) GetStatus(ctx context.Context, in *GetStatusRequest, opts ...grpc.CallOption) (*GetStatusResponse, error) {
out := new(GetStatusResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/GetStatus", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletServiceClient) DeriveAddress(ctx context.Context, in *DeriveAddressRequest, opts ...grpc.CallOption) (*DeriveAddressResponse, error) {
out := new(DeriveAddressResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/DeriveAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *walletServiceClient) GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error) {
out := new(GetBalanceResponse)
err := c.cc.Invoke(ctx, "/ark.v1.WalletService/GetBalance", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// WalletServiceServer is the server API for WalletService service.
// All implementations should embed UnimplementedWalletServiceServer
// for forward compatibility
type WalletServiceServer interface {
GenSeed(context.Context, *GenSeedRequest) (*GenSeedResponse, error)
Create(context.Context, *CreateRequest) (*CreateResponse, error)
Restore(context.Context, *RestoreRequest) (*RestoreResponse, error)
Unlock(context.Context, *UnlockRequest) (*UnlockResponse, error)
Lock(context.Context, *LockRequest) (*LockResponse, error)
GetStatus(context.Context, *GetStatusRequest) (*GetStatusResponse, error)
DeriveAddress(context.Context, *DeriveAddressRequest) (*DeriveAddressResponse, error)
GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error)
}
// UnimplementedWalletServiceServer should be embedded to have forward compatible implementations.
type UnimplementedWalletServiceServer struct {
}
func (UnimplementedWalletServiceServer) GenSeed(context.Context, *GenSeedRequest) (*GenSeedResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GenSeed not implemented")
}
func (UnimplementedWalletServiceServer) Create(context.Context, *CreateRequest) (*CreateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedWalletServiceServer) Restore(context.Context, *RestoreRequest) (*RestoreResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Restore not implemented")
}
func (UnimplementedWalletServiceServer) Unlock(context.Context, *UnlockRequest) (*UnlockResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Unlock not implemented")
}
func (UnimplementedWalletServiceServer) Lock(context.Context, *LockRequest) (*LockResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Lock not implemented")
}
func (UnimplementedWalletServiceServer) GetStatus(context.Context, *GetStatusRequest) (*GetStatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStatus not implemented")
}
func (UnimplementedWalletServiceServer) DeriveAddress(context.Context, *DeriveAddressRequest) (*DeriveAddressResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DeriveAddress not implemented")
}
func (UnimplementedWalletServiceServer) GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetBalance not implemented")
}
// UnsafeWalletServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to WalletServiceServer will
// result in compilation errors.
type UnsafeWalletServiceServer interface {
mustEmbedUnimplementedWalletServiceServer()
}
func RegisterWalletServiceServer(s grpc.ServiceRegistrar, srv WalletServiceServer) {
s.RegisterService(&WalletService_ServiceDesc, srv)
}
func _WalletService_GenSeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GenSeedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).GenSeed(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/GenSeed",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).GenSeed(ctx, req.(*GenSeedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).Create(ctx, req.(*CreateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletService_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RestoreRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).Restore(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/Restore",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).Restore(ctx, req.(*RestoreRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletService_Unlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UnlockRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).Unlock(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/Unlock",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).Unlock(ctx, req.(*UnlockRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletService_Lock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(LockRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).Lock(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/Lock",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).Lock(ctx, req.(*LockRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletService_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).GetStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/GetStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).GetStatus(ctx, req.(*GetStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletService_DeriveAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeriveAddressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).DeriveAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/DeriveAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).DeriveAddress(ctx, req.(*DeriveAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
func _WalletService_GetBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBalanceRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(WalletServiceServer).GetBalance(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ark.v1.WalletService/GetBalance",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(WalletServiceServer).GetBalance(ctx, req.(*GetBalanceRequest))
}
return interceptor(ctx, in, info, handler)
}
// WalletService_ServiceDesc is the grpc.ServiceDesc for WalletService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WalletService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "ark.v1.WalletService",
HandlerType: (*WalletServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GenSeed",
Handler: _WalletService_GenSeed_Handler,
},
{
MethodName: "Create",
Handler: _WalletService_Create_Handler,
},
{
MethodName: "Restore",
Handler: _WalletService_Restore_Handler,
},
{
MethodName: "Unlock",
Handler: _WalletService_Unlock_Handler,
},
{
MethodName: "Lock",
Handler: _WalletService_Lock_Handler,
},
{
MethodName: "GetStatus",
Handler: _WalletService_GetStatus_Handler,
},
{
MethodName: "DeriveAddress",
Handler: _WalletService_DeriveAddress_Handler,
},
{
MethodName: "GetBalance",
Handler: _WalletService_GetBalance_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "ark/v1/wallet.proto",
}

1
server/cmd/arkd/main.go
View File

@@ -50,7 +50,6 @@ func main() {
UnilateralExitDelay: cfg.UnilateralExitDelay,
EsploraURL: cfg.EsploraURL,
NeutrinoPeer: cfg.NeutrinoPeer,
WalletPassword: cfg.WalletPassword,
}
svc, err := grpcservice.NewService(svcConfig, appConfig)
if err != nil {

2
server/go.mod
View File

@@ -21,6 +21,7 @@ require (
github.com/spf13/viper v1.19.0
github.com/stretchr/testify v1.9.0
github.com/timshannon/badgerhold/v4 v4.0.3
github.com/vulpemventures/go-bip39 v1.0.2
github.com/vulpemventures/go-elements v0.5.4
google.golang.org/genproto/googleapis/api v0.0.0-20240624140628-dc46fd24d27d
google.golang.org/grpc v1.65.0
@@ -119,6 +120,7 @@ require (
github.com/soheilhy/cmux v0.1.5 // indirect
github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802 // indirect
github.com/tyler-smith/go-bip39 v1.1.0 // indirect
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
github.com/xeipuuv/gojsonschema v1.2.0 // indirect

4
server/go.sum
View File

@@ -573,11 +573,15 @@ github.com/timshannon/badgerhold/v4 v4.0.3 h1:W6pd2qckoXw2cl8eH0ZCV/9CXNaXvaM26t
github.com/timshannon/badgerhold/v4 v4.0.3/go.mod h1:IkZIr0kcZLMdD7YJfW/G6epb6ZXHD/h0XR2BTk/VZg8=
github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802 h1:uruHq4dN7GR16kFc5fp3d1RIYzJW5onx8Ybykw2YQFA=
github.com/tmc/grpc-websocket-proxy v0.0.0-20201229170055-e5319fda7802/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
github.com/vulpemventures/fastsha256 v0.0.0-20160815193821-637e65642941 h1:CTcw80hz/Sw8hqlKX5ZYvBUF5gAHSHwdjXxRf/cjDcI=
github.com/vulpemventures/fastsha256 v0.0.0-20160815193821-637e65642941/go.mod h1:GXBJykxW2kUcktGdsgyay7uwwWvkljASfljNcT0mbh8=
github.com/vulpemventures/go-bip32 v0.0.0-20200624192635-867c159da4d7 h1:X7DtNv+YWy76kELMZB/xVkIJ7YNp2vpgMFVsDcQA40U=
github.com/vulpemventures/go-bip32 v0.0.0-20200624192635-867c159da4d7/go.mod h1:Zrvx8XgpWvSPdz1lXnuN083CkoZnzwxBLEB03S8et1I=
github.com/vulpemventures/go-bip39 v1.0.2 h1:+BgKOVo04okKf1wA4Fhv8ccvql+qFyzVUdVJKkb48r0=
github.com/vulpemventures/go-bip39 v1.0.2/go.mod h1:mjFmuv9D6BtANI6iscMmbHhmBOwjMCFfny3mxHnuDrk=
github.com/vulpemventures/go-elements v0.5.4 h1:l94xoa9aYPPWiOB7Pmi08rKYvdk/n/sQIbLkQfEAASc=
github.com/vulpemventures/go-elements v0.5.4/go.mod h1:Tvhb+rZWv3lxoI5CdK03J3V+e2QVr/7UAnCYILxFSq4=
github.com/vulpemventures/go-secp256k1-zkp v1.1.6 h1:BmsrmXRLUibwa75Qkk8yELjpzCzlAjYFGLiLiOdq7Xo=

25
server/internal/app-config/config.go
View File

@@ -63,9 +63,8 @@ type Config struct {
RoundLifetime int64
UnilateralExitDelay int64
EsploraURL string
NeutrinoPeer string
WalletPassword string
EsploraURL string
NeutrinoPeer string
repo ports.RepoManager
svc application.Service
@@ -154,23 +153,29 @@ func (c *Config) Validate() error {
if err := c.schedulerService(); err != nil {
return err
}
if err := c.appService(); err != nil {
return err
}
if err := c.adminService(); err != nil {
return err
}
return nil
}
func (c *Config) AppService() application.Service {
return c.svc
func (c *Config) AppService() (application.Service, error) {
if c.svc == nil {
if err := c.appService(); err != nil {
return nil, err
}
}
return c.svc, nil
}
func (c *Config) AdminService() application.AdminService {
return c.adminSvc
}
func (c *Config) WalletService() ports.WalletService {
return c.wallet
}
func (c *Config) repoManager() error {
var svc ports.RepoManager
var err error
@@ -223,13 +228,9 @@ func (c *Config) walletService() error {
if len(c.EsploraURL) == 0 {
return fmt.Errorf("missing esplora url, covenant-less ark requires ARK_ESPLORA_URL to be set")
}
if len(c.WalletPassword) == 0 {
return fmt.Errorf("missing wallet password, covenant-less ark requires ARK_WALLET_PASSWORD to be set")
}
svc, err := btcwallet.NewService(btcwallet.WalletConfig{
Datadir: c.DbDir,
Password: []byte(c.WalletPassword),
Network: c.Network,
EsploraURL: c.EsploraURL,
},

3
server/internal/config/config.go
View File

@@ -31,7 +31,6 @@ type Config struct {
AuthPass string
EsploraURL string
NeutrinoPeer string
WalletPassword string
}
var (
@@ -55,7 +54,6 @@ var (
AuthPass = "AUTH_PASS"
EsploraURL = "ESPLORA_URL"
NeutrinoPeer = "NEUTRINO_PEER"
WalletPassword = "WALLET_PASSWORD"
defaultDatadir = common.AppDataDir("arkd", false)
defaultRoundInterval = 5
@@ -130,7 +128,6 @@ func LoadConfig() (*Config, error) {
AuthPass: viper.GetString(AuthPass),
EsploraURL: viper.GetString(EsploraURL),
NeutrinoPeer: viper.GetString(NeutrinoPeer),
WalletPassword: viper.GetString(WalletPassword),
}, nil
}

42
server/internal/core/application/admin.go
View File

@@ -41,12 +41,10 @@ type RoundDetails struct {
}
type AdminService interface {
GetBalance(ctx context.Context) (*ArkProviderBalance, error)
Wallet() ports.WalletService
GetScheduledSweeps(ctx context.Context) ([]ScheduledSweep, error)
GetRoundDetails(ctx context.Context, roundId string) (*RoundDetails, error)
GetRounds(ctx context.Context, after int64, before int64) ([]string, error)
GetWalletAddress(ctx context.Context) (string, error)
GetWalletStatus(ctx context.Context) (*WalletStatus, error)
}
type adminService struct {
@@ -63,21 +61,8 @@ func NewAdminService(walletSvc ports.WalletService, repoManager ports.RepoManage
}
}
func (a *adminService) GetBalance(ctx context.Context) (*ArkProviderBalance, error) {
mainBalance, mainBalanceLocked, err := a.walletSvc.MainAccountBalance(ctx)
if err != nil {
return nil, err
}
connectorBalance, connectorBalanceLocked, err := a.walletSvc.ConnectorsAccountBalance(ctx)
if err != nil {
return nil, err
}
return &ArkProviderBalance{
MainAccountBalance: Balance{Locked: mainBalanceLocked, Available: mainBalance},
ConnectorsAccountBalance: Balance{Locked: connectorBalanceLocked, Available: connectorBalance},
}, nil
func (a *adminService) Wallet() ports.WalletService {
return a.walletSvc
}
func (a *adminService) GetRoundDetails(ctx context.Context, roundId string) (*RoundDetails, error) {
@@ -169,24 +154,3 @@ func (a *adminService) GetScheduledSweeps(ctx context.Context) ([]ScheduledSweep
return scheduledSweeps, nil
}
func (a *adminService) GetWalletAddress(ctx context.Context) (string, error) {
addresses, err := a.walletSvc.DeriveAddresses(ctx, 1)
if err != nil {
return "", err
}
return addresses[0], nil
}
func (a *adminService) GetWalletStatus(ctx context.Context) (*WalletStatus, error) {
status, err := a.walletSvc.Status(ctx)
if err != nil {
return nil, err
}
return &WalletStatus{
IsInitialized: status.IsInitialized(),
IsUnlocked: status.IsUnlocked(),
IsSynced: status.IsSynced(),
}, nil
}

5
server/internal/core/ports/wallet.go
View File

@@ -12,6 +12,11 @@ var ErrNonFinalBIP68 = errors.New("non-final BIP68 sequence")
type WalletService interface {
BlockchainScanner
GenSeed(ctx context.Context) (string, error)
Create(ctx context.Context, seed, password string) error
Restore(ctx context.Context, seed, password string) error
Unlock(ctx context.Context, password string) error
Lock(ctx context.Context, password string) error
Status(ctx context.Context) (WalletStatus, error)
GetPubkey(ctx context.Context) (*secp256k1.PublicKey, error)
DeriveConnectorAddress(ctx context.Context) (string, error)

61
server/internal/infrastructure/tx-builder/covenant/mocks_test.go
View File

@@ -12,7 +12,36 @@ type mockedWallet struct {
mock.Mock
}
// BroadcastTransaction implements ports.WalletService.
func (m *mockedWallet) GenSeed(ctx context.Context) (string, error) {
args := m.Called(ctx)
var res string
if a := args.Get(0); a != nil {
res = a.(string)
}
return res, args.Error(1)
}
func (m *mockedWallet) Create(ctx context.Context, seed, password string) error {
args := m.Called(ctx, seed, password)
return args.Error(0)
}
func (m *mockedWallet) Restore(ctx context.Context, seed, password string) error {
args := m.Called(ctx, seed, password)
return args.Error(0)
}
func (m *mockedWallet) Unlock(ctx context.Context, password string) error {
args := m.Called(ctx, password)
return args.Error(0)
}
func (m *mockedWallet) Lock(ctx context.Context, password string) error {
args := m.Called(ctx, password)
return args.Error(0)
}
func (m *mockedWallet) BroadcastTransaction(ctx context.Context, txHex string) (string, error) {
args := m.Called(ctx, txHex)
@@ -23,12 +52,10 @@ func (m *mockedWallet) BroadcastTransaction(ctx context.Context, txHex string) (
return res, args.Error(1)
}
// Close implements ports.WalletService.
func (m *mockedWallet) Close() {
m.Called()
}
// DeriveAddresses implements ports.WalletService.
func (m *mockedWallet) DeriveAddresses(ctx context.Context, num int) ([]string, error) {
args := m.Called(ctx, num)
@@ -39,7 +66,6 @@ func (m *mockedWallet) DeriveAddresses(ctx context.Context, num int) ([]string,
return res, args.Error(1)
}
// DeriveConnectorAddress implements ports.WalletService.
func (m *mockedWallet) DeriveConnectorAddress(ctx context.Context) (string, error) {
args := m.Called(ctx)
@@ -50,7 +76,6 @@ func (m *mockedWallet) DeriveConnectorAddress(ctx context.Context) (string, erro
return res, args.Error(1)
}
// GetPubkey implements ports.WalletService.
func (m *mockedWallet) GetPubkey(ctx context.Context) (*secp256k1.PublicKey, error) {
args := m.Called(ctx)
@@ -61,7 +86,6 @@ func (m *mockedWallet) GetPubkey(ctx context.Context) (*secp256k1.PublicKey, err
return res, args.Error(1)
}
// SignTransaction implements ports.WalletService.
func (m *mockedWallet) SignTransaction(ctx context.Context, pset string, extractRawTx bool) (string, error) {
args := m.Called(ctx, pset, extractRawTx)
@@ -72,7 +96,6 @@ func (m *mockedWallet) SignTransaction(ctx context.Context, pset string, extract
return res, args.Error(1)
}
// Status implements ports.WalletService.
func (m *mockedWallet) Status(ctx context.Context) (ports.WalletStatus, error) {
args := m.Called(ctx)
@@ -179,11 +202,31 @@ func (m *mockedWallet) WaitForSync(ctx context.Context, txid string) error {
}
func (m *mockedWallet) ConnectorsAccountBalance(ctx context.Context) (uint64, uint64, error) {
panic("not implemented")
args := m.Called(ctx)
var res uint64
if a := args.Get(0); a != nil {
res = a.(uint64)
}
var res2 uint64
if a := args.Get(1); a != nil {
res2 = a.(uint64)
}
return res, res2, args.Error(2)
}
func (m *mockedWallet) MainAccountBalance(ctx context.Context) (uint64, uint64, error) {
panic("not implemented")
args := m.Called(ctx)
var res uint64
if a := args.Get(0); a != nil {
res = a.(uint64)
}
var res2 uint64
if a := args.Get(1); a != nil {
res2 = a.(uint64)
}
return res, res2, args.Error(2)
}
type mockedInput struct {

37
server/internal/infrastructure/tx-builder/covenantless/mocks_test.go
View File

@@ -12,7 +12,36 @@ type mockedWallet struct {
mock.Mock
}
// BroadcastTransaction implements ports.WalletService.
func (m *mockedWallet) GenSeed(ctx context.Context) (string, error) {
args := m.Called(ctx)
var res string
if a := args.Get(0); a != nil {
res = a.(string)
}
return res, args.Error(1)
}
func (m *mockedWallet) Create(ctx context.Context, seed, password string) error {
args := m.Called(ctx, seed, password)
return args.Error(0)
}
func (m *mockedWallet) Restore(ctx context.Context, seed, password string) error {
args := m.Called(ctx, seed, password)
return args.Error(0)
}
func (m *mockedWallet) Unlock(ctx context.Context, password string) error {
args := m.Called(ctx, password)
return args.Error(0)
}
func (m *mockedWallet) Lock(ctx context.Context, password string) error {
args := m.Called(ctx, password)
return args.Error(0)
}
func (m *mockedWallet) BroadcastTransaction(ctx context.Context, txHex string) (string, error) {
args := m.Called(ctx, txHex)
@@ -23,12 +52,10 @@ func (m *mockedWallet) BroadcastTransaction(ctx context.Context, txHex string) (
return res, args.Error(1)
}
// Close implements ports.WalletService.
func (m *mockedWallet) Close() {
m.Called()
}
// DeriveAddresses implements ports.WalletService.
func (m *mockedWallet) DeriveAddresses(ctx context.Context, num int) ([]string, error) {
args := m.Called(ctx, num)
@@ -39,7 +66,6 @@ func (m *mockedWallet) DeriveAddresses(ctx context.Context, num int) ([]string,
return res, args.Error(1)
}
// DeriveConnectorAddress implements ports.WalletService.
func (m *mockedWallet) DeriveConnectorAddress(ctx context.Context) (string, error) {
args := m.Called(ctx)
@@ -50,7 +76,6 @@ func (m *mockedWallet) DeriveConnectorAddress(ctx context.Context) (string, erro
return res, args.Error(1)
}
// GetPubkey implements ports.WalletService.
func (m *mockedWallet) GetPubkey(ctx context.Context) (*secp256k1.PublicKey, error) {
args := m.Called(ctx)
@@ -61,7 +86,6 @@ func (m *mockedWallet) GetPubkey(ctx context.Context) (*secp256k1.PublicKey, err
return res, args.Error(1)
}
// SignTransaction implements ports.WalletService.
func (m *mockedWallet) SignTransaction(ctx context.Context, pset string, extractRawTx bool) (string, error) {
args := m.Called(ctx, pset, extractRawTx)
@@ -72,7 +96,6 @@ func (m *mockedWallet) SignTransaction(ctx context.Context, pset string, extract
return res, args.Error(1)
}
// Status implements ports.WalletService.
func (m *mockedWallet) Status(ctx context.Context) (ports.WalletStatus, error) {
args := m.Called(ctx)

334
server/internal/infrastructure/wallet/btc-embedded/wallet.go
View File

@@ -32,13 +32,13 @@ import (
"github.com/lightningnetwork/lnd/lnwallet"
"github.com/lightningnetwork/lnd/lnwallet/btcwallet"
log "github.com/sirupsen/logrus"
"github.com/vulpemventures/go-bip39"
)
type WalletOption func(*service) error
type WalletConfig struct {
Datadir string
Password []byte
Network common.Network
EsploraURL string
}
@@ -154,160 +154,40 @@ func NewService(cfg WalletConfig, options ...WalletOption) (ports.WalletService,
}
}
opt := btcwallet.LoaderWithLocalWalletDB(cfg.Datadir, false, time.Minute)
config := btcwallet.Config{
LogDir: cfg.Datadir,
PrivatePass: cfg.Password,
PublicPass: cfg.Password,
Birthday: time.Now(),
RecoveryWindow: 0,
NetParams: cfg.chainParams(),
LoaderOptions: []btcwallet.LoaderOption{opt},
CoinSelectionStrategy: wallet.CoinSelectionLargest,
ChainSource: svc.chainSource,
}
blockCache := blockcache.NewBlockCache(20 * 1024 * 1024)
wallet, err := btcwallet.New(config, blockCache)
if err != nil {
return nil, fmt.Errorf("failed to setup wallet loader: %s", err)
}
if err := wallet.Start(); err != nil {
return nil, fmt.Errorf("failed to start wallet: %s", err)
}
svc.wallet = wallet
if err := svc.initWallet(); err != nil {
return nil, err
}
for {
if !wallet.InternalWallet().ChainSynced() {
log.Debug("waiting sync....")
time.Sleep(3 * time.Second)
continue
}
break
}
log.Debugf("chain synced")
return svc, nil
}
// setWalletLoader init the wallet db and configure the wallet accounts
func (s *service) initWallet() error {
w := s.wallet.InternalWallet()
walletAccounts, err := w.Accounts(p2wpkhKeyScope)
if err != nil {
return fmt.Errorf("failed to list wallet accounts: %s", err)
}
var mainAccountNumber, connectorAccountNumber, aspKeyAccountNumber uint32
if walletAccounts != nil {
for _, account := range walletAccounts.Accounts {
switch account.AccountName {
case string(mainAccount):
mainAccountNumber = account.AccountNumber
case string(connectorAccount):
connectorAccountNumber = account.AccountNumber
case string(aspKeyAccount):
aspKeyAccountNumber = account.AccountNumber
default:
continue
}
}
}
if mainAccountNumber == 0 && connectorAccountNumber == 0 && aspKeyAccountNumber == 0 {
log.Debug("creating default accounts for ark wallet...")
mainAccountNumber, err = w.NextAccount(p2wpkhKeyScope, string(mainAccount))
if err != nil {
return fmt.Errorf("failed to create %s: %s", mainAccount, err)
}
connectorAccountNumber, err = w.NextAccount(p2wpkhKeyScope, string(connectorAccount))
if err != nil {
return fmt.Errorf("failed to create %s: %s", connectorAccount, err)
}
aspKeyAccountNumber, err = w.NextAccount(p2trKeyScope, string(aspKeyAccount))
if err != nil {
return fmt.Errorf("failed to create %s: %s", aspKeyAccount, err)
}
}
log.Debugf("main account number: %d", mainAccountNumber)
log.Debugf("connector account number: %d", connectorAccountNumber)
log.Debugf("asp key account number: %d", aspKeyAccountNumber)
addrs, err := s.wallet.ListAddresses(string(aspKeyAccount), false)
if err != nil {
return err
}
if len(addrs) == 0 {
aspKeyAddr, err := s.wallet.NewAddress(lnwallet.TaprootPubkey, false, string(aspKeyAccount))
if err != nil {
return err
}
addrInfos, err := s.wallet.AddressInfo(aspKeyAddr)
if err != nil {
return err
}
managedAddr, ok := addrInfos.(waddrmgr.ManagedPubKeyAddress)
if !ok {
return errors.New("failed to cast address to managed pubkey address")
}
s.aspTaprootAddr = managedAddr
} else {
for info, addrs := range addrs {
if info.AccountName != string(aspKeyAccount) {
continue
}
for _, addr := range addrs {
fmt.Println(addr.DerivationPath)
if addr.Internal {
continue
}
splittedPath := strings.Split(addr.DerivationPath, "/")
last := splittedPath[len(splittedPath)-1]
if last == "0" {
decoded, err := btcutil.DecodeAddress(addr.Address, s.cfg.chainParams())
if err != nil {
return err
}
infos, err := s.wallet.AddressInfo(decoded)
if err != nil {
return err
}
managedPubkeyAddr, ok := infos.(waddrmgr.ManagedPubKeyAddress)
if !ok {
return errors.New("failed to cast address to managed pubkey address")
}
s.aspTaprootAddr = managedPubkeyAddr
break
}
}
}
}
return nil
}
func (s *service) Close() {
if err := s.wallet.Stop(); err != nil {
log.WithError(err).Warn("failed to gracefully stop the wallet, forcing shutdown")
}
}
func (s *service) GenSeed(_ context.Context) (string, error) {
entropy, err := bip39.NewEntropy(256)
if err != nil {
return "", err
}
return bip39.NewMnemonic(entropy)
}
func (s *service) Create(_ context.Context, seed, password string) error {
return s.create(seed, password, 0)
}
func (s *service) Restore(_ context.Context, seed, password string) error {
return s.create(seed, password, 100)
}
func (s *service) Unlock(_ context.Context, password string) error {
return s.wallet.InternalWallet().Unlock([]byte(password), nil)
}
func (s *service) Lock(_ context.Context, _ string) error {
s.wallet.InternalWallet().Lock()
return nil
}
func (s *service) BroadcastTransaction(ctx context.Context, txHex string) (string, error) {
if err := s.esploraClient.broadcast(txHex); err != nil {
return "", err
@@ -558,11 +438,14 @@ func (s *service) SignTransactionTapscript(ctx context.Context, partialTx string
}
func (s *service) Status(ctx context.Context) (ports.WalletStatus, error) {
w := s.wallet.InternalWallet()
if s.wallet == nil {
return status{}, nil
}
w := s.wallet.InternalWallet()
return status{
true,
true,
!w.Manager.IsLocked(),
w.ChainSynced(),
}, nil
}
@@ -712,6 +595,161 @@ func (s *service) castNotification(tx *wtxmgr.TxRecord) map[string]ports.VtxoWit
return vtxos
}
func (s *service) create(mnemonic, password string, addrGap uint32) error {
if len(mnemonic) <= 0 {
return fmt.Errorf("missing hd seed")
}
if len(password) <= 0 {
return fmt.Errorf("missing password")
}
pwd := []byte(password)
seed := bip39.NewSeed(mnemonic, password)
opt := btcwallet.LoaderWithLocalWalletDB(s.cfg.Datadir, false, time.Minute)
config := btcwallet.Config{
LogDir: s.cfg.Datadir,
PrivatePass: pwd,
PublicPass: pwd,
Birthday: time.Now(),
RecoveryWindow: addrGap,
HdSeed: seed,
NetParams: s.cfg.chainParams(),
LoaderOptions: []btcwallet.LoaderOption{opt},
CoinSelectionStrategy: wallet.CoinSelectionLargest,
ChainSource: s.chainSource,
}
blockCache := blockcache.NewBlockCache(20 * 1024 * 1024)
wallet, err := btcwallet.New(config, blockCache)
if err != nil {
return fmt.Errorf("failed to setup wallet loader: %s", err)
}
if err := wallet.Start(); err != nil {
return fmt.Errorf("failed to start wallet: %s", err)
}
if err := s.initWallet(wallet); err != nil {
return err
}
for {
if !wallet.InternalWallet().ChainSynced() {
log.Debug("waiting sync....")
time.Sleep(3 * time.Second)
continue
}
break
}
log.Debugf("chain synced")
wallet.InternalWallet().Lock()
s.wallet = wallet
return nil
}
func (s *service) initWallet(wallet *btcwallet.BtcWallet) error {
w := wallet.InternalWallet()
walletAccounts, err := w.Accounts(p2wpkhKeyScope)
if err != nil {
return fmt.Errorf("failed to list wallet accounts: %s", err)
}
var mainAccountNumber, connectorAccountNumber, aspKeyAccountNumber uint32
if walletAccounts != nil {
for _, account := range walletAccounts.Accounts {
switch account.AccountName {
case string(mainAccount):
mainAccountNumber = account.AccountNumber
case string(connectorAccount):
connectorAccountNumber = account.AccountNumber
case string(aspKeyAccount):
aspKeyAccountNumber = account.AccountNumber
default:
continue
}
}
}
if mainAccountNumber == 0 && connectorAccountNumber == 0 && aspKeyAccountNumber == 0 {
log.Debug("creating default accounts for ark wallet...")
mainAccountNumber, err = w.NextAccount(p2wpkhKeyScope, string(mainAccount))
if err != nil {
return fmt.Errorf("failed to create %s: %s", mainAccount, err)
}
connectorAccountNumber, err = w.NextAccount(p2wpkhKeyScope, string(connectorAccount))
if err != nil {
return fmt.Errorf("failed to create %s: %s", connectorAccount, err)
}
aspKeyAccountNumber, err = w.NextAccount(p2trKeyScope, string(aspKeyAccount))
if err != nil {
return fmt.Errorf("failed to create %s: %s", aspKeyAccount, err)
}
}
log.Debugf("main account number: %d", mainAccountNumber)
log.Debugf("connector account number: %d", connectorAccountNumber)
log.Debugf("asp key account number: %d", aspKeyAccountNumber)
addrs, err := wallet.ListAddresses(string(aspKeyAccount), false)
if err != nil {
return err
}
if len(addrs) == 0 {
aspKeyAddr, err := wallet.NewAddress(lnwallet.TaprootPubkey, false, string(aspKeyAccount))
if err != nil {
return err
}
addrInfos, err := wallet.AddressInfo(aspKeyAddr)
if err != nil {
return err
}
managedAddr, ok := addrInfos.(waddrmgr.ManagedPubKeyAddress)
if !ok {
return errors.New("failed to cast address to managed pubkey address")
}
s.aspTaprootAddr = managedAddr
} else {
for info, addrs := range addrs {
if info.AccountName != string(aspKeyAccount) {
continue
}
for _, addr := range addrs {
if addr.Internal {
continue
}
splittedPath := strings.Split(addr.DerivationPath, "/")
last := splittedPath[len(splittedPath)-1]
if last == "0" {
decoded, err := btcutil.DecodeAddress(addr.Address, s.cfg.chainParams())
if err != nil {
return err
}
infos, err := s.wallet.AddressInfo(decoded)
if err != nil {
return err
}
managedPubkeyAddr, ok := infos.(waddrmgr.ManagedPubKeyAddress)
if !ok {
return errors.New("failed to cast address to managed pubkey address")
}
s.aspTaprootAddr = managedPubkeyAddr
break
}
}
}
}
return nil
}
func (s *service) getBalance(account accountName) (uint64, error) {
balance, err := s.wallet.ConfirmedBalance(0, string(account))
if err != nil {

97
server/internal/infrastructure/wallet/liquid-standalone/service.go
View File

@@ -4,7 +4,6 @@ import (
"context"
"io"
"strings"
"time"
pb "github.com/ark-network/ark/api-spec/protobuf/gen/ocean/v1"
"github.com/ark-network/ark/internal/core/domain"
@@ -24,6 +23,7 @@ type service struct {
txClient pb.TransactionServiceClient
notifyClient pb.NotificationServiceClient
chVtxos chan map[string]ports.VtxoWithValue
isListening bool
}
func NewService(addr string) (ports.WalletService, error) {
@@ -48,28 +48,59 @@ func NewService(addr string) (ports.WalletService, error) {
ctx := context.Background()
isReady := false
for !isReady {
status, err := svc.Status(ctx)
if err != nil {
return nil, err
}
isReady = status.IsInitialized() && status.IsUnlocked()
if !isReady {
log.Info("Wallet must be initialized and unlocked to proceed. Waiting for wallet to be ready...")
time.Sleep(3 * time.Second)
}
}
// Create ark account at startup if needed.
info, err := walletClient.GetInfo(ctx, &pb.GetInfoRequest{})
status, err := svc.Status(ctx)
if err != nil {
return nil, err
}
if status.IsUnlocked() {
go svc.listenToNotifications()
}
return svc, nil
}
func (s *service) Close() {
close(s.chVtxos)
s.conn.Close()
}
func (s *service) GenSeed(ctx context.Context) (string, error) {
res, err := s.walletClient.GenSeed(ctx, &pb.GenSeedRequest{})
if err != nil {
return "", err
}
return res.GetMnemonic(), nil
}
func (s *service) Create(ctx context.Context, seed, password string) error {
_, err := s.walletClient.CreateWallet(ctx, &pb.CreateWalletRequest{
Mnemonic: seed,
Password: password,
})
return err
}
func (s *service) Restore(ctx context.Context, seed, password string) error {
_, err := s.walletClient.RestoreWallet(ctx, &pb.RestoreWalletRequest{
Mnemonic: seed,
Password: password,
})
return err
}
func (s *service) Unlock(ctx context.Context, password string) error {
if _, err := s.walletClient.Unlock(ctx, &pb.UnlockRequest{
Password: password,
}); err != nil {
return err
}
info, err := s.walletClient.GetInfo(ctx, &pb.GetInfoRequest{})
if err != nil {
return err
}
mainAccountFound, connectorAccountFound := false, false
for _, account := range info.GetAccounts() {
@@ -88,34 +119,42 @@ func NewService(addr string) (ports.WalletService, error) {
}
}
if !mainAccountFound {
if _, err := accountClient.CreateAccountBIP44(ctx, &pb.CreateAccountBIP44Request{
if _, err := s.accountClient.CreateAccountBIP44(ctx, &pb.CreateAccountBIP44Request{
Label: arkAccount,
Unconfidential: true,
}); err != nil {
return nil, err
return err
}
}
if !connectorAccountFound {
if _, err := accountClient.CreateAccountBIP44(ctx, &pb.CreateAccountBIP44Request{
if _, err := s.accountClient.CreateAccountBIP44(ctx, &pb.CreateAccountBIP44Request{
Label: connectorAccount,
Unconfidential: true,
}); err != nil {
return nil, err
return err
}
}
go svc.listenToNotifications()
return svc, nil
if !s.isListening {
go s.listenToNotifications()
}
return err
}
func (s *service) Close() {
close(s.chVtxos)
s.conn.Close()
func (s *service) Lock(ctx context.Context, password string) error {
_, err := s.walletClient.Lock(ctx, &pb.LockRequest{
Password: password,
})
return err
}
func (s *service) listenToNotifications() {
s.isListening = true
defer func() {
s.isListening = false
}()
var stream pb.NotificationService_UtxosNotificationsClient
var err error
for {

47
server/internal/interface/grpc/handlers/adminservice.go
View File

@@ -12,28 +12,13 @@ import (
type adminHandler struct {
adminService application.AdminService
aspService application.Service
}
func NewAdminHandler(adminService application.AdminService) arkv1.AdminServiceServer {
return &adminHandler{adminService}
}
func (a *adminHandler) GetBalance(ctx context.Context, _ *arkv1.GetBalanceRequest) (*arkv1.GetBalanceResponse, error) {
balance, err := a.adminService.GetBalance(ctx)
if err != nil {
return nil, err
}
return &arkv1.GetBalanceResponse{
MainAccount: &arkv1.Balance{
Locked: convertSatoshis(balance.MainAccountBalance.Locked),
Available: convertSatoshis(balance.MainAccountBalance.Available),
},
ConnectorsAccount: &arkv1.Balance{
Locked: convertSatoshis(balance.ConnectorsAccountBalance.Locked),
Available: convertSatoshis(balance.ConnectorsAccountBalance.Available),
},
}, nil
func NewAdminHandler(
adminService application.AdminService, aspService application.Service,
) arkv1.AdminServiceServer {
return &adminHandler{adminService, aspService}
}
func (a *adminHandler) GetRoundDetails(ctx context.Context, req *arkv1.GetRoundDetailsRequest) (*arkv1.GetRoundDetailsResponse, error) {
@@ -114,28 +99,6 @@ func (a *adminHandler) GetScheduledSweep(ctx context.Context, _ *arkv1.GetSchedu
return &arkv1.GetScheduledSweepResponse{Sweeps: sweeps}, nil
}
func (a *adminHandler) GetWalletAddress(ctx context.Context, _ *arkv1.GetWalletAddressRequest) (*arkv1.GetWalletAddressResponse, error) {
addr, err := a.adminService.GetWalletAddress(ctx)
if err != nil {
return nil, err
}
return &arkv1.GetWalletAddressResponse{Address: addr}, nil
}
func (a *adminHandler) GetWalletStatus(ctx context.Context, _ *arkv1.GetWalletStatusRequest) (*arkv1.GetWalletStatusResponse, error) {
status, err := a.adminService.GetWalletStatus(ctx)
if err != nil {
return nil, err
}
return &arkv1.GetWalletStatusResponse{
Initialized: status.IsInitialized,
Unlocked: status.IsUnlocked,
Synced: status.IsSynced,
}, nil
}
// convert sats to string BTC
func convertSatoshis(sats uint64) string {
btc := float64(sats) * 1e-8

129
server/internal/interface/grpc/handlers/walletservice.go Normal file
View File

@@ -0,0 +1,129 @@
package handlers
import (
"context"
"fmt"
arkv1 "github.com/ark-network/ark/api-spec/protobuf/gen/ark/v1"
"github.com/ark-network/ark/internal/core/ports"
)
type walletHandler struct {
walletService ports.WalletService
onUnlock func()
}
func NewWalletHandler(walletService ports.WalletService, onUnlock func()) arkv1.WalletServiceServer {
return &walletHandler{walletService, onUnlock}
}
func (a *walletHandler) GenSeed(ctx context.Context, _ *arkv1.GenSeedRequest) (*arkv1.GenSeedResponse, error) {
seed, err := a.walletService.GenSeed(ctx)
if err != nil {
return nil, err
}
return &arkv1.GenSeedResponse{Seed: seed}, nil
}
func (a *walletHandler) Create(ctx context.Context, req *arkv1.CreateRequest) (*arkv1.CreateResponse, error) {
if len(req.GetSeed()) <= 0 {
return nil, fmt.Errorf("missing wallet seed")
}
if len(req.GetPassword()) <= 0 {
return nil, fmt.Errorf("missing wallet password")
}
if err := a.walletService.Create(
ctx, req.GetSeed(), req.GetPassword(),
); err != nil {
return nil, err
}
return &arkv1.CreateResponse{}, nil
}
func (a *walletHandler) Restore(ctx context.Context, req *arkv1.RestoreRequest) (*arkv1.RestoreResponse, error) {
if len(req.GetSeed()) <= 0 {
return nil, fmt.Errorf("missing wallet seed")
}
if len(req.GetPassword()) <= 0 {
return nil, fmt.Errorf("missing wallet password")
}
if err := a.walletService.Restore(
ctx, req.GetSeed(), req.GetPassword(),
); err != nil {
return nil, err
}
return &arkv1.RestoreResponse{}, nil
}
func (a *walletHandler) Unlock(ctx context.Context, req *arkv1.UnlockRequest) (*arkv1.UnlockResponse, error) {
if len(req.GetPassword()) <= 0 {
return nil, fmt.Errorf("missing wallet password")
}
if err := a.walletService.Unlock(ctx, req.GetPassword()); err != nil {
return nil, err
}
go a.onUnlock()
return &arkv1.UnlockResponse{}, nil
}
func (a *walletHandler) Lock(ctx context.Context, req *arkv1.LockRequest) (*arkv1.LockResponse, error) {
if len(req.GetPassword()) <= 0 {
return nil, fmt.Errorf("missing wallet password")
}
if err := a.walletService.Lock(ctx, req.GetPassword()); err != nil {
return nil, err
}
return &arkv1.LockResponse{}, nil
}
func (a *walletHandler) GetStatus(ctx context.Context, _ *arkv1.GetStatusRequest) (*arkv1.GetStatusResponse, error) {
status, err := a.walletService.Status(ctx)
if err != nil {
return nil, err
}
return &arkv1.GetStatusResponse{
Initialized: status.IsInitialized(),
Unlocked: status.IsUnlocked(),
Synced: status.IsSynced(),
}, nil
}
func (a *walletHandler) DeriveAddress(ctx context.Context, _ *arkv1.DeriveAddressRequest) (*arkv1.DeriveAddressResponse, error) {
addr, err := a.walletService.DeriveAddresses(ctx, 1)
if err != nil {
return nil, err
}
return &arkv1.DeriveAddressResponse{Address: addr[0]}, nil
}
func (a *walletHandler) GetBalance(ctx context.Context, _ *arkv1.GetBalanceRequest) (*arkv1.GetBalanceResponse, error) {
availableMainBalance, lockedMainBalance, err := a.walletService.MainAccountBalance(ctx)
if err != nil {
return nil, err
}
availableConnectorsBalance, lockedConnectorsBalance, err := a.walletService.ConnectorsAccountBalance(ctx)
if err != nil {
return nil, err
}
return &arkv1.GetBalanceResponse{
MainAccount: &arkv1.Balance{
Locked: convertSatoshis(lockedMainBalance),
Available: convertSatoshis(availableMainBalance),
},
ConnectorsAccount: &arkv1.Balance{
Locked: convertSatoshis(lockedConnectorsBalance),
Available: convertSatoshis(availableConnectorsBalance),
},
}, nil
}

152
server/internal/interface/grpc/service.go
View File

@@ -9,6 +9,7 @@ import (
arkv1 "github.com/ark-network/ark/api-spec/protobuf/gen/ark/v1"
appconfig "github.com/ark-network/ark/internal/app-config"
"github.com/ark-network/ark/internal/core/application"
interfaces "github.com/ark-network/ark/internal/interface"
"github.com/ark-network/ark/internal/interface/grpc/handlers"
"github.com/ark-network/ark/internal/interface/grpc/interceptors"
@@ -24,9 +25,10 @@ import (
)
type service struct {
config Config
appConfig *appconfig.Config
server *http.Server
config Config
appConfig *appconfig.Config
server *http.Server
grpcServer *grpc.Server
}
func NewService(
@@ -39,44 +41,107 @@ func NewService(
return nil, fmt.Errorf("invalid app config: %s", err)
}
return &service{svcConfig, appConfig, nil, nil}, nil
}
func (s *service) Start() error {
withoutAppSvc := false
return s.start(withoutAppSvc)
}
func (s *service) Stop() {
withAppSvc := true
s.stop(withAppSvc)
}
func (s *service) start(withAppSvc bool) error {
if err := s.newServer(withAppSvc); err != nil {
return err
}
if withAppSvc {
appSvc, _ := s.appConfig.AppService()
if err := appSvc.Start(); err != nil {
return fmt.Errorf("failed to start app service: %s", err)
}
log.Info("started app service")
}
if s.config.insecure() {
// nolint:all
go s.server.ListenAndServe()
} else {
// nolint:all
go s.server.ListenAndServeTLS("", "")
}
log.Infof("started listening at %s", s.config.address())
return nil
}
func (s *service) stop(withAppSvc bool) {
//nolint:all
s.server.Shutdown(context.Background())
log.Info("stopped grpc server")
if withAppSvc {
appSvc, _ := s.appConfig.AppService()
if appSvc != nil {
appSvc.Stop()
log.Info("stopped app service")
}
}
}
func (s *service) newServer(withAppSvc bool) error {
grpcConfig := []grpc.ServerOption{
interceptors.UnaryInterceptor(svcConfig.AuthUser, svcConfig.AuthPass),
interceptors.UnaryInterceptor(s.config.AuthUser, s.config.AuthPass),
interceptors.StreamInterceptor(),
}
if !svcConfig.NoTLS {
return nil, fmt.Errorf("tls termination not supported yet")
if !s.config.NoTLS {
return fmt.Errorf("tls termination not supported yet")
}
creds := insecure.NewCredentials()
if !svcConfig.insecure() {
creds = credentials.NewTLS(svcConfig.tlsConfig())
if !s.config.insecure() {
creds = credentials.NewTLS(s.config.tlsConfig())
}
grpcConfig = append(grpcConfig, grpc.Creds(creds))
// Server grpc.
grpcServer := grpc.NewServer(grpcConfig...)
appHandler := handlers.NewHandler(appConfig.AppService())
arkv1.RegisterArkServiceServer(grpcServer, appHandler)
var appSvc application.Service
if withAppSvc {
svc, err := s.appConfig.AppService()
if err != nil {
return err
}
appSvc = svc
appHandler := handlers.NewHandler(appSvc)
arkv1.RegisterArkServiceServer(grpcServer, appHandler)
}
adminHandler := handlers.NewAdminHandler(appConfig.AdminService())
adminHandler := handlers.NewAdminHandler(s.appConfig.AdminService(), appSvc)
arkv1.RegisterAdminServiceServer(grpcServer, adminHandler)
walletHandler := handlers.NewWalletHandler(s.appConfig.WalletService(), s.onUnlock)
arkv1.RegisterWalletServiceServer(grpcServer, walletHandler)
healthHandler := handlers.NewHealthHandler()
grpchealth.RegisterHealthServer(grpcServer, healthHandler)
// Creds for grpc gateway reverse proxy.
gatewayCreds := insecure.NewCredentials()
if !svcConfig.insecure() {
if !s.config.insecure() {
gatewayCreds = credentials.NewTLS(&tls.Config{
InsecureSkipVerify: true, // #nosec
})
}
gatewayOpts := grpc.WithTransportCredentials(gatewayCreds)
conn, err := grpc.NewClient(
svcConfig.gatewayAddress(), gatewayOpts,
s.config.gatewayAddress(), gatewayOpts,
)
if err != nil {
return nil, err
return err
}
// Reverse proxy grpc-gateway.
gwmux := runtime.NewServeMux(
@@ -92,15 +157,22 @@ func NewService(
}),
)
ctx := context.Background()
if err := arkv1.RegisterArkServiceHandler(
ctx, gwmux, conn,
); err != nil {
return nil, err
}
if err := arkv1.RegisterAdminServiceHandler(
ctx, gwmux, conn,
); err != nil {
return nil, err
return err
}
if err := arkv1.RegisterWalletServiceHandler(
ctx, gwmux, conn,
); err != nil {
return err
}
if withAppSvc {
if err := arkv1.RegisterArkServiceHandler(
ctx, gwmux, conn,
); err != nil {
return err
}
}
grpcGateway := http.Handler(gwmux)
@@ -109,43 +181,27 @@ func NewService(
mux.Handle("/", handler)
httpServerHandler := http.Handler(mux)
if svcConfig.insecure() {
if s.config.insecure() {
httpServerHandler = h2c.NewHandler(httpServerHandler, &http2.Server{})
}
server := &http.Server{
Addr: svcConfig.address(),
s.server = &http.Server{
Addr: s.config.address(),
Handler: httpServerHandler,
TLSConfig: svcConfig.tlsConfig(),
TLSConfig: s.config.tlsConfig(),
}
return &service{svcConfig, appConfig, server}, nil
}
func (s *service) Start() error {
if s.config.insecure() {
// nolint:all
go s.server.ListenAndServe()
} else {
// nolint:all
go s.server.ListenAndServeTLS("", "")
}
log.Infof("started listening at %s", s.config.address())
if err := s.appConfig.AppService().Start(); err != nil {
return fmt.Errorf("failed to start app service: %s", err)
}
log.Info("started app service")
return nil
}
func (s *service) Stop() {
// nolint:all
s.server.Shutdown(context.Background())
log.Info("stopped grpc server")
s.appConfig.AppService().Stop()
log.Info("stopped app service")
func (s *service) onUnlock() {
withoutAppSvc := false
s.stop(withoutAppSvc)
withAppSvc := true
if err := s.start(withAppSvc); err != nil {
panic(err)
}
}
func router(

159
server/test/e2e/covenant/e2e_test.go
View File

@@ -1,8 +1,10 @@
package e2e_test
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"os"
"testing"
"time"
@@ -18,78 +20,22 @@ const (
)
func TestMain(m *testing.M) {
_, err := utils.RunCommand("docker-compose", "-f", composePath, "up", "-d", "--build")
_, err := utils.RunCommand("docker", "compose", "-f", composePath, "up", "-d", "--build")
if err != nil {
fmt.Printf("error starting docker-compose: %s", err)
os.Exit(1)
}
_, err = runOceanCommand("config", "init", "--no-tls")
if err != nil {
fmt.Printf("error initializing ocean config: %s", err)
os.Exit(1)
}
time.Sleep(10 * time.Second)
_, err = runOceanCommand("wallet", "create", "--password", utils.Password)
if err != nil {
fmt.Printf("error creating ocean wallet: %s", err)
os.Exit(1)
}
_, err = runOceanCommand("wallet", "unlock", "--password", utils.Password)
if err != nil {
fmt.Printf("error unlocking ocean wallet: %s", err)
os.Exit(1)
}
_, err = runOceanCommand("account", "create", "--label", "ark", "--unconf")
if err != nil {
fmt.Printf("error creating ocean account: %s", err)
os.Exit(1)
}
addrJSON, err := runOceanCommand("account", "derive", "--account-name", "ark")
if err != nil {
fmt.Printf("error deriving ocean account: %s", err)
os.Exit(1)
}
var addr struct {
Addresses []string `json:"addresses"`
}
if err := json.Unmarshal([]byte(addrJSON), &addr); err != nil {
fmt.Printf("error unmarshalling ocean account: %s (%s)", err, addrJSON)
os.Exit(1)
}
_, err = utils.RunCommand("nigiri", "faucet", "--liquid", addr.Addresses[0])
if err != nil {
fmt.Printf("error funding ocean account: %s", err)
os.Exit(1)
}
_, err = utils.RunCommand("nigiri", "faucet", "--liquid", addr.Addresses[0])
if err != nil {
fmt.Printf("error funding ocean account: %s", err)
os.Exit(1)
}
_, err = utils.RunCommand("nigiri", "faucet", "--liquid", addr.Addresses[0])
if err != nil {
fmt.Printf("error funding ocean account: %s", err)
os.Exit(1)
}
_, err = utils.RunCommand("nigiri", "faucet", "--liquid", addr.Addresses[0])
if err != nil {
fmt.Printf("error funding ocean account: %s", err)
if err := setupAspWallet(); err != nil {
fmt.Println(err)
os.Exit(1)
}
time.Sleep(3 * time.Second)
_, err = runArkCommand("init", "--ark-url", "localhost:6000", "--password", utils.Password, "--network", common.LiquidRegTest.Name, "--explorer", "http://chopsticks-liquid:3000")
_, err = runArkCommand("init", "--ark-url", "localhost:8080", "--password", utils.Password, "--network", common.LiquidRegTest.Name, "--explorer", "http://chopsticks-liquid:3000")
if err != nil {
fmt.Printf("error initializing ark config: %s", err)
os.Exit(1)
@@ -117,7 +63,7 @@ func TestMain(m *testing.M) {
code := m.Run()
_, err = utils.RunCommand("docker-compose", "-f", composePath, "down")
_, err = utils.RunCommand("docker", "compose", "-f", composePath, "down")
if err != nil {
fmt.Printf("error stopping docker-compose: %s", err)
os.Exit(1)
@@ -214,6 +160,8 @@ func TestUnilateralExit(t *testing.T) {
err = utils.GenerateBlock()
require.NoError(t, err)
time.Sleep(5 * time.Second)
balanceStr, err = runArkCommand("balance")
require.NoError(t, err)
require.NoError(t, json.Unmarshal([]byte(balanceStr), &balance))
@@ -256,12 +204,89 @@ func TestCollaborativeExit(t *testing.T) {
require.Equal(t, balanceOnchainBefore+1000, balance.Onchain.Spendable)
}
func runOceanCommand(arg ...string) (string, error) {
args := append([]string{"exec", "oceand", "ocean"}, arg...)
return utils.RunCommand("docker", args...)
}
func runArkCommand(arg ...string) (string, error) {
args := append([]string{"exec", "-t", "arkd", "ark"}, arg...)
return utils.RunCommand("docker", args...)
}
func setupAspWallet() error {
adminHttpClient := &http.Client{
Timeout: 15 * time.Second,
}
req, err := http.NewRequest("GET", "http://localhost:8080/v1/admin/wallet/seed", nil)
if err != nil {
return fmt.Errorf("failed to prepare generate seed request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
seedResp, err := adminHttpClient.Do(req)
if err != nil {
return fmt.Errorf("failed to generate seed: %s", err)
}
var seed struct {
Seed string `json:"seed"`
}
if err := json.NewDecoder(seedResp.Body).Decode(&seed); err != nil {
return fmt.Errorf("failed to parse response: %s", err)
}
reqBody := bytes.NewReader([]byte(fmt.Sprintf(`{"seed": "%s", "password": "%s"}`, seed.Seed, utils.Password)))
req, err = http.NewRequest("POST", "http://localhost:8080/v1/admin/wallet/create", reqBody)
if err != nil {
return fmt.Errorf("failed to prepare wallet create request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
req.Header.Set("Content-Type", "application/json")
if _, err := adminHttpClient.Do(req); err != nil {
return fmt.Errorf("failed to create wallet: %s", err)
}
reqBody = bytes.NewReader([]byte(fmt.Sprintf(`{"password": "%s"}`, utils.Password)))
req, err = http.NewRequest("POST", "http://localhost:8080/v1/admin/wallet/unlock", reqBody)
if err != nil {
return fmt.Errorf("failed to prepare wallet unlock request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
req.Header.Set("Content-Type", "application/json")
if _, err := adminHttpClient.Do(req); err != nil {
return fmt.Errorf("failed to unlock wallet: %s", err)
}
time.Sleep(time.Second)
req, err = http.NewRequest("GET", "http://localhost:8080/v1/admin/wallet/address", nil)
if err != nil {
return fmt.Errorf("failed to prepare new address request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
resp, err := adminHttpClient.Do(req)
if err != nil {
return fmt.Errorf("failed to get new address: %s", err)
}
var addr struct {
Address string `json:"address"`
}
if err := json.NewDecoder(resp.Body).Decode(&addr); err != nil {
return fmt.Errorf("failed to parse response: %s", err)
}
if _, err := utils.RunCommand("nigiri", "faucet", "--liquid", addr.Address); err != nil {
return fmt.Errorf("failed to fund wallet: %s", err)
}
if _, err := utils.RunCommand("nigiri", "faucet", "--liquid", addr.Address); err != nil {
return fmt.Errorf("failed to fund wallet: %s", err)
}
if _, err := utils.RunCommand("nigiri", "faucet", "--liquid", addr.Address); err != nil {
return fmt.Errorf("failed to fund wallet: %s", err)
}
return nil
}

123
server/test/e2e/covenantless/e2e_test.go
View File

@@ -1,6 +1,7 @@
package e2e_test
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
@@ -18,51 +19,16 @@ const (
)
func TestMain(m *testing.M) {
_, err := utils.RunCommand("docker-compose", "-f", composePath, "up", "-d", "--build")
_, err := utils.RunCommand("docker", "compose", "-f", composePath, "up", "-d", "--build")
if err != nil {
fmt.Printf("error starting docker-compose: %s", err)
os.Exit(1)
}
// wait some time to let the wallet start
time.Sleep(12 * time.Second)
time.Sleep(10 * time.Second)
req, err := http.NewRequest("GET", "http://localhost:6000/v1/admin/address", nil)
if err != nil {
fmt.Printf("error requesting wallet address: %s", err)
os.Exit(1)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
adminHttpClient := &http.Client{
Timeout: 15 * time.Second,
}
resp, err := adminHttpClient.Do(req)
if err != nil {
fmt.Printf("error requesting wallet address: %s", err)
os.Exit(1)
}
var addr struct {
Address string `json:"address"`
}
if err := json.NewDecoder(resp.Body).Decode(&addr); err != nil {
fmt.Printf("error unmarshalling /address response: %s", err)
os.Exit(1)
}
_, err = utils.RunCommand("nigiri", "faucet", addr.Address)
if err != nil {
fmt.Printf("error funding ASP account: %s", err)
os.Exit(1)
}
_, err = utils.RunCommand("nigiri", "faucet", addr.Address)
if err != nil {
fmt.Printf("error funding ASP account: %s", err)
if err := setupAspWallet(); err != nil {
fmt.Println(err)
os.Exit(1)
}
@@ -96,7 +62,7 @@ func TestMain(m *testing.M) {
code := m.Run()
_, err = utils.RunCommand("docker-compose", "-f", composePath, "down")
_, err = utils.RunCommand("docker", "compose", "-f", composePath, "down")
if err != nil {
fmt.Printf("error stopping docker-compose: %s", err)
os.Exit(1)
@@ -210,3 +176,80 @@ func runClarkCommand(arg ...string) (string, error) {
args := append([]string{"exec", "-t", "clarkd", "ark"}, arg...)
return utils.RunCommand("docker", args...)
}
func setupAspWallet() error {
adminHttpClient := &http.Client{
Timeout: 15 * time.Second,
}
req, err := http.NewRequest("GET", "http://localhost:6000/v1/admin/wallet/seed", nil)
if err != nil {
return fmt.Errorf("failed to prepare generate seed request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
seedResp, err := adminHttpClient.Do(req)
if err != nil {
return fmt.Errorf("failed to generate seed: %s", err)
}
var seed struct {
Seed string `json:"seed"`
}
if err := json.NewDecoder(seedResp.Body).Decode(&seed); err != nil {
return fmt.Errorf("failed to parse response: %s", err)
}
reqBody := bytes.NewReader([]byte(fmt.Sprintf(`{"seed": "%s", "password": "%s"}`, seed.Seed, utils.Password)))
req, err = http.NewRequest("POST", "http://localhost:6000/v1/admin/wallet/create", reqBody)
if err != nil {
return fmt.Errorf("failed to prepare wallet create request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
req.Header.Set("Content-Type", "application/json")
if _, err := adminHttpClient.Do(req); err != nil {
return fmt.Errorf("failed to create wallet: %s", err)
}
reqBody = bytes.NewReader([]byte(fmt.Sprintf(`{"password": "%s"}`, utils.Password)))
req, err = http.NewRequest("POST", "http://localhost:6000/v1/admin/wallet/unlock", reqBody)
if err != nil {
return fmt.Errorf("failed to prepare wallet unlock request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
req.Header.Set("Content-Type", "application/json")
if _, err := adminHttpClient.Do(req); err != nil {
return fmt.Errorf("failed to unlock wallet: %s", err)
}
time.Sleep(time.Second)
req, err = http.NewRequest("GET", "http://localhost:6000/v1/admin/wallet/address", nil)
if err != nil {
return fmt.Errorf("failed to prepare new address request: %s", err)
}
req.Header.Set("Authorization", "Basic YWRtaW46YWRtaW4=")
resp, err := adminHttpClient.Do(req)
if err != nil {
return fmt.Errorf("failed to get new address: %s", err)
}
var addr struct {
Address string `json:"address"`
}
if err := json.NewDecoder(resp.Body).Decode(&addr); err != nil {
return fmt.Errorf("failed to parse response: %s", err)
}
_, err = utils.RunCommand("nigiri", "faucet", addr.Address)
if err != nil {
return fmt.Errorf("failed to fund wallet: %s", err)
}
return nil
}