nostrdb

an unfairly fast embedded nostr database backed by lmdb
git clone git://jb55.com/nostrdb
Log | Files | Refs | Submodules | README | LICENSE

amount.h (7675B)


      1 #ifndef LIGHTNING_COMMON_AMOUNT_H
      2 #define LIGHTNING_COMMON_AMOUNT_H
      3 #include "../config.h"
      4 #include "ccan/short_types/short_types.h"
      5 #include "ccan/tal/tal.h"
      6 
      7 #define MSAT_PER_SAT ((u64)1000)
      8 #define SAT_PER_BTC ((u64)100000000)
      9 #define MSAT_PER_BTC (MSAT_PER_SAT * SAT_PER_BTC)
     10 
     11 /* Use these to wrap amounts, for typesafety.  Please use ops where possible,
     12  * rather than accessing the members directly. */
     13 struct amount_sat {
     14     /* Amount in satoshis. */
     15     u64 satoshis;
     16 };
     17 
     18 struct amount_msat {
     19     /* Amount in millisatoshis. */
     20     u64 millisatoshis;
     21 };
     22 
     23 struct amount_asset {
     24     u64 value;
     25     u8 asset[33]; /* 1 version byte + 32 byte asset_tag */
     26 };
     27 
     28 /* For constants only: others must be built from primitives! */
     29 #if HAVE_BUILTIN_CONSTANT_P
     30 #define AMOUNT_MUST_BE_CONST(c) BUILD_ASSERT_OR_ZERO(IS_COMPILE_CONSTANT(c))
     31 #else
     32 #define AMOUNT_MUST_BE_CONST(c) 0
     33 #endif
     34 
     35 /* GCC 4.8.5 (Centos 7.6!) thinks struct casts are not constants, so we
     36  * need to not use a cast for static initializations. */
     37 #define AMOUNT_MSAT_INIT(msat)        \
     38     { .millisatoshis = (msat) }
     39 #define AMOUNT_SAT_INIT(sat)        \
     40     { .satoshis = (sat) }
     41 
     42 #define AMOUNT_MSAT(constant)                        \
     43     ((struct amount_msat){(constant) + AMOUNT_MUST_BE_CONST(constant)})
     44 
     45 #define AMOUNT_SAT(constant)                        \
     46     ((struct amount_sat){(constant) + AMOUNT_MUST_BE_CONST(constant)})
     47 
     48 /* We do sometimes need to import from raw types, eg. wally or wire fmt */
     49 struct amount_msat amount_msat(u64 millisatoshis);
     50 struct amount_sat amount_sat(u64 satoshis);
     51 
     52 /* You may not always be able to convert satoshis->millisatoshis. */
     53  bool amount_sat_to_msat(struct amount_msat *msat,
     54                        struct amount_sat sat);
     55 
     56 /* You may not always be able to convert millisatoshis->satoshis without rounding. */
     57  bool amount_msat_to_sat(struct amount_sat *sat,
     58                        struct amount_msat msat);
     59 
     60 /* You can always truncate millisatoshis->satoshis. */
     61 struct amount_sat amount_msat_to_sat_round_down(struct amount_msat msat);
     62 
     63 /* Simple operations: val = a + b, val = a - b. */
     64  bool amount_msat_add(struct amount_msat *val,
     65                     struct amount_msat a,
     66                     struct amount_msat b);
     67  bool amount_msat_sub(struct amount_msat *val,
     68                     struct amount_msat a,
     69                     struct amount_msat b);
     70  bool amount_sat_add(struct amount_sat *val,
     71                        struct amount_sat a,
     72                        struct amount_sat b);
     73  bool amount_sat_sub(struct amount_sat *val,
     74                        struct amount_sat a,
     75                        struct amount_sat b);
     76  bool amount_msat_sub_sat(struct amount_msat *val,
     77                         struct amount_msat a,
     78                         struct amount_sat b);
     79  bool amount_msat_add_sat(struct amount_msat *val,
     80                         struct amount_msat a,
     81                         struct amount_sat b);
     82  bool amount_sat_sub_msat(struct amount_msat *val,
     83                         struct amount_sat a,
     84                         struct amount_msat b);
     85  bool amount_msat_scale(struct amount_msat *val,
     86                       struct amount_msat msat,
     87                       double scale);
     88  bool amount_sat_scale(struct amount_sat *val,
     89                      struct amount_sat sat,
     90                      double scale);
     91 
     92 struct amount_msat amount_msat_div(struct amount_msat msat, u64 div);
     93 struct amount_sat amount_sat_div(struct amount_sat sat, u64 div);
     94 
     95 /* Is a == b? */
     96 bool amount_sat_eq(struct amount_sat a, struct amount_sat b);
     97 bool amount_msat_eq(struct amount_msat a, struct amount_msat b);
     98 
     99 /* Is a zero? */
    100 bool amount_sat_zero(struct amount_sat a);
    101 bool amount_msat_zero(struct amount_msat a);
    102 
    103 /* Is a > b? */
    104 bool amount_sat_greater(struct amount_sat a, struct amount_sat b);
    105 bool amount_msat_greater(struct amount_msat a, struct amount_msat b);
    106 
    107 /* Is a >= b */
    108 bool amount_sat_greater_eq(struct amount_sat a, struct amount_sat b);
    109 bool amount_msat_greater_eq(struct amount_msat a, struct amount_msat b);
    110 
    111 /* Is a < b? */
    112 bool amount_sat_less(struct amount_sat a, struct amount_sat b);
    113 bool amount_msat_less(struct amount_msat a, struct amount_msat b);
    114 
    115 /* Is a <= b? */
    116 bool amount_sat_less_eq(struct amount_sat a, struct amount_sat b);
    117 bool amount_msat_less_eq(struct amount_msat a, struct amount_msat b);
    118 
    119 /* Is msat > sat? */
    120 bool amount_msat_greater_sat(struct amount_msat msat, struct amount_sat sat);
    121 /* Is msat >= sat? */
    122 bool amount_msat_greater_eq_sat(struct amount_msat msat, struct amount_sat sat);
    123 /* Is msat < sat? */
    124 bool amount_msat_less_sat(struct amount_msat msat, struct amount_sat sat);
    125 /* Is msat <= sat? */
    126 bool amount_msat_less_eq_sat(struct amount_msat msat, struct amount_sat sat);
    127 /* Is msat == sat? */
    128 bool amount_msat_eq_sat(struct amount_msat msat, struct amount_sat sat);
    129 
    130 /* a / b */
    131 double amount_msat_ratio(struct amount_msat a, struct amount_msat b);
    132 
    133 /* Check whether this asset is actually the main / fee-paying asset of the
    134  * current chain. */
    135 bool amount_asset_is_main(struct amount_asset *asset);
    136 
    137 /* Convert an amount_sat to an amount_asset */
    138 struct amount_asset amount_sat_to_asset(struct amount_sat *sat, const u8 *asset);
    139 
    140 /* amount_asset_extract_value -Prefix the amount_asset's value
    141  * to have the 'explicit' marker. Returns NULL if the
    142  * asset was originally blinded.
    143  * FIXME: pass through blinded amounts */
    144 u8 *amount_asset_extract_value(const tal_t *ctx, struct amount_asset *asset);
    145 
    146 /* Convert from a generic asset to the fee-paying asset if possible. */
    147 struct amount_sat amount_asset_to_sat(struct amount_asset *asset);
    148 
    149 /* Returns true if msat fits in a u32 value. */
    150  bool amount_msat_to_u32(struct amount_msat msat,
    151                        u32 *millisatoshis);
    152 
    153 /* Common operation: what is the HTLC fee for given feerate?  Can overflow! */
    154  bool amount_msat_fee(struct amount_msat *fee,
    155                     struct amount_msat amt,
    156                     u32 fee_base_msat,
    157                     u32 fee_proportional_millionths);
    158 
    159 /* Same, but add into amt. */
    160  bool amount_msat_add_fee(struct amount_msat *amt,
    161                         u32 fee_base_msat,
    162                         u32 fee_proportional_millionths);
    163 
    164 /* What is the fee for this tx weight? */
    165 struct amount_sat amount_tx_fee(u32 fee_per_kw, size_t weight);
    166 
    167 /* Different formatting by amounts: btc, sat and msat */
    168 /* => 1.23456789012btc (11 decimals!) */
    169 const char *fmt_amount_msat_btc(const tal_t *ctx,
    170                 struct amount_msat msat,
    171                 bool append_unit);
    172 /* => 1234msat */
    173 const char *fmt_amount_msat(const tal_t *ctx, struct amount_msat msat);
    174 
    175 /* => 1.23456789btc (8 decimals!) */
    176 const char *fmt_amount_sat_btc(const tal_t *ctx,
    177                    struct amount_sat sat,
    178                    bool append_unit);
    179 /* => 1234sat */
    180 const char *fmt_amount_sat(const tal_t *ctx, struct amount_sat sat);
    181 
    182 /* Valid strings:
    183  *  [0-9]+ => millisatoshi.
    184  *  [0-9]+msat => millisatoshi.
    185  *  [0-9]+sat => *1000 -> millisatopshi.
    186  *  [0-9]+.[0-9]{1,11}btc => millisatoshi.
    187  */
    188 bool parse_amount_msat(struct amount_msat *msat, const char *s, size_t slen);
    189 
    190 /* Valid strings:
    191  *  [0-9]+ => satoshi.
    192  *  [0-9]+sat => satoshi.
    193  *  [0-9]+000msat => satoshi.
    194  *  [0-9]+.[0-9]{1,8}btc => satoshi.
    195  */
    196 bool parse_amount_sat(struct amount_sat *sat, const char *s, size_t slen);
    197 
    198 /* Marshal/unmarshal functions */
    199 struct amount_msat fromwire_amount_msat(const u8 **cursor, size_t *max);
    200 struct amount_sat fromwire_amount_sat(const u8 **cursor, size_t *max);
    201 void towire_amount_msat(u8 **pptr, const struct amount_msat msat);
    202 void towire_amount_sat(u8 **pptr, const struct amount_sat sat);
    203 #endif /* LIGHTNING_COMMON_AMOUNT_H */