starknet
Version:
JavaScript library for Starknet
1,480 lines (1,439 loc) • 684 kB
JavaScript
"use strict";
var starknet = (() => {
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
// src/index.ts
var index_exports = {};
__export(index_exports, {
Account: () => Account,
AccountInterface: () => AccountInterface,
BatchClient: () => BatchClient,
BlockStatus: () => BlockStatus,
BlockTag: () => BlockTag,
CairoCustomEnum: () => CairoCustomEnum,
CairoFixedArray: () => CairoFixedArray,
CairoOption: () => CairoOption,
CairoOptionVariant: () => CairoOptionVariant,
CairoResult: () => CairoResult,
CairoResultVariant: () => CairoResultVariant,
CairoUint256: () => CairoUint256,
CairoUint512: () => CairoUint512,
CallData: () => CallData,
Contract: () => Contract,
ContractFactory: () => ContractFactory,
ContractInterface: () => ContractInterface,
EDAMode: () => EDAMode3,
EDataAvailabilityMode: () => EDataAvailabilityMode3,
ETH_ADDRESS: () => ETH_ADDRESS,
ETransactionExecutionStatus: () => ETransactionExecutionStatus3,
ETransactionStatus: () => ETransactionStatus3,
ETransactionVersion: () => ETransactionVersion5,
ETransactionVersion2: () => ETransactionVersion23,
ETransactionVersion3: () => ETransactionVersion33,
EntryPointType: () => EntryPointType,
EthSigner: () => EthSigner,
LedgerSigner: () => LedgerSigner111,
LedgerSigner111: () => LedgerSigner111,
LedgerSigner221: () => LedgerSigner221,
LedgerSigner231: () => LedgerSigner231,
LibraryError: () => LibraryError,
Literal: () => Literal,
LogLevelIndex: () => LogLevelIndex,
NON_ZERO_PREFIX: () => NON_ZERO_PREFIX,
OutsideExecutionTypesV1: () => OutsideExecutionTypesV1,
OutsideExecutionTypesV2: () => OutsideExecutionTypesV2,
OutsideExecutionVersion: () => OutsideExecutionVersion,
PaymasterInterface: () => PaymasterInterface,
PaymasterRpc: () => PaymasterRpc,
Provider: () => RpcProvider2,
ProviderInterface: () => ProviderInterface,
RPC: () => api_exports3,
RPC07: () => rpc_0_7_1_exports,
RPC08: () => rpc_0_8_1_exports,
RPCResponseParser: () => RPCResponseParser,
ReceiptTx: () => ReceiptTx,
ResponseParser: () => ResponseParser,
RpcChannel: () => RpcChannel2,
RpcError: () => RpcError,
RpcProvider: () => RpcProvider2,
Signer: () => Signer,
SignerInterface: () => SignerInterface,
Subscription: () => Subscription,
TimeoutError: () => TimeoutError,
TransactionExecutionStatus: () => TransactionExecutionStatus,
TransactionFinalityStatus: () => TransactionFinalityStatus,
TransactionType: () => TransactionType,
TypedDataRevision: () => TypedDataRevision,
UINT_128_MAX: () => UINT_128_MAX,
UINT_128_MIN: () => UINT_128_MIN,
UINT_256_HIGH_MAX: () => UINT_256_HIGH_MAX,
UINT_256_HIGH_MIN: () => UINT_256_HIGH_MIN,
UINT_256_LOW_MAX: () => UINT_256_LOW_MAX,
UINT_256_LOW_MIN: () => UINT_256_LOW_MIN,
UINT_256_MAX: () => UINT_256_MAX,
UINT_256_MIN: () => UINT_256_MIN,
UINT_512_MAX: () => UINT_512_MAX,
UINT_512_MIN: () => UINT_512_MIN,
Uint: () => Uint,
ValidateType: () => ValidateType,
WalletAccount: () => WalletAccount,
WebSocketChannel: () => WebSocketChannel,
WebSocketNotConnectedError: () => WebSocketNotConnectedError,
addAddressPadding: () => addAddressPadding,
byteArray: () => byteArray_exports,
cairo: () => cairo_exports,
config: () => config,
constants: () => constants_exports,
contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
defaultPaymaster: () => defaultPaymaster,
defaultProvider: () => defaultProvider,
ec: () => ec_exports,
encode: () => encode_exports,
eth: () => eth_exports,
events: () => events_exports,
extractContractHashes: () => extractContractHashes,
getCalldata: () => getCalldata,
getChecksumAddress: () => getChecksumAddress,
getLedgerPathBuffer: () => getLedgerPathBuffer111,
getLedgerPathBuffer111: () => getLedgerPathBuffer111,
getLedgerPathBuffer221: () => getLedgerPathBuffer221,
hash: () => hash_exports,
isPendingBlock: () => isPendingBlock,
isPendingStateUpdate: () => isPendingStateUpdate,
isPendingTransaction: () => isPendingTransaction,
isRPC08_FeeEstimate: () => isRPC08_FeeEstimate,
isRPC08_ResourceBounds: () => isRPC08_ResourceBounds,
isSierra: () => isSierra,
isSupportedSpecVersion: () => isSupportedSpecVersion,
isV3Tx: () => isV3Tx,
isVersion: () => isVersion,
json: () => json_exports,
logger: () => logger,
merkle: () => merkle_exports,
num: () => num_exports,
outsideExecution: () => outsideExecution_exports,
parseCalldataField: () => parseCalldataField,
paymaster: () => paymaster_exports,
provider: () => provider_exports,
selector: () => selector_exports,
shortString: () => shortString_exports,
src5: () => src5_exports,
stark: () => stark_exports,
starknetId: () => starknetId_exports,
toAnyPatchVersion: () => toAnyPatchVersion,
toApiVersion: () => toApiVersion,
transaction: () => transaction_exports,
typedData: () => typedData_exports,
types: () => types_exports,
uint256: () => uint256_exports,
units: () => units,
v2hash: () => v2_exports,
v3hash: () => v3_exports,
validateAndParseAddress: () => validateAndParseAddress,
validateChecksumAddress: () => validateChecksumAddress,
wallet: () => connect_exports
});
// src/global/constants.ts
var constants_exports = {};
__export(constants_exports, {
ADDR_BOUND: () => ADDR_BOUND,
API_VERSION: () => API_VERSION,
BaseUrl: () => _BaseUrl,
DEFAULT_GLOBAL_CONFIG: () => DEFAULT_GLOBAL_CONFIG,
HARDENING_4BYTES: () => HARDENING_4BYTES,
HARDENING_BYTE: () => HARDENING_BYTE,
IS_BROWSER: () => IS_BROWSER,
MASK_250: () => MASK_250,
MASK_31: () => MASK_31,
MAX_STORAGE_ITEM_SIZE: () => MAX_STORAGE_ITEM_SIZE,
NetworkName: () => _NetworkName,
OutsideExecutionCallerAny: () => OutsideExecutionCallerAny,
PAYMASTER_RPC_NODES: () => PAYMASTER_RPC_NODES,
PRIME: () => PRIME,
RANGE_FELT: () => RANGE_FELT,
RANGE_I128: () => RANGE_I128,
RANGE_U128: () => RANGE_U128,
RPC_DEFAULT_NODES: () => RPC_DEFAULT_NODES,
SNIP9_V1_INTERFACE_ID: () => SNIP9_V1_INTERFACE_ID,
SNIP9_V2_INTERFACE_ID: () => SNIP9_V2_INTERFACE_ID,
SYSTEM_MESSAGES: () => SYSTEM_MESSAGES,
StarknetChainId: () => _StarknetChainId,
SupportedRpcVersion: () => _SupportedRpcVersion,
TEXT_TO_FELT_MAX_LEN: () => TEXT_TO_FELT_MAX_LEN,
TRANSACTION_VERSION: () => TRANSACTION_VERSION,
TransactionHashPrefix: () => _TransactionHashPrefix,
UDC: () => UDC,
ZERO: () => ZERO
});
// src/types/api/index.ts
var api_exports3 = {};
__export(api_exports3, {
ABI_TYPE_CONSTRUCTOR: () => ABI_TYPE_CONSTRUCTOR,
ABI_TYPE_ENUM: () => ABI_TYPE_ENUM,
ABI_TYPE_FUNCTION: () => ABI_TYPE_FUNCTION,
ABI_TYPE_L1_HANDLER: () => ABI_TYPE_L1_HANDLER,
API: () => api_exports2,
CALL_TYPE: () => CALL_TYPE,
CONTRACT: () => contract_exports,
EBlockTag: () => EBlockTag2,
EDAMode: () => EDAMode2,
EDataAvailabilityMode: () => EDataAvailabilityMode2,
ESimulationFlag: () => ESimulationFlag2,
ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
ETransactionStatus: () => ETransactionStatus2,
ETransactionType: () => ETransactionType2,
ETransactionVersion: () => ETransactionVersion4,
ETransactionVersion2: () => ETransactionVersion22,
ETransactionVersion3: () => ETransactionVersion32,
EVENT_ABI_TYPE: () => EVENT_ABI_TYPE,
JRPC: () => jsonrpc_exports,
L1_DA_MODE: () => L1_DA_MODE,
PAYMASTER_API: () => snip_29_exports,
PRICE_UNIT_FRI: () => PRICE_UNIT_FRI,
PRICE_UNIT_WEI: () => PRICE_UNIT_WEI,
Permission: () => Permission2,
RPCSPEC07: () => esm_exports,
RPCSPEC08: () => esm_exports2,
STATE_MUTABILITY_EXTERNAL: () => STATE_MUTABILITY_EXTERNAL,
STATE_MUTABILITY_VIEW: () => STATE_MUTABILITY_VIEW,
STATUS_ACCEPTED_ON_L1: () => STATUS_ACCEPTED_ON_L1,
STATUS_ACCEPTED_ON_L2: () => STATUS_ACCEPTED_ON_L2,
STATUS_PENDING: () => STATUS_PENDING,
STATUS_RECEIVED: () => STATUS_RECEIVED,
STATUS_REJECTED: () => STATUS_REJECTED,
STATUS_REVERTED: () => STATUS_REVERTED,
STATUS_SUCCEEDED: () => STATUS_SUCCEEDED,
STRUCT_ABI_TYPE: () => STRUCT_ABI_TYPE,
TXN_TYPE_DECLARE: () => TXN_TYPE_DECLARE,
TXN_TYPE_DEPLOY: () => TXN_TYPE_DEPLOY,
TXN_TYPE_DEPLOY_ACCOUNT: () => TXN_TYPE_DEPLOY_ACCOUNT,
TXN_TYPE_INVOKE: () => TXN_TYPE_INVOKE,
TXN_TYPE_L1_HANDLER: () => TXN_TYPE_L1_HANDLER,
TypedDataRevision: () => TypedDataRevision2,
WALLET_API: () => wallet_api_exports2
});
// src/types/api/jsonrpc/index.ts
var jsonrpc_exports = {};
// node_modules/@starknet-io/starknet-types-07/dist/esm/index.js
var esm_exports = {};
__export(esm_exports, {
API: () => api_exports,
EBlockTag: () => EBlockTag,
EDAMode: () => EDAMode,
EDataAvailabilityMode: () => EDataAvailabilityMode,
ESimulationFlag: () => ESimulationFlag,
ETransactionExecutionStatus: () => ETransactionExecutionStatus,
ETransactionFinalityStatus: () => ETransactionFinalityStatus,
ETransactionStatus: () => ETransactionStatus,
ETransactionType: () => ETransactionType,
ETransactionVersion: () => ETransactionVersion,
ETransactionVersion2: () => ETransactionVersion2,
ETransactionVersion3: () => ETransactionVersion3,
Errors: () => errors_exports,
Permission: () => Permission,
SPEC: () => components_exports,
TypedDataRevision: () => TypedDataRevision,
WALLET_API: () => wallet_api_exports
});
// node_modules/@starknet-io/starknet-types-07/dist/esm/api/index.js
var api_exports = {};
__export(api_exports, {
EBlockTag: () => EBlockTag,
EDAMode: () => EDAMode,
EDataAvailabilityMode: () => EDataAvailabilityMode,
ESimulationFlag: () => ESimulationFlag,
ETransactionExecutionStatus: () => ETransactionExecutionStatus,
ETransactionFinalityStatus: () => ETransactionFinalityStatus,
ETransactionStatus: () => ETransactionStatus,
ETransactionType: () => ETransactionType,
ETransactionVersion: () => ETransactionVersion,
ETransactionVersion2: () => ETransactionVersion2,
ETransactionVersion3: () => ETransactionVersion3,
Errors: () => errors_exports,
SPEC: () => components_exports
});
// node_modules/@starknet-io/starknet-types-07/dist/esm/api/errors.js
var errors_exports = {};
// node_modules/@starknet-io/starknet-types-07/dist/esm/api/components.js
var components_exports = {};
// node_modules/@starknet-io/starknet-types-07/dist/esm/api/nonspec.js
var ETransactionType = {
DECLARE: "DECLARE",
DEPLOY: "DEPLOY",
DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
INVOKE: "INVOKE",
L1_HANDLER: "L1_HANDLER"
};
var ESimulationFlag = {
SKIP_VALIDATE: "SKIP_VALIDATE",
SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
};
var ETransactionStatus = {
RECEIVED: "RECEIVED",
REJECTED: "REJECTED",
ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
};
var ETransactionFinalityStatus = {
ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
};
var ETransactionExecutionStatus = {
SUCCEEDED: "SUCCEEDED",
REVERTED: "REVERTED"
};
var EBlockTag = {
LATEST: "latest",
PENDING: "pending"
};
var EDataAvailabilityMode = {
L1: "L1",
L2: "L2"
};
var EDAMode = {
L1: 0,
L2: 1
};
var ETransactionVersion = {
V0: "0x0",
V1: "0x1",
V2: "0x2",
V3: "0x3",
F0: "0x100000000000000000000000000000000",
F1: "0x100000000000000000000000000000001",
F2: "0x100000000000000000000000000000002",
F3: "0x100000000000000000000000000000003"
};
var ETransactionVersion2 = {
V0: "0x0",
V1: "0x1",
V2: "0x2",
F0: "0x100000000000000000000000000000000",
F1: "0x100000000000000000000000000000001",
F2: "0x100000000000000000000000000000002"
};
var ETransactionVersion3 = {
V3: "0x3",
F3: "0x100000000000000000000000000000003"
};
// node_modules/@starknet-io/starknet-types-07/dist/esm/wallet-api/index.js
var wallet_api_exports = {};
__export(wallet_api_exports, {
Permission: () => Permission,
TypedDataRevision: () => TypedDataRevision
});
// node_modules/@starknet-io/starknet-types-07/dist/esm/wallet-api/constants.js
var Permission = {
ACCOUNTS: "accounts"
};
// node_modules/@starknet-io/starknet-types-07/dist/esm/wallet-api/typedData.js
var TypedDataRevision = {
ACTIVE: "1",
LEGACY: "0"
};
// node_modules/@starknet-io/starknet-types-08/dist/esm/index.js
var esm_exports2 = {};
__export(esm_exports2, {
ABI_TYPE_CONSTRUCTOR: () => ABI_TYPE_CONSTRUCTOR,
ABI_TYPE_ENUM: () => ABI_TYPE_ENUM,
ABI_TYPE_FUNCTION: () => ABI_TYPE_FUNCTION,
ABI_TYPE_L1_HANDLER: () => ABI_TYPE_L1_HANDLER,
API: () => api_exports2,
CALL_TYPE: () => CALL_TYPE,
CONTRACT: () => contract_exports,
EBlockTag: () => EBlockTag2,
EDAMode: () => EDAMode2,
EDataAvailabilityMode: () => EDataAvailabilityMode2,
ESimulationFlag: () => ESimulationFlag2,
ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
ETransactionStatus: () => ETransactionStatus2,
ETransactionType: () => ETransactionType2,
ETransactionVersion: () => ETransactionVersion4,
ETransactionVersion2: () => ETransactionVersion22,
ETransactionVersion3: () => ETransactionVersion32,
EVENT_ABI_TYPE: () => EVENT_ABI_TYPE,
L1_DA_MODE: () => L1_DA_MODE,
PAYMASTER_API: () => snip_29_exports,
PRICE_UNIT_FRI: () => PRICE_UNIT_FRI,
PRICE_UNIT_WEI: () => PRICE_UNIT_WEI,
Permission: () => Permission2,
STATE_MUTABILITY_EXTERNAL: () => STATE_MUTABILITY_EXTERNAL,
STATE_MUTABILITY_VIEW: () => STATE_MUTABILITY_VIEW,
STATUS_ACCEPTED_ON_L1: () => STATUS_ACCEPTED_ON_L1,
STATUS_ACCEPTED_ON_L2: () => STATUS_ACCEPTED_ON_L2,
STATUS_PENDING: () => STATUS_PENDING,
STATUS_RECEIVED: () => STATUS_RECEIVED,
STATUS_REJECTED: () => STATUS_REJECTED,
STATUS_REVERTED: () => STATUS_REVERTED,
STATUS_SUCCEEDED: () => STATUS_SUCCEEDED,
STRUCT_ABI_TYPE: () => STRUCT_ABI_TYPE,
TXN_TYPE_DECLARE: () => TXN_TYPE_DECLARE,
TXN_TYPE_DEPLOY: () => TXN_TYPE_DEPLOY,
TXN_TYPE_DEPLOY_ACCOUNT: () => TXN_TYPE_DEPLOY_ACCOUNT,
TXN_TYPE_INVOKE: () => TXN_TYPE_INVOKE,
TXN_TYPE_L1_HANDLER: () => TXN_TYPE_L1_HANDLER,
TypedDataRevision: () => TypedDataRevision2,
WALLET_API: () => wallet_api_exports2
});
// node_modules/@starknet-io/starknet-types-08/dist/esm/api/index.js
var api_exports2 = {};
__export(api_exports2, {
ABI_TYPE_CONSTRUCTOR: () => ABI_TYPE_CONSTRUCTOR,
ABI_TYPE_ENUM: () => ABI_TYPE_ENUM,
ABI_TYPE_FUNCTION: () => ABI_TYPE_FUNCTION,
ABI_TYPE_L1_HANDLER: () => ABI_TYPE_L1_HANDLER,
CALL_TYPE: () => CALL_TYPE,
CONTRACT: () => contract_exports,
EBlockTag: () => EBlockTag2,
EDAMode: () => EDAMode2,
EDataAvailabilityMode: () => EDataAvailabilityMode2,
ESimulationFlag: () => ESimulationFlag2,
ETransactionExecutionStatus: () => ETransactionExecutionStatus2,
ETransactionFinalityStatus: () => ETransactionFinalityStatus2,
ETransactionStatus: () => ETransactionStatus2,
ETransactionType: () => ETransactionType2,
ETransactionVersion: () => ETransactionVersion4,
ETransactionVersion2: () => ETransactionVersion22,
ETransactionVersion3: () => ETransactionVersion32,
EVENT_ABI_TYPE: () => EVENT_ABI_TYPE,
L1_DA_MODE: () => L1_DA_MODE,
PRICE_UNIT_FRI: () => PRICE_UNIT_FRI,
PRICE_UNIT_WEI: () => PRICE_UNIT_WEI,
STATE_MUTABILITY_EXTERNAL: () => STATE_MUTABILITY_EXTERNAL,
STATE_MUTABILITY_VIEW: () => STATE_MUTABILITY_VIEW,
STATUS_ACCEPTED_ON_L1: () => STATUS_ACCEPTED_ON_L1,
STATUS_ACCEPTED_ON_L2: () => STATUS_ACCEPTED_ON_L2,
STATUS_PENDING: () => STATUS_PENDING,
STATUS_RECEIVED: () => STATUS_RECEIVED,
STATUS_REJECTED: () => STATUS_REJECTED,
STATUS_REVERTED: () => STATUS_REVERTED,
STATUS_SUCCEEDED: () => STATUS_SUCCEEDED,
STRUCT_ABI_TYPE: () => STRUCT_ABI_TYPE,
TXN_TYPE_DECLARE: () => TXN_TYPE_DECLARE,
TXN_TYPE_DEPLOY: () => TXN_TYPE_DEPLOY,
TXN_TYPE_DEPLOY_ACCOUNT: () => TXN_TYPE_DEPLOY_ACCOUNT,
TXN_TYPE_INVOKE: () => TXN_TYPE_INVOKE,
TXN_TYPE_L1_HANDLER: () => TXN_TYPE_L1_HANDLER
});
// node_modules/@starknet-io/starknet-types-08/dist/esm/api/contract.js
var contract_exports = {};
// node_modules/@starknet-io/starknet-types-08/dist/esm/api/constants.js
var STATUS_ACCEPTED_ON_L2 = "ACCEPTED_ON_L2";
var STATUS_ACCEPTED_ON_L1 = "ACCEPTED_ON_L1";
var STATUS_SUCCEEDED = "SUCCEEDED";
var STATUS_REVERTED = "REVERTED";
var STATUS_PENDING = "PENDING";
var STATUS_REJECTED = "REJECTED";
var STATUS_RECEIVED = "RECEIVED";
var TXN_TYPE_DECLARE = "DECLARE";
var TXN_TYPE_DEPLOY = "DEPLOY";
var TXN_TYPE_DEPLOY_ACCOUNT = "DEPLOY_ACCOUNT";
var TXN_TYPE_INVOKE = "INVOKE";
var TXN_TYPE_L1_HANDLER = "L1_HANDLER";
var STRUCT_ABI_TYPE = "struct";
var EVENT_ABI_TYPE = "event";
var ABI_TYPE_FUNCTION = "function";
var ABI_TYPE_CONSTRUCTOR = "constructor";
var ABI_TYPE_L1_HANDLER = "l1_handler";
var ABI_TYPE_ENUM = "enum";
var STATE_MUTABILITY_VIEW = "view";
var STATE_MUTABILITY_EXTERNAL = "external";
var PRICE_UNIT_WEI = "WEI";
var PRICE_UNIT_FRI = "FRI";
var L1_DA_MODE = {
BLOB: "BLOB",
CALLDATA: "CALLDATA"
};
var CALL_TYPE = {
DELEGATE: "DELEGATE",
LIBRARY_CALL: "LIBRARY_CALL",
CALL: "CALL"
};
var ETransactionType2 = {
DECLARE: TXN_TYPE_DECLARE,
DEPLOY: TXN_TYPE_DEPLOY,
DEPLOY_ACCOUNT: TXN_TYPE_DEPLOY_ACCOUNT,
INVOKE: TXN_TYPE_INVOKE,
L1_HANDLER: TXN_TYPE_L1_HANDLER
};
var ESimulationFlag2 = {
SKIP_VALIDATE: "SKIP_VALIDATE",
SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
};
var ETransactionStatus2 = {
RECEIVED: STATUS_RECEIVED,
REJECTED: STATUS_REJECTED,
ACCEPTED_ON_L2: STATUS_ACCEPTED_ON_L2,
ACCEPTED_ON_L1: STATUS_ACCEPTED_ON_L1
};
var ETransactionFinalityStatus2 = {
ACCEPTED_ON_L2: STATUS_ACCEPTED_ON_L2,
ACCEPTED_ON_L1: STATUS_ACCEPTED_ON_L1
};
var ETransactionExecutionStatus2 = {
SUCCEEDED: STATUS_SUCCEEDED,
REVERTED: STATUS_REVERTED
};
var EBlockTag2 = {
LATEST: "latest",
PENDING: "pending"
};
var EDataAvailabilityMode2 = {
L1: "L1",
L2: "L2"
};
var EDAMode2 = {
L1: 0,
L2: 1
};
var ETransactionVersion4 = {
/**
* @deprecated Starknet 0.14 will not support this transaction
*/
V0: "0x0",
/**
* @deprecated Starknet 0.14 will not support this transaction
*/
V1: "0x1",
/**
* @deprecated Starknet 0.14 will not support this transaction
*/
V2: "0x2",
V3: "0x3",
/**
* @deprecated Starknet 0.14 will not support this transaction
*/
F0: "0x100000000000000000000000000000000",
/**
* @deprecated Starknet 0.14 will not support this transaction
*/
F1: "0x100000000000000000000000000000001",
/**
* @deprecated Starknet 0.14 will not support this transaction
*/
F2: "0x100000000000000000000000000000002",
F3: "0x100000000000000000000000000000003"
};
var ETransactionVersion22 = {
V0: ETransactionVersion4.V0,
V1: ETransactionVersion4.V1,
V2: ETransactionVersion4.V2,
F0: ETransactionVersion4.F0,
F1: ETransactionVersion4.F1,
F2: ETransactionVersion4.F2
};
var ETransactionVersion32 = {
V3: ETransactionVersion4.V3,
F3: ETransactionVersion4.F3
};
// node_modules/@starknet-io/starknet-types-08/dist/esm/wallet-api/index.js
var wallet_api_exports2 = {};
__export(wallet_api_exports2, {
Permission: () => Permission2,
TypedDataRevision: () => TypedDataRevision2
});
// node_modules/@starknet-io/starknet-types-08/dist/esm/wallet-api/constants.js
var Permission2 = {
ACCOUNTS: "accounts"
};
// node_modules/@starknet-io/starknet-types-08/dist/esm/wallet-api/typedData.js
var TypedDataRevision2 = {
ACTIVE: "1",
LEGACY: "0"
};
// node_modules/@starknet-io/starknet-types-08/dist/esm/snip-29/index.js
var snip_29_exports = {};
// src/utils/encode.ts
var encode_exports = {};
__export(encode_exports, {
IS_BROWSER: () => IS_BROWSER,
addHexPrefix: () => addHexPrefix,
arrayBufferToString: () => arrayBufferToString,
atobUniversal: () => atobUniversal,
btoaUniversal: () => btoaUniversal,
buf2hex: () => buf2hex,
calcByteLength: () => calcByteLength,
concatenateArrayBuffer: () => concatenateArrayBuffer,
padLeft: () => padLeft,
pascalToSnake: () => pascalToSnake,
removeHexPrefix: () => removeHexPrefix,
sanitizeBytes: () => sanitizeBytes,
sanitizeHex: () => sanitizeHex,
utf8ToArray: () => utf8ToArray
});
// node_modules/@scure/base/lib/esm/index.js
function isBytes(a) {
return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
}
function isArrayOf(isString2, arr) {
if (!Array.isArray(arr))
return false;
if (arr.length === 0)
return true;
if (isString2) {
return arr.every((item) => typeof item === "string");
} else {
return arr.every((item) => Number.isSafeInteger(item));
}
}
function astr(label, input) {
if (typeof input !== "string")
throw new Error(`${label}: string expected`);
return true;
}
function anumber(n) {
if (!Number.isSafeInteger(n))
throw new Error(`invalid integer: ${n}`);
}
function aArr(input) {
if (!Array.isArray(input))
throw new Error("array expected");
}
function astrArr(label, input) {
if (!isArrayOf(true, input))
throw new Error(`${label}: array of strings expected`);
}
function anumArr(label, input) {
if (!isArrayOf(false, input))
throw new Error(`${label}: array of numbers expected`);
}
// @__NO_SIDE_EFFECTS__
function chain(...args) {
const id = (a) => a;
const wrap = (a, b) => (c) => a(b(c));
const encode = args.map((x) => x.encode).reduceRight(wrap, id);
const decode = args.map((x) => x.decode).reduce(wrap, id);
return { encode, decode };
}
// @__NO_SIDE_EFFECTS__
function alphabet(letters) {
const lettersA = typeof letters === "string" ? letters.split("") : letters;
const len = lettersA.length;
astrArr("alphabet", lettersA);
const indexes = new Map(lettersA.map((l, i) => [l, i]));
return {
encode: (digits) => {
aArr(digits);
return digits.map((i) => {
if (!Number.isSafeInteger(i) || i < 0 || i >= len)
throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
return lettersA[i];
});
},
decode: (input) => {
aArr(input);
return input.map((letter) => {
astr("alphabet.decode", letter);
const i = indexes.get(letter);
if (i === void 0)
throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
return i;
});
}
};
}
// @__NO_SIDE_EFFECTS__
function join(separator = "") {
astr("join", separator);
return {
encode: (from) => {
astrArr("join.decode", from);
return from.join(separator);
},
decode: (to) => {
astr("join.decode", to);
return to.split(separator);
}
};
}
// @__NO_SIDE_EFFECTS__
function padding(bits, chr = "=") {
anumber(bits);
astr("padding", chr);
return {
encode(data) {
astrArr("padding.encode", data);
while (data.length * bits % 8)
data.push(chr);
return data;
},
decode(input) {
astrArr("padding.decode", input);
let end = input.length;
if (end * bits % 8)
throw new Error("padding: invalid, string should have whole number of bytes");
for (; end > 0 && input[end - 1] === chr; end--) {
const last = end - 1;
const byte = last * bits;
if (byte % 8 === 0)
throw new Error("padding: invalid, string has too much padding");
}
return input.slice(0, end);
}
};
}
var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
var powers = /* @__PURE__ */ (() => {
let res = [];
for (let i = 0; i < 40; i++)
res.push(2 ** i);
return res;
})();
function convertRadix2(data, from, to, padding2) {
aArr(data);
if (from <= 0 || from > 32)
throw new Error(`convertRadix2: wrong from=${from}`);
if (to <= 0 || to > 32)
throw new Error(`convertRadix2: wrong to=${to}`);
if (/* @__PURE__ */ radix2carry(from, to) > 32) {
throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
}
let carry = 0;
let pos = 0;
const max = powers[from];
const mask = powers[to] - 1;
const res = [];
for (const n of data) {
anumber(n);
if (n >= max)
throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
carry = carry << from | n;
if (pos + from > 32)
throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
pos += from;
for (; pos >= to; pos -= to)
res.push((carry >> pos - to & mask) >>> 0);
const pow3 = powers[pos];
if (pow3 === void 0)
throw new Error("invalid carry");
carry &= pow3 - 1;
}
carry = carry << to - pos & mask;
if (!padding2 && pos >= from)
throw new Error("Excess padding");
if (!padding2 && carry > 0)
throw new Error(`Non-zero padding: ${carry}`);
if (padding2 && pos > 0)
res.push(carry >>> 0);
return res;
}
// @__NO_SIDE_EFFECTS__
function radix2(bits, revPadding = false) {
anumber(bits);
if (bits <= 0 || bits > 32)
throw new Error("radix2: bits should be in (0..32]");
if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
throw new Error("radix2: carry overflow");
return {
encode: (bytes) => {
if (!isBytes(bytes))
throw new Error("radix2.encode input should be Uint8Array");
return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
},
decode: (digits) => {
anumArr("radix2.decode", digits);
return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
}
};
}
var base64 = /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join(""));
// src/utils/encode.ts
var IS_BROWSER = typeof window !== "undefined";
var STRING_ZERO = "0";
function arrayBufferToString(array) {
return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), "");
}
function utf8ToArray(str) {
return new TextEncoder().encode(str);
}
function atobUniversal(a) {
return base64.decode(a);
}
function btoaUniversal(b) {
return base64.encode(new Uint8Array(b));
}
function buf2hex(buffer) {
return buffer.reduce((r, x) => r + x.toString(16).padStart(2, "0"), "");
}
function removeHexPrefix(hex) {
return hex.replace(/^0x/i, "");
}
function addHexPrefix(hex) {
return `0x${removeHexPrefix(hex)}`;
}
function padString(str, length, left, padding2 = STRING_ZERO) {
const diff = length - str.length;
let result = str;
if (diff > 0) {
const pad = padding2.repeat(diff);
result = left ? pad + str : str + pad;
}
return result;
}
function padLeft(str, length, padding2 = STRING_ZERO) {
return padString(str, length, true, padding2);
}
function calcByteLength(str, byteSize = 8) {
const { length } = str;
const remainder = length % byteSize;
return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
}
function sanitizeBytes(str, byteSize = 8, padding2 = STRING_ZERO) {
return padLeft(str, calcByteLength(str, byteSize), padding2);
}
function sanitizeHex(hex) {
const hexWithoutPrefix = removeHexPrefix(hex);
const sanitizedHex = sanitizeBytes(hexWithoutPrefix, 2);
return sanitizedHex ? addHexPrefix(sanitizedHex) : sanitizedHex;
}
var pascalToSnake = (text) => /[a-z]/.test(text) ? text.split(/(?=[A-Z])/).join("_").toUpperCase() : text;
function concatenateArrayBuffer(uint8arrays) {
const totalLength = uint8arrays.reduce((total, uint8array) => total + uint8array.byteLength, 0);
const result = new Uint8Array(totalLength);
let offset = 0;
uint8arrays.forEach((uint8array) => {
result.set(uint8array, offset);
offset += uint8array.byteLength;
});
return result;
}
// src/global/constants.ts
var TEXT_TO_FELT_MAX_LEN = 31;
var { ETransactionVersion: TRANSACTION_VERSION } = esm_exports2;
var ZERO = 0n;
var MASK_250 = 2n ** 250n - 1n;
var MASK_31 = 2n ** 31n - 1n;
var API_VERSION = ZERO;
var PRIME = 2n ** 251n + 17n * 2n ** 192n + 1n;
var MAX_STORAGE_ITEM_SIZE = 256n;
var ADDR_BOUND = 2n ** 251n - MAX_STORAGE_ITEM_SIZE;
var range = (min, max) => ({ min, max });
var RANGE_FELT = range(ZERO, PRIME - 1n);
var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
var RANGE_U128 = range(ZERO, 2n ** 128n - 1n);
var UDC = {
ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
ENTRYPOINT: "deployContract"
};
var OutsideExecutionCallerAny = "0x414e595f43414c4c4552";
var SNIP9_V1_INTERFACE_ID = "0x68cfd18b92d1907b8ba3cc324900277f5a3622099431ea85dd8089255e4181";
var SNIP9_V2_INTERFACE_ID = "0x1d1144bb2138366ff28d8e9ab57456b1d332ac42196230c3a602003c89872";
var HARDENING_BYTE = 128;
var HARDENING_4BYTES = 2147483648n;
var _BaseUrl = {
SN_MAIN: "https://alpha-mainnet.starknet.io",
SN_SEPOLIA: "https://alpha-sepolia.starknet.io"
};
var _NetworkName = {
SN_MAIN: "SN_MAIN",
SN_SEPOLIA: "SN_SEPOLIA"
};
var _StarknetChainId = {
SN_MAIN: "0x534e5f4d41494e",
// encodeShortString('SN_MAIN'),
SN_SEPOLIA: "0x534e5f5345504f4c4941"
// encodeShortString('SN_SEPOLIA')
};
var _TransactionHashPrefix = {
DECLARE: "0x6465636c617265",
// encodeShortString('declare'),
DEPLOY: "0x6465706c6f79",
// encodeShortString('deploy'),
DEPLOY_ACCOUNT: "0x6465706c6f795f6163636f756e74",
// encodeShortString('deploy_account'),
INVOKE: "0x696e766f6b65",
// encodeShortString('invoke'),
L1_HANDLER: "0x6c315f68616e646c6572"
// encodeShortString('l1_handler'),
};
var _SupportedRpcVersion = {
"0.7.1": "0.7.1",
"0.8.1": "0.8.1",
v0_7_1: "0.7.1",
v0_8_1: "0.8.1"
};
var DEFAULT_GLOBAL_CONFIG = {
legacyMode: false,
rpcVersion: "0.8.1",
transactionVersion: ETransactionVersion4.V3,
logLevel: "INFO",
feeMarginPercentage: {
bounds: {
l1_gas: {
max_amount: 50,
max_price_per_unit: 50
},
l1_data_gas: {
max_amount: 50,
max_price_per_unit: 50
},
l2_gas: {
max_amount: 50,
max_price_per_unit: 50
}
},
maxFee: 50
},
fetch: void 0,
websocket: void 0
};
var RPC_DEFAULT_NODES = {
SN_MAIN: [`https://starknet-mainnet.public.blastapi.io/rpc/`],
SN_SEPOLIA: [`https://starknet-sepolia.public.blastapi.io/rpc/`]
};
var PAYMASTER_RPC_NODES = {
SN_MAIN: [`https://starknet.paymaster.avnu.fi`],
SN_SEPOLIA: [`https://sepolia.paymaster.avnu.fi`]
};
var SYSTEM_MESSAGES = {
legacyTxWarningMessage: "You are using a deprecated transaction version (V0,V1,V2)!\nUpdate to the latest V3 transactions!",
legacyTxRPC08Message: "RPC 0.8 do not support legacy transactions",
SWOldV3: "RPC 0.7 V3 tx (improper resource bounds) not supported in RPC 0.8",
channelVersionMismatch: "Channel specification version is not compatible with the connected node Specification Version",
unsupportedSpecVersion: "The connected node specification version is not supported by this library",
maxFeeInV3: "maxFee is not supported in V3 transactions, use resourceBounds instead"
};
// src/global/config.ts
var Configuration = class _Configuration {
static instance;
config;
constructor() {
this.initialize();
}
initialize() {
this.config = { ...DEFAULT_GLOBAL_CONFIG };
}
static getInstance() {
if (!_Configuration.instance) {
_Configuration.instance = new _Configuration();
}
return _Configuration.instance;
}
get(key, defaultValue) {
return this.config[key] ?? defaultValue;
}
set(key, value) {
this.config[key] = value;
}
update(configData) {
this.config = {
...this.config,
...configData
};
}
getAll() {
return { ...this.config };
}
reset() {
this.initialize();
}
delete(key) {
delete this.config[key];
}
hasKey(key) {
return key in this.config;
}
};
var config = Configuration.getInstance();
// src/global/logger.type.ts
var LogLevelIndex = {
DEBUG: 5,
INFO: 4,
WARN: 3,
ERROR: 2,
FATAL: 1,
OFF: 0
};
// src/global/logger.ts
var Logger = class _Logger {
static instance;
config;
constructor() {
this.config = config;
}
static getInstance() {
if (!_Logger.instance) {
_Logger.instance = new _Logger();
}
return _Logger.instance;
}
getTimestamp() {
return (/* @__PURE__ */ new Date()).toISOString();
}
shouldLog(messageLevel) {
const configLevel = this.config.get("logLevel", "INFO");
return messageLevel <= LogLevelIndex[configLevel];
}
formatMessage(logMessage) {
const { level, message, timestamp, data } = logMessage;
let formattedMessage = `[${timestamp}] ${level}: ${message}`;
if (data) {
try {
formattedMessage += `
${JSON.stringify(data, null, 2)}`;
} catch (error) {
formattedMessage += `
[JSON.stringify Error/Circular]: ${error}`;
}
}
return formattedMessage;
}
log(level, message, data) {
if (!this.shouldLog(LogLevelIndex[level])) {
return;
}
const logMessage = {
level,
message,
timestamp: this.getTimestamp(),
data
};
const formattedMessage = this.formatMessage(logMessage);
switch (level) {
case "DEBUG":
console.debug(formattedMessage);
break;
case "INFO":
console.info(formattedMessage);
break;
case "WARN":
console.warn(formattedMessage);
break;
case "ERROR":
case "FATAL":
console.error(formattedMessage);
break;
case "OFF":
break;
default:
console.log(formattedMessage);
break;
}
}
/**
* debug will be displayed when LogLevel level is set to DEBUG(5)
*/
debug(message, data) {
this.log("DEBUG", message, data);
}
/**
* info will be displayed when LogLevel level is set to DEBUG(5), INFO(4)
*/
info(message, data) {
this.log("INFO", message, data);
}
/**
* warn will be displayed when LogLevel level is set to DEBUG(5), INFO(4), WARN(3)
*/
warn(message, data) {
this.log("WARN", message, data);
}
/**
* error will be displayed when LogLevel level is set to DEBUG(5), INFO(4), WARN(3), ERROR(2)
*/
error(message, data) {
this.log("ERROR", message, data);
}
/**
* fatal will be displayed when LogLevel level is set to DEBUG(5), INFO(4), WARN(3), ERROR(2), FATAL(1)
*/
fatal(message, data) {
this.log("FATAL", message, data);
}
/**
* Set the logging level you would like system to display
* * 5 DEBUG - show all logs
* * 4 INFO
* * 3 WARN
* * 2 ERROR
* * 1 FATAL
* * 0 OFF - disable logs
*/
setLogLevel(level) {
this.config.set("logLevel", level);
}
getLogLevel() {
return this.config.get("logLevel", "INFO");
}
/**
*
* @returns logs levels displayed on the configured LogLevel
*/
getEnabledLogLevels() {
return Object.keys(LogLevelIndex).filter((s) => {
return this.shouldLog(LogLevelIndex[s]) && s !== "OFF";
});
}
};
var logger = Logger.getInstance();
// src/channel/rpc_0_7_1.ts
var rpc_0_7_1_exports = {};
__export(rpc_0_7_1_exports, {
RpcChannel: () => RpcChannel
});
// src/types/index.ts
var types_exports = {};
__export(types_exports, {
BlockStatus: () => BlockStatus,
BlockTag: () => BlockTag,
EDAMode: () => EDAMode3,
EDataAvailabilityMode: () => EDataAvailabilityMode3,
ETH_ADDRESS: () => ETH_ADDRESS,
ETransactionExecutionStatus: () => ETransactionExecutionStatus3,
ETransactionStatus: () => ETransactionStatus3,
ETransactionVersion: () => ETransactionVersion5,
ETransactionVersion2: () => ETransactionVersion23,
ETransactionVersion3: () => ETransactionVersion33,
EntryPointType: () => EntryPointType,
Literal: () => Literal,
NON_ZERO_PREFIX: () => NON_ZERO_PREFIX,
OutsideExecutionTypesV1: () => OutsideExecutionTypesV1,
OutsideExecutionTypesV2: () => OutsideExecutionTypesV2,
OutsideExecutionVersion: () => OutsideExecutionVersion,
RPC: () => api_exports3,
TransactionExecutionStatus: () => TransactionExecutionStatus,
TransactionFinalityStatus: () => TransactionFinalityStatus,
TransactionType: () => TransactionType,
TypedDataRevision: () => TypedDataRevision,
Uint: () => Uint,
ValidateType: () => ValidateType,
isRPC08_FeeEstimate: () => isRPC08_FeeEstimate,
isRPC08_ResourceBounds: () => isRPC08_ResourceBounds
});
// src/types/lib/contract/index.ts
var EntryPointType = {
EXTERNAL: "EXTERNAL",
L1_HANDLER: "L1_HANDLER",
CONSTRUCTOR: "CONSTRUCTOR"
};
// src/types/lib/index.ts
var TransactionType = {
DECLARE: "DECLARE",
DEPLOY: "DEPLOY",
DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
INVOKE: "INVOKE_FUNCTION"
};
var TransactionFinalityStatus = {
NOT_RECEIVED: "NOT_RECEIVED",
RECEIVED: "RECEIVED",
ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
};
var TransactionExecutionStatus = {
REJECTED: "REJECTED",
REVERTED: "REVERTED",
SUCCEEDED: "SUCCEEDED"
};
var BlockStatus = {
PENDING: "PENDING",
ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
REJECTED: "REJECTED"
};
var BlockTag = {
PENDING: "pending",
LATEST: "latest"
};
// src/provider/types/spec.type.ts
var { ETransactionVersion: ETransactionVersion5 } = esm_exports2;
var { ETransactionVersion2: ETransactionVersion23 } = esm_exports2;
var { ETransactionVersion3: ETransactionVersion33 } = esm_exports2;
var { EDataAvailabilityMode: EDataAvailabilityMode3 } = esm_exports2;
var { EDAMode: EDAMode3 } = esm_exports2;
function isRPC08_FeeEstimate(entry) {
return "l1_data_gas_consumed" in entry;
}
function isRPC08_ResourceBounds(entry) {
return "l1_data_gas" in entry;
}
var { ETransactionStatus: ETransactionStatus3 } = esm_exports2;
var { ETransactionExecutionStatus: ETransactionExecutionStatus3 } = esm_exports2;
// src/types/calldata.ts
var ValidateType = {
DEPLOY: "DEPLOY",
CALL: "CALL",
INVOKE: "INVOKE"
};
var Uint = {
u8: "core::integer::u8",
u16: "core::integer::u16",
u32: "core::integer::u32",
u64: "core::integer::u64",
u128: "core::integer::u128",
u256: "core::integer::u256",
// This one is struct
u512: "core::integer::u512"
// This one is struct
};
var Literal = {
ClassHash: "core::starknet::class_hash::ClassHash",
ContractAddress: "core::starknet::contract_address::ContractAddress",
Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point",
U96: "core::internal::bounded_int::BoundedInt::<0, 79228162514264337593543950335>"
};
var ETH_ADDRESS = "core::starknet::eth_address::EthAddress";
var NON_ZERO_PREFIX = "core::zeroable::NonZero::";
// src/types/outsideExecution.ts
var OutsideExecutionTypesV1 = {
StarkNetDomain: [
{ name: "name", type: "felt" },
{ name: "version", type: "felt" },
{ name: "chainId", type: "felt" }
],
OutsideExecution: [
{ name: "caller", type: "felt" },
{ name: "nonce", type: "felt" },
{ name: "execute_after", type: "felt" },
{ name: "execute_before", type: "felt" },
{ name: "calls_len", type: "felt" },
{ name: "calls", type: "OutsideCall*" }
],
OutsideCall: [
{ name: "to", type: "felt" },
{ name: "selector", type: "felt" },
{ name: "calldata_len", type: "felt" },
{ name: "calldata", type: "felt*" }
]
};
var OutsideExecutionTypesV2 = {
StarknetDomain: [
// SNIP-12 revision 1 is used, so should be "StarknetDomain", not "StarkNetDomain"
{ name: "name", type: "shortstring" },
{ name: "version", type: "shortstring" },
// set to 2 in v2
{ name: "chainId", type: "shortstring" },
{ name: "revision", type: "shortstring" }
],
OutsideExecution: [
{ name: "Caller", type: "ContractAddress" },
{ name: "Nonce", type: "felt" },
{ name: "Execute After", type: "u128" },
{ name: "Execute Before", type: "u128" },
{ name: "Calls", type: "Call*" }
],
Call: [
{ name: "To", type: "ContractAddress" },
{ name: "Selector", type: "selector" },
{ name: "Calldata", type: "felt*" }
]
};
var OutsideExecutionVersion = {
UNSUPPORTED: "0",
V1: "1",
V2: "2"
};
// src/utils/json.ts
var json_exports = {};
__export(json_exports, {
parse: () => parse2,
parseAlwaysAsBig: () => parseAlwaysAsBig,
stringify: () => stringify2
});
// node_modules/lossless-json/lib/esm/utils.js
function isInteger(value) {
return INTEGER_REGEX.test(value);
}
var INTEGER_REGEX = /^-?[0-9]+$/;
function isNumber(value) {
return NUMBER_REGEX.test(value);
}
var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
function isSafeNumber(value, config3) {
const num = Number.parseFloat(value);
const str = String(num);
const v = extractSignificantDigits(value);
const s = extractSignificantDigits(str);
if (v === s) {
return true;
}
if (config3?.approx === true) {
const requiredDigits = 14;
if (!isInteger(value) && s.length >= requiredDigits && v.startsWith(s.substring(0, requiredDigits))) {
return true;
}
}
return false;
}
var UnsafeNumberReason = /* @__PURE__ */ function(UnsafeNumberReason2) {
UnsafeNumberReason2["underflow"] = "underflow";
UnsafeNumberReason2["overflow"] = "overflow";
UnsafeNumberReason2["truncate_integer"] = "truncate_integer";
UnsafeNumberReason2["truncate_float"] = "truncate_float";
return UnsafeNumberReason2;
}({});
function getUnsafeNumberReason(value) {
if (isSafeNumber(value, {
approx: false
})) {
return void 0;
}
if (isInteger(value)) {
return UnsafeNumberReason.truncate_integer;
}
const num = Number.parseFloat(value);
if (!Number.isFinite(num)) {
return UnsafeNumberReason.overflow;
}
if (num === 0) {
return UnsafeNumberReason.underflow;
}
return UnsafeNumberReason.truncate_float;
}
function extractSignificantDigits(value) {
return value.replace(EXPONENTIAL_PART_REGEX, "").replace(DOT_REGEX, "").replace(TRAILING_ZEROS_REGEX, "").replace(LEADING_MINUS_AND_ZEROS_REGEX, "");
}
var EXPONENTIAL_PART_REGEX = /[eE][+-]?\d+$/;
var LEADING_MINUS_AND_ZEROS_REGEX = /^-?(0*)?/;
var DOT_REGEX = /\./;
var TRAILING_ZEROS_REGEX = /0+$/;
// node_modules/lossless-json/lib/esm/LosslessNumber.js
var LosslessNumber = class {
// numeric value as string
// type information
isLosslessNumber = true;
constructor(value) {
if (!isNumber(value)) {
throw new Error(`Invalid number (value: "${value}")`);
}
this.value = value;
}
/**
* Get the value of the LosslessNumber as number or bigint.
*
* - a number is returned for safe numbers and decimal values that only lose some insignificant digits
* - a bigint is returned for big integer numbers
* - an Error is thrown for values that will overflow or underflow
*
* Note that you can implement your own strategy for conversion by just getting the value as string
* via .toString(), and using util functions like isInteger, isSafeNumber, getUnsafeNumberReason,
* and toSafeNumberOrThrow to convert it to a numeric value.
*/
valueOf() {
const unsafeReason = getUnsafeNumberReason(this.value);
if (unsafeReason === void 0 || unsafeReason === UnsafeNumberReason.truncate_float) {
return Number.parseFloat(this.value);
}
if (isInteger(this.value)) {
return BigInt(this.value);
}
throw new Error(`Cannot safely convert to number: the value '${this.value}' would ${unsafeReason} and become ${Number.parseFloat(this.value)}`);
}
/**
* Get the value of the LosslessNumber as string.
*/
toString() {
return this.value;
}
// Note: we do NOT implement a .toJSON() method, and you should not implement
// or use that, it cannot safely turn the numeric value in the string into
// stringified JSON since it has to be parsed into a number first.
};
function isLosslessNumber(value) {
return value && typeof value === "object" && value.isLosslessNumber === true || false;
}
// node_modules/lossless-json/lib/esm/numberParsers.js
function parseLosslessNumber(value) {
return new LosslessNumber(value);
}
function parseNumberAndBigInt(value) {
return isInteger(value) ? BigInt(value) : Number.parseFloat(value);
}
// node_modules/lossless-json/lib/esm/revive.js
function revive(json, reviver) {
return reviveValue({
"": json
}, "", json, reviver);
}
function reviveValue(context, key, value, reviver) {
if (Array.isArray(value)) {
return reviver.call(context, key, reviveArray(value, reviver));
}
if (value && typeof value === "object" && !isLosslessNumber(value)) {
return reviver.call(context, key, reviveObject(value, reviver));
}
return reviver.call(context, key, value);
}
function reviveObject(object, reviver) {
for (const key of Object.keys(object)) {
const value = reviveValue(object, key, object[key], reviver);
if (value !== void 0) {
object[key] = value;
} else {
delete object[key];
}
}
return object;
}
function reviveArray(array, reviver) {
for (let i = 0; i < array.length; i++) {
array[i] = reviveValue(array, String(i), array[i], reviver);
}
return array;
}
// node_modules/lossless-json/lib/esm/parse.js
function parse(text, reviver) {
let parseNumber = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : parseLosslessNumber;
let i = 0;
const value = parseValue();
expectValue(value);
expectEndOfInput();
return reviver ? revive(value, reviver) : value;
function parseObject() {
if (text.charCodeAt(i) === codeOpeningBrace) {
i++;
skipWhitespace();
const object = {};
let initial = true;
while (i < text.length && text.charCodeAt(i) !== codeClosingBrace) {
if (!initial) {
eatComma();
skipWhitespace();
} else {
initial = false;
}
const start = i;
const key = parseString();
if (key === void 0) {
throwObjectKeyExpected();
return;
}
skipWhitespace();
eatColon();
const value2 = parseValue();
if (value2 === void 0) {
throwObjectValueExpected();
return;
}
if (Object.prototype.hasOwnProperty.call(object, key) && !isDeepEqual(value2, object[key])) {
throwDuplicateKey(key, start + 1);
}
object[key] = value2;
}
if (text.charCodeAt(i) !== codeClosingBrace) {
throwObjectKeyOrEndExpected();
}
i++;
return object;
}
}
function parseArray() {
if (text.charCodeAt(i) === codeOpeningBracket) {
i++;