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/1111 sync chain dwn endpoint (#1143)

Browse Source 
- **feat(did): add assertion type to DID spec**
- **refactor: update build process to include assets generation**
- **refactor: update import paths for  to**
- **feat: introduce new authentication state management**
- **feat: add current account route**
- **feat: implement global toasts with custom HTML**
- **refactor: remove unused session code**
- **feat: add config.json to embedded assets**
- **refactor: remove unused dependency on gorilla/sessions**
- **refactor: simplify session management and remove unnecessary
fields**
- **fix: remove unnecessary import for unused protobuf types**
- **feat: introduce separate HTTP contexts for Highway and DWN**
- **fix(keeper): Handle missing controller during initial sync**
- **refactor: extract DWN configuration from DWNContext**
- **feat: add  view route**
- **fix: update configuration file name in embed.go**
- **feat: improve vaultindex page loading experience**
- **feat(hway): add highway context to echo context**
- **chore(deps): bump onsonr/crypto from 1.32.0 to 1.33.0**
- **refactor: rename DWNSessionMiddleware to WebNodeSessionMiddleware**
- **feat: rename client API to web node API**
- **refactor: separate API and view routes**
- **refactor: remove unused build targets in Makefile**
- **feat: add Devbox integration to container**
- **feat: add wasm support for dwn**
- **refactor: update module proto import**
- **feat: add default first and third party caveats**
- **feat: Add target vault allocation mechanism**
- **refactor: introduce standardized session cookie handling**
- **fix: update service worker installation and ready states**
- **feat: add worker handlers**
- **feat: Enable SSH access to devcontainer**
- **refactor: rename HighwayContext to HwayContext**
- **feat: add block expiration calculation to sonr context**
- **feat: remove config from cookie and header**
- **feat(gen): Remove generated code for IPFS, Motr and Sonr**
- **refactor: remove unused createMotrConfig function**
- **feat: add project analytics with Repobeats**
- **docs: Remove component details from README**
- **refactor: rename SetConfig to injectConfig**
This commit is contained in:
Prad Nukala
2024-10-15 14:31:19 -04:00
committed by GitHub
parent 104df074e9
commit b6c49828ed
146 changed files with 18035 additions and 4202 deletions
Download Patch File Download Diff File Expand all files Collapse all files
x/did/types/codec.go
-3
View File
@@ -7,7 +7,6 @@ import (
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/msgservice"
// this line is used by starport scaffolding # 1
)
var (
@@ -24,7 +23,6 @@ func init() {
// RegisterLegacyAminoCodec registers concrete types on the LegacyAmino codec
func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
cdc.RegisterConcrete(&MsgUpdateParams{}, ModuleName+"/MsgUpdateParams", nil)
cdc.RegisterConcrete(&MsgRegisterController{}, ModuleName+"/MsgRegisterController", nil)
}
func RegisterInterfaces(registry types.InterfaceRegistry) {
@@ -36,7 +34,6 @@ func RegisterInterfaces(registry types.InterfaceRegistry) {
registry.RegisterImplementations(
(*sdk.Msg)(nil),
&MsgUpdateParams{},
&MsgRegisterController{},
)
msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
}
x/did/types/controller.go
+14 -2
View File
@@ -5,6 +5,7 @@ import (
"github.com/onsonr/crypto/mpc"
sdk "github.com/cosmos/cosmos-sdk/types"
didv1 "github.com/onsonr/sonr/api/did/v1"
)
@@ -19,7 +20,7 @@ type ControllerI interface {
ExportUserKs() (string, error)
}
func NewController(shares []mpc.Share) (ControllerI, error) {
func NewController(ctx sdk.Context, shares []mpc.Share) (ControllerI, error) {
var (
valKs = shares[0]
userKs = shares[1]
@@ -48,11 +49,21 @@ func NewController(shares []mpc.Share) (ControllerI, error) {
address: sonrAddr,
btcAddr: btcAddr,
ethAddr: ethAddr,
chainID: "sonr-testnet-1",
chainID: ctx.ChainID(),
publicKey: pbBz,
}, nil
}
func LoadControllerFromTableEntry(ctx sdk.Context, entry *didv1.Controller) (ControllerI, error) {
return &controller{
address: entry.Did,
btcAddr: entry.BtcAddress,
ethAddr: entry.EthAddress,
chainID: ctx.ChainID(),
publicKey: entry.PublicKey.RawKey.Key,
}, nil
}
type controller struct {
userKs mpc.Share
valKs mpc.Share
@@ -61,6 +72,7 @@ type controller struct {
ethAddr string
btcAddr string
publicKey []byte
did string
}
func (c *controller) BtcAddress() string {
x/did/types/msgs.go
+3 -38
View File
@@ -7,9 +7,9 @@ import (
var _ sdk.Msg = &MsgUpdateParams{}
//
// [UpdateParams]
//
// ╭────────────────────────────────────────────────────────╮
// │ MsgUpdateParams │
// ╰────────────────────────────────────────────────────────╯
// NewMsgUpdateParams creates new instance of MsgUpdateParams
func NewMsgUpdateParams(
@@ -47,38 +47,3 @@ func (msg *MsgUpdateParams) Validate() error {
return msg.Params.Validate()
}
//
// [RegisterController]
//
// NewMsgRegisterController creates a new instance of MsgRegisterController
func NewMsgRegisterController(
sender sdk.Address,
) (*MsgRegisterController, error) {
return &MsgRegisterController{
Authority: sender.String(),
}, nil
}
// Route returns the name of the module
func (msg MsgRegisterController) Route() string { return ModuleName }
// Type returns the the action
func (msg MsgRegisterController) Type() string { return "register_controller" }
// GetSignBytes implements the LegacyMsg interface.
func (msg MsgRegisterController) GetSignBytes() []byte {
return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
}
// GetSigners returns the expected signers for a MsgUpdateParams message.
func (msg *MsgRegisterController) GetSigners() []sdk.AccAddress {
addr, _ := sdk.AccAddressFromBech32(msg.Authority)
return []sdk.AccAddress{addr}
}
// ValidateBasic does a sanity check on the provided data.
func (msg *MsgRegisterController) Validate() error {
return nil
}
x/did/types/state.pb.go
+646 -47
View File
@@ -23,6 +23,105 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type Assertion struct {
// The unique identifier of the assertion
Did string `protobuf:"bytes,1,opt,name=did,proto3" json:"did,omitempty"`
// The authentication of the DID
Controller string `protobuf:"bytes,2,opt,name=controller,proto3" json:"controller,omitempty"`
// Origin of the authentication
Subject string `protobuf:"bytes,3,opt,name=subject,proto3" json:"subject,omitempty"`
// PubKey is the verification method
PublicKey *PubKey `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
// AssertionType is the assertion type
AssertionType string `protobuf:"bytes,5,opt,name=assertion_type,json=assertionType,proto3" json:"assertion_type,omitempty"`
// Metadata of the authentication
Accumulator map[string][]byte `protobuf:"bytes,6,rep,name=accumulator,proto3" json:"accumulator,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// CreationBlock is the block number of the creation of the authentication
CreationBlock int64 `protobuf:"varint,7,opt,name=creation_block,json=creationBlock,proto3" json:"creation_block,omitempty"`
}
func (m *Assertion) Reset() { *m = Assertion{} }
func (m *Assertion) String() string { return proto.CompactTextString(m) }
func (*Assertion) ProtoMessage() {}
func (*Assertion) Descriptor() ([]byte, []int) {
return fileDescriptor_f44bb702879c34b4, []int{0}
}
func (m *Assertion) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Assertion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Assertion.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 *Assertion) XXX_Merge(src proto.Message) {
xxx_messageInfo_Assertion.Merge(m, src)
}
func (m *Assertion) XXX_Size() int {
return m.Size()
}
func (m *Assertion) XXX_DiscardUnknown() {
xxx_messageInfo_Assertion.DiscardUnknown(m)
}
var xxx_messageInfo_Assertion proto.InternalMessageInfo
func (m *Assertion) GetDid() string {
if m != nil {
return m.Did
}
return ""
}
func (m *Assertion) GetController() string {
if m != nil {
return m.Controller
}
return ""
}
func (m *Assertion) GetSubject() string {
if m != nil {
return m.Subject
}
return ""
}
func (m *Assertion) GetPublicKey() *PubKey {
if m != nil {
return m.PublicKey
}
return nil
}
func (m *Assertion) GetAssertionType() string {
if m != nil {
return m.AssertionType
}
return ""
}
func (m *Assertion) GetAccumulator() map[string][]byte {
if m != nil {
return m.Accumulator
}
return nil
}
func (m *Assertion) GetCreationBlock() int64 {
if m != nil {
return m.CreationBlock
}
return 0
}
type Authentication struct {
// The unique identifier of the authentication
Did string `protobuf:"bytes,1,opt,name=did,proto3" json:"did,omitempty"`
@@ -44,7 +143,7 @@ func (m *Authentication) Reset() { *m = Authentication{} }
func (m *Authentication) String() string { return proto.CompactTextString(m) }
func (*Authentication) ProtoMessage() {}
func (*Authentication) Descriptor() ([]byte, []int) {
return fileDescriptor_f44bb702879c34b4, []int{0}
return fileDescriptor_f44bb702879c34b4, []int{1}
}
func (m *Authentication) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -148,7 +247,7 @@ func (m *Controller) Reset() { *m = Controller{} }
func (m *Controller) String() string { return proto.CompactTextString(m) }
func (*Controller) ProtoMessage() {}
func (*Controller) Descriptor() ([]byte, []int) {
return fileDescriptor_f44bb702879c34b4, []int{1}
return fileDescriptor_f44bb702879c34b4, []int{2}
}
func (m *Controller) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -266,7 +365,7 @@ func (m *Verification) Reset() { *m = Verification{} }
func (m *Verification) String() string { return proto.CompactTextString(m) }
func (*Verification) ProtoMessage() {}
func (*Verification) Descriptor() ([]byte, []int) {
return fileDescriptor_f44bb702879c34b4, []int{2}
return fileDescriptor_f44bb702879c34b4, []int{3}
}
func (m *Verification) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -359,6 +458,8 @@ func (m *Verification) GetCreationBlock() int64 {
}
func init() {
proto.RegisterType((*Assertion)(nil), "did.v1.Assertion")
proto.RegisterMapType((map[string][]byte)(nil), "did.v1.Assertion.AccumulatorEntry")
proto.RegisterType((*Authentication)(nil), "did.v1.Authentication")
proto.RegisterMapType((map[string]string)(nil), "did.v1.Authentication.MetadataEntry")
proto.RegisterType((*Controller)(nil), "did.v1.Controller")
@@ -369,50 +470,143 @@ func init() {
func init() { proto.RegisterFile("did/v1/state.proto", fileDescriptor_f44bb702879c34b4) }
var fileDescriptor_f44bb702879c34b4 = []byte{
// 674 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xd1, 0x6a, 0xd3, 0x50,
0x1c, 0xc6, 0x77, 0x9a, 0xb6, 0x5b, 0xff, 0xed, 0x4a, 0x77, 0x98, 0x7a, 0x18, 0x1a, 0x6b, 0xa7,
0x52, 0x71, 0xb6, 0x6c, 0xde, 0xc8, 0x14, 0x71, 0x13, 0x2f, 0x64, 0x0c, 0x24, 0xca, 0x40, 0x6f,
0x42, 0x92, 0x73, 0x5c, 0x8f, 0x4d, 0x72, 0x6a, 0xce, 0x49, 0x31, 0x97, 0x82, 0x17, 0x5e, 0x89,
0x4f, 0xe0, 0xf3, 0x78, 0x39, 0xf0, 0xc6, 0x4b, 0xd9, 0xde, 0xc0, 0x27, 0x90, 0x9c, 0x24, 0x6b,
0x8a, 0xc3, 0xa1, 0x78, 0x53, 0x7a, 0xbe, 0x7c, 0xf9, 0x37, 0xff, 0xdf, 0xd7, 0x2f, 0x80, 0x29,
0xa7, 0xc3, 0xe9, 0xe6, 0x50, 0x2a, 0x47, 0xb1, 0xc1, 0x24, 0x12, 0x4a, 0xe0, 0x3a, 0xe5, 0x74,
0x30, 0xdd, 0x5c, 0xbb, 0xe4, 0x09, 0x19, 0x08, 0x39, 0x14, 0x51, 0x90, 0x5a, 0x44, 0x14, 0x64,
0x86, 0xb5, 0xd5, 0xfc, 0xa6, 0x43, 0x16, 0x32, 0xc9, 0x65, 0xa6, 0xf6, 0xde, 0x1b, 0xd0, 0xde,
0x89, 0xd5, 0x88, 0x85, 0x8a, 0x7b, 0x8e, 0xe2, 0x22, 0xc4, 0x1d, 0x30, 0x28, 0xa7, 0x04, 0x75,
0x51, 0xbf, 0x61, 0xa5, 0x5f, 0xb1, 0x09, 0xe0, 0x89, 0x50, 0x45, 0xc2, 0xf7, 0x59, 0x44, 0x2a,
0xfa, 0x42, 0x49, 0xc1, 0x04, 0x16, 0x65, 0xec, 0xbe, 0x61, 0x9e, 0x22, 0x86, 0xbe, 0x58, 0x1c,
0xf1, 0x1d, 0x80, 0x49, 0xec, 0xfa, 0xdc, 0xb3, 0xc7, 0x2c, 0x21, 0xd5, 0x2e, 0xea, 0x37, 0xb7,
0xda, 0x83, 0xec, 0x51, 0x07, 0xcf, 0x62, 0x77, 0x8f, 0x25, 0x56, 0x23, 0x73, 0xec, 0xb1, 0x04,
0xaf, 0xc3, 0xb2, 0x17, 0x31, 0x9a, 0x3e, 0x8c, 0xe3, 0xdb, 0x9c, 0x92, 0x5a, 0x17, 0xf5, 0x5b,
0x56, 0x6b, 0x26, 0x3e, 0xa5, 0xf8, 0x11, 0x2c, 0x05, 0x4c, 0x39, 0xd4, 0x51, 0x0e, 0xa9, 0x77,
0x8d, 0x7e, 0x73, 0xeb, 0x7a, 0x31, 0x71, 0x7e, 0x93, 0xc1, 0x7e, 0x6e, 0x7b, 0x12, 0xaa, 0x28,
0xb1, 0x4e, 0xef, 0xc2, 0x37, 0xa0, 0xed, 0x45, 0x4c, 0x7b, 0x6c, 0xd7, 0x17, 0xde, 0x98, 0x2c,
0x76, 0x51, 0xdf, 0xb0, 0x96, 0x0b, 0x75, 0x37, 0x15, 0xd7, 0xee, 0xc3, 0xf2, 0xdc, 0x84, 0x94,
0x4c, 0xba, 0x46, 0x4e, 0x66, 0xcc, 0x12, 0xbc, 0x0a, 0xb5, 0xa9, 0xe3, 0xc7, 0x2c, 0x87, 0x92,
0x1d, 0xb6, 0x2b, 0xf7, 0xd0, 0xf6, 0xad, 0x9f, 0x5f, 0xbe, 0x7d, 0x32, 0xd6, 0xa1, 0xa6, 0x69,
0x62, 0x02, 0x78, 0x06, 0x6c, 0x23, 0xc7, 0xd3, 0x41, 0x04, 0x11, 0xd4, 0xfb, 0x68, 0x00, 0x3c,
0x9e, 0xd1, 0xbc, 0x08, 0xf5, 0x30, 0x0e, 0x5c, 0x16, 0xe9, 0x1f, 0xaa, 0x5a, 0xf9, 0xa9, 0xc8,
0xa5, 0x32, 0xcb, 0xe5, 0x1a, 0xb4, 0xa4, 0x08, 0x23, 0xdb, 0xa1, 0x34, 0x62, 0x52, 0xe6, 0xf0,
0x9b, 0xa9, 0xb6, 0x93, 0x49, 0xf8, 0x2a, 0x34, 0x99, 0x1a, 0x9d, 0x3a, 0xaa, 0x59, 0x76, 0x4c,
0x8d, 0x4a, 0x06, 0x57, 0x79, 0xa7, 0x86, 0x5a, 0x66, 0x70, 0x95, 0x57, 0x18, 0xe6, 0x23, 0xac,
0x9f, 0x17, 0xe1, 0x05, 0xa8, 0x8f, 0xa5, 0x3d, 0x75, 0x7c, 0xcd, 0xb4, 0x61, 0xd5, 0xc6, 0xf2,
0xc0, 0xf1, 0x75, 0xb2, 0xbe, 0xc3, 0x03, 0x46, 0x73, 0xe2, 0x4b, 0x9a, 0x78, 0x2b, 0x17, 0x35,
0xf0, 0x33, 0x72, 0x69, 0x9c, 0x91, 0xcb, 0xf6, 0x4b, 0x8d, 0xf6, 0x39, 0x40, 0x01, 0xaa, 0x83,
0x30, 0x9e, 0x47, 0x91, 0x92, 0xc5, 0x2b, 0x73, 0xbb, 0x77, 0x2a, 0x99, 0x54, 0xda, 0xb6, 0x63,
0x10, 0x84, 0x1b, 0x1a, 0x6b, 0xa7, 0x4a, 0x10, 0xa9, 0xf4, 0x3e, 0x54, 0xa1, 0x75, 0xc0, 0x22,
0xfe, 0xfa, 0xdf, 0xcb, 0x70, 0x05, 0x80, 0x72, 0x6a, 0x07, 0x4c, 0x8d, 0x04, 0xcd, 0x23, 0x69,
0x50, 0x4e, 0xf7, 0xb5, 0x90, 0xa6, 0xcb, 0xa5, 0x8c, 0x59, 0x94, 0x67, 0x91, 0x9f, 0xca, 0x1d,
0xaa, 0xfd, 0xa9, 0x43, 0xe7, 0x06, 0x70, 0x1b, 0x56, 0xa6, 0xa5, 0x0d, 0x6c, 0x95, 0x4c, 0x58,
0x9e, 0x45, 0xa7, 0x7c, 0xe1, 0x45, 0x32, 0x61, 0xf8, 0x61, 0xa9, 0x4b, 0x4b, 0xba, 0x4b, 0xbd,
0x62, 0x72, 0x19, 0xc3, 0x5f, 0x34, 0xa9, 0xf1, 0xdf, 0x9b, 0xf4, 0x56, 0xc7, 0x3d, 0x2e, 0x9a,
0xb4, 0x0a, 0xed, 0x0c, 0x59, 0xb9, 0x45, 0xb8, 0x07, 0x97, 0x4b, 0xfd, 0x9a, 0x05, 0xb0, 0x91,
0x79, 0x75, 0xf8, 0x37, 0xa1, 0xfb, 0x1b, 0x99, 0x62, 0x48, 0xe1, 0x33, 0x08, 0x22, 0xd5, 0xdd,
0x07, 0x5f, 0x8f, 0x4d, 0x74, 0x74, 0x6c, 0xa2, 0x1f, 0xc7, 0x26, 0xfa, 0x7c, 0x62, 0x2e, 0x1c,
0x9d, 0x98, 0x0b, 0xdf, 0x4f, 0xcc, 0x85, 0x57, 0xbd, 0x43, 0xae, 0x46, 0xb1, 0x3b, 0xf0, 0x44,
0x30, 0x14, 0x61, 0xfa, 0x97, 0x1b, 0xea, 0x8f, 0x77, 0xc3, 0xf4, 0xf5, 0x9a, 0x4e, 0x94, 0x6e,
0x5d, 0xbf, 0x5a, 0xef, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x91, 0xe2, 0xb2, 0x85, 0xa7, 0x05,
0x00, 0x00,
// 745 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x95, 0xc1, 0x6e, 0xd3, 0x48,
0x18, 0xc7, 0x3b, 0x71, 0x92, 0xd6, 0x5f, 0xd2, 0xc8, 0x1d, 0x75, 0x77, 0x47, 0xd5, 0x6e, 0x36,
0x9b, 0xee, 0xae, 0xb2, 0xda, 0x6e, 0xa2, 0x76, 0x2f, 0xa8, 0xa0, 0x8a, 0x14, 0x38, 0xa0, 0xaa,
0x12, 0x32, 0xa8, 0x12, 0x5c, 0xa2, 0xb1, 0x67, 0x68, 0x4c, 0x6c, 0x4f, 0xf0, 0x8c, 0x23, 0x72,
0x44, 0x02, 0x89, 0x13, 0xe2, 0x09, 0x78, 0x1e, 0x8e, 0x95, 0xb8, 0x70, 0x44, 0xed, 0x1b, 0xf0,
0x04, 0xc8, 0x63, 0x3b, 0x71, 0xa0, 0xa2, 0x50, 0x21, 0x71, 0x89, 0x32, 0x7f, 0xff, 0xfd, 0x79,
0xbe, 0xff, 0xcf, 0xdf, 0x18, 0x30, 0xf3, 0x58, 0x6f, 0xb2, 0xdd, 0x93, 0x8a, 0x2a, 0xde, 0x1d,
0x47, 0x42, 0x09, 0x5c, 0x65, 0x1e, 0xeb, 0x4e, 0xb6, 0x37, 0x7e, 0x71, 0x85, 0x0c, 0x84, 0xec,
0x89, 0x28, 0x48, 0x2c, 0x22, 0x0a, 0x52, 0xc3, 0xc6, 0x7a, 0x76, 0xd3, 0x31, 0x0f, 0xb9, 0xf4,
0x64, 0xaa, 0xb6, 0x9f, 0x1b, 0x60, 0xf6, 0xa5, 0xe4, 0x91, 0xf2, 0x44, 0x88, 0x2d, 0x30, 0x98,
0xc7, 0x08, 0x6a, 0xa1, 0x8e, 0x69, 0x27, 0x7f, 0x71, 0x13, 0xc0, 0x15, 0xa1, 0x8a, 0x84, 0xef,
0xf3, 0x88, 0x94, 0xf4, 0x85, 0x82, 0x82, 0x09, 0x2c, 0xcb, 0xd8, 0x79, 0xc4, 0x5d, 0x45, 0x0c,
0x7d, 0x31, 0x5f, 0xe2, 0xff, 0x00, 0xc6, 0xb1, 0xe3, 0x7b, 0xee, 0x60, 0xc4, 0xa7, 0xa4, 0xdc,
0x42, 0x9d, 0xda, 0x4e, 0xa3, 0x9b, 0xee, 0xb2, 0x7b, 0x27, 0x76, 0x0e, 0xf8, 0xd4, 0x36, 0x53,
0xc7, 0x01, 0x9f, 0xe2, 0xbf, 0xa0, 0x41, 0xf3, 0x7d, 0x0c, 0xd4, 0x74, 0xcc, 0x49, 0x45, 0xd7,
0x5b, 0x9d, 0xa9, 0xf7, 0xa6, 0x63, 0x8e, 0x6f, 0x42, 0x8d, 0xba, 0x6e, 0x1c, 0xc4, 0x3e, 0x55,
0x22, 0x22, 0xd5, 0x96, 0xd1, 0xa9, 0xed, 0xb4, 0xf3, 0xb2, 0xb3, 0x4e, 0xba, 0xfd, 0xb9, 0xe9,
0x56, 0xa8, 0xa2, 0xa9, 0x5d, 0xbc, 0x2d, 0x79, 0x98, 0x1b, 0x71, 0xaa, 0x9f, 0xe5, 0xf8, 0xc2,
0x1d, 0x91, 0xe5, 0x16, 0xea, 0x18, 0xf6, 0x6a, 0xae, 0xee, 0x27, 0xe2, 0xc6, 0x1e, 0x58, 0x9f,
0xd6, 0x49, 0x22, 0x4a, 0xfa, 0xc9, 0x22, 0x1a, 0xf1, 0x29, 0x5e, 0x87, 0xca, 0x84, 0xfa, 0x31,
0xd7, 0xe9, 0xd4, 0xed, 0x74, 0xb1, 0x5b, 0xba, 0x82, 0x76, 0xff, 0xf9, 0xf0, 0xfa, 0xed, 0x4b,
0x63, 0x13, 0x2a, 0x3a, 0x56, 0x4c, 0x00, 0xcf, 0x93, 0xdb, 0xca, 0x72, 0xb2, 0x10, 0x41, 0x04,
0xb5, 0x9f, 0x1a, 0xd0, 0xe8, 0xc7, 0x6a, 0xc8, 0x43, 0xe5, 0xb9, 0xf4, 0x47, 0xc3, 0xd8, 0x84,
0x24, 0x09, 0x96, 0x6c, 0x86, 0xfa, 0x03, 0x8f, 0x69, 0x16, 0x75, 0xbb, 0x3e, 0x17, 0x6f, 0x33,
0x7c, 0x1d, 0x56, 0x02, 0xae, 0x28, 0xa3, 0x8a, 0x66, 0x1c, 0xfe, 0x9c, 0x71, 0x58, 0xe8, 0xa4,
0x7b, 0x98, 0xd9, 0x52, 0x12, 0xb3, 0xbb, 0xbe, 0x16, 0xc3, 0x55, 0x58, 0x5d, 0xa8, 0x70, 0x11,
0x03, 0xf3, 0x52, 0x0c, 0x4a, 0xed, 0x17, 0x06, 0xc0, 0x8d, 0x79, 0x9a, 0x3f, 0x43, 0x35, 0x8c,
0x03, 0x87, 0x47, 0xfa, 0x41, 0x65, 0x3b, 0x5b, 0xe5, 0x5c, 0x4a, 0x73, 0x2e, 0x7f, 0x40, 0x5d,
0x8a, 0x30, 0x1a, 0x50, 0xc6, 0x22, 0x2e, 0x65, 0x16, 0x7e, 0x2d, 0xd1, 0xfa, 0xa9, 0x84, 0x7f,
0x87, 0x1a, 0x57, 0xc3, 0x99, 0xa3, 0x9c, 0xb2, 0xe3, 0x6a, 0x58, 0x30, 0x38, 0xca, 0x9d, 0x19,
0xd2, 0x97, 0x1f, 0x1c, 0xe5, 0xe6, 0x86, 0x45, 0x84, 0xd5, 0x8b, 0x10, 0xfe, 0x04, 0xd5, 0x91,
0x1c, 0x4c, 0xa8, 0xaf, 0x33, 0x35, 0xed, 0xca, 0x48, 0x1e, 0x51, 0x5f, 0x93, 0xf5, 0xa9, 0x17,
0x70, 0x96, 0x25, 0xbe, 0xa2, 0x13, 0xaf, 0x67, 0xa2, 0x0e, 0xfc, 0x1c, 0x2e, 0xe6, 0x39, 0x5c,
0x76, 0xef, 0xeb, 0x68, 0xef, 0x02, 0xe4, 0x41, 0x59, 0x08, 0xe3, 0xc5, 0x28, 0x92, 0x64, 0xf1,
0xda, 0x42, 0xef, 0x56, 0x29, 0x95, 0x0a, 0xdd, 0x5a, 0x06, 0x41, 0xd8, 0xd4, 0xb1, 0x5a, 0x65,
0x82, 0x88, 0xd1, 0x7e, 0x56, 0x86, 0xfa, 0x11, 0x8f, 0xbc, 0x87, 0x97, 0x1f, 0x86, 0xdf, 0x00,
0x98, 0xc7, 0x06, 0x01, 0x57, 0x43, 0xc1, 0x32, 0x24, 0x26, 0xf3, 0xd8, 0xa1, 0x16, 0x12, 0xba,
0x9e, 0x94, 0x31, 0x8f, 0x32, 0x16, 0xd9, 0xaa, 0x38, 0x43, 0x95, 0x2f, 0xcd, 0xd0, 0x85, 0x00,
0xfe, 0x85, 0xb5, 0x49, 0xa1, 0x83, 0xf4, 0x4c, 0x4b, 0x59, 0x58, 0xc5, 0x0b, 0xfa, 0x58, 0xdb,
0x2b, 0xcc, 0xd2, 0xca, 0xe2, 0x99, 0x56, 0x8c, 0xe1, 0x1b, 0x26, 0xc9, 0xfc, 0xee, 0x93, 0xf4,
0x58, 0xe3, 0x1e, 0xe5, 0x93, 0xb4, 0x0e, 0x8d, 0x34, 0xb2, 0xe2, 0x14, 0xe1, 0x36, 0xfc, 0x5a,
0x98, 0xaf, 0x39, 0x80, 0xad, 0xd4, 0xab, 0xe1, 0xff, 0x0d, 0xad, 0xcf, 0x92, 0xc9, 0x8b, 0xe4,
0x3e, 0x83, 0x20, 0x52, 0xde, 0xbf, 0xf6, 0xe6, 0xb4, 0x89, 0x4e, 0x4e, 0x9b, 0xe8, 0xfd, 0x69,
0x13, 0xbd, 0x3a, 0x6b, 0x2e, 0x9d, 0x9c, 0x35, 0x97, 0xde, 0x9d, 0x35, 0x97, 0x1e, 0xb4, 0x8f,
0x3d, 0x35, 0x8c, 0x9d, 0xae, 0x2b, 0x82, 0x9e, 0x08, 0x93, 0x57, 0xae, 0xa7, 0x7f, 0x9e, 0xf4,
0x92, 0xcf, 0x5c, 0x52, 0x51, 0x3a, 0x55, 0xfd, 0x89, 0xfb, 0xff, 0x63, 0x00, 0x00, 0x00, 0xff,
0xff, 0x4d, 0x8f, 0xef, 0xfc, 0x2f, 0x07, 0x00, 0x00,
}
func (m *Assertion) 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 *Assertion) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Assertion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.CreationBlock != 0 {
i = encodeVarintState(dAtA, i, uint64(m.CreationBlock))
i--
dAtA[i] = 0x38
}
if len(m.Accumulator) > 0 {
for k := range m.Accumulator {
v := m.Accumulator[k]
baseI := i
if len(v) > 0 {
i -= len(v)
copy(dAtA[i:], v)
i = encodeVarintState(dAtA, i, uint64(len(v)))
i--
dAtA[i] = 0x12
}
i -= len(k)
copy(dAtA[i:], k)
i = encodeVarintState(dAtA, i, uint64(len(k)))
i--
dAtA[i] = 0xa
i = encodeVarintState(dAtA, i, uint64(baseI-i))
i--
dAtA[i] = 0x32
}
}
if len(m.AssertionType) > 0 {
i -= len(m.AssertionType)
copy(dAtA[i:], m.AssertionType)
i = encodeVarintState(dAtA, i, uint64(len(m.AssertionType)))
i--
dAtA[i] = 0x2a
}
if m.PublicKey != nil {
{
size, err := m.PublicKey.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintState(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
}
if len(m.Subject) > 0 {
i -= len(m.Subject)
copy(dAtA[i:], m.Subject)
i = encodeVarintState(dAtA, i, uint64(len(m.Subject)))
i--
dAtA[i] = 0x1a
}
if len(m.Controller) > 0 {
i -= len(m.Controller)
copy(dAtA[i:], m.Controller)
i = encodeVarintState(dAtA, i, uint64(len(m.Controller)))
i--
dAtA[i] = 0x12
}
if len(m.Did) > 0 {
i -= len(m.Did)
copy(dAtA[i:], m.Did)
i = encodeVarintState(dAtA, i, uint64(len(m.Did)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Authentication) Marshal() (dAtA []byte, err error) {
@@ -699,6 +893,50 @@ func encodeVarintState(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *Assertion) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Did)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
l = len(m.Controller)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
l = len(m.Subject)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
if m.PublicKey != nil {
l = m.PublicKey.Size()
n += 1 + l + sovState(uint64(l))
}
l = len(m.AssertionType)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
if len(m.Accumulator) > 0 {
for k, v := range m.Accumulator {
_ = k
_ = v
l = 0
if len(v) > 0 {
l = 1 + len(v) + sovState(uint64(len(v)))
}
mapEntrySize := 1 + len(k) + sovState(uint64(len(k))) + l
n += mapEntrySize + 1 + sovState(uint64(mapEntrySize))
}
}
if m.CreationBlock != 0 {
n += 1 + sovState(uint64(m.CreationBlock))
}
return n
}
func (m *Authentication) Size() (n int) {
if m == nil {
return 0
@@ -835,6 +1073,367 @@ func sovState(x uint64) (n int) {
func sozState(x uint64) (n int) {
return sovState(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Assertion) 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 ErrIntOverflowState
}
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: Assertion: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Assertion: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Did", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
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 ErrInvalidLengthState
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Did = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
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 ErrIntOverflowState
}
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 ErrInvalidLengthState
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthState
}
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 Subject", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
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 ErrInvalidLengthState
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Subject = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthState
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.PublicKey == nil {
m.PublicKey = &PubKey{}
}
if err := m.PublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AssertionType", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
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 ErrInvalidLengthState
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AssertionType = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Accumulator", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthState
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Accumulator == nil {
m.Accumulator = make(map[string][]byte)
}
var mapkey string
mapvalue := []byte{}
for iNdEx < postIndex {
entryPreIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
if fieldNum == 1 {
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthState
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey < 0 {
return ErrInvalidLengthState
}
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
} else if fieldNum == 2 {
var mapbyteLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
mapbyteLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intMapbyteLen := int(mapbyteLen)
if intMapbyteLen < 0 {
return ErrInvalidLengthState
}
postbytesIndex := iNdEx + intMapbyteLen
if postbytesIndex < 0 {
return ErrInvalidLengthState
}
if postbytesIndex > l {
return io.ErrUnexpectedEOF
}
mapvalue = make([]byte, mapbyteLen)
copy(mapvalue, dAtA[iNdEx:postbytesIndex])
iNdEx = postbytesIndex
} else {
iNdEx = entryPreIndex
skippy, err := skipState(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthState
}
if (iNdEx + skippy) > postIndex {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
m.Accumulator[mapkey] = mapvalue
iNdEx = postIndex
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field CreationBlock", wireType)
}
m.CreationBlock = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.CreationBlock |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipState(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthState
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Authentication) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
x/did/types/tx.pb.go
+2079 -217
View File
File diff suppressed because it is too large Load Diff