@wharfkit/resources 1.0.0

package/src/index.ts

@@ -0,0 +1,87 @@
+import {API, APIClient, APIClientOptions, FetchProvider, UInt128} from '@wharfkit/antelope'
+import BN from 'bn.js'
+
+import {PowerUpAPI} from './powerup'
+import {RAMAPI} from './ram'
+import {REXAPI} from './rex'
+
+export * from './powerup'
+export * from './ram'
+export * from './rex'
+
+interface ResourcesOptions extends APIClientOptions {
+    api?: APIClient
+    sampleAccount?: string
+    symbol?: string
+    url?: string
+}
+
+export interface SampleUsage {
+    account: API.v1.AccountObject
+    cpu: UInt128
+    net: UInt128
+}
+
+export const BNPrecision = new BN(1000 * 1000)
+
+export class Resources {
+    static __className = 'Resources'
+
+    readonly api: APIClient
+
+    // the account to use when sampling usage
+    sampleAccount = 'b1'
+
+    // token precision/symbol
+    symbol = '4,EOS'
+
+    constructor(options: ResourcesOptions) {
+        // Allow overriding of the sample account name
+        if (options.sampleAccount) {
+            this.sampleAccount = options.sampleAccount
+        }
+        // Allow overriding of the system token symbol
+        if (options.symbol) {
+            this.symbol = options.symbol
+        }
+        // Allow variations on how to specify the API configuration
+        if (options.api) {
+            this.api = options.api
+        } else if (options.url) {
+            this.api = new APIClient({provider: new FetchProvider(options.url, options)})
+        } else {
+            throw new Error('Missing url or api client')
+        }
+    }
+
+    v1 = {
+        powerup: new PowerUpAPI(this),
+        ram: new RAMAPI(this),
+        rex: new REXAPI(this),
+    }
+
+    async getSampledUsage(): Promise<SampleUsage> {
+        const account = await this.api.v1.chain.get_account(this.sampleAccount)
+        const us = UInt128.from(account.cpu_limit.max.value.mul(BNPrecision))
+        const byte = UInt128.from(account.net_limit.max.value.mul(BNPrecision))
+
+        const cpu_weight = UInt128.from(account.cpu_weight.value)
+        const net_weight = UInt128.from(account.net_weight.value)
+
+        return {
+            account,
+            cpu: divCeil(us.value, cpu_weight.value),
+            net: divCeil(byte.value, net_weight.value),
+        }
+    }
+}
+
+function divCeil(num: BN, den: BN): UInt128 {
+    let v: BN = num.div(den)
+    const zero = new BN(0)
+    const one = new BN(1)
+    if (num.mod(den).gt(zero)) {
+        v = v.sub(one)
+    }
+    return UInt128.from(v)
+}

package/src/powerup/abstract.ts

