@wharfkit/resources 1.5.0-rc3 → 1.5.0-rc5

package/src/powerup/cpu.ts

@@ -1,10 +1,8 @@
-import {Int64, Int64Type, Struct, UInt128, UInt128Type} from '@wharfkit/antelope'
+import {Asset, Int64, Int64Type, Struct, UInt128, UInt128Type} from '@wharfkit/antelope'
 
 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 {
@@ -26,9 +24,6 @@ export class PowerUpStateResourceCPU extends PowerUpStateResource {
     }
 
     // Convert weight to μs (microseconds)
-    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')
@@ -36,29 +31,17 @@ export class PowerUpStateResourceCPU extends PowerUpStateResource {
     }
 
     // Convert μs (microseconds) to weight
-    us_to_weight_legacy(sample: UInt128, us: number): number {
-        const sampled = intToBigDecimal(sample)
-        return Math.floor((us / Number(sampled.getValue())) * BNPrecision)
-    }
     us_to_weight(sample: UInt128, us: Int64Type): Int64 {
-        return Int64.from(us).multiplying(BNPrecision).dividing(Int64.from(sample), 'floor')
+        return Int64.from(us).multiplying(BNPrecision).dividing(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_legacy(usage: SampleUsage, us: number) {
-        const weight = intToBigDecimal(this.us_to_weight_legacy(usage.cpu, us))
-        const current = intToBigDecimal(this.weight)
-        const frac = weight.divide(current)
-        return Math.floor(Number(frac.getValue()) * 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))
@@ -69,64 +52,43 @@ export class PowerUpStateResourceCPU extends PowerUpStateResource {
     }
 
     // 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))
-        console.log('frac', String(frac))
-
-        const utilization_increase = this.utilization_increase_legacy(frac)
-        console.log('utilization_increase', String(utilization_increase))
-
-        // Determine the adjusted utilization if needed
-        const adjusted_utilization = this.determine_adjusted_utilization(options)
-        console.log('adjusted_utilization', String(adjusted_utilization))
-
-        // Derive the fee from the increase and utilization
-        const fee = this.fee_legacy(utilization_increase, adjusted_utilization)
-        console.log('fee', fee)
-
-        // 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
-        console.log('ceil', value)
-
-        // 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))
-        console.log('frac', String(frac))
-
         const utilization_increase = this.utilization_increase(frac)
-        console.log('utilization_increase', String(utilization_increase))
-
         // Determine the adjusted utilization if needed
         const adjusted_utilization = this.determine_adjusted_utilization(options)
-        console.log('adjusted_utilization', String(adjusted_utilization))
-
         // Derive the fee from the increase and utilization
         const fee = this.fee(utilization_increase, adjusted_utilization)
-        console.log('fee', fee)
-
         // 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
-
-        console.log('ceil', value)
-
+        const price = fee * precision
+        const value = Math.ceil(price) / precision
+        const asset = Asset.fromFloat(fee, this.symbol)
+        if (price < 1) {
+            throw new Error(
+                `Price (${String(
+                    asset
+                )}) for requested CPU amount (${us}us) below required precision, increase requested amount.`
+            )
+        }
+        if (options && options.min_payment && options.min_payment.units.gt(asset.units)) {
+            throw new Error(
+                `Price (${String(
+                    asset
+                )}) for requested CPU amount (${us}us) below minimum required payment (${String(
+                    options.min_payment
+                )}), increase requested CPU amount.`
+            )
+        }
         // Return the modified fee
         return value
     }

package/src/powerup/net.ts

@@ -3,7 +3,6 @@ import {Int64, Int64Type, Struct, UInt128} from '@wharfkit/antelope'
 import {BNPrecision, intToBigDecimal, SampleUsage} from '..'
 import {PowerUpStateResource} from './abstract'
 import {PowerUpStateOptions} from './options'
-import BN from 'bn.js'
 
 @Struct.type('powerupstateresourcenet')
 export class PowerUpStateResourceNET extends PowerUpStateResource {
@@ -25,9 +24,6 @@ export class PowerUpStateResourceNET extends PowerUpStateResource {
     }
 
     // Convert weight to bytes
-    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')
@@ -35,29 +31,18 @@ export class PowerUpStateResourceNET extends PowerUpStateResource {
     }
 
     // Convert bytes to weight
-    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_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))
@@ -68,38 +53,14 @@ export class PowerUpStateResourceNET extends PowerUpStateResource {
     }
 
     // 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))

package/src/powerup/options.ts

@@ -1,4 +1,4 @@
-import {TimePointType, UInt64} from '@wharfkit/antelope'
+import {Asset, TimePointType, UInt64} from '@wharfkit/antelope'
 
 export interface PowerUpStateOptions {
     // timestamp to base adjusted_utilization off
@@ -6,4 +6,6 @@ export interface PowerUpStateOptions {
     // blockchain resource limits for calculating usage
     virtual_block_cpu_limit?: UInt64
     virtual_block_net_limit?: UInt64
+    // minimum payment amount
+    min_payment?: Asset
 }

package/src/rex.ts

@@ -1,4 +1,4 @@
-import {BNPrecision, Resources, SampleUsage} from './'
+import {BNPrecision, intToBigDecimal, Resources, SampleUsage} from './'
 
 import {Asset, Struct, UInt128, UInt64, UInt8} from '@wharfkit/antelope'
 
@@ -26,17 +26,18 @@ export class REXState extends Struct {
     }
 
     public get value() {
-        return (
-            (Number(this.total_lent.units) + Number(this.total_unlent.units)) /
-            Number(this.total_rex.units)
-        )
+        const lent = intToBigDecimal(this.total_lent.units)
+        const unlent = intToBigDecimal(this.total_unlent.units)
+        const rex = intToBigDecimal(this.total_rex.units)
+        return Number(lent.add(unlent).divide(rex, 18).getValue())
     }
 
     exchange(amount: Asset): Asset {
-        return Asset.from(
-            (amount.value * this.total_lendable.value) / this.total_rex.value,
-            this.symbol
-        )
+        const value = intToBigDecimal(amount.units)
+        const lendable = intToBigDecimal(this.total_lendable.units)
+        const rex = intToBigDecimal(this.total_rex.units)
+        const tokens = value.multiply(lendable).divide(rex, this.precision)
+        return Asset.fromUnits(Number(tokens.getValue()), this.symbol)
     }
 
     cpu_price_per_ms(sample: SampleUsage, ms = 1): number {