NUT-02: fees

.env.mint.example

@@ -2,6 +2,8 @@
 MINT_PRIVATE_KEY="mykey"
 # use only if setting up mint with one unit (defaults to sat)
 MINT_DERIVATION_PATH="0/0/0"
+# fee to charge per input (in parts per thousand)
+INPUT_FEE_PPK=100
 
 # mint info
 MINT_NAME="a cashu mint"

cashu/cashu.go

@@ -240,7 +240,7 @@ var (
 	EmptyInputsErr           = Error{Detail: "inputs cannot be empty", Code: ProofsErrCode}
 	QuoteNotExistErr         = Error{Detail: "quote does not exist", Code: QuoteErrCode}
 	QuoteAlreadyPaid         = Error{Detail: "quote already paid", Code: QuoteErrCode}
-	InsufficientProofsAmount = Error{Detail: "insufficient amount in proofs", Code: ProofsErrCode}
+	InsufficientProofsAmount = Error{Detail: "amount of input proofs is below amount needed for transaction", Code: ProofsErrCode}
 	InvalidKeysetProof       = Error{Detail: "proof from an invalid keyset", Code: ProofsErrCode}
 	InvalidSignatureRequest  = Error{Detail: "requested signature from non-active keyset", Code: KeysetErrCode}
 )
@@ -258,3 +258,20 @@ func AmountSplit(amount uint64) []uint64 {
 	}
 	return rv
 }
+
+func Max(x, y uint64) uint64 {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+func Count(amounts []uint64, amount uint64) uint {
+	var count uint = 0
+	for _, amt := range amounts {
+		if amt == amount {
+			count++
+		}
+	}
+	return count
+}

cashu/nuts/nut02/nut02.go

@@ -8,7 +8,8 @@ type GetKeysetsResponse struct {
 }
 
 type Keyset struct {
-	Id     string `json:"id"`
-	Unit   string `json:"unit"`
-	Active bool   `json:"active"`
+	Id          string `json:"id"`
+	Unit        string `json:"unit"`
+	Active      bool   `json:"active"`
+	InputFeePpk uint   `json:"input_fee_ppk"`
 }

crypto/keyset.go

@@ -12,45 +12,41 @@ import (
 	"github.com/decred/dcrd/dcrec/secp256k1/v4"
 )
 
-const maxOrder = 64
+const MAX_ORDER = 64
 
 type Keyset struct {
-	Id     string
-	Unit   string
-	Active bool
-	Keys   map[uint64]KeyPair
+	Id          string
+	Unit        string
+	Active      bool
+	Keys        map[uint64]KeyPair
+	InputFeePpk uint
 }
 
 type KeyPair struct {
 	PrivateKey *secp256k1.PrivateKey
 	PublicKey  *secp256k1.PublicKey
 }
 
-// KeysetsMap maps a mint url to map of string keyset id to keyset
-type KeysetsMap map[string]map[string]WalletKeyset
-
-type WalletKeyset struct {
-	Id         string
-	MintURL    string
-	Unit       string
-	Active     bool
-	PublicKeys map[uint64]*secp256k1.PublicKey
-	Counter    uint32
-}
-
-func GenerateKeyset(seed, derivationPath string) *Keyset {
-	keys := make(map[uint64]KeyPair, maxOrder)
+func GenerateKeyset(seed, derivationPath string, inputFeePpk uint) *Keyset {
+	keys := make(map[uint64]KeyPair, MAX_ORDER)
 
 	pks := make(map[uint64]*secp256k1.PublicKey)
-	for i := 0; i < maxOrder; i++ {
+	for i := 0; i < MAX_ORDER; i++ {
 		amount := uint64(math.Pow(2, float64(i)))
 		hash := sha256.Sum256([]byte(seed + derivationPath + strconv.FormatUint(amount, 10)))
 		privKey, pubKey := btcec.PrivKeyFromBytes(hash[:])
 		keys[amount] = KeyPair{PrivateKey: privKey, PublicKey: pubKey}
 		pks[amount] = pubKey
 	}
 	keysetId := DeriveKeysetId(pks)
-	return &Keyset{Id: keysetId, Unit: "sat", Active: true, Keys: keys}
+
+	return &Keyset{
+		Id:          keysetId,
+		Unit:        "sat",
+		Active:      true,
+		Keys:        keys,
+		InputFeePpk: inputFeePpk,
+	}
 }
 
 // DeriveKeysetId returns the string ID derived from the map keyset
@@ -97,10 +93,11 @@ func (ks *Keyset) DerivePublic() map[uint64]string {
 }
 
 type KeysetTemp struct {
-	Id     string
-	Unit   string
-	Active bool
-	Keys   map[uint64]json.RawMessage
+	Id          string
+	Unit        string
+	Active      bool
+	Keys        map[uint64]json.RawMessage
+	InputFeePpk uint
 }
 
 func (ks *Keyset) MarshalJSON() ([]byte, error) {
@@ -116,6 +113,7 @@ func (ks *Keyset) MarshalJSON() ([]byte, error) {
 			}
 			return m
 		}(),
+		InputFeePpk: ks.InputFeePpk,
 	}
 
 	return json.Marshal(temp)
@@ -180,13 +178,27 @@ func (kp *KeyPair) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// KeysetsMap maps a mint url to map of string keyset id to keyset
+type KeysetsMap map[string]map[string]WalletKeyset
+
+type WalletKeyset struct {
+	Id          string
+	MintURL     string
+	Unit        string
+	Active      bool
+	PublicKeys  map[uint64]*secp256k1.PublicKey
+	Counter     uint32
+	InputFeePpk uint
+}
+
 type WalletKeysetTemp struct {
-	Id         string
-	MintURL    string
-	Unit       string
-	Active     bool
-	PublicKeys map[uint64][]byte
-	Counter    uint32
+	Id          string
+	MintURL     string
+	Unit        string
+	Active      bool
+	PublicKeys  map[uint64][]byte
+	Counter     uint32
+	InputFeePpk uint
 }
 
 func (wk *WalletKeyset) MarshalJSON() ([]byte, error) {
@@ -202,7 +214,8 @@ func (wk *WalletKeyset) MarshalJSON() ([]byte, error) {
 			}
 			return m
 		}(),
-		Counter: wk.Counter,
+		Counter:     wk.Counter,
+		InputFeePpk: wk.InputFeePpk,
 	}
 
 	return json.Marshal(temp)
@@ -220,6 +233,7 @@ func (wk *WalletKeyset) UnmarshalJSON(data []byte) error {
 	wk.Unit = temp.Unit
 	wk.Active = temp.Active
 	wk.Counter = temp.Counter
+	wk.InputFeePpk = temp.InputFeePpk
 
 	wk.PublicKeys = make(map[uint64]*secp256k1.PublicKey)
 	for k, v := range temp.PublicKeys {

mint/config.go

@@ -4,7 +4,9 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"log"
 	"os"
+	"strconv"
 
 	"github.com/decred/dcrd/dcrec/secp256k1/v4"
 	"github.com/elnosh/gonuts/cashu/nuts/nut06"
@@ -15,14 +17,25 @@ type Config struct {
 	DerivationPath string
 	Port           string
 	DBPath         string
+	InputFeePpk    uint
 }
 
 func GetConfig() Config {
+	var inputFeePpk uint = 0
+	if len(os.Getenv("INPUT_FEE_PPK")) > 0 {
+		fee, err := strconv.ParseUint(os.Getenv("INPUT_FEE_PPK"), 10, 16)
+		if err != nil {
+			log.Fatalf("unable to parse INPUT_FEE_PPK: %v", err)
+		}
+		inputFeePpk = uint(fee)
+	}
+
 	return Config{
 		PrivateKey:     os.Getenv("MINT_PRIVATE_KEY"),
 		DerivationPath: os.Getenv("MINT_DERIVATION_PATH"),
 		Port:           os.Getenv("MINT_PORT"),
 		DBPath:         os.Getenv("MINT_DB_PATH"),
+		InputFeePpk:    inputFeePpk,
 	}
 }
 

mint/mint.go

@@ -51,7 +51,7 @@ func LoadMint(config Config) (*Mint, error) {
 		log.Fatalf("error starting mint: %v", err)
 	}
 
-	activeKeyset := crypto.GenerateKeyset(config.PrivateKey, config.DerivationPath)
+	activeKeyset := crypto.GenerateKeyset(config.PrivateKey, config.DerivationPath, config.InputFeePpk)
 	mint := &Mint{db: db, ActiveKeysets: map[string]crypto.Keyset{activeKeyset.Id: *activeKeyset}}
 
 	mint.db.SaveKeyset(activeKeyset)
@@ -240,9 +240,9 @@ func (m *Mint) Swap(proofs cashu.Proofs, blindedMessages cashu.BlindedMessages)
 			}
 		}
 	}