@@ -0,0 +1,144 @@
+import {
+    Asset,
+    Float64,
+    Int64,
+    Struct,
+    TimePointSec,
+    UInt128,
+    UInt32,
+    UInt64,
+    UInt8,
+} from '@wharfkit/antelope'
+
+import BN from 'bn.js'
+import {PowerUpStateOptions} from './options'
+
+export abstract class PowerUpStateResource extends Struct {
+    @Struct.field('uint8') version!: UInt8
+    @Struct.field('int64') weight!: Int64
+    @Struct.field('int64') weight_ratio!: Int64
+    @Struct.field('int64') assumed_stake_weight!: Int64
+    @Struct.field('int64') initial_weight_ratio!: Int64
+    @Struct.field('int64') target_weight_ratio!: Int64
+    @Struct.field('time_point_sec') initial_timestamp!: TimePointSec
+    @Struct.field('time_point_sec') target_timestamp!: TimePointSec
+    @Struct.field('float64') exponent!: Float64
+    @Struct.field('uint32') decay_secs!: UInt32
+    @Struct.field('asset') min_price!: Asset
+    @Struct.field('asset') max_price!: Asset
+    @Struct.field('int64') utilization!: Int64
+    @Struct.field('int64') adjusted_utilization!: Int64
+    @Struct.field('time_point_sec') utilization_timestamp!: TimePointSec
+
+    readonly default_block_cpu_limit: UInt64 = UInt64.from(200000)
+    readonly default_block_net_limit: UInt64 = UInt64.from(1048576000)
+
+    abstract per_day(options?: PowerUpStateOptions): number
+
+    // Get the current number of allocated units (shift from REX -> PowerUp)
+    public get allocated() {
+        return 1 - Number(this.weight_ratio) / Number(this.target_weight_ratio) / 100
+    }
+
+    // Get the current percentage of reserved units
+    public get reserved() {
+        return Number(this.utilization) / Number(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: Number(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) {
+        const {weight} = this
+        const frac128 = UInt128.from(frac)
+        const utilization_increase =
+            new BN(weight.value.mul(new BN(frac128.value))) / Math.pow(10, 15)
+        return Math.ceil(utilization_increase)
+    }
+
+    // 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()
+        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
+        if (new_exponent <= 0.0) {
+            return max_price
+        } else {
+            price += (max_price - min_price) * Math.pow(utilization / 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()
+        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 = start_utilization / weight
+        const end_u = end_utilization / weight
+        const delta =
+            min_price * end_u -
+            min_price * start_u +
+            coefficient * Math.pow(end_u, exponent) -
+            coefficient * Math.pow(start_u, exponent)
+        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()
+
+        let start_utilization: number = utilization
+        const end_utilization: number = start_utilization + utilization_increase
+
+        let fee = 0
+        if (start_utilization < adjusted_utilization) {
+            fee +=
+                (this.price_function(adjusted_utilization) *
+                    Math.min(utilization_increase, adjusted_utilization - start_utilization)) /
+                weight
+            start_utilization = adjusted_utilization
+        }
+        if (start_utilization < end_utilization) {
+            fee += this.price_integral_delta(start_utilization, end_utilization)
+        }
+        return fee
+    }
+
+    // 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()
+        // If utilization is less than adjusted, calculate real time value
+        if (utilization < 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)
+            delta = Math.min(Math.max(delta, 0), diff) // Clamp the delta
+            adjusted_utilization = utilization + delta
+        }
+        return adjusted_utilization
+    }
+}

package/src/powerup/cpu.ts

@@ -0,0 +1,76 @@
+import {Struct, UInt128} from '@wharfkit/antelope'
+
+import {BNPrecision, SampleUsage} from '..'
+import {PowerUpStateResource} from './abstract'
+import {PowerUpStateOptions} from './options'
+
+@Struct.type('powerupstateresourcecpu')
+export class PowerUpStateResourceCPU extends PowerUpStateResource {
+    // Return smallest units per day, μs (microseconds)
+    per_day = (options?: PowerUpStateOptions) => this.us_per_day(options)
+
+    // Return ms (milliseconds) per day
+    ms_per_day(options?: PowerUpStateOptions) {
+        return this.us_per_day(options) / 1000
+    }
+
+    // Return μs (microseconds) per day
+    us_per_day(options?: PowerUpStateOptions) {
+        const limit =
+            options && options.virtual_block_cpu_limit
+                ? options.virtual_block_cpu_limit
+                : this.default_block_cpu_limit
+        return Number(limit) * 2 * 60 * 60 * 24
+    }
+
+    // Convert weight to μs (microseconds)
+    weight_to_us(sample: UInt128, weight: number): number {
+        return Math.ceil((weight * Number(sample)) / BNPrecision)
+    }
+
+    // Convert μs (microseconds) to weight
+    us_to_weight(sample: UInt128, us: number): number {
+        return Math.floor((us / Number(sample)) * BNPrecision)
+    }
+
+    // Default frac generation by smallest unit type
+    frac = (usage: SampleUsage, us: number) => this.frac_by_us(usage, us)
+
+    // Frac generation by ms (milliseconds)
+    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 = this.us_to_weight(usage.cpu, us) / weight
+        return Math.floor(frac * Math.pow(10, 15))
+    }
+
+    // Price generation by smallest units, μs (microseconds)
+    price_per = (usage: SampleUsage, us = 1000, options?: PowerUpStateOptions): number =>
+        this.price_per_us(usage, us, options)
+
+    // Price generation by ms (milliseconds)
+    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(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)
+
+        // 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(utilization_increase, adjusted_utilization)
+
+        // Force the fee up to the next highest value of precision
+        const precision = Math.pow(10, 4)
+        const value = Math.ceil(fee * precision) / precision
+
+        // Return the modified fee
+        return value
+    }
+}

