go/sonr
1
0
Fork 0
mirror of https://github.com/sonr-io/sonr.git synced 2026-08-02 17:31:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

feature/driver indexed db (#14)

Browse Source 
* fix: update commitizen version

* feat: add WASM build tags to db actions

* feat: Update all actions to follow `AddAsset` for error handling

* feat: remove database dependency in dwn and motr commands

* feat: add basic info form to registration view

* feat: implement basic browser navigation component

* refactor: move database related files to middleware

* fix: remove unused test command

* fix: update source directory for buf-publish workflow

* feat: embed dwn config data

* feat: add Sync RPC to query service

* refactor: rename  package to  for better organization

* feat: add new javascript exception handling for server requests

* refactor: move dwn.wasm to embed directory

* refactor: move server files to a new directory

* refactor: move session related code to client package

* refactor: Update dwn.wasm build path

* refactor: move dwn wasm build to vfs

* feat: introduce config loading middleware

* feat: introduce DWN config and address JSON

* refactor: move dwn wasm build output to embed directory

* feat: introduce  config and IndexedDB model

* refactor: move DWN config file generation to vfs

* refactor: move config package to

* feat: add Sonr.ID IPFS gateway proxy

* feat: add SWT data structure

* feat: update index.html to use Sonr styles and scripts

* feat(dwn): remove index.html server endpoint

* feat: add Navigator API for web credential management
This commit is contained in:
Prad Nukala
2024-09-18 02:22:17 -04:00
committed by GitHub
parent 8022428e37
commit 2c1cf56e3c
150 changed files with 2819 additions and 6661 deletions
Download Patch File Download Diff File Expand all files Collapse all files
x/did/builder/openid.go
+20 -25
View File
@@ -1,27 +1,22 @@
package builder
import (
"fmt"
"github.com/onsonr/sonr/internal/dwn/models"
)
func GetDiscovery(origin string) *models.DiscoveryDocument {
baseURL := "https://" + origin // Ensure this is the correct base URL for your service
discoveryDoc := &models.DiscoveryDocument{
Issuer: baseURL,
AuthorizationEndpoint: fmt.Sprintf("%s/auth", baseURL),
TokenEndpoint: fmt.Sprintf("%s/token", baseURL),
UserinfoEndpoint: fmt.Sprintf("%s/userinfo", baseURL),
JwksUri: fmt.Sprintf("%s/jwks", baseURL),
RegistrationEndpoint: fmt.Sprintf("%s/register", baseURL),
ScopesSupported: []string{"openid", "profile", "email", "web3", "sonr"},
ResponseTypesSupported: []string{"code"},
ResponseModesSupported: []string{"query", "form_post"},
GrantTypesSupported: []string{"authorization_code", "refresh_token"},
AcrValuesSupported: []string{"passkey"},
SubjectTypesSupported: []string{"public"},
ClaimsSupported: []string{"sub", "iss", "name", "email"},
}
return discoveryDoc
}
//
// func GetDiscovery(origin string) *types.DiscoveryDocument {
// baseURL := "https://" + origin // Ensure this is the correct base URL for your service
// discoveryDoc := &types.DiscoveryDocument{
// Issuer: baseURL,
// AuthorizationEndpoint: fmt.Sprintf("%s/auth", baseURL),
// TokenEndpoint: fmt.Sprintf("%s/token", baseURL),
// UserinfoEndpoint: fmt.Sprintf("%s/userinfo", baseURL),
// JwksUri: fmt.Sprintf("%s/jwks", baseURL),
// RegistrationEndpoint: fmt.Sprintf("%s/register", baseURL),
// ScopesSupported: []string{"openid", "profile", "email", "web3", "sonr"},
// ResponseTypesSupported: []string{"code"},
// ResponseModesSupported: []string{"query", "form_post"},
// GrantTypesSupported: []string{"authorization_code", "refresh_token"},
// AcrValuesSupported: []string{"passkey"},
// SubjectTypesSupported: []string{"public"},
// ClaimsSupported: []string{"sub", "iss", "name", "email"},
// }
// return discoveryDoc
// }
x/did/builder/signer.go
-59
View File
@@ -1,59 +0,0 @@
package builder
import (
"github.com/onsonr/crypto"
"github.com/onsonr/sonr/x/did/types"
)
type Signer interface {
Sign(msg []byte) ([]byte, error)
Verify(msg []byte, sig []byte) error
PublicKey() []byte
}
type signer struct {
user *types.Keyshare
val *types.Keyshare
}
func (k signer) Sign(msg []byte) ([]byte, error) {
valSignFunc, err := crypto.GetSignFunc(k.val, msg)
if err != nil {
return nil, err
}
usrSignFunc, err := crypto.GetSignFunc(k.user, msg)
if err != nil {
return nil, err
}
sig, err := crypto.RunMPCSign(valSignFunc, usrSignFunc)
if err != nil {
return nil, err
}
return crypto.SerializeMPCSignature(sig)
}
func (k signer) Verify(msg []byte, sig []byte) error {
sigMpc, err := crypto.DeserializeMPCSignature(sig)
if err != nil {
return err
}
pk, err := crypto.GetECDSAPublicKey(k.val)
if err != nil {
return err
}
ok := crypto.VerifyMPCSignature(sigMpc, msg, pk)
if !ok {
return types.ErrInvalidSignature
}
return nil
}
func (k signer) PublicKey() []byte {
if k.user != nil {
return k.user.PublicKey
}
if k.val != nil {
return k.val.PublicKey
}
return nil
}
x/did/builder/vault.go
+1
View File
@@ -0,0 +1 @@
package builder
x/did/keeper/ipfs.go
+12 -1
View File
@@ -15,7 +15,18 @@ import (
// assembleInitialVault assembles the initial vault
func (k Keeper) assembleInitialVault(ctx sdk.Context) (string, int64, error) {
cid, err := k.ipfsClient.Unixfs().Add(context.Background(), vfs.AssembleDirectory())
cnfg, err := vfs.NewDWNConfigFile("test", "test")
if err != nil {
return "", 0, err
}
fileMap := map[string]files.Node{
"config.pkl": cnfg,
"sw.js": vfs.SWJSFile(),
"app.wasm": vfs.DWNWasmFile(),
"index.html": vfs.IndexFile(),
}
cid, err := k.ipfsClient.Unixfs().Add(context.Background(), files.NewMapDirectory(fileMap))
if err != nil {
return "", 0, err
}
x/did/keeper/querier.go
+4 -21
View File
@@ -43,26 +43,9 @@ func (k Querier) Service(
return &types.QueryServiceResponse{Service: ctx.GetServiceInfo(req.GetOrigin())}, nil
}
// ParamsAssets implements types.QueryServer.
func (k Querier) ParamsAssets(goCtx context.Context, req *types.QueryRequest) (*types.QueryParamsAssetsResponse, error) {
// Sync implements types.QueryServer.
func (k Querier) Sync(goCtx context.Context, req *types.SyncRequest) (*types.SyncResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
return &types.QueryParamsAssetsResponse{}, nil
}
// ParamsByAsset implements types.QueryServer.
func (k Querier) ParamsByAsset(goCtx context.Context, req *types.QueryRequest) (*types.QueryParamsByAssetResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
return &types.QueryParamsByAssetResponse{}, nil
}
// ParamsKeys implements types.QueryServer.
func (k Querier) ParamsKeys(goCtx context.Context, req *types.QueryRequest) (*types.QueryParamsKeysResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
return &types.QueryParamsKeysResponse{}, nil
}
// ParamsByKey implements types.QueryServer.
func (k Querier) ParamsByKey(goCtx context.Context, req *types.QueryRequest) (*types.QueryParamsByKeyResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
return &types.QueryParamsByKeyResponse{}, nil
panic("Sync is unimplemented")
return &types.SyncResponse{}, nil
}
x/did/keeper/server.go
-8
View File
@@ -101,14 +101,6 @@ func (ms msgServer) RegisterService(
return ms.k.insertService(ctx, msg.Service)
}
// # SyncController
//
// SyncController implements types.MsgServer.
func (ms msgServer) SyncController(ctx context.Context, msg *types.MsgSyncController) (*types.MsgSyncControllerResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
return &types.MsgSyncControllerResponse{}, nil
}
// # UpdateParams
//
// UpdateParams updates the x/did module parameters.
x/did/types/query.pb.go
+407 -1036
View File
File diff suppressed because it is too large Load Diff
x/did/types/query.pb.gw.go
+83 -404
View File
@@ -69,222 +69,6 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal
}
var (
filter_Query_ParamsAssets_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_Query_ParamsAssets_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsAssets_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.ParamsAssets(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_ParamsAssets_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsAssets_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.ParamsAssets(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_Query_ParamsByAsset_0 = &utilities.DoubleArray{Encoding: map[string]int{"asset": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
)
func request_Query_ParamsByAsset_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["asset"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset")
}
protoReq.Asset, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset", err)
}
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsByAsset_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.ParamsByAsset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_ParamsByAsset_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["asset"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset")
}
protoReq.Asset, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset", err)
}
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsByAsset_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.ParamsByAsset(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_Query_ParamsKeys_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_Query_ParamsKeys_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsKeys_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.ParamsKeys(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_ParamsKeys_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsKeys_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.ParamsKeys(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_Query_ParamsByKey_0 = &utilities.DoubleArray{Encoding: map[string]int{"key": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
)
func request_Query_ParamsByKey_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["key"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "key")
}
protoReq.Key, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "key", err)
}
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsByKey_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.ParamsByKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_ParamsByKey_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryRequest
var metadata runtime.ServerMetadata
var (
val string
ok bool
err error
_ = err
)
val, ok = pathParams["key"]
if !ok {
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "key")
}
protoReq.Key, err = runtime.String(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "key", err)
}
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ParamsByKey_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.ParamsByKey(ctx, &protoReq)
return msg, metadata, err
}
var (
filter_Query_Resolve_0 = &utilities.DoubleArray{Encoding: map[string]int{"did": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
)
@@ -429,6 +213,42 @@ func local_request_Query_Service_0(ctx context.Context, marshaler runtime.Marsha
}
var (
filter_Query_Sync_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_Query_Sync_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq SyncRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Sync_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.Sync(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_Sync_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq SyncRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Sync_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.Sync(ctx, &protoReq)
return msg, metadata, err
}
// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
// UnaryRPC :call QueryServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -458,98 +278,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
})
mux.Handle("GET", pattern_Query_ParamsAssets_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)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_ParamsAssets_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsAssets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_ParamsByAsset_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)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_ParamsByAsset_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsByAsset_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_ParamsKeys_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)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_ParamsKeys_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsKeys_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_ParamsByKey_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)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_ParamsByKey_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsByKey_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_Resolve_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@@ -596,6 +324,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
})
mux.Handle("POST", pattern_Query_Sync_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)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_Sync_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_Sync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@@ -657,86 +408,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
})
mux.Handle("GET", pattern_Query_ParamsAssets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_ParamsAssets_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsAssets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_ParamsByAsset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_ParamsByAsset_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsByAsset_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_ParamsKeys_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_ParamsKeys_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsKeys_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_ParamsByKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_ParamsByKey_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_ParamsByKey_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
mux.Handle("GET", pattern_Query_Resolve_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
@@ -777,37 +448,45 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
})
mux.Handle("POST", pattern_Query_Sync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_Sync_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_Sync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
var (
pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"params"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_ParamsAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"params", "assets"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_ParamsByAsset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"params", "assets", "asset"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_ParamsKeys_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"params", "keys"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_ParamsByKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"params", "keys", "key"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_Resolve_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 0}, []string{"did"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_Service_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 1}, []string{"service", "origin"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_Sync_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"sync"}, "", runtime.AssumeColonVerbOpt(false)))
)
var (
forward_Query_Params_0 = runtime.ForwardResponseMessage
forward_Query_ParamsAssets_0 = runtime.ForwardResponseMessage
forward_Query_ParamsByAsset_0 = runtime.ForwardResponseMessage
forward_Query_ParamsKeys_0 = runtime.ForwardResponseMessage
forward_Query_ParamsByKey_0 = runtime.ForwardResponseMessage
forward_Query_Resolve_0 = runtime.ForwardResponseMessage
forward_Query_Service_0 = runtime.ForwardResponseMessage
forward_Query_Sync_0 = runtime.ForwardResponseMessage
)
x/did/types/tx.pb.go
+59 -485
View File
@@ -273,106 +273,6 @@ func (m *MsgAllocateVaultResponse) GetLocalhost() bool {
return false
}
// MsgSyncController is the message type for the SyncController RPC.
type MsgSyncController struct {
// controller is the address of the controller to sync.
Controller string `protobuf:"bytes,1,opt,name=controller,proto3" json:"controller,omitempty"`
// Token is the public token to authenticate the operation.
Token string `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"`
}
func (m *MsgSyncController) Reset() { *m = MsgSyncController{} }
func (m *MsgSyncController) String() string { return proto.CompactTextString(m) }
func (*MsgSyncController) ProtoMessage() {}
func (*MsgSyncController) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{4}
}
func (m *MsgSyncController) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgSyncController) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgSyncController.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *MsgSyncController) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgSyncController.Merge(m, src)
}
func (m *MsgSyncController) XXX_Size() int {
return m.Size()
}
func (m *MsgSyncController) XXX_DiscardUnknown() {
xxx_messageInfo_MsgSyncController.DiscardUnknown(m)
}
var xxx_messageInfo_MsgSyncController proto.InternalMessageInfo
func (m *MsgSyncController) GetController() string {
if m != nil {
return m.Controller
}
return ""
}
func (m *MsgSyncController) GetToken() string {
if m != nil {
return m.Token
}
return ""
}
// MsgSyncControllerResponse is the response type for the SyncController RPC.
type MsgSyncControllerResponse struct {
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
}
func (m *MsgSyncControllerResponse) Reset() { *m = MsgSyncControllerResponse{} }
func (m *MsgSyncControllerResponse) String() string { return proto.CompactTextString(m) }
func (*MsgSyncControllerResponse) ProtoMessage() {}
func (*MsgSyncControllerResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{5}
}
func (m *MsgSyncControllerResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgSyncControllerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgSyncControllerResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *MsgSyncControllerResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgSyncControllerResponse.Merge(m, src)
}
func (m *MsgSyncControllerResponse) XXX_Size() int {
return m.Size()
}
func (m *MsgSyncControllerResponse) XXX_DiscardUnknown() {
xxx_messageInfo_MsgSyncControllerResponse.DiscardUnknown(m)
}
var xxx_messageInfo_MsgSyncControllerResponse proto.InternalMessageInfo
func (m *MsgSyncControllerResponse) GetSuccess() bool {
if m != nil {
return m.Success
}
return false
}
// MsgRegisterController is the message type for the InitializeController RPC.
type MsgRegisterController struct {
// authority is the address of the governance account.
@@ -389,7 +289,7 @@ func (m *MsgRegisterController) Reset() { *m = MsgRegisterController{} }
func (m *MsgRegisterController) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterController) ProtoMessage() {}
func (*MsgRegisterController) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{6}
return fileDescriptor_d73284df019ff211, []int{4}
}
func (m *MsgRegisterController) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -460,7 +360,7 @@ func (m *MsgRegisterControllerResponse) Reset() { *m = MsgRegisterContro
func (m *MsgRegisterControllerResponse) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterControllerResponse) ProtoMessage() {}
func (*MsgRegisterControllerResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{7}
return fileDescriptor_d73284df019ff211, []int{5}
}
func (m *MsgRegisterControllerResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -526,7 +426,7 @@ func (m *MsgAuthorizeService) Reset() { *m = MsgAuthorizeService{} }
func (m *MsgAuthorizeService) String() string { return proto.CompactTextString(m) }
func (*MsgAuthorizeService) ProtoMessage() {}
func (*MsgAuthorizeService) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{8}
return fileDescriptor_d73284df019ff211, []int{6}
}
func (m *MsgAuthorizeService) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -593,7 +493,7 @@ func (m *MsgAuthorizeServiceResponse) Reset() { *m = MsgAuthorizeService
func (m *MsgAuthorizeServiceResponse) String() string { return proto.CompactTextString(m) }
func (*MsgAuthorizeServiceResponse) ProtoMessage() {}
func (*MsgAuthorizeServiceResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{9}
return fileDescriptor_d73284df019ff211, []int{7}
}
func (m *MsgAuthorizeServiceResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -648,7 +548,7 @@ func (m *MsgRegisterService) Reset() { *m = MsgRegisterService{} }
func (m *MsgRegisterService) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterService) ProtoMessage() {}
func (*MsgRegisterService) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{10}
return fileDescriptor_d73284df019ff211, []int{8}
}
func (m *MsgRegisterService) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -701,7 +601,7 @@ func (m *MsgRegisterServiceResponse) Reset() { *m = MsgRegisterServiceRe
func (m *MsgRegisterServiceResponse) String() string { return proto.CompactTextString(m) }
func (*MsgRegisterServiceResponse) ProtoMessage() {}
func (*MsgRegisterServiceResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_d73284df019ff211, []int{11}
return fileDescriptor_d73284df019ff211, []int{9}
}
func (m *MsgRegisterServiceResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -749,8 +649,6 @@ func init() {
proto.RegisterType((*MsgUpdateParamsResponse)(nil), "did.v1.MsgUpdateParamsResponse")
proto.RegisterType((*MsgAllocateVault)(nil), "did.v1.MsgAllocateVault")
proto.RegisterType((*MsgAllocateVaultResponse)(nil), "did.v1.MsgAllocateVaultResponse")
proto.RegisterType((*MsgSyncController)(nil), "did.v1.MsgSyncController")
proto.RegisterType((*MsgSyncControllerResponse)(nil), "did.v1.MsgSyncControllerResponse")
proto.RegisterType((*MsgRegisterController)(nil), "did.v1.MsgRegisterController")
proto.RegisterType((*MsgRegisterControllerResponse)(nil), "did.v1.MsgRegisterControllerResponse")
proto.RegisterMapType((map[string]string)(nil), "did.v1.MsgRegisterControllerResponse.AccountsEntry")
@@ -763,62 +661,59 @@ func init() {
func init() { proto.RegisterFile("did/v1/tx.proto", fileDescriptor_d73284df019ff211) }
var fileDescriptor_d73284df019ff211 = []byte{
// 865 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4f, 0x8f, 0xdb, 0x44,
0x14, 0x5f, 0x27, 0xdb, 0x74, 0xf7, 0xed, 0x9f, 0x2c, 0x93, 0xc0, 0x3a, 0x2e, 0x4d, 0x53, 0x03,
0x52, 0x28, 0x90, 0x68, 0x53, 0x81, 0xaa, 0xc2, 0x65, 0x83, 0x90, 0x2a, 0xa1, 0x50, 0xf0, 0x02,
0x87, 0x5e, 0x56, 0x8e, 0x3d, 0x38, 0x43, 0x1c, 0x8f, 0x35, 0x33, 0x89, 0xd6, 0x9c, 0x80, 0x23,
0xe2, 0xc0, 0x17, 0x40, 0xe2, 0x23, 0xf4, 0xc0, 0x8d, 0x23, 0x97, 0x1e, 0x2b, 0x4e, 0x9c, 0x10,
0xda, 0x3d, 0xf4, 0x2b, 0x70, 0x44, 0xe3, 0xb1, 0x1d, 0xe7, 0x6f, 0xb7, 0xdd, 0x4b, 0xe2, 0xf7,
0x7e, 0x6f, 0x7e, 0xf3, 0x7b, 0x6f, 0xde, 0x1b, 0x1b, 0xca, 0x2e, 0x71, 0xdb, 0x93, 0xa3, 0xb6,
0x38, 0x6b, 0x85, 0x8c, 0x0a, 0x8a, 0x4a, 0x2e, 0x71, 0x5b, 0x93, 0x23, 0xe3, 0xd0, 0xa1, 0x7c,
0x44, 0x79, 0x7b, 0xc4, 0x3d, 0x89, 0x8f, 0xb8, 0xa7, 0x02, 0x8c, 0x9a, 0x02, 0x4e, 0x63, 0xab,
0xad, 0x8c, 0x04, 0xaa, 0x26, 0x64, 0x1e, 0x0e, 0x30, 0x27, 0xa9, 0xb7, 0x92, 0x78, 0x47, 0xd4,
0xc5, 0x7e, 0x16, 0xea, 0x51, 0x8f, 0x2a, 0x0a, 0xf9, 0xa4, 0xbc, 0xe6, 0xaf, 0x1a, 0x94, 0x7b,
0xdc, 0xfb, 0x2a, 0x74, 0x6d, 0x81, 0x3f, 0xb7, 0x99, 0x3d, 0xe2, 0xe8, 0x03, 0xd8, 0xb6, 0xc7,
0x62, 0x40, 0x19, 0x11, 0x91, 0xae, 0x35, 0xb4, 0xe6, 0x76, 0x57, 0xff, 0xeb, 0xf7, 0xf7, 0xaa,
0xc9, 0xce, 0xc7, 0xae, 0xcb, 0x30, 0xe7, 0x27, 0x82, 0x91, 0xc0, 0xb3, 0xa6, 0xa1, 0xe8, 0x5d,
0x28, 0x85, 0x31, 0x83, 0x5e, 0x68, 0x68, 0xcd, 0x9d, 0xce, 0x7e, 0x4b, 0x65, 0xd6, 0x52, 0xbc,
0xdd, 0xcd, 0x27, 0xff, 0xdc, 0xda, 0xb0, 0x92, 0x18, 0x54, 0x85, 0x6b, 0x82, 0x0e, 0x71, 0xa0,
0x17, 0xe5, 0x0e, 0x96, 0x32, 0xee, 0xef, 0xff, 0xf8, 0xec, 0xf1, 0x9d, 0x29, 0xa7, 0x59, 0x83,
0xc3, 0x39, 0x79, 0x16, 0xe6, 0x21, 0x0d, 0x38, 0x36, 0x7f, 0xd6, 0xe0, 0xa0, 0xc7, 0xbd, 0x63,
0xdf, 0xa7, 0x8e, 0x2d, 0xf0, 0xd7, 0xf6, 0xd8, 0x17, 0x2f, 0xad, 0x5d, 0x87, 0xeb, 0x7c, 0xdc,
0xff, 0x16, 0x3b, 0x22, 0x16, 0xbf, 0x6d, 0xa5, 0x26, 0x7a, 0x0d, 0x4a, 0x94, 0x11, 0x8f, 0xa4,
0x42, 0x13, 0x6b, 0x41, 0xe9, 0x6f, 0x1a, 0xe8, 0xf3, 0x72, 0x52, 0xad, 0xe8, 0x00, 0x8a, 0x0e,
0x71, 0x95, 0x20, 0x4b, 0x3e, 0xa2, 0xdb, 0xb0, 0x8b, 0xcf, 0x42, 0xc2, 0xa2, 0xd3, 0xbe, 0x4f,
0x9d, 0x61, 0xbc, 0x6b, 0xd1, 0xda, 0x51, 0xbe, 0xae, 0x74, 0xa1, 0x23, 0xa8, 0x32, 0xec, 0x11,
0x2e, 0x98, 0x2d, 0x08, 0x0d, 0x4e, 0x69, 0x28, 0xff, 0x78, 0xa2, 0xa3, 0x92, 0xc7, 0x1e, 0x2a,
0x08, 0xbd, 0x0e, 0xdb, 0x72, 0x7b, 0x7f, 0x40, 0xb9, 0xd0, 0x37, 0x1b, 0x5a, 0x73, 0xcb, 0x9a,
0x3a, 0x4c, 0x01, 0xaf, 0xf4, 0xb8, 0x77, 0x12, 0x05, 0xce, 0xc7, 0x34, 0x10, 0x8c, 0xfa, 0x3e,
0x66, 0xe8, 0x1e, 0x80, 0x93, 0x59, 0xcf, 0x2d, 0x59, 0x2e, 0x76, 0xc5, 0x09, 0x96, 0x65, 0x5d,
0x72, 0x61, 0xe6, 0xfb, 0x50, 0x5b, 0xd8, 0x35, 0x2b, 0x4c, 0x5c, 0x77, 0xc7, 0xc1, 0x9c, 0xc7,
0x5b, 0x6f, 0x59, 0xa9, 0x69, 0xfe, 0xa9, 0xc1, 0xab, 0x3d, 0xee, 0x59, 0x71, 0x96, 0x98, 0xe5,
0x14, 0xbf, 0xec, 0x19, 0xd7, 0x01, 0x6c, 0xce, 0x31, 0x53, 0x55, 0x2c, 0x34, 0x8a, 0xcd, 0x5d,
0x2b, 0xe7, 0x91, 0xc5, 0x1b, 0xe2, 0x88, 0x0f, 0x6c, 0x86, 0x65, 0x91, 0x25, 0x3c, 0x75, 0xa0,
0x37, 0x61, 0x6f, 0x82, 0x19, 0xf9, 0x86, 0x38, 0xb6, 0x22, 0xd8, 0x8c, 0x23, 0x66, 0x9d, 0x0b,
0x5d, 0xf1, 0x43, 0x01, 0x6e, 0x2e, 0xcd, 0xe2, 0xf9, 0x15, 0x98, 0x3b, 0x99, 0xc2, 0x0b, 0x9c,
0xcc, 0x43, 0xd8, 0xb2, 0x1d, 0x87, 0x8e, 0x03, 0xa1, 0x12, 0xd9, 0xe9, 0xdc, 0x4d, 0x67, 0x71,
0xad, 0x98, 0xd6, 0x71, 0xb2, 0xea, 0x93, 0x40, 0xb0, 0xc8, 0xca, 0x48, 0x8c, 0x0f, 0x61, 0x6f,
0x06, 0x92, 0x0d, 0x3d, 0xc4, 0x51, 0xda, 0xd0, 0x43, 0x1c, 0xc9, 0x6e, 0x98, 0xd8, 0xfe, 0x18,
0x27, 0xf3, 0xa3, 0x8c, 0xfb, 0x85, 0x7b, 0x9a, 0xf9, 0x87, 0x06, 0x15, 0x39, 0x19, 0xaa, 0x28,
0xdf, 0xe1, 0x13, 0xcc, 0x26, 0xc4, 0xc1, 0x57, 0xe8, 0xbc, 0xe9, 0x4c, 0x16, 0xf2, 0x33, 0x89,
0xde, 0x81, 0x12, 0x77, 0x68, 0x88, 0xd5, 0x8c, 0xec, 0x74, 0x2a, 0xd9, 0x0d, 0x84, 0xd9, 0x88,
0x70, 0x2e, 0x8f, 0xc8, 0x4a, 0x42, 0xa6, 0xed, 0xbb, 0xb9, 0xb6, 0x7d, 0x7b, 0x70, 0x63, 0x89,
0xf8, 0x4b, 0x1c, 0x5f, 0xc6, 0x5f, 0xc8, 0xf1, 0x9b, 0x3f, 0x69, 0x80, 0x72, 0x67, 0x70, 0xf5,
0x5a, 0xbc, 0x0d, 0xd7, 0xb9, 0x22, 0x49, 0xae, 0xdd, 0x72, 0x9a, 0x74, 0x2a, 0x35, 0xc5, 0x17,
0x73, 0x7b, 0x00, 0xc6, 0xa2, 0x96, 0x4b, 0xa4, 0x76, 0x00, 0x45, 0x97, 0xb8, 0x49, 0x62, 0xf2,
0xb1, 0xf3, 0x5f, 0x11, 0x8a, 0x3d, 0xee, 0xa1, 0x07, 0xb0, 0x3b, 0xf3, 0x2e, 0x39, 0xcc, 0xf5,
0x5d, 0x1e, 0x30, 0x6e, 0xad, 0x00, 0xb2, 0xdd, 0xbf, 0x84, 0x83, 0x85, 0x8e, 0xb9, 0x91, 0x5b,
0x34, 0x0f, 0x1a, 0x6f, 0xac, 0x01, 0x33, 0xd6, 0x4f, 0x61, 0x6f, 0xf6, 0x85, 0xa1, 0xe7, 0x57,
0xe5, 0x11, 0xa3, 0xb1, 0x0a, 0xc9, 0xc8, 0x3e, 0x83, 0xfd, 0xb9, 0xcb, 0xb4, 0x96, 0x5b, 0x33,
0x0b, 0x19, 0xb7, 0x57, 0x42, 0x19, 0xdf, 0x23, 0x40, 0x4b, 0xae, 0xbb, 0x9b, 0x6b, 0x47, 0xd7,
0x78, 0xeb, 0x52, 0x93, 0x8d, 0xbe, 0x80, 0xf2, 0x7c, 0xcf, 0x19, 0x4b, 0x56, 0xa6, 0xc5, 0x34,
0x57, 0x63, 0x29, 0xa5, 0x71, 0xed, 0xfb, 0x67, 0x8f, 0xef, 0x68, 0xdd, 0x8f, 0x9e, 0x9c, 0xd7,
0xb5, 0xa7, 0xe7, 0x75, 0xed, 0xdf, 0xf3, 0xba, 0xf6, 0xcb, 0x45, 0x7d, 0xe3, 0xe9, 0x45, 0x7d,
0xe3, 0xef, 0x8b, 0xfa, 0xc6, 0x23, 0xd3, 0x23, 0x62, 0x30, 0xee, 0xb7, 0x1c, 0x3a, 0x6a, 0xd3,
0x80, 0xd3, 0x80, 0xb5, 0xe3, 0x9f, 0xb3, 0xb6, 0xfc, 0x40, 0x11, 0x51, 0x88, 0x79, 0xbf, 0x14,
0x7f, 0x87, 0xdc, 0xfd, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x66, 0x1e, 0x8e, 0x51, 0x17, 0x09, 0x00,
0x00,
// 824 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xbf, 0x8f, 0x1b, 0x45,
0x14, 0xbe, 0xb1, 0x1d, 0xe7, 0xfc, 0x7c, 0x17, 0x5b, 0x63, 0xc3, 0x6d, 0x36, 0xc4, 0x31, 0x0b,
0x48, 0x26, 0x80, 0xad, 0x73, 0x24, 0x14, 0x05, 0x9a, 0x33, 0x42, 0x8a, 0x84, 0xac, 0xc0, 0x06,
0x28, 0xd2, 0x9c, 0xd6, 0xbb, 0xc3, 0x7a, 0xf0, 0x7a, 0x67, 0x35, 0x33, 0xb6, 0xce, 0x54, 0x40,
0x89, 0x28, 0xf8, 0x07, 0x90, 0x28, 0x29, 0x53, 0xd0, 0x51, 0xd2, 0xa4, 0x8c, 0xa8, 0xa8, 0x10,
0xba, 0x2b, 0xf2, 0x6f, 0xa0, 0xd9, 0xd9, 0x5d, 0xaf, 0x7f, 0x9c, 0x75, 0x84, 0xc6, 0x9e, 0xf7,
0xbe, 0x37, 0xdf, 0x7c, 0xdf, 0xcc, 0x9b, 0x59, 0xa8, 0x79, 0xd4, 0xeb, 0xcd, 0x8f, 0x7b, 0xf2,
0xac, 0x1b, 0x71, 0x26, 0x19, 0x2e, 0x7b, 0xd4, 0xeb, 0xce, 0x8f, 0xcd, 0x23, 0x97, 0x89, 0x29,
0x13, 0xbd, 0xa9, 0xf0, 0x15, 0x3e, 0x15, 0xbe, 0x2e, 0x30, 0x6f, 0x6a, 0xe0, 0x34, 0x8e, 0x7a,
0x3a, 0x48, 0xa0, 0x66, 0x42, 0xe6, 0x93, 0x90, 0x08, 0x9a, 0x66, 0x1b, 0x49, 0x76, 0xca, 0x3c,
0x12, 0x64, 0xa5, 0x3e, 0xf3, 0x99, 0xa6, 0x50, 0x23, 0x9d, 0xb5, 0x7e, 0x46, 0x50, 0x1b, 0x0a,
0xff, 0x8b, 0xc8, 0x73, 0x24, 0xf9, 0xd4, 0xe1, 0xce, 0x54, 0xe0, 0xf7, 0xa1, 0xe2, 0xcc, 0xe4,
0x98, 0x71, 0x2a, 0x17, 0x06, 0x6a, 0xa3, 0x4e, 0x65, 0x60, 0xfc, 0xf9, 0xdb, 0x7b, 0xcd, 0x64,
0xe5, 0x13, 0xcf, 0xe3, 0x44, 0x88, 0xc7, 0x92, 0xd3, 0xd0, 0xb7, 0x97, 0xa5, 0xf8, 0x5d, 0x28,
0x47, 0x31, 0x83, 0x51, 0x68, 0xa3, 0x4e, 0xb5, 0x7f, 0xa3, 0xab, 0x9d, 0x75, 0x35, 0xef, 0xa0,
0xf4, 0xec, 0xef, 0x3b, 0x7b, 0x76, 0x52, 0x83, 0x9b, 0x70, 0x4d, 0xb2, 0x09, 0x09, 0x8d, 0xa2,
0x5a, 0xc1, 0xd6, 0xc1, 0x83, 0x1b, 0xdf, 0xbf, 0x78, 0x7a, 0x77, 0xc9, 0x69, 0xdd, 0x84, 0xa3,
0x35, 0x79, 0x36, 0x11, 0x11, 0x0b, 0x05, 0xb1, 0x7e, 0x44, 0x50, 0x1f, 0x0a, 0xff, 0x24, 0x08,
0x98, 0xeb, 0x48, 0xf2, 0xa5, 0x33, 0x0b, 0xe4, 0x4b, 0x6b, 0x37, 0xe0, 0xba, 0x98, 0x8d, 0xbe,
0x26, 0xae, 0x8c, 0xc5, 0x57, 0xec, 0x34, 0xc4, 0xaf, 0x42, 0x99, 0x71, 0xea, 0xd3, 0x54, 0x68,
0x12, 0x6d, 0x28, 0xfd, 0x05, 0x81, 0xb1, 0x2e, 0x27, 0xd5, 0x8a, 0xeb, 0x50, 0x74, 0xa9, 0xa7,
0x05, 0xd9, 0x6a, 0x88, 0x5f, 0x87, 0x03, 0x72, 0x16, 0x51, 0xbe, 0x38, 0x1d, 0x05, 0xcc, 0x9d,
0xc4, 0xab, 0x16, 0xed, 0xaa, 0xce, 0x0d, 0x54, 0x0a, 0x1f, 0x43, 0x93, 0x13, 0x9f, 0x0a, 0xc9,
0x1d, 0x49, 0x59, 0x78, 0xca, 0x22, 0xf5, 0x27, 0x12, 0x1d, 0x8d, 0x3c, 0xf6, 0x48, 0x43, 0xf8,
0x35, 0xa8, 0xa8, 0xe5, 0x83, 0x31, 0x13, 0xd2, 0x28, 0xb5, 0x51, 0x67, 0xdf, 0x5e, 0x26, 0xac,
0x3f, 0x10, 0xbc, 0x32, 0x14, 0xbe, 0x1d, 0x4f, 0x24, 0xfc, 0x23, 0x16, 0x4a, 0xce, 0x82, 0x80,
0xf0, 0x97, 0xde, 0xb6, 0x16, 0x80, 0x23, 0x04, 0xe1, 0x5a, 0x58, 0xa1, 0x5d, 0xec, 0x1c, 0xd8,
0xb9, 0x8c, 0xd2, 0x33, 0x21, 0x0b, 0x31, 0x76, 0x38, 0x51, 0xba, 0x15, 0xbc, 0x4c, 0xe0, 0x37,
0xe1, 0x70, 0x4e, 0x38, 0xfd, 0x8a, 0xba, 0x8e, 0x26, 0x28, 0xc5, 0x15, 0xab, 0xc9, 0x8d, 0x8d,
0xfe, 0xae, 0x00, 0xb7, 0xb7, 0xba, 0xc8, 0x76, 0x3b, 0x3e, 0x4c, 0xd7, 0x25, 0x42, 0xc4, 0x5e,
0xf6, 0xed, 0x34, 0xc4, 0xf7, 0x01, 0xdc, 0xac, 0x5e, 0x9f, 0xf4, 0x0e, 0xa3, 0xb9, 0x5a, 0xfc,
0x08, 0xf6, 0x1d, 0xd7, 0x65, 0xb3, 0x50, 0x6a, 0x23, 0xd5, 0xfe, 0xbd, 0xb4, 0xbd, 0x77, 0x8a,
0xe9, 0x9e, 0x24, 0xb3, 0x3e, 0x0e, 0x25, 0x5f, 0xd8, 0x19, 0x89, 0xf9, 0x01, 0x1c, 0xae, 0x40,
0xaa, 0x47, 0x26, 0x64, 0x91, 0xf6, 0xc8, 0x84, 0x2c, 0xd4, 0x15, 0x99, 0x3b, 0xc1, 0x8c, 0x24,
0x2d, 0xa9, 0x83, 0x07, 0x85, 0xfb, 0xc8, 0xfa, 0x1d, 0x41, 0x43, 0x35, 0x9b, 0xde, 0x94, 0x6f,
0xc8, 0x63, 0xc2, 0xe7, 0xd4, 0x25, 0x6b, 0xfe, 0xd0, 0x7f, 0xf0, 0xb7, 0x6c, 0xf3, 0x42, 0xbe,
0xcd, 0xf1, 0x3b, 0x50, 0x16, 0x2e, 0x8b, 0x88, 0x6e, 0xbb, 0x6a, 0xbf, 0x91, 0x5d, 0x6a, 0xc2,
0xa7, 0x54, 0x08, 0x75, 0x44, 0x76, 0x52, 0xb2, 0xbc, 0xd3, 0xa5, 0xfc, 0x9d, 0xae, 0xa9, 0x03,
0xcc, 0xad, 0x65, 0x0d, 0xe1, 0xd6, 0x16, 0xf1, 0x57, 0x38, 0xbe, 0x8c, 0xbf, 0x90, 0xe3, 0xb7,
0x7e, 0x40, 0x80, 0x73, 0x67, 0xf0, 0xff, 0xf7, 0xe2, 0x6d, 0xb8, 0x2e, 0x34, 0x49, 0xf2, 0x92,
0xd5, 0x52, 0xd3, 0xa9, 0xd4, 0x14, 0xdf, 0xf4, 0xf6, 0x10, 0xcc, 0x4d, 0x2d, 0x57, 0xb0, 0x56,
0x87, 0xa2, 0x47, 0xbd, 0xc4, 0x98, 0x1a, 0xf6, 0x7f, 0x2d, 0x42, 0x71, 0x28, 0x7c, 0xfc, 0x10,
0x0e, 0x56, 0x9e, 0xe7, 0xa3, 0x5c, 0xdf, 0xe5, 0x01, 0xf3, 0xce, 0x25, 0x40, 0xb6, 0xfa, 0xe7,
0x50, 0xdf, 0xe8, 0x98, 0x5b, 0xb9, 0x49, 0xeb, 0xa0, 0xf9, 0xc6, 0x0e, 0x30, 0x63, 0xfd, 0x04,
0x0e, 0x57, 0xdf, 0x60, 0x23, 0x3f, 0x2b, 0x8f, 0x98, 0xed, 0xcb, 0x90, 0x8c, 0xec, 0x09, 0xe0,
0x2d, 0xcf, 0xd3, 0xed, 0x9d, 0x57, 0xcd, 0x7c, 0xeb, 0x4a, 0x37, 0x11, 0x7f, 0x06, 0xb5, 0xf5,
0x1e, 0x31, 0xb7, 0xcc, 0x4c, 0xcd, 0x5b, 0x97, 0x63, 0x29, 0xa5, 0x79, 0xed, 0xdb, 0x17, 0x4f,
0xef, 0xa2, 0xc1, 0x87, 0xcf, 0xce, 0x5b, 0xe8, 0xf9, 0x79, 0x0b, 0xfd, 0x73, 0xde, 0x42, 0x3f,
0x5d, 0xb4, 0xf6, 0x9e, 0x5f, 0xb4, 0xf6, 0xfe, 0xba, 0x68, 0xed, 0x3d, 0xb1, 0x7c, 0x2a, 0xc7,
0xb3, 0x51, 0xd7, 0x65, 0xd3, 0x1e, 0x0b, 0x05, 0x0b, 0x79, 0x2f, 0xfe, 0x39, 0xeb, 0xa9, 0x6f,
0xb4, 0x5c, 0x44, 0x44, 0x8c, 0xca, 0xf1, 0xa7, 0xf8, 0xde, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff,
0xf9, 0xc0, 0x77, 0x8b, 0x1a, 0x08, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -842,8 +737,6 @@ type MsgClient interface {
// AllocateVault assembles a sqlite3 database in a local directory and returns the CID of the database.
// this operation is called by services initiating a controller registration.
AllocateVault(ctx context.Context, in *MsgAllocateVault, opts ...grpc.CallOption) (*MsgAllocateVaultResponse, error)
// SyncController synchronizes the controller with the Vault Motr DWN WASM Wallet.
SyncController(ctx context.Context, in *MsgSyncController, opts ...grpc.CallOption) (*MsgSyncControllerResponse, error)
// RegisterController initializes a controller with the given authentication set, address, cid, publicKey, and user-defined alias.
RegisterController(ctx context.Context, in *MsgRegisterController, opts ...grpc.CallOption) (*MsgRegisterControllerResponse, error)
// RegisterService initializes a Service with a given permission scope and URI. The domain must have a valid TXT record containing the public key.
@@ -885,15 +778,6 @@ func (c *msgClient) AllocateVault(ctx context.Context, in *MsgAllocateVault, opt
return out, nil
}
func (c *msgClient) SyncController(ctx context.Context, in *MsgSyncController, opts ...grpc.CallOption) (*MsgSyncControllerResponse, error) {
out := new(MsgSyncControllerResponse)
err := c.cc.Invoke(ctx, "/did.v1.Msg/SyncController", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *msgClient) RegisterController(ctx context.Context, in *MsgRegisterController, opts ...grpc.CallOption) (*MsgRegisterControllerResponse, error) {
out := new(MsgRegisterControllerResponse)
err := c.cc.Invoke(ctx, "/did.v1.Msg/RegisterController", in, out, opts...)
@@ -923,8 +807,6 @@ type MsgServer interface {
// AllocateVault assembles a sqlite3 database in a local directory and returns the CID of the database.
// this operation is called by services initiating a controller registration.
AllocateVault(context.Context, *MsgAllocateVault) (*MsgAllocateVaultResponse, error)
// SyncController synchronizes the controller with the Vault Motr DWN WASM Wallet.
SyncController(context.Context, *MsgSyncController) (*MsgSyncControllerResponse, error)
// RegisterController initializes a controller with the given authentication set, address, cid, publicKey, and user-defined alias.
RegisterController(context.Context, *MsgRegisterController) (*MsgRegisterControllerResponse, error)
// RegisterService initializes a Service with a given permission scope and URI. The domain must have a valid TXT record containing the public key.
@@ -944,9 +826,6 @@ func (*UnimplementedMsgServer) AuthorizeService(ctx context.Context, req *MsgAut
func (*UnimplementedMsgServer) AllocateVault(ctx context.Context, req *MsgAllocateVault) (*MsgAllocateVaultResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method AllocateVault not implemented")
}
func (*UnimplementedMsgServer) SyncController(ctx context.Context, req *MsgSyncController) (*MsgSyncControllerResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SyncController not implemented")
}
func (*UnimplementedMsgServer) RegisterController(ctx context.Context, req *MsgRegisterController) (*MsgRegisterControllerResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method RegisterController not implemented")
}
@@ -1012,24 +891,6 @@ func _Msg_AllocateVault_Handler(srv interface{}, ctx context.Context, dec func(i
return interceptor(ctx, in, info, handler)
}
func _Msg_SyncController_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgSyncController)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MsgServer).SyncController(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/did.v1.Msg/SyncController",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MsgServer).SyncController(ctx, req.(*MsgSyncController))
}
return interceptor(ctx, in, info, handler)
}
func _Msg_RegisterController_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgRegisterController)
if err := dec(in); err != nil {
@@ -1082,10 +943,6 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
MethodName: "AllocateVault",
Handler: _Msg_AllocateVault_Handler,
},
{
MethodName: "SyncController",
Handler: _Msg_SyncController_Handler,
},
{
MethodName: "RegisterController",
Handler: _Msg_RegisterController_Handler,
@@ -1265,76 +1122,6 @@ func (m *MsgAllocateVaultResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
return len(dAtA) - i, nil
}
func (m *MsgSyncController) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *MsgSyncController) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgSyncController) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Token) > 0 {
i -= len(m.Token)
copy(dAtA[i:], m.Token)
i = encodeVarintTx(dAtA, i, uint64(len(m.Token)))
i--
dAtA[i] = 0x1a
}
if len(m.Controller) > 0 {
i -= len(m.Controller)
copy(dAtA[i:], m.Controller)
i = encodeVarintTx(dAtA, i, uint64(len(m.Controller)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *MsgSyncControllerResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *MsgSyncControllerResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgSyncControllerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Success {
i--
if m.Success {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *MsgRegisterController) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -1712,35 +1499,6 @@ func (m *MsgAllocateVaultResponse) Size() (n int) {
return n
}
func (m *MsgSyncController) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Controller)
if l > 0 {
n += 1 + l + sovTx(uint64(l))
}
l = len(m.Token)
if l > 0 {
n += 1 + l + sovTx(uint64(l))
}
return n
}
func (m *MsgSyncControllerResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Success {
n += 2
}
return n
}
func (m *MsgRegisterController) Size() (n int) {
if m == nil {
return 0
@@ -2372,190 +2130,6 @@ func (m *MsgAllocateVaultResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *MsgSyncController) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MsgSyncController: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgSyncController: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTx
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTx
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Controller = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTx
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTx
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Token = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTx(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTx
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *MsgSyncControllerResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: MsgSyncControllerResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgSyncControllerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Success = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipTx(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTx
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *MsgRegisterController) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0