-
-	if proofsAmount < blindedMessagesAmount {
-		return nil, cashu.InputsBelowOutputs
+	fees := m.TransactionFees(proofs)
+	if proofsAmount-uint64(fees) < blindedMessagesAmount {
+		return nil, cashu.InsufficientProofsAmount
 	}
 
 	err := m.verifyProofs(proofs)
@@ -351,18 +351,18 @@ func (m *Mint) MeltTokens(method, quoteId string, proofs cashu.Proofs) (MeltQuot
 		return MeltQuote{}, cashu.QuoteAlreadyPaid
 	}
 
-	proofsAmount := proofs.Amount()
-
-	// checks if amount in proofs is enough
-	if proofsAmount < meltQuote.Amount+meltQuote.FeeReserve {
-		return MeltQuote{}, cashu.InsufficientProofsAmount
-	}
-
 	err := m.verifyProofs(proofs)
 	if err != nil {
 		return MeltQuote{}, err
 	}
 
+	proofsAmount := proofs.Amount()
+	fees := m.TransactionFees(proofs)
+	// checks if amount in proofs is enough
+	if proofsAmount < meltQuote.Amount+meltQuote.FeeReserve+uint64(fees) {
+		return MeltQuote{}, cashu.InsufficientProofsAmount
+	}
+
 	// if proofs are valid, ask the lightning backend
 	// to make the payment
 	preimage, err := m.LightningClient.SendPayment(meltQuote.InvoiceRequest, meltQuote.Amount)
@@ -482,3 +482,13 @@ func (m *Mint) requestInvoice(amount uint64) (*lightning.Invoice, error) {
 
 	return &invoice, nil
 }
+
+func (m *Mint) TransactionFees(inputs cashu.Proofs) uint {
+	var fees uint = 0
+	for _, proof := range inputs {
+		// note: not checking that proof id is from valid keyset
+		// because already doing that in call to verifyProofs
+		fees += m.Keysets[proof.Id].InputFeePpk
+	}
+	return (fees + 999) / 1000
+}