go/sonr
go/sonr
1
1
Fork 0
mirror of https://github.com/onsonr/sonr.git synced 2025-03-10 13:07:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

docs(marketing): improve section data model and section rendering

Browse Source
This commit is contained in:
Prad Nukala 2024-10-24 16:11:30 -04:00
parent c8657022a2
commit f14f6ff536
9 changed files with 97 additions and 1007 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

719
api/macaroon/v1/genesis.pulsar.go
View File

@ -2763,610 +2763,6 @@ func (x *fastReflection_Caveats) ProtoMethods() *protoiface.Methods {
}
}
var _ protoreflect.List = (*_Transactions_1_list)(nil)
type _Transactions_1_list struct {
list *[]string
}
func (x *_Transactions_1_list) Len() int {
if x.list == nil {
return 0
}
return len(*x.list)
}
func (x *_Transactions_1_list) Get(i int) protoreflect.Value {
return protoreflect.ValueOfString((*x.list)[i])
}
func (x *_Transactions_1_list) Set(i int, value protoreflect.Value) {
valueUnwrapped := value.String()
concreteValue := valueUnwrapped
(*x.list)[i] = concreteValue
}
func (x *_Transactions_1_list) Append(value protoreflect.Value) {
valueUnwrapped := value.String()
concreteValue := valueUnwrapped
*x.list = append(*x.list, concreteValue)
}
func (x *_Transactions_1_list) AppendMutable() protoreflect.Value {
panic(fmt.Errorf("AppendMutable can not be called on message Transactions at list field Allowlist as it is not of Message kind"))
}
func (x *_Transactions_1_list) Truncate(n int) {
*x.list = (*x.list)[:n]
}
func (x *_Transactions_1_list) NewElement() protoreflect.Value {
v := ""
return protoreflect.ValueOfString(v)
}
func (x *_Transactions_1_list) IsValid() bool {
return x.list != nil
}
var _ protoreflect.List = (*_Transactions_2_list)(nil)
type _Transactions_2_list struct {
list *[]string
}
func (x *_Transactions_2_list) Len() int {
if x.list == nil {
return 0
}
return len(*x.list)
}
func (x *_Transactions_2_list) Get(i int) protoreflect.Value {
return protoreflect.ValueOfString((*x.list)[i])
}
func (x *_Transactions_2_list) Set(i int, value protoreflect.Value) {
valueUnwrapped := value.String()
concreteValue := valueUnwrapped
(*x.list)[i] = concreteValue
}
func (x *_Transactions_2_list) Append(value protoreflect.Value) {
valueUnwrapped := value.String()
concreteValue := valueUnwrapped
*x.list = append(*x.list, concreteValue)
}
func (x *_Transactions_2_list) AppendMutable() protoreflect.Value {
panic(fmt.Errorf("AppendMutable can not be called on message Transactions at list field Denylist as it is not of Message kind"))
}
func (x *_Transactions_2_list) Truncate(n int) {
*x.list = (*x.list)[:n]
}
func (x *_Transactions_2_list) NewElement() protoreflect.Value {
v := ""
return protoreflect.ValueOfString(v)
}
func (x *_Transactions_2_list) IsValid() bool {
return x.list != nil
}
var (
md_Transactions protoreflect.MessageDescriptor
fd_Transactions_allowlist protoreflect.FieldDescriptor
fd_Transactions_denylist protoreflect.FieldDescriptor
)
func init() {
file_macaroon_v1_genesis_proto_init()
md_Transactions = File_macaroon_v1_genesis_proto.Messages().ByName("Transactions")
fd_Transactions_allowlist = md_Transactions.Fields().ByName("allowlist")
fd_Transactions_denylist = md_Transactions.Fields().ByName("denylist")
}
var _ protoreflect.Message = (*fastReflection_Transactions)(nil)
type fastReflection_Transactions Transactions
func (x *Transactions) ProtoReflect() protoreflect.Message {
return (*fastReflection_Transactions)(x)
}
func (x *Transactions) slowProtoReflect() protoreflect.Message {
mi := &file_macaroon_v1_genesis_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
var _fastReflection_Transactions_messageType fastReflection_Transactions_messageType
var _ protoreflect.MessageType = fastReflection_Transactions_messageType{}
type fastReflection_Transactions_messageType struct{}
func (x fastReflection_Transactions_messageType) Zero() protoreflect.Message {
return (*fastReflection_Transactions)(nil)
}
func (x fastReflection_Transactions_messageType) New() protoreflect.Message {
return new(fastReflection_Transactions)
}
func (x fastReflection_Transactions_messageType) Descriptor() protoreflect.MessageDescriptor {
return md_Transactions
}
// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Transactions) Descriptor() protoreflect.MessageDescriptor {
return md_Transactions
}
// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Transactions) Type() protoreflect.MessageType {
return _fastReflection_Transactions_messageType
}
// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Transactions) New() protoreflect.Message {
return new(fastReflection_Transactions)
}
// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Transactions) Interface() protoreflect.ProtoMessage {
return (*Transactions)(x)
}
// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Transactions) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
if len(x.Allowlist) != 0 {
value := protoreflect.ValueOfList(&_Transactions_1_list{list: &x.Allowlist})
if !f(fd_Transactions_allowlist, value) {
return
}
}
if len(x.Denylist) != 0 {
value := protoreflect.ValueOfList(&_Transactions_2_list{list: &x.Denylist})
if !f(fd_Transactions_denylist, value) {
return
}
}
}
// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Transactions) Has(fd protoreflect.FieldDescriptor) bool {
switch fd.FullName() {
case "macaroon.v1.Transactions.allowlist":
return len(x.Allowlist) != 0
case "macaroon.v1.Transactions.denylist":
return len(x.Denylist) != 0
default:
if fd.IsExtension() {
panic(fmt.Errorf("proto3 declared messages do not support extensions: macaroon.v1.Transactions"))
}
panic(fmt.Errorf("message macaroon.v1.Transactions does not contain field %s", fd.FullName()))
}
}
// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Transactions) Clear(fd protoreflect.FieldDescriptor) {
switch fd.FullName() {
case "macaroon.v1.Transactions.allowlist":
x.Allowlist = nil
case "macaroon.v1.Transactions.denylist":
x.Denylist = nil
default:
if fd.IsExtension() {
panic(fmt.Errorf("proto3 declared messages do not support extensions: macaroon.v1.Transactions"))
}
panic(fmt.Errorf("message macaroon.v1.Transactions does not contain field %s", fd.FullName()))
}
}
// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Transactions) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
switch descriptor.FullName() {
case "macaroon.v1.Transactions.allowlist":
if len(x.Allowlist) == 0 {
return protoreflect.ValueOfList(&_Transactions_1_list{})
}
listValue := &_Transactions_1_list{list: &x.Allowlist}
return protoreflect.ValueOfList(listValue)
case "macaroon.v1.Transactions.denylist":
if len(x.Denylist) == 0 {
return protoreflect.ValueOfList(&_Transactions_2_list{})
}
listValue := &_Transactions_2_list{list: &x.Denylist}
return protoreflect.ValueOfList(listValue)
default:
if descriptor.IsExtension() {
panic(fmt.Errorf("proto3 declared messages do not support extensions: macaroon.v1.Transactions"))
}
panic(fmt.Errorf("message macaroon.v1.Transactions does not contain field %s", descriptor.FullName()))
}
}
// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Transactions) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
switch fd.FullName() {
case "macaroon.v1.Transactions.allowlist":
lv := value.List()
clv := lv.(*_Transactions_1_list)
x.Allowlist = *clv.list
case "macaroon.v1.Transactions.denylist":
lv := value.List()
clv := lv.(*_Transactions_2_list)
x.Denylist = *clv.list
default:
if fd.IsExtension() {
panic(fmt.Errorf("proto3 declared messages do not support extensions: macaroon.v1.Transactions"))
}
panic(fmt.Errorf("message macaroon.v1.Transactions does not contain field %s", fd.FullName()))
}
}
// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Transactions) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
case "macaroon.v1.Transactions.allowlist":
if x.Allowlist == nil {
x.Allowlist = []string{}
}
value := &_Transactions_1_list{list: &x.Allowlist}
return protoreflect.ValueOfList(value)
case "macaroon.v1.Transactions.denylist":
if x.Denylist == nil {
x.Denylist = []string{}
}
value := &_Transactions_2_list{list: &x.Denylist}
return protoreflect.ValueOfList(value)
default:
if fd.IsExtension() {
panic(fmt.Errorf("proto3 declared messages do not support extensions: macaroon.v1.Transactions"))
}
panic(fmt.Errorf("message macaroon.v1.Transactions does not contain field %s", fd.FullName()))
}
}
// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Transactions) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
switch fd.FullName() {
case "macaroon.v1.Transactions.allowlist":
list := []string{}
return protoreflect.ValueOfList(&_Transactions_1_list{list: &list})
case "macaroon.v1.Transactions.denylist":
list := []string{}
return protoreflect.ValueOfList(&_Transactions_2_list{list: &list})
default:
if fd.IsExtension() {
panic(fmt.Errorf("proto3 declared messages do not support extensions: macaroon.v1.Transactions"))
}
panic(fmt.Errorf("message macaroon.v1.Transactions does not contain field %s", fd.FullName()))
}
}
// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Transactions) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
switch d.FullName() {
default:
panic(fmt.Errorf("%s is not a oneof field in macaroon.v1.Transactions", d.FullName()))
}
panic("unreachable")
}
// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Transactions) GetUnknown() protoreflect.RawFields {
return x.unknownFields
}
// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Transactions) SetUnknown(fields protoreflect.RawFields) {
x.unknownFields = fields
}
// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Transactions) IsValid() bool {
return x != nil
}
// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Transactions) ProtoMethods() *protoiface.Methods {
size := func(input protoiface.SizeInput) protoiface.SizeOutput {
x := input.Message.Interface().(*Transactions)
if x == nil {
return protoiface.SizeOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
Size: 0,
}
}
options := runtime.SizeInputToOptions(input)
_ = options
var n int
var l int
_ = l
if len(x.Allowlist) > 0 {
for _, s := range x.Allowlist {
l = len(s)
n += 1 + l + runtime.Sov(uint64(l))
}
}
if len(x.Denylist) > 0 {
for _, s := range x.Denylist {
l = len(s)
n += 1 + l + runtime.Sov(uint64(l))
}
}
if x.unknownFields != nil {
n += len(x.unknownFields)
}
return protoiface.SizeOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
Size: n,
}
}
marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
x := input.Message.Interface().(*Transactions)
if x == nil {
return protoiface.MarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
Buf: input.Buf,
}, nil
}
options := runtime.MarshalInputToOptions(input)
_ = options
size := options.Size(x)
dAtA := make([]byte, size)
i := len(dAtA)
_ = i
var l int
_ = l
if x.unknownFields != nil {
i -= len(x.unknownFields)
copy(dAtA[i:], x.unknownFields)
}
if len(x.Denylist) > 0 {
for iNdEx := len(x.Denylist) - 1; iNdEx >= 0; iNdEx-- {
i -= len(x.Denylist[iNdEx])
copy(dAtA[i:], x.Denylist[iNdEx])
i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Denylist[iNdEx])))
i--
dAtA[i] = 0x12
}
}
if len(x.Allowlist) > 0 {
for iNdEx := len(x.Allowlist) - 1; iNdEx >= 0; iNdEx-- {
i -= len(x.Allowlist[iNdEx])
copy(dAtA[i:], x.Allowlist[iNdEx])
i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Allowlist[iNdEx])))
i--
dAtA[i] = 0xa
}
}
if input.Buf != nil {
input.Buf = append(input.Buf, dAtA...)
} else {
input.Buf = dAtA
}
return protoiface.MarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
Buf: input.Buf,
}, nil
}
unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
x := input.Message.Interface().(*Transactions)
if x == nil {
return protoiface.UnmarshalOutput{
NoUnkeyedLiterals: input.NoUnkeyedLiterals,
Flags: input.Flags,
}, nil
}
options := runtime.UnmarshalInputToOptions(input)
_ = options
dAtA := input.Buf
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
}
if iNdEx >= l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Transactions: wiretype end group for non-group")
}
if fieldNum <= 0 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Transactions: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Allowlist", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
}
if iNdEx >= l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
}
if postIndex > l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
x.Allowlist = append(x.Allowlist, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 2:
if wireType != 2 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Denylist", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
}
if iNdEx >= l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
}
if postIndex > l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
x.Denylist = append(x.Denylist, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := runtime.Skip(dAtA[iNdEx:])
if err != nil {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
}
if (iNdEx + skippy) > l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
if !options.DiscardUnknown {
x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
}
iNdEx += skippy
}
}
if iNdEx > l {
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
}
return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
}
return &protoiface.Methods{
NoUnkeyedLiterals: struct{}{},
Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
Size: size,
Marshal: marshal,
Unmarshal: unmarshal,
Merge: nil,
CheckInitialized: nil,
}
}
var _ protoreflect.List = (*_Caveat_1_list)(nil)
type _Caveat_1_list struct {
@ -3437,7 +2833,7 @@ func (x *Caveat) ProtoReflect() protoreflect.Message {
}
func (x *Caveat) slowProtoReflect() protoreflect.Message {
mi := &file_macaroon_v1_genesis_proto_msgTypes[6]
mi := &file_macaroon_v1_genesis_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@ -4212,51 +3608,6 @@ func (x *Caveats) GetSupportedThirdParty() []*Caveat {
return nil
}
// Transactions defines the allowlist,denylist for transactions which can be
// broadcasted to the network with the Sonr DWN Signed macaroon.
type Transactions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Allowlist []string `protobuf:"bytes,1,rep,name=allowlist,proto3" json:"allowlist,omitempty"`
Denylist []string `protobuf:"bytes,2,rep,name=denylist,proto3" json:"denylist,omitempty"`
}
func (x *Transactions) Reset() {
*x = Transactions{}
if protoimpl.UnsafeEnabled {
mi := &file_macaroon_v1_genesis_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Transactions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Transactions) ProtoMessage() {}
// Deprecated: Use Transactions.ProtoReflect.Descriptor instead.
func (*Transactions) Descriptor() ([]byte, []int) {
return file_macaroon_v1_genesis_proto_rawDescGZIP(), []int{5}
}
func (x *Transactions) GetAllowlist() []string {
if x != nil {
return x.Allowlist
}
return nil
}
func (x *Transactions) GetDenylist() []string {
if x != nil {
return x.Denylist
}
return nil
}
type Caveat struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
@ -4270,7 +3621,7 @@ type Caveat struct {
func (x *Caveat) Reset() {
*x = Caveat{}
if protoimpl.UnsafeEnabled {
mi := &file_macaroon_v1_genesis_proto_msgTypes[6]
mi := &file_macaroon_v1_genesis_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@ -4284,7 +3635,7 @@ func (*Caveat) ProtoMessage() {}
// Deprecated: Use Caveat.ProtoReflect.Descriptor instead.
func (*Caveat) Descriptor() ([]byte, []int) {
return file_macaroon_v1_genesis_proto_rawDescGZIP(), []int{6}
return file_macaroon_v1_genesis_proto_rawDescGZIP(), []int{5}
}
func (x *Caveat) GetScopes() []string {
@ -4355,30 +3706,23 @@ var file_macaroon_v1_genesis_proto_rawDesc = []byte{
0x31, 0x2e, 0x43, 0x61, 0x76, 0x65, 0x61, 0x74, 0x52, 0x13, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72,
0x74, 0x65, 0x64, 0x54, 0x68, 0x69, 0x72, 0x64, 0x50, 0x61, 0x72, 0x74, 0x79, 0x3a, 0x19, 0xe8,
0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x10, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e,
0x2f, 0x63, 0x61, 0x76, 0x65, 0x61, 0x74, 0x73, 0x22, 0x68, 0x0a, 0x0c, 0x54, 0x72, 0x61, 0x6e,
0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x6c, 0x6c, 0x6f,
0x77, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x61, 0x6c, 0x6c,
0x6f, 0x77, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x6e, 0x79, 0x6c, 0x69,
0x73, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x64, 0x65, 0x6e, 0x79, 0x6c, 0x69,
0x73, 0x74, 0x3a, 0x1e, 0xe8, 0xa0, 0x1f, 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x15, 0x6d, 0x61, 0x63,
0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x22, 0x5a, 0x0a, 0x06, 0x43, 0x61, 0x76, 0x65, 0x61, 0x74, 0x12, 0x16, 0x0a, 0x06,
0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x73, 0x63,
0x6f, 0x70, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x61, 0x76, 0x65, 0x61, 0x74, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x61, 0x76, 0x65, 0x61, 0x74, 0x12, 0x20, 0x0a, 0x0b,
0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x9f,
0x01, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x2e, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x2e,
0x76, 0x31, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f,
0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6f,
0x6e, 0x73, 0x6f, 0x6e, 0x72, 0x2f, 0x73, 0x6f, 0x6e, 0x72, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6d,
0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x61, 0x63, 0x61, 0x72,
0x6f, 0x6f, 0x6e, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x4d, 0x58, 0x58, 0xaa, 0x02, 0x0b, 0x4d, 0x61,
0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x0b, 0x4d, 0x61, 0x63, 0x61,
0x72, 0x6f, 0x6f, 0x6e, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x17, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f,
0x6f, 0x6e, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0xea, 0x02, 0x0c, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x3a, 0x3a, 0x56, 0x31,
0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
0x2f, 0x63, 0x61, 0x76, 0x65, 0x61, 0x74, 0x73, 0x22, 0x5a, 0x0a, 0x06, 0x43, 0x61, 0x76, 0x65,
0x61, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03,
0x28, 0x09, 0x52, 0x06, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x61,
0x76, 0x65, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x61, 0x76, 0x65,
0x61, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f,
0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
0x74, 0x69, 0x6f, 0x6e, 0x42, 0x9f, 0x01, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x2e, 0x6d, 0x61, 0x63,
0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69,
0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6f, 0x6e, 0x73, 0x6f, 0x6e, 0x72, 0x2f, 0x73, 0x6f, 0x6e, 0x72,
0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x2f, 0x76, 0x31,
0x3b, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x4d, 0x58,
0x58, 0xaa, 0x02, 0x0b, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x2e, 0x56, 0x31, 0xca,
0x02, 0x0b, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x17,
0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0c, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f,
0x6f, 0x6e, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
@ -4393,23 +3737,22 @@ func file_macaroon_v1_genesis_proto_rawDescGZIP() []byte {
return file_macaroon_v1_genesis_proto_rawDescData
}
var file_macaroon_v1_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_macaroon_v1_genesis_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
var file_macaroon_v1_genesis_proto_goTypes = []interface{}{
(*GenesisState)(nil), // 0: macaroon.v1.GenesisState
(*Params)(nil), // 1: macaroon.v1.Params
(*Methods)(nil), // 2: macaroon.v1.Methods
(*Scopes)(nil), // 3: macaroon.v1.Scopes
(*Caveats)(nil), // 4: macaroon.v1.Caveats
(*Transactions)(nil), // 5: macaroon.v1.Transactions
(*Caveat)(nil), // 6: macaroon.v1.Caveat
(*Caveat)(nil), // 5: macaroon.v1.Caveat
}
var file_macaroon_v1_genesis_proto_depIdxs = []int32{
1, // 0: macaroon.v1.GenesisState.params:type_name -> macaroon.v1.Params
2, // 1: macaroon.v1.Params.methods:type_name -> macaroon.v1.Methods
3, // 2: macaroon.v1.Params.scopes:type_name -> macaroon.v1.Scopes
4, // 3: macaroon.v1.Params.caveats:type_name -> macaroon.v1.Caveats
6, // 4: macaroon.v1.Caveats.supported_first_party:type_name -> macaroon.v1.Caveat
6, // 5: macaroon.v1.Caveats.supported_third_party:type_name -> macaroon.v1.Caveat
5, // 4: macaroon.v1.Caveats.supported_first_party:type_name -> macaroon.v1.Caveat
5, // 5: macaroon.v1.Caveats.supported_third_party:type_name -> macaroon.v1.Caveat
6, // [6:6] is the sub-list for method output_type
6, // [6:6] is the sub-list for method input_type
6, // [6:6] is the sub-list for extension type_name
@ -4484,18 +3827,6 @@ func file_macaroon_v1_genesis_proto_init() {
}
}
file_macaroon_v1_genesis_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Transactions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_macaroon_v1_genesis_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Caveat); i {
case 0:
return &v.state
@ -4514,7 +3845,7 @@ func file_macaroon_v1_genesis_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_macaroon_v1_genesis_proto_rawDesc,
NumEnums: 0,
NumMessages: 7,
NumMessages: 6,
NumExtensions: 0,
NumServices: 0,
},

9
pkg/nebula/components/marketing/sections/architecture.templ
View File

@ -2,6 +2,10 @@ package sections
import models "github.com/onsonr/sonr/internal/orm/marketing"
// ╭───────────────────────────────────────────────────────────╮
// │ Data Model │
// ╰───────────────────────────────────────────────────────────╯
// architecture is the (4th) home page architecture section
var arch = &models.Architecture{
Heading: "Onchain Security with Offchain Privacy",
@ -28,6 +32,11 @@ var arch = &models.Architecture{
},
}
// ╭───────────────────────────────────────────────────────────╮
// │ Render Section View │
// ╰───────────────────────────────────────────────────────────╯
// Architecture is the (4th) home page architecture section
templ Architecture() {
<!-- Features #2 -->
<section>

7
pkg/nebula/components/marketing/sections/cta.templ
View File

@ -2,6 +2,10 @@ package sections
import models "github.com/onsonr/sonr/internal/orm/marketing"
// ╭───────────────────────────────────────────────────────────╮
// │ Data Model │
// ╰───────────────────────────────────────────────────────────╯
var cta = &models.CallToAction{
Logo: &models.Image{
Src: "https://cdn.sonr.id/logo-zinc.svg",
@ -20,6 +24,9 @@ var cta = &models.CallToAction{
},
}
// ╭───────────────────────────────────────────────────────────╮
// │ Render Section View │
// ╰───────────────────────────────────────────────────────────╯
templ CallToAction() {
<section>
<div class="py-12 md:py-20">

7
pkg/nebula/components/marketing/sections/hero.templ
View File

@ -6,6 +6,10 @@ import (
"github.com/onsonr/sonr/pkg/nebula/global/ui"
)
// ╭───────────────────────────────────────────────────────────╮
// │ Data Model │
// ╰───────────────────────────────────────────────────────────╯
// hero is the (1st) home page hero section
var hero = &models.Hero{
TitleFirst: "Simplified",
@ -27,6 +31,9 @@ var hero = &models.Hero{
},
}
// ╭───────────────────────────────────────────────────────────╮
// │ Render Section View │
// ╰───────────────────────────────────────────────────────────╯
templ Hero() {
<!-- Hero -->
<section class="relative before:absolute before:inset-0 before:h-80 before:pointer-events-none before:bg-gradient-to-b before:from-zinc-100 before:-z-10">

7
pkg/nebula/components/marketing/sections/highlights.templ
View File

@ -5,6 +5,10 @@ import (
models "github.com/onsonr/sonr/internal/orm/marketing"
)
// ╭───────────────────────────────────────────────────────────╮
// │ Data Model │
// ╰───────────────────────────────────────────────────────────╯
// highlights is the (2nd) home page highlights section
var highlights = &models.Highlights{
Heading: "The Internet Rebuilt for You",
@ -33,6 +37,9 @@ var highlights = &models.Highlights{
},
}
// ╭───────────────────────────────────────────────────────────╮
// │ Render Section View │
// ╰───────────────────────────────────────────────────────────╯
templ Highlights() {
<!-- Features -->
<section class="relative bg-zinc-50">

9
pkg/nebula/components/marketing/sections/lowlights.templ
View File

@ -1,5 +1,14 @@
package sections
// ╭───────────────────────────────────────────────────────────╮
// │ Data Model │
// ╰───────────────────────────────────────────────────────────╯
// ╭───────────────────────────────────────────────────────────╮
// │ Render Section View │
// ╰───────────────────────────────────────────────────────────╯
// Lowlights is the (4th) home page lowlights section
templ Lowlights() {
<section class="bg-zinc-800">
<div class="py-12 md:py-20">

1
pkg/workers/README.md Normal file
View File

@ -0,0 +1 @@
# Workers

10
proto/macaroon/v1/genesis.proto
View File

@ -54,16 +54,6 @@ message Caveats {
repeated Caveat supported_third_party = 2;
}
// Transactions defines the allowlist,denylist for transactions which can be
// broadcasted to the network with the Sonr DWN Signed macaroon.
message Transactions {
option (amino.name) = "macaroon/transactions";
option (gogoproto.equal) = true;
repeated string allowlist = 1;
repeated string denylist = 2;
}
message Caveat {
repeated string scopes = 1;
string caveat = 2;

335
x/macaroon/types/genesis.pb.go
View File

@ -293,60 +293,6 @@ func (m *Caveats) GetSupportedThirdParty() []*Caveat {
return nil
}
// Transactions defines the allowlist,denylist for transactions which can be
// broadcasted to the network with the Sonr DWN Signed macaroon.
type Transactions struct {
Allowlist []string `protobuf:"bytes,1,rep,name=allowlist,proto3" json:"allowlist,omitempty"`
Denylist []string `protobuf:"bytes,2,rep,name=denylist,proto3" json:"denylist,omitempty"`
}
func (m *Transactions) Reset() { *m = Transactions{} }
func (m *Transactions) String() string { return proto.CompactTextString(m) }
func (*Transactions) ProtoMessage() {}
func (*Transactions) Descriptor() ([]byte, []int) {
return fileDescriptor_06e0b5dfdf5e52ba, []int{5}
}
func (m *Transactions) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Transactions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Transactions.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 *Transactions) XXX_Merge(src proto.Message) {
xxx_messageInfo_Transactions.Merge(m, src)
}
func (m *Transactions) XXX_Size() int {
return m.Size()
}
func (m *Transactions) XXX_DiscardUnknown() {
xxx_messageInfo_Transactions.DiscardUnknown(m)
}
var xxx_messageInfo_Transactions proto.InternalMessageInfo
func (m *Transactions) GetAllowlist() []string {
if m != nil {
return m.Allowlist
}
return nil
}
func (m *Transactions) GetDenylist() []string {
if m != nil {
return m.Denylist
}
return nil
}
type Caveat struct {
Scopes []string `protobuf:"bytes,1,rep,name=scopes,proto3" json:"scopes,omitempty"`
Caveat string `protobuf:"bytes,2,opt,name=caveat,proto3" json:"caveat,omitempty"`
@ -357,7 +303,7 @@ func (m *Caveat) Reset() { *m = Caveat{} }
func (m *Caveat) String() string { return proto.CompactTextString(m) }
func (*Caveat) ProtoMessage() {}
func (*Caveat) Descriptor() ([]byte, []int) {
return fileDescriptor_06e0b5dfdf5e52ba, []int{6}
return fileDescriptor_06e0b5dfdf5e52ba, []int{5}
}
func (m *Caveat) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -413,47 +359,43 @@ func init() {
proto.RegisterType((*Methods)(nil), "macaroon.v1.Methods")
proto.RegisterType((*Scopes)(nil), "macaroon.v1.Scopes")
proto.RegisterType((*Caveats)(nil), "macaroon.v1.Caveats")
proto.RegisterType((*Transactions)(nil), "macaroon.v1.Transactions")
proto.RegisterType((*Caveat)(nil), "macaroon.v1.Caveat")
}
func init() { proto.RegisterFile("macaroon/v1/genesis.proto", fileDescriptor_06e0b5dfdf5e52ba) }
var fileDescriptor_06e0b5dfdf5e52ba = []byte{
// 517 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcd, 0x6a, 0xdb, 0x40,
0x10, 0xb6, 0xec, 0x20, 0x57, 0xe3, 0x40, 0xda, 0xcd, 0x0f, 0x8a, 0x09, 0xb2, 0xd1, 0xa5, 0xa1,
0x05, 0x09, 0xb7, 0x37, 0xdf, 0x92, 0x42, 0x73, 0x2a, 0x84, 0x8d, 0x4f, 0xa1, 0x10, 0xd6, 0xd2,
0xc6, 0x16, 0x58, 0x5a, 0xb1, 0xbb, 0x76, 0xe3, 0x57, 0xe8, 0xa9, 0xc7, 0x1e, 0xf3, 0x08, 0x85,
0x42, 0x9f, 0x21, 0xc7, 0x1c, 0x7b, 0x2a, 0xc5, 0x3e, 0xb4, 0x8f, 0x51, 0xb4, 0xbb, 0x92, 0x1d,
0x62, 0x68, 0x2e, 0xcb, 0xce, 0x7c, 0xf3, 0x7d, 0xf3, 0xed, 0x68, 0x04, 0x87, 0x29, 0x89, 0x08,
0x67, 0x2c, 0x0b, 0x67, 0xbd, 0x70, 0x44, 0x33, 0x2a, 0x12, 0x11, 0xe4, 0x9c, 0x49, 0x86, 0x5a,
0x25, 0x14, 0xcc, 0x7a, 0xed, 0x17, 0x24, 0x4d, 0x32, 0x16, 0xaa, 0x53, 0xe3, 0xed, 0x9d, 0x38,
0x89, 0x0b, 0x96, 0xbc, 0x31, 0x89, 0xbd, 0x11, 0x1b, 0x31, 0x75, 0x0d, 0x8b, 0x9b, 0xce, 0xfa,
0x27, 0xb0, 0x7d, 0xa6, 0x75, 0x2f, 0x24, 0x91, 0x14, 0xf5, 0xc0, 0xce, 0x09, 0x27, 0xa9, 0x70,
0xad, 0xae, 0x75, 0xdc, 0x7a, 0xb3, 0x1b, 0xac, 0xf5, 0x09, 0xce, 0x15, 0x74, 0xba, 0x75, 0xf7,
0xab, 0x53, 0xc3, 0xa6, 0xd0, 0xff, 0x6e, 0x81, 0xad, 0x01, 0x14, 0x40, 0x33, 0xa5, 0x72, 0xcc,
0xe2, 0x92, 0xbe, 0xf7, 0x80, 0xfe, 0x41, 0x63, 0xb8, 0x2c, 0x42, 0xaf, 0xc1, 0x16, 0x11, 0xcb,
0xa9, 0x70, 0xeb, 0x1b, 0xba, 0x5d, 0x28, 0x08, 0x9b, 0x92, 0x42, 0x3c, 0x22, 0x33, 0x4a, 0xa4,
0x70, 0x1b, 0x1b, 0xc4, 0xdf, 0x69, 0x0c, 0x97, 0x45, 0xfd, 0xa3, 0xaf, 0xb7, 0x9d, 0xda, 0xdf,
0xdb, 0x8e, 0xf5, 0xf9, 0xcf, 0xb7, 0x57, 0x3b, 0xd5, 0x24, 0x8d, 0xeb, 0x8f, 0xd0, 0x34, 0x76,
0x90, 0x0b, 0xcd, 0x98, 0x5e, 0x93, 0xe9, 0x44, 0x2a, 0xd7, 0x0e, 0x2e, 0x43, 0x74, 0x04, 0x8e,
0x98, 0xe6, 0x39, 0xe3, 0x92, 0xc6, 0x6e, 0xbd, 0xdb, 0x38, 0x76, 0xf0, 0x2a, 0xd1, 0x3f, 0x2c,
0xc5, 0x9f, 0x57, 0xe2, 0xe6, 0x61, 0xfe, 0x00, 0x6c, 0xed, 0x1e, 0x21, 0xd8, 0x1a, 0x12, 0x41,
0x8d, 0xb2, 0xba, 0xff, 0x47, 0xd6, 0x7d, 0xec, 0x59, 0x4f, 0xc0, 0xff, 0x61, 0x41, 0xd3, 0x3c,
0x13, 0x9d, 0xc1, 0x7e, 0x45, 0xb9, 0xba, 0x4e, 0xb8, 0x90, 0x57, 0x39, 0xe1, 0x72, 0xee, 0x5a,
0xdd, 0xc6, 0xa3, 0x49, 0x6a, 0x12, 0xde, 0xad, 0x18, 0xef, 0x0b, 0xc2, 0x79, 0x51, 0xff, 0x50,
0x48, 0x8e, 0x13, 0x1e, 0x1b, 0xa1, 0xfa, 0x53, 0x84, 0x06, 0x05, 0x41, 0x09, 0x6d, 0x1a, 0x87,
0xf9, 0x14, 0xfe, 0x18, 0xb6, 0x07, 0x9c, 0x64, 0x82, 0x44, 0x32, 0x61, 0x99, 0x28, 0x06, 0x40,
0x26, 0x13, 0xf6, 0x69, 0x92, 0x08, 0xa9, 0x0c, 0x3b, 0x78, 0x95, 0x40, 0x6d, 0x78, 0x16, 0xd3,
0x6c, 0xae, 0x40, 0x3d, 0x9d, 0x2a, 0xee, 0x7b, 0x65, 0x93, 0xfd, 0xaa, 0x89, 0x5c, 0x53, 0xf6,
0x2f, 0xc1, 0xd6, 0x1e, 0xd1, 0x41, 0xb5, 0x5b, 0xba, 0x41, 0xb9, 0x46, 0x07, 0x60, 0x6b, 0x5b,
0x6a, 0xe7, 0x1c, 0x6c, 0x22, 0xd4, 0x85, 0x56, 0x4c, 0x45, 0xc4, 0x93, 0xbc, 0x50, 0x52, 0x2b,
0xe6, 0xe0, 0xf5, 0xd4, 0xe9, 0xc9, 0xdd, 0xc2, 0xb3, 0xee, 0x17, 0x9e, 0xf5, 0x7b, 0xe1, 0x59,
0x5f, 0x96, 0x5e, 0xed, 0x7e, 0xe9, 0xd5, 0x7e, 0x2e, 0xbd, 0xda, 0xe5, 0xcb, 0x51, 0x22, 0xc7,
0xd3, 0x61, 0x10, 0xb1, 0x34, 0x64, 0x99, 0x60, 0x19, 0x0f, 0xd5, 0x71, 0x13, 0xae, 0x5c, 0xce,
0x73, 0x2a, 0x86, 0xb6, 0xfa, 0xeb, 0xde, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x50, 0xa1, 0x26,
0x49, 0xd9, 0x03, 0x00, 0x00,
// 471 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcf, 0x6a, 0xdb, 0x30,
0x18, 0xb7, 0x92, 0xe2, 0xe0, 0x2f, 0x83, 0x6e, 0x6a, 0x57, 0xdc, 0x52, 0x9c, 0xe0, 0xcb, 0xca,
0x06, 0x36, 0xd9, 0x6e, 0xbd, 0xb5, 0x83, 0xf5, 0x34, 0x28, 0x6a, 0x4f, 0x65, 0x50, 0x14, 0x5b,
0x4d, 0x0c, 0xb3, 0x25, 0x24, 0x25, 0xb4, 0xaf, 0xb0, 0xd3, 0x8e, 0x3b, 0xf6, 0x11, 0x06, 0x83,
0x3d, 0x43, 0x8f, 0x3d, 0xee, 0x34, 0x46, 0x72, 0xd8, 0x1e, 0x63, 0x58, 0x92, 0xbd, 0x96, 0x06,
0xd6, 0x8b, 0x90, 0xbe, 0xdf, 0x1f, 0xfd, 0xf4, 0x7d, 0x36, 0x6c, 0x97, 0x34, 0xa3, 0x92, 0xf3,
0x2a, 0x9d, 0x8f, 0xd2, 0x09, 0xab, 0x98, 0x2a, 0x54, 0x22, 0x24, 0xd7, 0x1c, 0xf7, 0x1b, 0x28,
0x99, 0x8f, 0x76, 0x9e, 0xd1, 0xb2, 0xa8, 0x78, 0x6a, 0x56, 0x8b, 0xef, 0xac, 0xe7, 0x45, 0x5e,
0xab, 0xf4, 0xa5, 0x2b, 0x6c, 0x4e, 0xf8, 0x84, 0x9b, 0x6d, 0x5a, 0xef, 0x6c, 0x35, 0x3e, 0x80,
0x27, 0x47, 0xd6, 0xf7, 0x44, 0x53, 0xcd, 0xf0, 0x08, 0x7c, 0x41, 0x25, 0x2d, 0x55, 0x88, 0x86,
0x68, 0xaf, 0xff, 0x7a, 0x23, 0xb9, 0x73, 0x4f, 0x72, 0x6c, 0xa0, 0xc3, 0xb5, 0x9b, 0x9f, 0x03,
0x8f, 0x38, 0x62, 0xfc, 0x0d, 0x81, 0x6f, 0x01, 0x9c, 0x40, 0xaf, 0x64, 0x7a, 0xca, 0xf3, 0x46,
0xbe, 0x79, 0x4f, 0xfe, 0xde, 0x62, 0xa4, 0x21, 0xe1, 0x57, 0xe0, 0xab, 0x8c, 0x0b, 0xa6, 0xc2,
0xce, 0x8a, 0xdb, 0x4e, 0x0c, 0x44, 0x1c, 0xa5, 0x36, 0xcf, 0xe8, 0x9c, 0x51, 0xad, 0xc2, 0xee,
0x0a, 0xf3, 0xb7, 0x16, 0x23, 0x0d, 0x69, 0x7f, 0xf7, 0xcb, 0xf5, 0xc0, 0xfb, 0x73, 0x3d, 0x40,
0x9f, 0x7e, 0x7f, 0x7d, 0xb9, 0xde, 0x76, 0xd2, 0xa5, 0xfe, 0x00, 0x3d, 0x17, 0x07, 0x87, 0xd0,
0xcb, 0xd9, 0x05, 0x9d, 0x7d, 0xd4, 0x26, 0x75, 0x40, 0x9a, 0x23, 0xde, 0x85, 0x40, 0xcd, 0x84,
0xe0, 0x52, 0xb3, 0x3c, 0xec, 0x0c, 0xbb, 0x7b, 0x01, 0xf9, 0x57, 0xd8, 0xdf, 0x6e, 0xcc, 0x9f,
0xb6, 0xe6, 0xee, 0x61, 0xf1, 0x29, 0xf8, 0x36, 0x3d, 0xc6, 0xb0, 0x36, 0xa6, 0x8a, 0x39, 0x67,
0xb3, 0xff, 0x8f, 0x6d, 0xf8, 0x30, 0xb3, 0xed, 0x40, 0xfc, 0x1d, 0x41, 0xcf, 0x3d, 0x13, 0x1f,
0xc1, 0xf3, 0x56, 0x72, 0x7e, 0x51, 0x48, 0xa5, 0xcf, 0x05, 0x95, 0xfa, 0x2a, 0x44, 0xc3, 0xee,
0x83, 0x4e, 0x5a, 0x11, 0xd9, 0x68, 0x15, 0xef, 0x6a, 0xc1, 0x71, 0xcd, 0xbf, 0x6f, 0xa4, 0xa7,
0x85, 0xcc, 0x9d, 0x51, 0xe7, 0x31, 0x46, 0xa7, 0xb5, 0xc0, 0x18, 0xad, 0x6a, 0x87, 0x1b, 0x45,
0x7c, 0x06, 0xbe, 0x55, 0xe2, 0xad, 0x76, 0xe2, 0xc8, 0xbc, 0xbb, 0x19, 0xee, 0x16, 0xf8, 0x96,
0x6c, 0xbe, 0x84, 0x80, 0xb8, 0x13, 0x1e, 0x42, 0x3f, 0x67, 0x2a, 0x93, 0x85, 0xd0, 0x05, 0xaf,
0xcc, 0xe0, 0x03, 0x72, 0xb7, 0x74, 0x78, 0x70, 0xb3, 0x88, 0xd0, 0xed, 0x22, 0x42, 0xbf, 0x16,
0x11, 0xfa, 0xbc, 0x8c, 0xbc, 0xdb, 0x65, 0xe4, 0xfd, 0x58, 0x46, 0xde, 0xd9, 0x8b, 0x49, 0xa1,
0xa7, 0xb3, 0x71, 0x92, 0xf1, 0x32, 0xe5, 0x95, 0xe2, 0x95, 0x4c, 0xcd, 0x72, 0x99, 0xb6, 0x01,
0xf5, 0x95, 0x60, 0x6a, 0xec, 0x9b, 0x7f, 0xe1, 0xcd, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a,
0x01, 0xb7, 0x87, 0x6f, 0x03, 0x00, 0x00,
}
func (this *Params) Equal(that interface{}) bool {
@ -587,43 +529,6 @@ func (this *Caveats) Equal(that interface{}) bool {
}
return true
}
func (this *Transactions) Equal(that interface{}) bool {
if that == nil {
return this == nil
}
that1, ok := that.(*Transactions)
if !ok {
that2, ok := that.(Transactions)
if ok {
that1 = &that2
} else {
return false
}
}
if that1 == nil {
return this == nil
} else if this == nil {
return false
}
if len(this.Allowlist) != len(that1.Allowlist) {
return false
}
for i := range this.Allowlist {
if this.Allowlist[i] != that1.Allowlist[i] {
return false
}
}
if len(this.Denylist) != len(that1.Denylist) {
return false
}
for i := range this.Denylist {
if this.Denylist[i] != that1.Denylist[i] {
return false
}
}
return true
}
func (m *GenesisState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -845,47 +750,6 @@ func (m *Caveats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Transactions) 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 *Transactions) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Transactions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Denylist) > 0 {
for iNdEx := len(m.Denylist) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Denylist[iNdEx])
copy(dAtA[i:], m.Denylist[iNdEx])
i = encodeVarintGenesis(dAtA, i, uint64(len(m.Denylist[iNdEx])))
i--
dAtA[i] = 0x12
}
}
if len(m.Allowlist) > 0 {
for iNdEx := len(m.Allowlist) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Allowlist[iNdEx])
copy(dAtA[i:], m.Allowlist[iNdEx])
i = encodeVarintGenesis(dAtA, i, uint64(len(m.Allowlist[iNdEx])))
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *Caveat) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -1034,27 +898,6 @@ func (m *Caveats) Size() (n int) {
return n
}
func (m *Transactions) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Allowlist) > 0 {
for _, s := range m.Allowlist {
l = len(s)
n += 1 + l + sovGenesis(uint64(l))
}
}
if len(m.Denylist) > 0 {
for _, s := range m.Denylist {
l = len(s)
n += 1 + l + sovGenesis(uint64(l))
}
}
return n
}
func (m *Caveat) Size() (n int) {
if m == nil {
return 0
@ -1671,120 +1514,6 @@ func (m *Caveats) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Transactions) 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 ErrIntOverflowGenesis
}
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: Transactions: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Transactions: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Allowlist", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
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 ErrInvalidLengthGenesis
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Allowlist = append(m.Allowlist, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Denylist", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
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 ErrInvalidLengthGenesis
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthGenesis
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Denylist = append(m.Denylist, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthGenesis
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Caveat) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0