@wharfkit/resources 1.3.1 → 1.5.0-rc1

package/src/powerup/abstract.ts

@@ -37,35 +37,30 @@ export abstract class PowerUpStateResource extends Struct {
     abstract per_day(options?: PowerUpStateOptions): number
 
     // Get the current number of allocated units (shift from REX -> PowerUp)
-    public get allocated() {
+    public get allocated_legacy() {
         return 1 - Number(this.weight_ratio) / Number(this.target_weight_ratio) / 100
     }
 
+    public get allocated(): number {
+        return 1 - Number(this.weight_ratio.dividing(this.target_weight_ratio)) / 100
+    }
+
     // Get the current percentage of reserved units
-    public get reserved() {
+    public get reserved_legacy() {
         return new BN(String(this.utilization)) / new BN(String(this.weight))
     }
 
+    public get reserved(): Int64 {
+        return this.utilization.dividing(this.weight)
+    }
+
     // Get the symbol definition for the token
     public get symbol() {
         return this.min_price.symbol
     }
 
-    // Common casting for typed values to numbers
-    cast() {
-        return {
-            adjusted_utilization: Number(this.adjusted_utilization),
-            decay_secs: Number(this.decay_secs.value),
-            exponent: Number(this.exponent),
-            utilization: Number(this.utilization),
-            utilization_timestamp: Number(this.utilization_timestamp.value),
-            weight: new BN(String(this.weight)),
-            weight_ratio: Number(this.weight_ratio),
-        }
-    }
-
     // Mimic: https://github.com/EOSIO/eosio.contracts/blob/d7bc0a5cc8c0c2edd4dc61b0126517d0cb46fd94/contracts/eosio.system/src/powerup.cpp#L358
-    utilization_increase(sample: UInt128, frac) {
+    utilization_increase_legacy(frac) {
         const {weight} = this
         const frac128 = UInt128.from(frac)
         const utilization_increase =
@@ -73,56 +68,127 @@ export abstract class PowerUpStateResource extends Struct {
         return Math.ceil(utilization_increase)
     }
 
+    utilization_increase(frac: UInt128) {
+        return frac.multiplying(this.weight).dividing(UInt128.from(Math.pow(10, 15)), 'ceil')
+    }
+
     // Mimic: https://github.com/EOSIO/eosio.contracts/blob/d7bc0a5cc8c0c2edd4dc61b0126517d0cb46fd94/contracts/eosio.system/src/powerup.cpp#L284-L298
-    price_function(utilization: number): number {
-        const {exponent, weight} = this.cast()
+    price_function_legacy(utilization: Int64): number {
+        const {exponent, weight} = this
         const max_price: number = this.max_price.value
         const min_price: number = this.min_price.value
         let price = min_price
-        const new_exponent = exponent - 1.0
+        const new_exponent = Number(exponent) - 1.0
         if (new_exponent <= 0.0) {
             return max_price
         } else {
-            const util_weight = new BN(utilization) / weight
-            price += (max_price - min_price) * Math.pow(util_weight, new_exponent)
+            const util_weight = utilization.dividing(weight)
+            price += (max_price - min_price) * Math.pow(Number(util_weight), new_exponent)
+        }
+        return price
+    }
+
+    price_function(utilization: Int64): Int64 {
+        const {weight} = this
+        const price = this.min_price.units
+        const new_exponent = Number(this.exponent) - 1.0
+        if (new_exponent <= 0.0) {
+            return this.max_price.units
+        } else {
+            const util_weight = utilization.dividing(weight)
+            const difference = Asset.fromUnits(
+                this.max_price.units.subtracting(this.min_price.units),
+                this.symbol
+            )
+            price.add(difference.value * Math.pow(Number(util_weight), new_exponent))
         }
         return price
     }
 
     // Mimic: https://github.com/EOSIO/eosio.contracts/blob/d7bc0a5cc8c0c2edd4dc61b0126517d0cb46fd94/contracts/eosio.system/src/powerup.cpp#L274-L280
-    price_integral_delta(start_utilization: number, end_utilization: number): number {
-        const {exponent, weight} = this.cast()
+    price_integral_delta_legacy(start_utilization: Int64, end_utilization: Int64): number {
+        const {exponent, weight} = this
         const max_price: number = this.max_price.value
         const min_price: number = this.min_price.value
-        const coefficient = (max_price - min_price) / exponent
-        const start_u = new BN(start_utilization) / weight
-        const end_u = new BN(end_utilization) / weight
+        const coefficient = (max_price - min_price) / exponent.value
+        const start_u = Number(start_utilization.dividing(weight))
+        const end_u = Number(end_utilization.dividing(weight))
         const delta =
             min_price * end_u -
             min_price * start_u +
-            coefficient * Math.pow(end_u, exponent) -
-            coefficient * Math.pow(start_u, exponent)
+            coefficient * Math.pow(end_u, exponent.value) -
+            coefficient * Math.pow(start_u, exponent.value)
+        return delta
+    }
+
+    price_integral_delta(start_utilization: Int64, end_utilization: Int64): number {
+        const difference = Asset.fromUnits(
+            this.max_price.units.subtracting(this.min_price.units),
+            this.symbol
+        )
+        const coefficient = difference.value / this.exponent.value
+        const start_u = Number(start_utilization.dividing(this.weight))
+        const end_u = Number(end_utilization.dividing(this.weight))
+        const delta =
+            this.min_price.value * end_u -
+            this.min_price.value * start_u +
+            coefficient * Math.pow(end_u, this.exponent.value) -
+            coefficient * Math.pow(start_u, this.exponent.value)
         return delta
     }
 
     // Mimic: https://github.com/EOSIO/eosio.contracts/blob/d7bc0a5cc8c0c2edd4dc61b0126517d0cb46fd94/contracts/eosio.system/src/powerup.cpp#L262-L315
-    fee(utilization_increase, adjusted_utilization) {
-        const {utilization, weight} = this.cast()
+    fee_legacy(utilization_increase, adjusted_utilization) {
+        const {utilization, weight} = this
 
-        let start_utilization: number = utilization
-        const end_utilization: number = start_utilization + utilization_increase
+        let start_utilization = Int64.from(utilization)
+        const end_utilization = start_utilization.adding(utilization_increase)
 
         let fee = 0
         if (start_utilization < adjusted_utilization) {
-            const min = Math.min(utilization_increase, adjusted_utilization - start_utilization)
+            const min = Math.min(
+                utilization_increase,
+                adjusted_utilization.subtracting(start_utilization)
+            )
+            fee += Number(
+                new bigDecimal(this.price_function_legacy(adjusted_utilization) * min)
+                    .divide(new bigDecimal(weight.toString()))
+                    .getValue()
+            )
+            start_utilization = adjusted_utilization
+        }
+        if (start_utilization.gt(end_utilization)) {
+            fee += this.price_integral_delta(start_utilization, end_utilization)
+        }
+        return fee
+    }
+
+    fee(utilization_increase, adjusted_utilization) {
+        const {utilization, weight} = this
+
+        let start_utilization = Int64.from(utilization)
+        const end_utilization = start_utilization.adding(utilization_increase)
+
+        let fee = 0
+        if (start_utilization.lt(adjusted_utilization)) {
+            const min = Math.min(
+                utilization_increase,
+                adjusted_utilization.subtracting(start_utilization)
+            )
             fee += Number(
-                new bigDecimal(this.price_function(adjusted_utilization) * min)
+                new bigDecimal(
+                    String(
+                        this.price_function(adjusted_utilization)
+                            .dividing(Math.pow(10, this.symbol.precision))
+                            .multiplying(min)
+                    )
+                )
                     .divide(new bigDecimal(weight.toString()))
                     .getValue()
             )
             start_utilization = adjusted_utilization
         }
-        if (start_utilization < end_utilization) {
+        if (start_utilization.gt(end_utilization)) {
             fee += this.price_integral_delta(start_utilization, end_utilization)
         }
         return fee
@@ -131,17 +197,19 @@ export abstract class PowerUpStateResource extends Struct {
     // Mimic: https://github.com/EOSIO/eosio.contracts/blob/d7bc0a5cc8c0c2edd4dc61b0126517d0cb46fd94/contracts/eosio.system/src/powerup.cpp#L105-L117
     determine_adjusted_utilization(options?: PowerUpStateOptions) {
         // Casting EOSIO types to usable formats for JS calculations
-        const {decay_secs, utilization, utilization_timestamp} = this.cast()
-        let {adjusted_utilization} = this.cast()
+        const {decay_secs, utilization, utilization_timestamp} = this
+        let {adjusted_utilization} = this
         // If utilization is less than adjusted, calculate real time value
-        if (utilization < adjusted_utilization) {
+        if (utilization.lt(adjusted_utilization)) {
             // Create now & adjust JS timestamp to match EOSIO timestamp values
             const ts = options && options.timestamp ? options.timestamp : new Date()
             const now = TimePointSec.from(ts).toMilliseconds() / 1000
-            const diff: number = adjusted_utilization - utilization
-            let delta: number = diff * Math.exp(-(now - utilization_timestamp) / decay_secs)
+            const diff = adjusted_utilization.subtracting(utilization).toNumber()
+            let delta: number =
+                diff *
+                Math.exp(-(now - utilization_timestamp.toMilliseconds()) / Number(decay_secs))
             delta = Math.min(Math.max(delta, 0), diff) // Clamp the delta
-            adjusted_utilization = utilization + delta
+            adjusted_utilization = utilization.adding(delta)
         }
         return adjusted_utilization
     }

package/src/powerup/cpu.ts

@@ -1,9 +1,10 @@
-import {Struct, UInt128} from '@wharfkit/antelope'
+import {Int64, Int64Type, Struct, UInt128, UInt128Type} from '@wharfkit/antelope'
 
-import {BNPrecision, SampleUsage} from '..'
+import {BNPrecision, intToBigDecimal, SampleUsage} from '..'
 import {PowerUpStateResource} from './abstract'
 import {PowerUpStateOptions} from './options'
 import BN from 'bn.js'
+import bigDecimal from 'js-big-decimal'
 
 @Struct.type('powerupstateresourcecpu')
 export class PowerUpStateResourceCPU extends PowerUpStateResource {
@@ -25,41 +26,80 @@ export class PowerUpStateResourceCPU extends PowerUpStateResource {
     }
 
     // Convert weight to μs (microseconds)
-    weight_to_us(sample: UInt128, weight: number): number {
+    weight_to_us_legacy(sample: UInt128, weight: number): number {
         return Math.ceil((weight * Number(sample)) / BNPrecision)
     }
+    weight_to_us(sample: UInt128Type, weight: Int64Type): UInt128 {
+        return UInt128.from(
+            UInt128.from(weight).multiplying(Int64.from(sample)).dividing(BNPrecision, 'ceil')
+        )
+    }
 
     // Convert μs (microseconds) to weight
-    us_to_weight(sample: UInt128, us: number): number {
+    us_to_weight_legacy(sample: UInt128, us: number): number {
         return Math.floor((us / Number(sample)) * BNPrecision)
     }
+    us_to_weight(sample: UInt128, us: Int64Type): Int64 {
+        return Int64.from(us).multiplying(BNPrecision).dividing(Int64.from(sample), 'floor')
+    }
 
     // Default frac generation by smallest unit type
+    frac_legacy = (usage: SampleUsage, us: number) => this.frac_by_us_legacy(usage, us)
     frac = (usage: SampleUsage, us: number) => this.frac_by_us(usage, us)
 
     // Frac generation by ms (milliseconds)
+    frac_by_ms_legacy = (usage: SampleUsage, ms: number) => this.frac_by_us_legacy(usage, ms * 1000)
     frac_by_ms = (usage: SampleUsage, ms: number) => this.frac_by_us(usage, ms * 1000)
 
     // Frac generation by μs (microseconds)
-    frac_by_us(usage: SampleUsage, us: number) {
-        const {weight} = this.cast()
-        const frac = new BN(this.us_to_weight(usage.cpu, us)) / weight
+    frac_by_us_legacy(usage: SampleUsage, us: number) {
+        const frac = new BN(this.us_to_weight_legacy(usage.cpu, us)) / Number(this.weight)
         return Math.floor(frac * Math.pow(10, 15))
     }
+    frac_by_us(usage: SampleUsage, us: Int64Type): Int64 {
+        const precision = 15
+        const converted = intToBigDecimal(this.us_to_weight(usage.cpu, us))
+        const current = intToBigDecimal(this.weight)
+        const multiplier = intToBigDecimal(Math.pow(10, precision))
+        const frac = converted.divide(current, precision).multiply(multiplier)
+        return Int64.from(frac.getValue())
+    }
 
     // Price generation by smallest units, μs (microseconds)
+    price_per_legacy = (usage: SampleUsage, us = 1000, options?: PowerUpStateOptions): number =>
+        this.price_per_us_legacy(usage, us, options)
     price_per = (usage: SampleUsage, us = 1000, options?: PowerUpStateOptions): number =>
         this.price_per_us(usage, us, options)
 
     // Price generation by ms (milliseconds)
+    price_per_ms_legacy = (usage: SampleUsage, ms = 1, options?: PowerUpStateOptions): number =>
+        this.price_per_us_legacy(usage, ms * 1000, options)
     price_per_ms = (usage: SampleUsage, ms = 1, options?: PowerUpStateOptions): number =>
         this.price_per_us(usage, ms * 1000, options)
 
     // Price generation by μs (microseconds)
+    price_per_us_legacy(usage: SampleUsage, us = 1000, options?: PowerUpStateOptions): number {
+        // Determine the utilization increase by this action
+        const frac = UInt128.from(this.frac_legacy(usage, us))
+        const utilization_increase = this.utilization_increase_legacy(frac)
+
+        // Determine the adjusted utilization if needed
+        const adjusted_utilization = this.determine_adjusted_utilization(options)
+
+        // Derive the fee from the increase and utilization
+        const fee = this.fee_legacy(utilization_increase, adjusted_utilization)
+
+        // Force the fee up to the next highest value of precision
+        const precision = Math.pow(10, this.max_price.symbol.precision)
+        const value = Math.ceil(fee * precision) / precision
+
+        // Return the modified fee
+        return value
+    }
     price_per_us(usage: SampleUsage, us = 1000, options?: PowerUpStateOptions): number {
         // Determine the utilization increase by this action
         const frac = UInt128.from(this.frac(usage, us))
-        const utilization_increase = this.utilization_increase(usage.cpu, frac)
+        const utilization_increase = this.utilization_increase(frac)
 
         // Determine the adjusted utilization if needed
         const adjusted_utilization = this.determine_adjusted_utilization(options)

package/src/powerup/net.ts

@@ -1,6 +1,6 @@
-import {Struct, UInt128} from '@wharfkit/antelope'
+import {Int64, Int64Type, Struct, UInt128} from '@wharfkit/antelope'
 
-import {BNPrecision, SampleUsage} from '..'
+import {BNPrecision, intToBigDecimal, SampleUsage} from '..'
 import {PowerUpStateResource} from './abstract'
 import {PowerUpStateOptions} from './options'
 import BN from 'bn.js'
@@ -25,42 +25,85 @@ export class PowerUpStateResourceNET extends PowerUpStateResource {
     }
 
     // Convert weight to bytes
-    weight_to_bytes(sample: UInt128, weight: number): number {
+    weight_to_bytes_legacy(sample: UInt128, weight: number): number {
         return Math.ceil((weight * Number(sample)) / BNPrecision)
     }
+    weight_to_bytes(sample: UInt128, weight: number): UInt128 {
+        return UInt128.from(
+            UInt128.from(weight).multiplying(Int64.from(sample)).dividing(BNPrecision, 'ceil')
+        )
+    }
 
     // Convert bytes to weight
-    bytes_to_weight(sample: UInt128, bytes: number): number {
+    bytes_to_weight_legacy(sample: UInt128, bytes: number): number {
         return Math.floor((bytes / Number(sample)) * BNPrecision)
     }
+    bytes_to_weight(sample: UInt128, bytes: Int64Type): Int64 {
+        return Int64.from(bytes).multiplying(BNPrecision).dividing(Int64.from(sample), 'floor')
+    }
 
     // Default frac generation by smallest unit type
+    frac_legacy = (usage: SampleUsage, bytes: number) => this.frac_by_bytes_legacy(usage, bytes)
     frac = (usage: SampleUsage, bytes: number) => this.frac_by_bytes(usage, bytes)
 
     // Frac generation by kb
+    frac_by_kb_legacy = (usage: SampleUsage, kilobytes: number) =>
+        this.frac_by_bytes_legacy(usage, kilobytes * 1000)
     frac_by_kb = (usage: SampleUsage, kilobytes: number) =>
         this.frac_by_bytes(usage, kilobytes * 1000)
 
     // Frac generation by bytes
-    frac_by_bytes(usage: SampleUsage, bytes: number) {
-        const {weight} = this.cast()
-        const frac = new BN(this.bytes_to_weight(usage.net, bytes)) / weight
+    frac_by_bytes_legacy(usage: SampleUsage, bytes: number) {
+        const {weight} = this
+        const frac = new BN(this.bytes_to_weight_legacy(usage.net, bytes)) / Number(weight)
         return Math.floor(frac * Math.pow(10, 15))
     }
+    frac_by_bytes(usage: SampleUsage, bytes: Int64Type): Int64 {
+        const precision = 15
+        const converted = intToBigDecimal(this.bytes_to_weight(usage.net, bytes))
+        const current = intToBigDecimal(this.weight)
+        const multiplier = intToBigDecimal(Math.pow(10, precision))
+        const frac = converted.divide(current, precision).multiply(multiplier)
+        return Int64.from(frac.getValue())
+    }
 
     // Price generation by smallest units, bytes
+    price_per_legacy = (usage: SampleUsage, bytes = 1000, options?: PowerUpStateOptions) =>
+        this.price_per_byte_legacy(usage, bytes, options)
     price_per = (usage: SampleUsage, bytes = 1000, options?: PowerUpStateOptions) =>
         this.price_per_byte(usage, bytes, options)
 
     // Price generation by kb
+    price_per_kb_legacy = (
+        usage: SampleUsage,
+        kilobytes = 1,
+        options?: PowerUpStateOptions
+    ): number => this.price_per_byte_legacy(usage, kilobytes * 1000, options)
     price_per_kb = (usage: SampleUsage, kilobytes = 1, options?: PowerUpStateOptions): number =>
         this.price_per_byte(usage, kilobytes * 1000, options)
 
     // Price generation by bytes
+    price_per_byte_legacy(usage: SampleUsage, bytes = 1000, options?: PowerUpStateOptions): number {
+        // Determine the utilization increase by this action
+        const frac = UInt128.from(this.frac_legacy(usage, bytes))
+        const utilization_increase = this.utilization_increase_legacy(frac)
+
+        // Determine the adjusted utilization if needed
+        const adjusted_utilization = this.determine_adjusted_utilization(options)
+
+        // Derive the fee from the increase and utilization
+        const fee = this.fee_legacy(utilization_increase, adjusted_utilization)
+
+        const precision = Math.pow(10, this.max_price.symbol.precision)
+        const value = Math.ceil(fee * precision) / precision
+
+        // Return the modified fee
+        return value
+    }
     price_per_byte(usage: SampleUsage, bytes = 1000, options?: PowerUpStateOptions): number {
         // Determine the utilization increase by this action
         const frac = UInt128.from(this.frac(usage, bytes))
-        const utilization_increase = this.utilization_increase(usage.net, frac)
+        const utilization_increase = this.utilization_increase(frac)
 
         // Determine the adjusted utilization if needed
         const adjusted_utilization = this.determine_adjusted_utilization(options)