types.mx raw

   1  // Package types provides fixed-size cryptographic types for Nostr.
   2  package types
   3  
   4  import (
   5  	"encoding/hex"
   6  )
   7  
   8  const (
   9  	EventIDSize   = 32
  10  	PubkeySize    = 32
  11  	SignatureSize = 64
  12  	SecretKeySize = 32
  13  )
  14  
  15  type EventID [EventIDSize]byte
  16  type Pubkey [PubkeySize]byte
  17  type Signature [SignatureSize]byte
  18  type SecretKey [SecretKeySize]byte
  19  
  20  // --- EventID ---
  21  
  22  func (id *EventID) Bytes() []byte { return id[:] }
  23  
  24  func (id EventID) Copy() []byte {
  25  	b := []byte{:EventIDSize}
  26  	copy(b, id[:])
  27  	return b
  28  }
  29  
  30  func (id EventID) Hex() []byte {
  31  	b := []byte{:EventIDSize*2}
  32  	hex.Encode(b, id[:])
  33  	return b
  34  }
  35  
  36  func (id EventID) IsZero() bool { return id == EventID{} }
  37  
  38  func EventIDFromBytes(src []byte) (id EventID) {
  39  	copy(id[:], src)
  40  	return
  41  }
  42  
  43  func EventIDFromHex(s []byte) (id EventID, err error) {
  44  	if len(s) != EventIDSize*2 {
  45  		return id, hex.InvalidByteError(0)
  46  	}
  47  	_, err = hex.Decode(id[:], s)
  48  	return
  49  }
  50  
  51  // --- Pubkey ---
  52  
  53  func (pk *Pubkey) Bytes() []byte { return pk[:] }
  54  
  55  func (pk Pubkey) Copy() []byte {
  56  	b := []byte{:PubkeySize}
  57  	copy(b, pk[:])
  58  	return b
  59  }
  60  
  61  func (pk Pubkey) Hex() []byte {
  62  	b := []byte{:PubkeySize*2}
  63  	hex.Encode(b, pk[:])
  64  	return b
  65  }
  66  
  67  func (pk Pubkey) IsZero() bool { return pk == Pubkey{} }
  68  
  69  func PubkeyFromBytes(src []byte) (pk Pubkey) {
  70  	copy(pk[:], src)
  71  	return
  72  }
  73  
  74  func PubkeyFromHex(s []byte) (pk Pubkey, err error) {
  75  	if len(s) != PubkeySize*2 {
  76  		return pk, hex.InvalidByteError(0)
  77  	}
  78  	_, err = hex.Decode(pk[:], s)
  79  	return
  80  }
  81  
  82  // --- Signature ---
  83  
  84  func (sig *Signature) Bytes() []byte { return sig[:] }
  85  
  86  func (sig Signature) Copy() []byte {
  87  	b := []byte{:SignatureSize}
  88  	copy(b, sig[:])
  89  	return b
  90  }
  91  
  92  func (sig Signature) Hex() []byte {
  93  	b := []byte{:SignatureSize*2}
  94  	hex.Encode(b, sig[:])
  95  	return b
  96  }
  97  
  98  func (sig Signature) IsZero() bool { return sig == Signature{} }
  99  
 100  func SignatureFromBytes(src []byte) (sig Signature) {
 101  	copy(sig[:], src)
 102  	return
 103  }
 104  
 105  func SignatureFromHex(s []byte) (sig Signature, err error) {
 106  	if len(s) != SignatureSize*2 {
 107  		return sig, hex.InvalidByteError(0)
 108  	}
 109  	_, err = hex.Decode(sig[:], s)
 110  	return
 111  }
 112  
 113  // --- SecretKey ---
 114  
 115  func (sk *SecretKey) Bytes() []byte { return sk[:] }
 116  
 117  func (sk SecretKey) Copy() []byte {
 118  	b := []byte{:SecretKeySize}
 119  	copy(b, sk[:])
 120  	return b
 121  }
 122  
 123  func (sk SecretKey) Hex() []byte {
 124  	b := []byte{:SecretKeySize*2}
 125  	hex.Encode(b, sk[:])
 126  	return b
 127  }
 128  
 129  func (sk SecretKey) IsZero() bool { return sk == SecretKey{} }
 130  
 131  func SecretKeyFromBytes(src []byte) (sk SecretKey) {
 132  	copy(sk[:], src)
 133  	return
 134  }
 135  
 136  func SecretKeyFromHex(s []byte) (sk SecretKey, err error) {
 137  	if len(s) != SecretKeySize*2 {
 138  		return sk, hex.InvalidByteError(0)
 139  	}
 140  	_, err = hex.Decode(sk[:], s)
 141  	return
 142  }
 143  
 144  func (sk *SecretKey) Zero() {
 145  	for i := range sk {
 146  		sk[i] = 0
 147  	}
 148  }
 149