package/src/powerup/net.ts

@@ -0,0 +1,77 @@
+import {Struct, UInt128} from '@wharfkit/antelope'
+
+import {BNPrecision, SampleUsage} from '..'
+import {PowerUpStateResource} from './abstract'
+import {PowerUpStateOptions} from './options'
+
+@Struct.type('powerupstateresourcenet')
+export class PowerUpStateResourceNET extends PowerUpStateResource {
+    // Return smallest units per day, bytes
+    per_day = (options?: PowerUpStateOptions) => this.bytes_per_day(options)
+
+    // Return kb per day
+    kb_per_day(options?: PowerUpStateOptions) {
+        return this.bytes_per_day(options) / 1000
+    }
+
+    // Return bytes per day
+    bytes_per_day(options?: PowerUpStateOptions) {
+        const limit =
+            options && options.virtual_block_net_limit
+                ? options.virtual_block_net_limit
+                : this.default_block_net_limit
+        return Number(limit) * 2 * 60 * 60 * 24
+    }
+
+    // Convert weight to bytes
+    weight_to_bytes(sample: UInt128, weight: number): number {
+        return Math.ceil((weight * Number(sample)) / BNPrecision)
+    }
+
+    // Convert bytes to weight
+    bytes_to_weight(sample: UInt128, bytes: number): number {
+        return Math.floor((bytes / Number(sample)) * BNPrecision)
+    }
+
+    // Default frac generation by smallest unit type
+    frac = (usage: SampleUsage, bytes: number) => this.frac_by_bytes(usage, bytes)
+
+    // Frac generation by kb
+    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 = this.bytes_to_weight(usage.net, bytes) / weight
+        return Math.floor(frac * Math.pow(10, 15))
+    }
+
+    // Price generation by smallest units, bytes
+    price_per = (usage: SampleUsage, bytes = 1000, options?: PowerUpStateOptions) =>
+        this.price_per_byte(usage, bytes, options)
+
+    // Price generation by kb
+    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(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)
+
+        // 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(utilization_increase, adjusted_utilization)
+
+        // Force the fee up to the next highest value of precision
+        const precision = Math.pow(10, 4)
+        const value = Math.ceil(fee * precision) / precision
+
+        // Return the modified fee
+        return value
+    }
+}

package/src/powerup/options.ts

@@ -0,0 +1,9 @@
+import {TimePointType, UInt64} from '@wharfkit/antelope'
+
+export interface PowerUpStateOptions {
+    // timestamp to base adjusted_utilization off
+    timestamp?: TimePointType
+    // blockchain resource limits for calculating usage
+    virtual_block_cpu_limit?: UInt64
+    virtual_block_net_limit?: UInt64
+}

package/src/powerup.ts

@@ -0,0 +1,28 @@
+import {Asset, Struct, UInt32, UInt8} from '@wharfkit/antelope'
+
+import {Resources} from '.'
+import {PowerUpStateResourceCPU} from './powerup/cpu'
+import {PowerUpStateResourceNET} from './powerup/net'
+
+@Struct.type('powerupstate')
+export class PowerUpState extends Struct {
+    @Struct.field('uint8') version!: UInt8
+    @Struct.field(PowerUpStateResourceNET) net!: PowerUpStateResourceNET
+    @Struct.field(PowerUpStateResourceCPU) cpu!: PowerUpStateResourceCPU
+    @Struct.field('uint32') powerup_days!: UInt32
+    @Struct.field('asset') min_powerup_fee!: Asset
+}
+
+export class PowerUpAPI {
+    constructor(private parent: Resources) {}
+
+    async get_state(): Promise<PowerUpState> {
+        const response = await this.parent.api.v1.chain.get_table_rows({
+            code: 'eosio',
+            scope: '',
+            table: 'powup.state',
+            type: PowerUpState,
+        })
+        return response.rows[0]
+    }
+}

package/src/ram.ts

