binary.mx raw

   1  package event
   2  
   3  import (
   4  	"bytes"
   5  	"io"
   6  
   7  	"smesh.lol/pkg/nostr/ec/schnorr"
   8  	"smesh.lol/pkg/nostr/tag"
   9  	"smesh.lol/pkg/nostr/varint"
  10  	"smesh.lol/pkg/lol/chk"
  11  )
  12  
  13  func (ev *E) MarshalBinary(w io.Writer) {
  14  	_, _ = w.Write(ev.ID)
  15  	_, _ = w.Write(ev.Pubkey)
  16  	varint.Encode(w, uint64(ev.CreatedAt))
  17  	varint.Encode(w, uint64(ev.Kind))
  18  	if ev.Tags == nil {
  19  		varint.Encode(w, 0)
  20  	} else {
  21  		varint.Encode(w, uint64(ev.Tags.Len()))
  22  		for _, x := range *ev.Tags {
  23  			varint.Encode(w, uint64(x.Len()))
  24  			for _, y := range x.T {
  25  				varint.Encode(w, uint64(len(y)))
  26  				_, _ = w.Write(y)
  27  			}
  28  		}
  29  	}
  30  	varint.Encode(w, uint64(len(ev.Content)))
  31  	_, _ = w.Write(ev.Content)
  32  	_, _ = w.Write(ev.Sig)
  33  }
  34  
  35  func (ev *E) MarshalBinaryToBytes(dst []byte) []byte {
  36  	var buf *bytes.Buffer
  37  	if dst == nil {
  38  		size := 32 + 32 + 10 + 10 + 64
  39  		if ev.Tags != nil {
  40  			for _, t := range *ev.Tags {
  41  				size += 10
  42  				for _, elem := range t.T {
  43  					size += 10 + len(elem)
  44  				}
  45  			}
  46  		}
  47  		size += 10 + len(ev.Content)
  48  		b := []byte{:0:size}
  49  		buf = bytes.NewBuffer(b)
  50  	} else {
  51  		buf = bytes.NewBuffer(dst[:0])
  52  	}
  53  	ev.MarshalBinary(buf)
  54  	return buf.Bytes()
  55  }
  56  
  57  func (ev *E) UnmarshalBinary(r io.Reader) (err error) {
  58  	ev.ID = []byte{:32}
  59  	if _, err = r.Read(ev.ID); chk.E(err) {
  60  		return
  61  	}
  62  	ev.Pubkey = []byte{:32}
  63  	if _, err = r.Read(ev.Pubkey); chk.E(err) {
  64  		return
  65  	}
  66  	var ca uint64
  67  	if ca, err = varint.Decode(r); chk.E(err) {
  68  		return
  69  	}
  70  	ev.CreatedAt = int64(ca)
  71  	var k uint64
  72  	if k, err = varint.Decode(r); chk.E(err) {
  73  		return
  74  	}
  75  	ev.Kind = uint16(k)
  76  	var nTags uint64
  77  	if nTags, err = varint.Decode(r); chk.E(err) {
  78  		return
  79  	}
  80  	if nTags == 0 {
  81  		ev.Tags = nil
  82  	} else {
  83  		ev.Tags = tag.NewSWithCap(int(nTags))
  84  		for range nTags {
  85  			var nField uint64
  86  			if nField, err = varint.Decode(r); chk.E(err) {
  87  				return
  88  			}
  89  			t := tag.NewWithCap(int(nField))
  90  			for range nField {
  91  				var lenField uint64
  92  				if lenField, err = varint.Decode(r); chk.E(err) {
  93  					return
  94  				}
  95  				field := []byte{:lenField}
  96  				if _, err = r.Read(field); chk.E(err) {
  97  					return
  98  				}
  99  				t.T = append(t.T, field)
 100  			}
 101  			*ev.Tags = append(*ev.Tags, t)
 102  		}
 103  	}
 104  	var cLen uint64
 105  	if cLen, err = varint.Decode(r); chk.E(err) {
 106  		return
 107  	}
 108  	ev.Content = []byte{:cLen}
 109  	if _, err = r.Read(ev.Content); chk.E(err) {
 110  		return
 111  	}
 112  	ev.Sig = []byte{:schnorr.SignatureSize}
 113  	if _, err = r.Read(ev.Sig); chk.E(err) {
 114  		return
 115  	}
 116  	return
 117  }
 118