@ocap/indexdb 1.28.8 → 1.29.0

package/lib/util.cjs

@@ -0,0 +1,579 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _ocap_util = require("@ocap/util");
+let _ocap_util_lib_create_sorted_list = require("@ocap/util/lib/create-sorted-list");
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+let lodash_pick = require("lodash/pick");
+lodash_pick = require_rolldown_runtime.__toESM(lodash_pick);
+let lodash_uniq = require("lodash/uniq");
+lodash_uniq = require_rolldown_runtime.__toESM(lodash_uniq);
+let lodash_uniqBy = require("lodash/uniqBy");
+lodash_uniqBy = require_rolldown_runtime.__toESM(lodash_uniqBy);
+
+//#region src/util.ts
+/**
+* Format token with metadata from token states
+* @param token - Token with address
+* @param tokenStates - Array of token states for metadata lookup
+* @param rest - Additional args for debug logging
+*/
+const formatTokenMeta = (token, tokenStates, ...rest) => {
+	if (!tokenStates) return token;
+	const tokenState = tokenStates.filter(Boolean).find((x) => x.address === token.address);
+	if (tokenState) {
+		token.decimal = tokenState.decimal;
+		token.unit = tokenState.unit;
+		token.symbol = tokenState.symbol;
+		token.icon = tokenState.icon;
+	} else console.warn("Invalid token state on formatting", token, tokenStates, ...rest);
+	return token;
+};
+/**
+* Create indexed account from account state
+*/
+const createIndexedAccount = async (x, getTokenFn) => {
+	const tasks = Object.keys(x.tokens || {}).map((address) => getTokenFn(address));
+	const tokenStates = await Promise.all(tasks);
+	return {
+		address: x.address,
+		balance: x.balance || "0",
+		moniker: x.moniker || "",
+		nonce: x.nonce ?? 0,
+		numAssets: x.numAssets ?? 0,
+		numTxs: x.numTxs ?? 0,
+		recentNumTxs: [],
+		renaissanceTime: x.context.renaissanceTime,
+		tokens: Object.keys(x.tokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: x.tokens[address]
+		}, tokenStates)),
+		genesisTime: x.context.genesisTime,
+		migratedTo: x.migratedTo?.[0] || "",
+		migratedFrom: x.migratedFrom?.[0] || ""
+	};
+};
+/**
+* Create indexed asset from asset state
+* Note: display/endpoint/data types from IAssetState may differ from TIndexedAssetState,
+* they are passed through without transformation
+*/
+const createIndexedAsset = (x) => ({
+	address: x.address,
+	issuer: x.issuer,
+	moniker: x.moniker,
+	owner: x.owner,
+	parent: x.parent,
+	readonly: x.readonly,
+	transferrable: x.transferrable,
+	ttl: String(x.ttl || 0),
+	consumedTime: x.consumedTime || "",
+	genesisTime: x.context.genesisTime,
+	renaissanceTime: x.context.renaissanceTime,
+	data: x.data,
+	display: x.display,
+	endpoint: x.endpoint,
+	tags: x.tags || []
+});
+/**
+* Create indexed delegation from delegation state
+*/
+const createIndexedDelegation = (x, ctx) => {
+	const result = {
+		address: x.address,
+		data: x.data,
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime,
+		ops: [x.ops]
+	};
+	if (x.from) result.from = x.from;
+	else if (ctx.senderState) result.from = (0, lodash_get.default)(ctx, "senderState.address", "");
+	else result.from = (0, lodash_get.default)(ctx, "tx.from", "");
+	if (x.to) result.to = x.to;
+	else if (ctx.receiverState) result.to = (0, lodash_get.default)(ctx, "receiverState.address", "");
+	else result.to = (0, lodash_get.default)(ctx, "itx.to", "");
+	return result;
+};
+/**
+* Create indexed token from token state
+* Note: foreignToken/metadata/data types from ITokenState may differ from TIndexedTokenState,
+* they are passed through without transformation
+*/
+const createIndexedToken = (x) => ({
+	address: x.address,
+	issuer: x.issuer || "",
+	name: x.name,
+	description: x.description,
+	symbol: x.symbol,
+	unit: x.unit,
+	decimal: x.decimal,
+	icon: x.icon || "",
+	website: x.website || "",
+	totalSupply: x.totalSupply,
+	initialSupply: x.initialSupply,
+	maxTotalSupply: x.maxTotalSupply || "",
+	foreignToken: x.foreignToken,
+	tokenFactoryAddress: x.tokenFactoryAddress || "",
+	metadata: x.metadata,
+	spenders: x.spenders || [],
+	minters: x.minters || [],
+	type: x.type || "",
+	data: x.data,
+	genesisTime: x.context.genesisTime,
+	renaissanceTime: x.context.renaissanceTime
+});
+/**
+* Create indexed token factory from token factory state
+* Note: token/reserveToken may not have all TIndexedTokenInput fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedTokenFactory = (tokenFactory, context) => {
+	return {
+		...(0, lodash_pick.default)(tokenFactory, [
+			"address",
+			"owner",
+			"tokenAddress",
+			"reserveAddress",
+			"curve",
+			"feeRate",
+			"currentSupply",
+			"reserveBalance",
+			"status",
+			"data"
+		]),
+		token: formatTokenMeta({ address: tokenFactory.tokenAddress }, context.itx?.token ? [context.itx.token] : []),
+		reserveToken: formatTokenMeta({ address: tokenFactory.reserveAddress }, context.config?.token ? [context.config.token] : []),
+		genesisTime: tokenFactory.context.genesisTime,
+		renaissanceTime: tokenFactory.context.renaissanceTime
+	};
+};
+/**
+* Create indexed factory from asset factory state
+* Note: tokens array may not have all TTokenMeta fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedFactory = (factory, context) => {
+	if (context.factoryTokens && context.factoryTokens.length > 0 && factory.input?.tokens) factory.input.tokens = factory.input.tokens.map((token) => formatTokenMeta(token, context.tokenStates));
+	return {
+		...(0, lodash_pick.default)(factory, [
+			"address",
+			"owner",
+			"name",
+			"description",
+			"settlement",
+			"limit",
+			"trustedIssuers",
+			"input",
+			"output",
+			"hooks",
+			"data",
+			"numMinted",
+			"lastSettlement",
+			"balance",
+			"display"
+		]),
+		tokens: Object.keys(factory.tokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: factory.tokens[address]
+		}, context.tokenStates)),
+		genesisTime: factory.context.genesisTime,
+		renaissanceTime: factory.context.renaissanceTime
+	};
+};
+/**
+* Create indexed transaction from transaction context
+* These fields are used internally to filter transactions by some entity
+*/
+const createIndexedTransaction = async (tx, ctx, indexdb) => {
+	tx.accounts = [
+		tx.tx.from,
+		tx.sender,
+		tx.receiver
+	].filter(Boolean);
+	tx.assets = [];
+	tx.tokens = [];
+	tx.factories = [];
+	tx.stakes = [];
+	tx.rollups = [];
+	tx.delegations = [];
+	tx.tokenFactories = [];
+	tx.valid = tx.code === "OK";
+	if (ctx.senderState) tx.accounts.push(ctx.senderState.address);
+	if (ctx.receiverState) tx.accounts.push(ctx.receiverState.address);
+	if (ctx.feeVaultState && ctx.feeVaultChange) tx.accounts.push(ctx.feeVaultState.address);
+	if (ctx.gasVaultState && ctx.gasVaultChange) tx.accounts.push(ctx.gasVaultState.address);
+	if (ctx.updatedAccounts && Array.isArray(ctx.updatedAccounts)) tx.accounts.push(...ctx.updatedAccounts.map((x) => x.address));
+	if (ctx.delegatorState) tx.accounts.push(ctx.delegatorState.address);
+	if (ctx.delegationState) tx.delegations.push(ctx.delegationState.address);
+	if (ctx.delegationState && ctx.txType === "fg:t:revoke_delegate") {
+		const indexed = await indexdb.delegation?.get(ctx.delegationState.address);
+		if (indexed) tx.accounts.push(indexed.to);
+	}
+	if (Array.isArray(ctx.delegatorStates)) tx.accounts.push(...ctx.delegatorStates.map((x) => x.address));
+	if (Array.isArray(ctx.signerStates)) tx.accounts.push(...ctx.signerStates.map((x) => x.address));
+	if (Array.isArray(ctx.receiverStates)) tx.accounts.push(...ctx.receiverStates.map((x) => x.address));
+	if (ctx.assetState) {
+		tx.assets.push(ctx.assetState.address);
+		if (ctx.txType === "fg:t:update_asset") tx.accounts.push(ctx.assetState.owner);
+		if (ctx.txType === "fg:t:mint_asset") tx.accounts.push(ctx.ownerAddress);
+	}
+	if (ctx.assetStates && Array.isArray(ctx.assetStates)) tx.assets.push(...ctx.assetStates.map((x) => x.address));
+	if (ctx.tokenState) tx.tokens.push(ctx.tokenState.address);
+	if (ctx.tokenStates && Array.isArray(ctx.tokenStates)) tx.tokens.push(...ctx.tokenStates.map((x) => x.address));
+	if (ctx.factoryState) tx.factories.push(ctx.factoryState.address);
+	if (ctx.stakeState) {
+		tx.stakes.push(ctx.stakeState.address);
+		if (ctx.txType === "fg:t:slash_stake") tx.accounts.push(ctx.stakeState.sender);
+		if (ctx.txType === "fg:t:return_stake") tx.accounts.push(ctx.stakeState.sender);
+	}
+	if (Array.isArray(ctx.stakeStates)) tx.stakes.push(...ctx.stakeStates.map((x) => x.address));
+	if (ctx.rollupState) tx.rollups.push(ctx.rollupState.address);
+	if (ctx.tokenFactoryState) tx.tokenFactories.push(ctx.tokenFactoryState.address);
+	const pickedFields = [
+		"address",
+		"symbol",
+		"decimal",
+		"unit"
+	];
+	if (Array.isArray(ctx.tokenStates)) tx.tokenSymbols = ctx.tokenStates.map((t) => (0, lodash_pick.default)(t, pickedFields));
+	else if (ctx.tokenState) tx.tokenSymbols = [(0, lodash_pick.default)(ctx.tokenState, pickedFields)];
+	else tx.tokenSymbols = [];
+	tx.accounts = [...tx.accounts, ...tx.stakes];
+	return tx;
+};
+/**
+* Create indexed stake from stake state
+* Note: tokens/revokedTokens arrays may not have all TTokenMeta fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedStake = async (x, ctx, indexdb) => {
+	const tokens = (0, lodash_uniq.default)(Object.keys(x.tokens || {}).concat(Object.keys(x.revokedTokens || {})));
+	const existTokenStates = ctx.tokenStates || [];
+	const missingTokenStates = await Promise.all(tokens.filter((a) => !existTokenStates.find((t) => t.address === a)).map((t) => indexdb.token?.get(t)));
+	const tokenStates = [...existTokenStates, ...missingTokenStates.filter(Boolean)];
+	return {
+		...(0, lodash_pick.default)(x, [
+			"address",
+			"sender",
+			"receiver",
+			"assets",
+			"slashers",
+			"revocable",
+			"data",
+			"nonce",
+			"message",
+			"revokeWaitingPeriod",
+			"revokedAssets"
+		]),
+		tokens: Object.keys(x.tokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: x.tokens[address]
+		}, tokenStates, x)),
+		revokedTokens: Object.keys(x.revokedTokens || {}).map((address) => formatTokenMeta({
+			address,
+			balance: x.revokedTokens[address]
+		}, tokenStates)),
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime
+	};
+};
+/**
+* Create indexed rollup from rollup state
+* Note: foreignToken from TokenStateInfo is passed through without transformation
+*/
+const createIndexedRollup = (x, ctx) => {
+	const rollup = {
+		...(0, lodash_pick.default)(x, [
+			"address",
+			"paused",
+			"closed",
+			"tokenAddress",
+			"vaultAddress",
+			"contractAddress",
+			"seedValidators",
+			"validators",
+			"minStakeAmount",
+			"maxStakeAmount",
+			"minSignerCount",
+			"maxSignerCount",
+			"minBlockSize",
+			"maxBlockSize",
+			"minBlockInterval",
+			"minBlockConfirmation",
+			"minDepositAmount",
+			"maxDepositAmount",
+			"minWithdrawAmount",
+			"maxWithdrawAmount",
+			"depositFeeRate",
+			"withdrawFeeRate",
+			"proposerFeeShare",
+			"publisherFeeShare",
+			"minDepositFee",
+			"maxDepositFee",
+			"minWithdrawFee",
+			"maxWithdrawFee",
+			"issuer",
+			"blockHeight",
+			"blockHash",
+			"leaveWaitingPeriod",
+			"publishWaitingPeriod",
+			"publishSlashRate",
+			"migrateHistory",
+			"vaultHistory",
+			"data"
+		]),
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime
+	};
+	if (ctx.tokenStates) {
+		const tokenState = ctx.tokenStates.find((t) => t.address === x.tokenAddress);
+		rollup.tokenInfo = formatTokenMeta({
+			address: x.tokenAddress,
+			value: "0"
+		}, ctx.tokenStates);
+		if (tokenState) rollup.foreignToken = tokenState.foreignToken;
+	}
+	return rollup;
+};
+/**
+* Create indexed rollup block from rollup block state
+* Note: tokenInfo may not have all TIndexedTokenInput fields filled,
+* they are populated with available metadata from context
+*/
+const createIndexedRollupBlock = (x, ctx) => {
+	const signatures = x.signaturesList || x.signatures || [];
+	return {
+		...(0, lodash_pick.default)(x, [
+			"hash",
+			"height",
+			"merkleRoot",
+			"previousHash",
+			"txsHash",
+			"txs",
+			"proposer",
+			"signatures",
+			"rollup",
+			"mintedAmount",
+			"burnedAmount",
+			"rewardAmount",
+			"minReward",
+			"governance",
+			"data"
+		]),
+		genesisTime: x.context.genesisTime,
+		renaissanceTime: x.context.renaissanceTime,
+		tokenInfo: ctx.rollupState ? formatTokenMeta({
+			address: ctx.rollupState.tokenAddress,
+			value: "0"
+		}, ctx.tokenStates) : void 0,
+		validators: signatures.map((v) => v.signer)
+	};
+};
+/**
+* Create indexed token distribution
+*/
+const createIndexedTokenDistribution = (x) => {
+	return {
+		tokenAddress: x.tokenAddress,
+		txTime: x.txTime,
+		account: x.account.toString(),
+		gas: x.gas.toString(),
+		fee: x.fee.toString(),
+		slashedVault: x.slashedVault.toString(),
+		stake: x.stake.toString(),
+		revokedStake: x.revokedStake.toString(),
+		gasStake: x.gasStake.toString()
+	};
+};
+/**
+* Format transaction before inserting to index
+*/
+const formatTxBeforeInsert = (row) => {
+	const tx = { ...row };
+	tx.sender = tx.sender || "";
+	tx.receiver = tx.receiver || "";
+	if (!tx.tx || !tx.tx.itxJson) return tx;
+	const itx = tx.tx.itxJson;
+	tx.assets = tx.assets || [];
+	if (["transfer", "transfer_v2"].includes(tx.type || "") && itx.assets) tx.assets.push(...itx.assets);
+	else if (["transfer_v3", "stake"].includes(tx.type || "") && itx.inputs) tx.assets.push(...(0, _ocap_util_lib_create_sorted_list.createSortedList)(itx.inputs.map((x) => x.assets || [])));
+	else if ([
+		"revoke_stake",
+		"slash_stake",
+		"return_stake"
+	].includes(tx.type || "") && itx.outputs) tx.assets.push(...(0, _ocap_util_lib_create_sorted_list.createSortedList)(itx.outputs.map((x) => x.assets || [])));
+	else if (["exchange", "exchange_v2"].includes(tx.type || "")) tx.assets.push(...itx.sender?.assets || [], ...itx.receiver?.assets || []);
+	else if ([
+		"create_asset",
+		"update_asset",
+		"acquire_asset_v2",
+		"mint_asset"
+	].includes(tx.type || "") && itx.address) tx.assets.push(itx.address);
+	tx.factories = tx.factories || [];
+	if ([
+		"acquire_asset_v2",
+		"acquire_asset_v3",
+		"mint_asset",
+		"create_factory"
+	].includes(tx.type || "") && itx.factory) tx.factories.push(itx.factory);
+	tx.tokens = tx.tokens || [];
+	if (tx.type === "transfer_v2" && itx.tokens) tx.tokens.push(...itx.tokens.map((x) => x.address));
+	else if (["transfer_v3", "stake"].includes(tx.type || "") && itx.inputs) tx.tokens.push(...(0, _ocap_util_lib_create_sorted_list.createSortedList)(itx.inputs.map((x) => (x.tokens || []).map((t) => t.address))));
+	else if ([
+		"revoke_stake",
+		"slash_stake",
+		"return_stake"
+	].includes(tx.type || "") && itx.outputs) tx.tokens.push(...(0, _ocap_util_lib_create_sorted_list.createSortedList)(itx.outputs.map((x) => (x.tokens || []).map((t) => t.address))));
+	else if (tx.type === "exchange_v2") tx.tokens.push(...(itx.sender?.tokens || []).map((x) => x.address), ...(itx.receiver?.tokens || []).map((x) => x.address));
+	tx.accounts = tx.accounts || [];
+	tx.stakes = tx.stakes || [];
+	tx.assets = (0, lodash_uniq.default)(tx.assets).filter(Boolean);
+	tx.factories = (0, lodash_uniq.default)(tx.factories).filter(Boolean);
+	tx.tokens = (0, lodash_uniq.default)(tx.tokens).filter(Boolean);
+	tx.accounts = (0, lodash_uniq.default)(tx.accounts).filter(Boolean);
+	tx.stakes = (0, lodash_uniq.default)(tx.stakes).filter(Boolean);
+	tx.rollups = (0, lodash_uniq.default)(tx.rollups || []).filter(Boolean);
+	tx.tokenSymbols = (0, lodash_uniqBy.default)(tx.tokenSymbols || [], "address");
+	return tx;
+};
+/**
+* Format transaction after reading from index (remove internal indexing fields)
+*/
+const formatTxAfterRead = (tx) => {
+	delete tx.assets;
+	delete tx.factories;
+	delete tx.tokens;
+	delete tx.accounts;
+	delete tx.stakes;
+	delete tx.rollups;
+	delete tx.delegations;
+	return tx;
+};
+/**
+* Format delegation after reading from index
+*/
+const formatDelegationAfterRead = (delegation) => {
+	const opsRecord = Array.isArray(delegation.ops) ? delegation.ops[0] : delegation.ops;
+	return {
+		...delegation,
+		ops: Object.keys(opsRecord).map((x) => ({
+			key: x,
+			value: opsRecord[x]
+		}))
+	};
+};
+/**
+* Parse date time string to ISO format
+*/
+const parseDateTime = (str) => {
+	if (!str) return "";
+	const parsed = Date.parse(str);
+	if (Number.isNaN(parsed)) return "";
+	return new Date(parsed).toISOString();
+};
+const PAGE_SIZE_DEFAULT = 20;
+const PAGE_SIZE_MAX = 100;
+/**
+* Format pagination parameters with defaults
+*/
+const formatPagination = ({ paging, defaultSortField, supportedSortFields = [] }) => {
+	if (!defaultSortField) throw new Error("argument defaultSortField is required");
+	const pagination = {
+		size: paging?.size ?? PAGE_SIZE_DEFAULT,
+		cursor: typeof paging?.cursor === "number" ? paging.cursor : Number(paging?.cursor) || 0,
+		order: {
+			field: defaultSortField,
+			type: "desc"
+		}
+	};
+	let inputOrder = paging?.order;
+	if (Array.isArray(inputOrder)) inputOrder = inputOrder[0];
+	if (inputOrder?.field) pagination.order.field = inputOrder.field;
+	if (supportedSortFields.length > 0 && !supportedSortFields.includes(pagination.order.field)) pagination.order.field = defaultSortField;
+	if (inputOrder?.type) pagination.order.type = inputOrder.type;
+	pagination.size = Math.min(pagination.size, PAGE_SIZE_MAX);
+	return pagination;
+};
+/**
+* Format next pagination info for response
+*/
+const formatNextPagination = (total, pagination) => {
+	const nextCursor = pagination.cursor + pagination.size;
+	if (total > nextCursor) return {
+		cursor: String(nextCursor),
+		next: true,
+		total
+	};
+	return {
+		cursor: "0",
+		next: false,
+		total
+	};
+};
+/**
+* Check if a transaction changes the default token balance
+*/
+const isDefaultTokenChanged = (tx, token) => {
+	const itx = tx.tx.itxJson;
+	if ([
+		"fg:t:transfer",
+		"fg:t:transfer_v2",
+		"fg:t:transfer_v3",
+		"fg:t:acquire_asset_v2",
+		"fg:t:acquire_asset_v3",
+		"fg:t:exchange",
+		"fg:t:exchange_v2",
+		"fg:t:deposit_token",
+		"fg:t:withdraw_token",
+		"fg:t:faucet",
+		"fg:t:poke",
+		"fg:t:setup_swap",
+		"fg:t:retrieve_swap",
+		"fg:t:stake",
+		"fg:t:revoke_stake"
+	].includes(itx.type_url || "") === false) return false;
+	const ZERO = new _ocap_util.BN(0);
+	const isDefaultToken = (id) => [token.address, ""].includes(id);
+	const isPositive = (v) => new _ocap_util.BN(v || 0).gt(ZERO);
+	const isChangedByInput = (input) => isPositive(input.value) || (input.tokens?.some((x) => isDefaultToken(x.address) && isPositive(x.value)) ?? false);
+	switch (itx.type_url) {
+		case "fg:t:transfer": return isPositive(itx.value);
+		case "fg:t:transfer_v2": return isChangedByInput(itx);
+		case "fg:t:transfer_v3":
+		case "fg:t:acquire_asset_v3": return (itx.inputs || []).some((input) => isChangedByInput(input));
+		case "fg:t:acquire_asset_v2": return (tx.receipts || []).some((r) => r.changes.some((c) => isDefaultToken(c.target) && isPositive(c.value)));
+		case "fg:t:exchange": return isPositive(itx.sender?.value) || isPositive(itx.receiver?.value);
+		case "fg:t:exchange_v2": return isChangedByInput(itx.sender || {}) || isChangedByInput(itx.receiver || {});
+		case "fg:t:deposit_token":
+		case "fg:t:withdraw_token": return isPositive(itx.value);
+		case "fg:t:setup_swap":
+		case "fg:t:retrieve_swap": return isPositive(itx.value);
+		case "fg:t:poke": return true;
+		case "fg:t:faucet": return !itx.token;
+		case "fg:t:stake": return (itx.inputs || []).some((input) => isChangedByInput(input));
+		case "fg:t:revoke_stake":
+		case "fg:t:slash_stake":
+		case "fg:t:return_stake": return (itx.outputs || []).some((output) => isChangedByInput(output));
+		default: return false;
+	}
+};
+
+//#endregion
+exports.createIndexedAccount = createIndexedAccount;
+exports.createIndexedAsset = createIndexedAsset;
+exports.createIndexedDelegation = createIndexedDelegation;
+exports.createIndexedFactory = createIndexedFactory;
+exports.createIndexedRollup = createIndexedRollup;
+exports.createIndexedRollupBlock = createIndexedRollupBlock;
+exports.createIndexedStake = createIndexedStake;
+exports.createIndexedToken = createIndexedToken;
+exports.createIndexedTokenDistribution = createIndexedTokenDistribution;
+exports.createIndexedTokenFactory = createIndexedTokenFactory;
+exports.createIndexedTransaction = createIndexedTransaction;
+exports.formatDelegationAfterRead = formatDelegationAfterRead;
+exports.formatNextPagination = formatNextPagination;
+exports.formatPagination = formatPagination;
+exports.formatTokenMeta = formatTokenMeta;
+exports.formatTxAfterRead = formatTxAfterRead;
+exports.formatTxBeforeInsert = formatTxBeforeInsert;
+exports.isDefaultTokenChanged = isDefaultTokenChanged;
+exports.parseDateTime = parseDateTime;