evernode-js-client 0.5.1 → 0.5.3
Sign up to get free protection for your applications and to get access to all the features.
- package/index.js +171 -98
- package/package.json +1 -1
package/index.js
CHANGED
@@ -11846,29 +11846,29 @@ class BaseEvernodeClient {
|
|
11846
11846
|
}
|
11847
11847
|
|
11848
11848
|
/**
|
11849
|
-
* Get the moment from the given
|
11850
|
-
* @param {number}
|
11851
|
-
* @returns The moment of the given
|
11852
|
-
*/
|
11853
|
-
async getMoment(
|
11854
|
-
const
|
11855
|
-
const m = Math.floor((
|
11856
|
-
|
11857
|
-
await Promise.resolve(); // Awaiter placeholder for future async requirements.
|
11849
|
+
* Get the moment from the given index (timestamp).
|
11850
|
+
* @param {number} index [Optional] Index (timestamp) to get the moment value.
|
11851
|
+
* @returns The moment of the given index (timestamp) as 'number'. Returns current moment if index (timestamp) is not given.
|
11852
|
+
*/
|
11853
|
+
async getMoment(index = null) {
|
11854
|
+
const i = index || UtilHelpers.getCurrentUnixTime();
|
11855
|
+
const m = this.config.momentBaseInfo.baseTransitionMoment + Math.floor((i - this.config.momentBaseInfo.baseIdx) / this.config.momentSize);
|
11856
|
+
await Promise.resolve();
|
11858
11857
|
return m;
|
11859
11858
|
}
|
11860
11859
|
|
11861
11860
|
/**
|
11862
|
-
* Get start
|
11863
|
-
* @param {number}
|
11864
|
-
* @returns The
|
11861
|
+
* Get start index (timestamp) of the moment.
|
11862
|
+
* @param {number} index [Optional] Index (timestamp) to get the moment value.
|
11863
|
+
* @returns The index (timestamp) of the moment as a 'number'. Returns the current moment's start index (timestamp) if ledger index parameter is not given.
|
11865
11864
|
*/
|
11866
|
-
async getMomentStartIndex(
|
11867
|
-
const
|
11868
|
-
|
11865
|
+
async getMomentStartIndex(index = null) {
|
11866
|
+
const i = index || UtilHelpers.getCurrentUnixTime();
|
11867
|
+
|
11868
|
+
const m = Math.floor((i - this.config.momentBaseInfo.baseIdx) / this.config.momentSize);
|
11869
11869
|
|
11870
11870
|
await Promise.resolve(); // Awaiter placeholder for future async requirements.
|
11871
|
-
return this.config.
|
11871
|
+
return this.config.momentBaseInfo.baseIdx + (m * this.config.momentSize);
|
11872
11872
|
}
|
11873
11873
|
|
11874
11874
|
/**
|
@@ -11883,19 +11883,23 @@ class BaseEvernodeClient {
|
|
11883
11883
|
hostRegFee: HookStateKeys.HOST_REG_FEE,
|
11884
11884
|
momentSize: HookStateKeys.MOMENT_SIZE,
|
11885
11885
|
hostHeartbeatFreq: HookStateKeys.HOST_HEARTBEAT_FREQ,
|
11886
|
-
|
11886
|
+
momentBaseInfo: HookStateKeys.MOMENT_BASE_INFO,
|
11887
11887
|
purchaserTargetPrice: HookStateKeys.PURCHASER_TARGET_PRICE,
|
11888
11888
|
leaseAcquireWindow: HookStateKeys.LEASE_ACQUIRE_WINDOW,
|
11889
11889
|
rewardInfo: HookStateKeys.REWARD_INFO,
|
11890
|
-
|
11891
|
-
hostCount: HookStateKeys.HOST_COUNT
|
11890
|
+
rewardConfiguration: HookStateKeys.REWARD_CONFIGURATION,
|
11891
|
+
hostCount: HookStateKeys.HOST_COUNT,
|
11892
|
+
momentTransitInfo: HookStateKeys.MOMENT_TRANSIT_INFO
|
11892
11893
|
}
|
11893
11894
|
let config = {};
|
11894
11895
|
for (const [key, value] of Object.entries(configStateKeys)) {
|
11895
11896
|
const stateKey = Buffer.from(value, 'hex');
|
11896
|
-
const
|
11897
|
-
|
11898
|
-
|
11897
|
+
const stateDataBin = StateHelpers.getStateData(states, value);
|
11898
|
+
if (stateDataBin) {
|
11899
|
+
const stateData = Buffer.from(StateHelpers.getStateData(states, value), 'hex');
|
11900
|
+
const decoded = StateHelpers.decodeStateData(stateKey, stateData);
|
11901
|
+
config[key] = decoded.value;
|
11902
|
+
}
|
11899
11903
|
}
|
11900
11904
|
return config;
|
11901
11905
|
}
|
@@ -12159,9 +12163,9 @@ class BaseEvernodeClient {
|
|
12159
12163
|
if (addrStateData) {
|
12160
12164
|
const addrStateDecoded = StateHelpers.decodeHostAddressState(Buffer.from(addrStateKey, 'hex'), Buffer.from(addrStateData, 'hex'));
|
12161
12165
|
const curMomentStartIdx = await this.getMomentStartIndex();
|
12162
|
-
addrStateDecoded.active = (addrStateDecoded.
|
12163
|
-
(addrStateDecoded.
|
12164
|
-
(addrStateDecoded.
|
12166
|
+
addrStateDecoded.active = (addrStateDecoded.lastHeartbeatIndex > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
|
12167
|
+
(addrStateDecoded.lastHeartbeatIndex >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
|
12168
|
+
(addrStateDecoded.lastHeartbeatIndex > 0))
|
12165
12169
|
|
12166
12170
|
const nftIdStatekey = StateHelpers.generateTokenIdStateKey(addrStateDecoded.nfTokenId);
|
12167
12171
|
const nftIdStateIndex = StateHelpers.getHookStateIndex(this.registryAddress, nftIdStatekey);
|
@@ -12195,9 +12199,9 @@ class BaseEvernodeClient {
|
|
12195
12199
|
const curMomentStartIdx = await this.getMomentStartIndex();
|
12196
12200
|
// Populate the host active status.
|
12197
12201
|
(hosts.nextPageToken ? hosts.data : hosts).forEach(h => {
|
12198
|
-
h.active = (h.
|
12199
|
-
(h.
|
12200
|
-
(h.
|
12202
|
+
h.active = (h.lastHeartbeatIndex > (this.config.hostHeartbeatFreq * this.config.momentSize) ?
|
12203
|
+
(h.lastHeartbeatIndex >= (curMomentStartIdx - (this.config.hostHeartbeatFreq * this.config.momentSize))) :
|
12204
|
+
(h.lastHeartbeatIndex > 0))
|
12201
12205
|
});
|
12202
12206
|
return hosts;
|
12203
12207
|
}
|
@@ -12804,41 +12808,47 @@ class TenantClient extends BaseEvernodeClient {
|
|
12804
12808
|
* @returns An object including transaction details,instance info, and acquireReference Id.
|
12805
12809
|
*/
|
12806
12810
|
async watchAcquireResponse(tx, options = {}) {
|
12807
|
-
|
12811
|
+
console.log(`Waiting for acquire response... (txHash: ${tx.id})`);
|
12808
12812
|
|
12813
|
+
return new Promise(async (resolve, reject) => {
|
12814
|
+
let rejected = false;
|
12809
12815
|
const failTimeout = setTimeout(() => {
|
12810
|
-
|
12816
|
+
rejected = true;
|
12817
|
+
reject({ error: ErrorCodes.ACQUIRE_ERR, reason: ErrorReasons.TIMEOUT });
|
12811
12818
|
}, options.timeout || DEFAULT_WAIT_TIMEOUT);
|
12812
|
-
|
12819
|
+
|
12813
12820
|
let relevantTx = null;
|
12814
|
-
while (!relevantTx) {
|
12821
|
+
while (!rejected && !relevantTx) {
|
12815
12822
|
const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
|
12816
12823
|
for (let t of txList) {
|
12817
12824
|
t.tx.Memos = TransactionHelper.deserializeMemos(t.tx?.Memos);
|
12818
|
-
|
12819
|
-
|
12820
|
-
|
12821
|
-
|
12822
|
-
|
12823
|
-
|
12825
|
+
const res = await this.extractEvernodeEvent(t.tx);
|
12826
|
+
if ((res?.name === EvernodeEvents.AcquireSuccess || res?.name === EvernodeEvents.AcquireError) && res?.data?.acquireRefId === tx.id) {
|
12827
|
+
clearTimeout(failTimeout);
|
12828
|
+
relevantTx = res;
|
12829
|
+
break;
|
12830
|
+
}
|
12824
12831
|
}
|
12825
|
-
await new Promise(
|
12832
|
+
await new Promise(resolveSleep => setTimeout(resolveSleep, 2000));
|
12826
12833
|
}
|
12827
|
-
|
12828
|
-
if (
|
12829
|
-
|
12830
|
-
|
12831
|
-
|
12832
|
-
|
12833
|
-
|
12834
|
-
|
12835
|
-
|
12836
|
-
|
12837
|
-
|
12838
|
-
|
12839
|
-
|
12840
|
-
|
12834
|
+
|
12835
|
+
if (!rejected) {
|
12836
|
+
if (relevantTx?.name === TenantEvents.AcquireSuccess) {
|
12837
|
+
resolve({
|
12838
|
+
transaction: relevantTx?.data.transaction,
|
12839
|
+
instance: relevantTx?.data.payload.content,
|
12840
|
+
acquireRefId: relevantTx?.data.acquireRefId
|
12841
|
+
});
|
12842
|
+
} else if (relevantTx?.name === TenantEvents.AcquireError) {
|
12843
|
+
reject({
|
12844
|
+
error: ErrorCodes.ACQUIRE_ERR,
|
12845
|
+
transaction: relevantTx?.data.transaction,
|
12846
|
+
reason: relevantTx?.data.reason,
|
12847
|
+
acquireRefId: relevantTx?.data.acquireRefId
|
12848
|
+
});
|
12849
|
+
}
|
12841
12850
|
}
|
12851
|
+
});
|
12842
12852
|
}
|
12843
12853
|
|
12844
12854
|
/**
|
@@ -12887,38 +12897,44 @@ class TenantClient extends BaseEvernodeClient {
|
|
12887
12897
|
async watchExtendResponse(tx, options = {}) {
|
12888
12898
|
console.log(`Waiting for extend lease response... (txHash: ${tx.id})`);
|
12889
12899
|
|
12890
|
-
|
12891
|
-
|
12892
|
-
|
12893
|
-
|
12894
|
-
|
12895
|
-
|
12896
|
-
|
12897
|
-
|
12898
|
-
|
12899
|
-
const
|
12900
|
-
|
12901
|
-
|
12902
|
-
|
12903
|
-
|
12900
|
+
return new Promise(async (resolve, reject) => {
|
12901
|
+
let rejected = false;
|
12902
|
+
const failTimeout = setTimeout(() => {
|
12903
|
+
rejected = true;
|
12904
|
+
reject({ error: ErrorCodes.EXTEND_ERR, reason: ErrorReasons.TIMEOUT });
|
12905
|
+
}, options.timeout || DEFAULT_WAIT_TIMEOUT);
|
12906
|
+
|
12907
|
+
let relevantTx = null;
|
12908
|
+
while (!rejected && !relevantTx) {
|
12909
|
+
const txList = await this.xrplAcc.getAccountTrx(tx.details.ledger_index);
|
12910
|
+
for (let t of txList) {
|
12911
|
+
t.tx.Memos = TransactionHelper.deserializeMemos(t.tx.Memos);
|
12912
|
+
const res = await this.extractEvernodeEvent(t.tx);
|
12913
|
+
if ((res?.name === TenantEvents.ExtendSuccess || res?.name === TenantEvents.ExtendError) && res?.data?.extendRefId === tx.id) {
|
12914
|
+
clearTimeout(failTimeout);
|
12915
|
+
relevantTx = res;
|
12916
|
+
break;
|
12917
|
+
}
|
12904
12918
|
}
|
12919
|
+
await new Promise(resolveSleep => setTimeout(resolveSleep, 1000));
|
12905
12920
|
}
|
12906
|
-
await new Promise(resolve => setTimeout(resolve, 1000));
|
12907
|
-
}
|
12908
12921
|
|
12909
|
-
|
12910
|
-
|
12911
|
-
|
12912
|
-
|
12913
|
-
|
12914
|
-
|
12915
|
-
|
12916
|
-
|
12917
|
-
|
12918
|
-
|
12919
|
-
|
12920
|
-
|
12921
|
-
|
12922
|
+
if (!rejected) {
|
12923
|
+
if (relevantTx?.name === TenantEvents.ExtendSuccess) {
|
12924
|
+
resolve({
|
12925
|
+
transaction: relevantTx?.data.transaction,
|
12926
|
+
expiryMoment: relevantTx?.data.expiryMoment,
|
12927
|
+
extendeRefId: relevantTx?.data.extendRefId
|
12928
|
+
});
|
12929
|
+
} else if (relevantTx?.name === TenantEvents.ExtendError) {
|
12930
|
+
reject({
|
12931
|
+
error: ErrorCodes.EXTEND_ERR,
|
12932
|
+
transaction: relevantTx?.data.transaction,
|
12933
|
+
reason: relevantTx?.data.reason
|
12934
|
+
});
|
12935
|
+
}
|
12936
|
+
}
|
12937
|
+
});
|
12922
12938
|
}
|
12923
12939
|
|
12924
12940
|
/**
|
@@ -13422,10 +13438,11 @@ const HookStateKeys = {
|
|
13422
13438
|
LEASE_ACQUIRE_WINDOW: "4556520100000000000000000000000000000000000000000000000000000008",
|
13423
13439
|
REWARD_CONFIGURATION: "4556520100000000000000000000000000000000000000000000000000000009",
|
13424
13440
|
MAX_TOLERABLE_DOWNTIME: "455652010000000000000000000000000000000000000000000000000000000A",
|
13441
|
+
MOMENT_TRANSIT_INFO: "455652010000000000000000000000000000000000000000000000000000000B",
|
13425
13442
|
|
13426
13443
|
// Singleton
|
13427
13444
|
HOST_COUNT: "4556523200000000000000000000000000000000000000000000000000000000",
|
13428
|
-
|
13445
|
+
MOMENT_BASE_INFO: "4556523300000000000000000000000000000000000000000000000000000000",
|
13429
13446
|
HOST_REG_FEE: "4556523400000000000000000000000000000000000000000000000000000000",
|
13430
13447
|
MAX_REG: "4556523500000000000000000000000000000000000000000000000000000000",
|
13431
13448
|
REWARD_INFO: "4556523600000000000000000000000000000000000000000000000000000000",
|
@@ -13864,6 +13881,14 @@ const FIRST_EPOCH_REWARD_QUOTA_OFFSET = 1;
|
|
13864
13881
|
const EPOCH_REWARD_AMOUNT_OFFSET = 5;
|
13865
13882
|
const REWARD_START_MOMENT_OFFSET = 9;
|
13866
13883
|
|
13884
|
+
const TRANSIT_IDX_OFFSET = 0;
|
13885
|
+
const TRANSIT_MOMENT_SIZE_OFFSET = 8;
|
13886
|
+
const TRANSIT_MOMENT_TYPE_OFFSET = 10;
|
13887
|
+
|
13888
|
+
const MOMENT_BASE_POINT_OFFSET = 0;
|
13889
|
+
const MOMENT_AT_TRANSITION_OFFSET = 8;
|
13890
|
+
const MOMENT_TYPE_OFFSET = 12;
|
13891
|
+
|
13867
13892
|
const HOST_TOKEN_ID_OFFSET = 0;
|
13868
13893
|
const HOST_COUNTRY_CODE_OFFSET = 32;
|
13869
13894
|
const HOST_RESERVED_OFFSET = 34;
|
@@ -13874,6 +13899,7 @@ const HOST_TOT_INS_COUNT_OFFSET = 84;
|
|
13874
13899
|
const HOST_ACT_INS_COUNT_OFFSET = 88;
|
13875
13900
|
const HOST_HEARTBEAT_LEDGER_IDX_OFFSET = 92;
|
13876
13901
|
const HOST_VERSION_OFFSET = 100;
|
13902
|
+
const HOST_REG_TIMESTAMP_OFFSET = 103;
|
13877
13903
|
|
13878
13904
|
const HOST_ADDRESS_OFFSET = 0;
|
13879
13905
|
const HOST_CPU_MODEL_NAME_OFFSET = 20;
|
@@ -13888,6 +13914,11 @@ const STATE_KEY_TYPES = {
|
|
13888
13914
|
HOST_ADDR: 3
|
13889
13915
|
}
|
13890
13916
|
|
13917
|
+
const MOMENT_TYPES = {
|
13918
|
+
LEDGER: 0,
|
13919
|
+
TIMESTAMP: 1
|
13920
|
+
}
|
13921
|
+
|
13891
13922
|
const EVERNODE_PREFIX = 'EVR';
|
13892
13923
|
const HOST_ADDR_KEY_ZERO_COUNT = 8;
|
13893
13924
|
const HOOK_STATE_LEDGER_TYPE_PREFIX = 118; // Decimal value of ASCII 'v'
|
@@ -13900,8 +13931,20 @@ class StateHelpers {
|
|
13900
13931
|
CONFIGURATION: 'configuration'
|
13901
13932
|
}
|
13902
13933
|
|
13934
|
+
static timeLines = {
|
13935
|
+
SEC: "SEC"
|
13936
|
+
}
|
13937
|
+
|
13938
|
+
static getStateData(states, key) {
|
13939
|
+
const state = states.find(s => key === s.key);
|
13940
|
+
if (!state)
|
13941
|
+
return null;
|
13942
|
+
|
13943
|
+
return state.data;
|
13944
|
+
}
|
13945
|
+
|
13903
13946
|
static decodeHostAddressState(stateKeyBuf, stateDataBuf) {
|
13904
|
-
|
13947
|
+
let data = {
|
13905
13948
|
address: codec.encodeAccountID(stateKeyBuf.slice(12)),
|
13906
13949
|
nfTokenId: stateDataBuf.slice(HOST_TOKEN_ID_OFFSET, HOST_COUNTRY_CODE_OFFSET).toString('hex').toUpperCase(),
|
13907
13950
|
countryCode: stateDataBuf.slice(HOST_COUNTRY_CODE_OFFSET, HOST_RESERVED_OFFSET).toString(),
|
@@ -13910,9 +13953,12 @@ class StateHelpers {
|
|
13910
13953
|
registrationFee: Number(stateDataBuf.readBigUInt64BE(HOST_REG_FEE_OFFSET)),
|
13911
13954
|
maxInstances: stateDataBuf.readUInt32BE(HOST_TOT_INS_COUNT_OFFSET),
|
13912
13955
|
activeInstances: stateDataBuf.readUInt32BE(HOST_ACT_INS_COUNT_OFFSET),
|
13913
|
-
|
13914
|
-
version: `${stateDataBuf.readUInt8(HOST_VERSION_OFFSET)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 1)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 2)}
|
13956
|
+
lastHeartbeatIndex: Number(stateDataBuf.readBigUInt64BE(HOST_HEARTBEAT_LEDGER_IDX_OFFSET)),
|
13957
|
+
version: `${stateDataBuf.readUInt8(HOST_VERSION_OFFSET)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 1)}.${stateDataBuf.readUInt8(HOST_VERSION_OFFSET + 2)}`,
|
13915
13958
|
}
|
13959
|
+
if (stateDataBuf.length > HOST_REG_TIMESTAMP_OFFSET)
|
13960
|
+
data.registrationTimestamp = Number(stateDataBuf.readBigUInt64BE(HOST_REG_TIMESTAMP_OFFSET));
|
13961
|
+
return data;
|
13916
13962
|
}
|
13917
13963
|
|
13918
13964
|
static decodeTokenIdState(stateDataBuf) {
|
@@ -13955,11 +14001,15 @@ class StateHelpers {
|
|
13955
14001
|
value: stateData.readUInt32BE()
|
13956
14002
|
}
|
13957
14003
|
}
|
13958
|
-
else if (Buffer.from(HookStateKeys.
|
14004
|
+
else if (Buffer.from(HookStateKeys.MOMENT_BASE_INFO, 'hex').compare(stateKey) === 0) {
|
13959
14005
|
return {
|
13960
14006
|
type: this.StateTypes.SIGLETON,
|
13961
14007
|
key: hexKey,
|
13962
|
-
value:
|
14008
|
+
value: {
|
14009
|
+
baseIdx: Number(stateData.readBigUInt64BE(MOMENT_BASE_POINT_OFFSET)),
|
14010
|
+
baseTransitionMoment: stateData.length > MOMENT_AT_TRANSITION_OFFSET ? stateData.readUInt32BE(MOMENT_AT_TRANSITION_OFFSET) : 0,
|
14011
|
+
momentType: (stateData.length <= MOMENT_TYPE_OFFSET || stateData.readUInt8(MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER) ? 'ledger' : 'timestamp'
|
14012
|
+
}
|
13963
14013
|
}
|
13964
14014
|
}
|
13965
14015
|
else if (Buffer.from(HookStateKeys.HOST_REG_FEE, 'hex').compare(stateKey) === 0 || Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0) {
|
@@ -14033,6 +14083,18 @@ class StateHelpers {
|
|
14033
14083
|
value: stateData.readUInt16BE()
|
14034
14084
|
}
|
14035
14085
|
}
|
14086
|
+
else if (Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0) {
|
14087
|
+
Buffer.alloc(1).readUInt8()
|
14088
|
+
return {
|
14089
|
+
type: this.StateTypes.CONFIGURATION,
|
14090
|
+
key: hexKey,
|
14091
|
+
value: {
|
14092
|
+
transitionIndex: Number(stateData.readBigInt64BE(TRANSIT_IDX_OFFSET)),
|
14093
|
+
momentSize: stateData.readUInt16BE(TRANSIT_MOMENT_SIZE_OFFSET),
|
14094
|
+
momentType: stateData.readUInt8(TRANSIT_MOMENT_TYPE_OFFSET) === MOMENT_TYPES.LEDGER ? 'ledger' : 'timestamp'
|
14095
|
+
}
|
14096
|
+
}
|
14097
|
+
}
|
14036
14098
|
else
|
14037
14099
|
throw { type: 'Validation Error', message: 'Invalid state key.' };
|
14038
14100
|
}
|
@@ -14052,7 +14114,7 @@ class StateHelpers {
|
|
14052
14114
|
};
|
14053
14115
|
}
|
14054
14116
|
else if (Buffer.from(HookStateKeys.HOST_COUNT, 'hex').compare(stateKey) === 0 ||
|
14055
|
-
Buffer.from(HookStateKeys.
|
14117
|
+
Buffer.from(HookStateKeys.MOMENT_BASE_INFO, 'hex').compare(stateKey) === 0 ||
|
14056
14118
|
Buffer.from(HookStateKeys.HOST_REG_FEE, 'hex').compare(stateKey) === 0 ||
|
14057
14119
|
Buffer.from(HookStateKeys.MAX_REG, 'hex').compare(stateKey) === 0 ||
|
14058
14120
|
Buffer.from(HookStateKeys.REWARD_INFO, 'hex').compare(stateKey) === 0) {
|
@@ -14070,7 +14132,8 @@ class StateHelpers {
|
|
14070
14132
|
Buffer.from(HookStateKeys.FIXED_REG_FEE, 'hex').compare(stateKey) === 0 ||
|
14071
14133
|
Buffer.from(HookStateKeys.LEASE_ACQUIRE_WINDOW, 'hex').compare(stateKey) === 0 ||
|
14072
14134
|
Buffer.from(HookStateKeys.REWARD_CONFIGURATION, 'hex').compare(stateKey) === 0 ||
|
14073
|
-
Buffer.from(HookStateKeys.MAX_TOLERABLE_DOWNTIME, 'hex').compare(stateKey) === 0
|
14135
|
+
Buffer.from(HookStateKeys.MAX_TOLERABLE_DOWNTIME, 'hex').compare(stateKey) === 0 ||
|
14136
|
+
Buffer.from(HookStateKeys.MOMENT_TRANSIT_INFO, 'hex').compare(stateKey) === 0) {
|
14074
14137
|
return {
|
14075
14138
|
key: hexKey,
|
14076
14139
|
type: this.STATE_TYPES.CONFIGURATION
|
@@ -14209,14 +14272,6 @@ const { EvernodeConstants, ErrorReasons } = __nccwpck_require__(9849);
|
|
14209
14272
|
// Utility helper functions.
|
14210
14273
|
class UtilHelpers {
|
14211
14274
|
|
14212
|
-
static getStateData(states, key) {
|
14213
|
-
const state = states.find(s => key === s.key);
|
14214
|
-
if (!state)
|
14215
|
-
throw { code: ErrorReasons.NO_STATE_KEY, error: `State key '${key}' not found.` };
|
14216
|
-
|
14217
|
-
return state.data;
|
14218
|
-
}
|
14219
|
-
|
14220
14275
|
static readUInt(buf, base = 32, isBE = true) {
|
14221
14276
|
buf = Buffer.from(buf);
|
14222
14277
|
switch (base) {
|
@@ -14245,6 +14300,16 @@ class UtilHelpers {
|
|
14245
14300
|
leaseAmount: parseFloat(XflHelpers.toString(uriBuf.readBigInt64BE(prefixLen + 2 + halfToSLen)))
|
14246
14301
|
}
|
14247
14302
|
}
|
14303
|
+
|
14304
|
+
static getCurrentUnixTime(format = "sec") {
|
14305
|
+
const time = Date.now();
|
14306
|
+
switch (format) {
|
14307
|
+
case "sec":
|
14308
|
+
return Math.floor(time / 1000);
|
14309
|
+
default:
|
14310
|
+
return time;
|
14311
|
+
}
|
14312
|
+
}
|
14248
14313
|
}
|
14249
14314
|
|
14250
14315
|
module.exports = {
|
@@ -15110,6 +15175,14 @@ class XrplApi {
|
|
15110
15175
|
return this.#requestWithPaging({ command: 'account_offers', account: address, ledger_index: "validated", ...options }, API_REQ_TYPE.OFFERS);
|
15111
15176
|
}
|
15112
15177
|
|
15178
|
+
async getSellOffers(nfTokenId, options = {}) {
|
15179
|
+
return this.#requestWithPaging({ command: 'nft_sell_offers', nft_id: nfTokenId, ledger_index: "validated", ...options }, API_REQ_TYPE.OFFERS);
|
15180
|
+
}
|
15181
|
+
|
15182
|
+
async getBuyOffers(nfTokenId, options = {}) {
|
15183
|
+
return this.#requestWithPaging({ command: 'nft_buy_offers', nft_id: nfTokenId, ledger_index: "validated", ...options }, API_REQ_TYPE.OFFERS);
|
15184
|
+
}
|
15185
|
+
|
15113
15186
|
async getLedgerEntry(index, options) {
|
15114
15187
|
const resp = (await this.#client.request({ command: 'ledger_entry', index: index, ledger_index: "validated", ...options }));
|
15115
15188
|
return resp?.result?.node;
|