@@ -0,0 +1,52 @@
+import {Resources} from './'
+
+import {Asset, Float64, Struct} from '@wharfkit/antelope'
+
+@Struct.type('connector')
+export class Connector extends Struct {
+    @Struct.field('asset') balance!: Asset
+    @Struct.field('float64') weight!: Float64
+}
+
+@Struct.type('exchange_state')
+export class ExchangeState extends Struct {
+    @Struct.field('asset') supply!: Asset
+    @Struct.field(Connector) base!: Connector
+    @Struct.field(Connector) quote!: Connector
+}
+
+@Struct.type('ramstate')
+export class RAMState extends ExchangeState {
+    public price_per(bytes: number): number {
+        const base = this.base.balance.units.toNumber()
+        const quote = this.quote.balance.value
+        return this.get_input(base, quote, bytes)
+    }
+
+    public price_per_kb(kilobytes: number): number {
+        return this.price_per(kilobytes * 1000)
+    }
+
+    // Derived from https://github.com/EOSIO/eosio.contracts/blob/f6578c45c83ec60826e6a1eeb9ee71de85abe976/contracts/eosio.system/src/exchange_state.cpp#L96
+    public get_input(base: number, quote: number, value: number): number {
+        const result = (quote * value) / (base - value)
+        if (result < 0) {
+            return 0
+        }
+        return result
+    }
+}
+
+export class RAMAPI {
+    constructor(private parent: Resources) {}
+
+    async get_state() {
+        const response = await this.parent.api.v1.chain.get_table_rows({
+            code: 'eosio',
+            scope: 'eosio',
+            table: 'rammarket',
+            type: RAMState,
+        })
+        return response.rows[0]
+    }
+}

package/src/rex.ts

@@ -0,0 +1,75 @@
+import {BNPrecision, Resources, SampleUsage} from './'
+
+import {Asset, Struct, UInt64, UInt8} from '@wharfkit/antelope'
+
+@Struct.type('rexstate')
+export class REXState extends Struct {
+    @Struct.field('uint8') version!: UInt8
+    @Struct.field('asset') total_lent!: Asset
+    @Struct.field('asset') total_unlent!: Asset
+    @Struct.field('asset') total_rent!: Asset
+    @Struct.field('asset') total_lendable!: Asset
+    @Struct.field('asset') total_rex!: Asset
+    @Struct.field('asset') namebid_proceeds!: Asset
+    @Struct.field('uint64') loan_num!: UInt64
+
+    public get reserved() {
+        return Number(this.total_lent.units) / Number(this.total_lendable.units)
+    }
+
+    public get symbol() {
+        return this.total_lent.symbol
+    }
+
+    public get precision() {
+        return this.total_lent.symbol.precision
+    }
+
+    public get value() {
+        return (
+            (Number(this.total_lent.units) + Number(this.total_unlent.units)) /
+            Number(this.total_rex.units)
+        )
+    }
+
+    exchange(amount: Asset): Asset {
+        return Asset.from(
+            (amount.value * this.total_lendable.value) / this.total_rex.value,
+            this.symbol
+        )
+    }
+
+    price_per(sample: SampleUsage, unit = 1000): number {
+        // Sample token units
+        const tokens = Asset.fromUnits(10000, this.symbol)
+
+        // Spending 1 EOS (10000 units) on REX gives this many tokens
+        const bancor = Number(tokens.units) / (this.total_rent.value / this.total_unlent.value)
+
+        // The ratio of the number of tokens received vs the sampled values
+        const unitPrice = bancor * (Number(sample.cpu) / BNPrecision)
+
+        // The token units spent per unit
+        const perunit = Number(tokens.units) / unitPrice
+
+        // Multiply the per unit cost by the units requested
+        const cost = perunit * unit
+
+        // Converting to an Asset
+        return cost / Math.pow(10, this.precision)
+    }
+}
+
+export class REXAPI {
+    constructor(private parent: Resources) {}
+
+    async get_state() {
+        const response = await this.parent.api.v1.chain.get_table_rows({
+            code: 'eosio',
+            scope: 'eosio',
+            table: 'rexpool',
+            type: REXState,
+        })
+        return response.rows[0]
+    }
+}