starknet 6.9.0 → 6.10.1

package/dist/utils/hash/transactionHash/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateDeclareTransactionHash = calculateDeclareTransactionHash;
+exports.calculateDeployAccountTransactionHash = calculateDeployAccountTransactionHash;
+exports.calculateInvokeTransactionHash = calculateInvokeTransactionHash;
+var _api = require("../../../types/api/index.cjs");
+var _v = require("./v2.cjs");
+var _v2 = require("./v3.cjs");
+function isV3InvokeTx(args) {
+  return [_api.ETransactionVersion.V3, _api.ETransactionVersion.F3].includes(args.version);
+}
+function calculateInvokeTransactionHash(args) {
+  if (isV3InvokeTx(args)) {
+    return (0, _v2.calculateInvokeTransactionHash)(args.senderAddress, args.version, args.compiledCalldata, args.chainId, args.nonce, args.accountDeploymentData, args.nonceDataAvailabilityMode, args.feeDataAvailabilityMode, args.resourceBounds, args.tip, args.paymasterData);
+  }
+  return (0, _v.calculateTransactionHash)(args.senderAddress, args.version, args.compiledCalldata, args.maxFee, args.chainId, args.nonce);
+}
+function isV3DeclareTx(args) {
+  return [_api.ETransactionVersion.V3, _api.ETransactionVersion.F3].includes(args.version);
+}
+function calculateDeclareTransactionHash(args) {
+  if (isV3DeclareTx(args)) {
+    return (0, _v2.calculateDeclareTransactionHash)(args.classHash, args.compiledClassHash, args.senderAddress, args.version, args.chainId, args.nonce, args.accountDeploymentData, args.nonceDataAvailabilityMode, args.feeDataAvailabilityMode, args.resourceBounds, args.tip, args.paymasterData);
+  }
+  return (0, _v.calculateDeclareTransactionHash)(args.classHash, args.senderAddress, args.version, args.maxFee, args.chainId, args.nonce, args.compiledClassHash);
+}
+function isV3DeployAccountTx(args) {
+  return [_api.ETransactionVersion.V3, _api.ETransactionVersion.F3].includes(args.version);
+}
+function calculateDeployAccountTransactionHash(args) {
+  if (isV3DeployAccountTx(args)) {
+    return (0, _v2.calculateDeployAccountTransactionHash)(args.contractAddress, args.classHash, args.compiledConstructorCalldata, args.salt, args.version, args.chainId, args.nonce, args.nonceDataAvailabilityMode, args.feeDataAvailabilityMode, args.resourceBounds, args.tip, args.paymasterData);
+  }
+  return (0, _v.calculateDeployAccountTransactionHash)(args.contractAddress, args.classHash, args.constructorCalldata, args.salt, args.version, args.maxFee, args.chainId, args.nonce);
+}

package/dist/utils/hash/transactionHash/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Transaction Hash based on Transaction Version
+ */
+import { StarknetChainId } from '../../../constants';
+import { BigNumberish, Calldata } from '../../../types';
+import { EDAMode, ETransactionVersion2, ETransactionVersion3, ResourceBounds } from '../../../types/api';
+type CalcV2InvokeTxHashArgs = {
+    senderAddress: BigNumberish;
+    version: `${ETransactionVersion2}`;
+    compiledCalldata: Calldata;
+    maxFee: BigNumberish;
+    chainId: StarknetChainId;
+    nonce: BigNumberish;
+};
+type CalcV3InvokeTxHashArgs = {
+    senderAddress: BigNumberish;
+    version: `${ETransactionVersion3}`;
+    compiledCalldata: Calldata;
+    chainId: StarknetChainId;
+    nonce: BigNumberish;
+    accountDeploymentData: BigNumberish[];
+    nonceDataAvailabilityMode: EDAMode;
+    feeDataAvailabilityMode: EDAMode;
+    resourceBounds: ResourceBounds;
+    tip: BigNumberish;
+    paymasterData: BigNumberish[];
+};
+type CalcInvokeTxHashArgs = CalcV2InvokeTxHashArgs | CalcV3InvokeTxHashArgs;
+export declare function calculateInvokeTransactionHash(args: CalcInvokeTxHashArgs): string;
+type CalcV2DeclareTxHashArgs = {
+    classHash: string;
+    senderAddress: BigNumberish;
+    version: `${ETransactionVersion2}`;
+    maxFee: BigNumberish;
+    chainId: StarknetChainId;
+    nonce: BigNumberish;
+    compiledClassHash?: string;
+};
+type CalcV3DeclareTxHashArgs = {
+    classHash: string;
+    compiledClassHash: string;
+    senderAddress: BigNumberish;
+    version: `${ETransactionVersion3}`;
+    chainId: StarknetChainId;
+    nonce: BigNumberish;
+    accountDeploymentData: BigNumberish[];
+    nonceDataAvailabilityMode: EDAMode;
+    feeDataAvailabilityMode: EDAMode;
+    resourceBounds: ResourceBounds;
+    tip: BigNumberish;
+    paymasterData: BigNumberish[];
+};
+type CalcDeclareTxHashArgs = CalcV2DeclareTxHashArgs | CalcV3DeclareTxHashArgs;
+export declare function calculateDeclareTransactionHash(args: CalcDeclareTxHashArgs): string;
+type CalcV2DeployAccountTxHashArgs = {
+    contractAddress: BigNumberish;
+    classHash: BigNumberish;
+    constructorCalldata: Calldata;
+    salt: BigNumberish;
+    version: `${ETransactionVersion2}`;
+    maxFee: BigNumberish;
+    chainId: StarknetChainId;
+    nonce: BigNumberish;
+};
+type CalcV3DeployAccountTxHashArgs = {
+    contractAddress: BigNumberish;
+    classHash: BigNumberish;
+    compiledConstructorCalldata: Calldata;
+    salt: BigNumberish;
+    version: `${ETransactionVersion3}`;
+    chainId: StarknetChainId;
+    nonce: BigNumberish;
+    nonceDataAvailabilityMode: EDAMode;
+    feeDataAvailabilityMode: EDAMode;
+    resourceBounds: ResourceBounds;
+    tip: BigNumberish;
+    paymasterData: BigNumberish[];
+};
+type CalcDeployAccountTxHashArgs = CalcV2DeployAccountTxHashArgs | CalcV3DeployAccountTxHashArgs;
+export declare function calculateDeployAccountTransactionHash(args: CalcDeployAccountTxHashArgs): string;
+export {};

package/dist/utils/hash/transactionHash/index.mjs

@@ -0,0 +1,102 @@
+import {
+  ETransactionVersion
+} from "../../../types/api/index.mjs";
+import {
+  calculateDeclareTransactionHash as v2calculateDeclareTransactionHash,
+  calculateDeployAccountTransactionHash as v2calculateDeployAccountTransactionHash,
+  calculateTransactionHash as v2calculateInvokeTransactionHash
+} from "./v2.mjs";
+import {
+  calculateDeclareTransactionHash as v3calculateDeclareTransactionHash,
+  calculateDeployAccountTransactionHash as v3calculateDeployAccountTransactionHash,
+  calculateInvokeTransactionHash as v3calculateInvokeTransactionHash
+} from "./v3.mjs";
+function isV3InvokeTx(args) {
+  return [ETransactionVersion.V3, ETransactionVersion.F3].includes(args.version);
+}
+export function calculateInvokeTransactionHash(args) {
+  if (isV3InvokeTx(args)) {
+    return v3calculateInvokeTransactionHash(
+      args.senderAddress,
+      args.version,
+      args.compiledCalldata,
+      args.chainId,
+      args.nonce,
+      args.accountDeploymentData,
+      args.nonceDataAvailabilityMode,
+      args.feeDataAvailabilityMode,
+      args.resourceBounds,
+      args.tip,
+      args.paymasterData
+    );
+  }
+  return v2calculateInvokeTransactionHash(
+    args.senderAddress,
+    args.version,
+    args.compiledCalldata,
+    args.maxFee,
+    args.chainId,
+    args.nonce
+  );
+}
+function isV3DeclareTx(args) {
+  return [ETransactionVersion.V3, ETransactionVersion.F3].includes(args.version);
+}
+export function calculateDeclareTransactionHash(args) {
+  if (isV3DeclareTx(args)) {
+    return v3calculateDeclareTransactionHash(
+      args.classHash,
+      args.compiledClassHash,
+      args.senderAddress,
+      args.version,
+      args.chainId,
+      args.nonce,
+      args.accountDeploymentData,
+      args.nonceDataAvailabilityMode,
+      args.feeDataAvailabilityMode,
+      args.resourceBounds,
+      args.tip,
+      args.paymasterData
+    );
+  }
+  return v2calculateDeclareTransactionHash(
+    args.classHash,
+    args.senderAddress,
+    args.version,
+    args.maxFee,
+    args.chainId,
+    args.nonce,
+    args.compiledClassHash
+  );
+}
+function isV3DeployAccountTx(args) {
+  return [ETransactionVersion.V3, ETransactionVersion.F3].includes(args.version);
+}
+export function calculateDeployAccountTransactionHash(args) {
+  if (isV3DeployAccountTx(args)) {
+    return v3calculateDeployAccountTransactionHash(
+      args.contractAddress,
+      args.classHash,
+      args.compiledConstructorCalldata,
+      args.salt,
+      args.version,
+      args.chainId,
+      args.nonce,
+      args.nonceDataAvailabilityMode,
+      args.feeDataAvailabilityMode,
+      args.resourceBounds,
+      args.tip,
+      args.paymasterData
+    );
+  }
+  return v2calculateDeployAccountTransactionHash(
+    args.contractAddress,
+    args.classHash,
+    args.constructorCalldata,
+    args.salt,
+    args.version,
+    args.maxFee,
+    args.chainId,
+    args.nonce
+  );
+}

package/dist/utils/hash/transactionHash/v2.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateDeclareTransactionHash = calculateDeclareTransactionHash;
+exports.calculateDeployAccountTransactionHash = calculateDeployAccountTransactionHash;
+exports.calculateTransactionHash = calculateTransactionHash;
+exports.calculateTransactionHashCommon = calculateTransactionHashCommon;
+exports.computeHashOnElements = computeHashOnElements;
+var _constants = require("../../../constants.cjs");
+var _ec = require("../../ec.cjs");
+var _num = require("../../num.cjs");
+function computeHashOnElements(data) {
+  return [...data, data.length].reduce((x, y) => _ec.starkCurve.pedersen((0, _num.toBigInt)(x), (0, _num.toBigInt)(y)), 0).toString();
+}
+function calculateTransactionHashCommon(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
+  const calldataHash = computeHashOnElements(calldata);
+  const dataToHash = [txHashPrefix, version, contractAddress, entryPointSelector, calldataHash, maxFee, chainId, ...additionalData];
+  return computeHashOnElements(dataToHash);
+}
+function calculateDeclareTransactionHash(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
+  return calculateTransactionHashCommon(_constants.TransactionHashPrefix.DECLARE, version, senderAddress, 0, [classHash], maxFee, chainId, [nonce, ...(compiledClassHash ? [compiledClassHash] : [])]);
+}
+function calculateDeployAccountTransactionHash(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
+  const calldata = [classHash, salt, ...constructorCalldata];
+  return calculateTransactionHashCommon(_constants.TransactionHashPrefix.DEPLOY_ACCOUNT, version, contractAddress, 0, calldata, maxFee, chainId, [nonce]);
+}
+function calculateTransactionHash(contractAddress, version, calldata, maxFee, chainId, nonce) {
+  return calculateTransactionHashCommon(_constants.TransactionHashPrefix.INVOKE, version, contractAddress, 0, calldata, maxFee, chainId, [nonce]);
+}

package/dist/utils/hash/transactionHash/v2.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Calculate Hashes for v0 - v2 transactions
+ */
+import { StarknetChainId, TransactionHashPrefix } from '../../../constants';
+import { BigNumberish, RawCalldata } from '../../../types';
+/**
+ * Compute pedersen hash from data
+ * @returns format: hex-string - pedersen hash
+ */
+export declare function computeHashOnElements(data: BigNumberish[]): string;
+/**
+ * Calculate transaction pedersen hash for common properties
+ *
+ * Following implementation is based on this python [implementation #](https://github.com/starkware-libs/cairo-lang/blob/b614d1867c64f3fb2cf4a4879348cfcf87c3a5a7/src/starkware/starknet/core/os/transaction_hash/transaction_hash.py)
+ * @returns format: hex-string
+ */
+export declare function calculateTransactionHashCommon(txHashPrefix: TransactionHashPrefix, version: BigNumberish, contractAddress: BigNumberish, entryPointSelector: BigNumberish, calldata: RawCalldata, maxFee: BigNumberish, chainId: StarknetChainId, additionalData?: BigNumberish[]): string;
+/**
+ * Calculate declare transaction hash
+ * @param classHash hex-string
+ * @param compiledClassHash hex-string
+ * @returns format: hex-string
+ */
+export declare function calculateDeclareTransactionHash(classHash: string, senderAddress: BigNumberish, version: BigNumberish, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, compiledClassHash?: string): string;
+/**
+ * Calculate deploy_account transaction hash
+ * @returns format: hex-string
+ */
+export declare function calculateDeployAccountTransactionHash(contractAddress: BigNumberish, classHash: BigNumberish, constructorCalldata: RawCalldata, salt: BigNumberish, version: BigNumberish, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish): string;
+/**
+ * Calculate invoke transaction hash
+ * @returns format: hex-string
+ */
+export declare function calculateTransactionHash(contractAddress: BigNumberish, version: BigNumberish, calldata: RawCalldata, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish): string;

package/dist/utils/hash/transactionHash/v2.mjs

@@ -0,0 +1,57 @@
+import { TransactionHashPrefix } from "../../../constants.mjs";
+import { starkCurve } from "../../ec.mjs";
+import { toBigInt } from "../../num.mjs";
+export function computeHashOnElements(data) {
+  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
+}
+export function calculateTransactionHashCommon(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
+  const calldataHash = computeHashOnElements(calldata);
+  const dataToHash = [
+    txHashPrefix,
+    version,
+    contractAddress,
+    entryPointSelector,
+    calldataHash,
+    maxFee,
+    chainId,
+    ...additionalData
+  ];
+  return computeHashOnElements(dataToHash);
+}
+export function calculateDeclareTransactionHash(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.DECLARE,
+    version,
+    senderAddress,
+    0,
+    [classHash],
+    maxFee,
+    chainId,
+    [nonce, ...compiledClassHash ? [compiledClassHash] : []]
+  );
+}
+export function calculateDeployAccountTransactionHash(contractAddress, classHash, constructorCalldata, salt, version, maxFee, chainId, nonce) {
+  const calldata = [classHash, salt, ...constructorCalldata];
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.DEPLOY_ACCOUNT,
+    version,
+    contractAddress,
+    0,
+    calldata,
+    maxFee,
+    chainId,
+    [nonce]
+  );
+}
+export function calculateTransactionHash(contractAddress, version, calldata, maxFee, chainId, nonce) {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.INVOKE,
+    version,
+    contractAddress,
+    0,
+    calldata,
+    maxFee,
+    chainId,
+    [nonce]
+  );
+}

package/dist/utils/hash/transactionHash/v3.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateDeclareTransactionHash = calculateDeclareTransactionHash;
+exports.calculateDeployAccountTransactionHash = calculateDeployAccountTransactionHash;
+exports.calculateInvokeTransactionHash = calculateInvokeTransactionHash;
+exports.calculateTransactionHashCommon = calculateTransactionHashCommon;
+exports.hashDAMode = hashDAMode;
+exports.hashFeeField = hashFeeField;
+var _starknet = require("@scure/starknet");
+var _constants = require("../../../constants.cjs");
+var _num = require("../../num.cjs");
+var _shortString = require("../../shortString.cjs");
+const AToBI = array => array.map(it => BigInt(it));
+const DATA_AVAILABILITY_MODE_BITS = 32n;
+const MAX_AMOUNT_BITS = 64n;
+const MAX_PRICE_PER_UNIT_BITS = 128n;
+const RESOURCE_VALUE_OFFSET = MAX_AMOUNT_BITS + MAX_PRICE_PER_UNIT_BITS;
+const L1_GAS_NAME = BigInt((0, _shortString.encodeShortString)("L1_GAS"));
+const L2_GAS_NAME = BigInt((0, _shortString.encodeShortString)("L2_GAS"));
+function hashDAMode(nonceDAMode, feeDAMode) {
+  return (BigInt(nonceDAMode) << DATA_AVAILABILITY_MODE_BITS) + BigInt(feeDAMode);
+}
+function hashFeeField(tip, bounds) {
+  const L1Bound = (L1_GAS_NAME << RESOURCE_VALUE_OFFSET) + (BigInt(bounds.l1_gas.max_amount) << MAX_PRICE_PER_UNIT_BITS) + BigInt(bounds.l1_gas.max_price_per_unit);
+  const L2Bound = (L2_GAS_NAME << RESOURCE_VALUE_OFFSET) + (BigInt(bounds.l2_gas.max_amount) << MAX_PRICE_PER_UNIT_BITS) + BigInt(bounds.l2_gas.max_price_per_unit);
+  return (0, _starknet.poseidonHashMany)([BigInt(tip), L1Bound, L2Bound]);
+}
+function calculateTransactionHashCommon(txHashPrefix, version, senderAddress, chainId, nonce, tip, paymasterData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, additionalData = []) {
+  const feeFieldHash = hashFeeField(tip, resourceBounds);
+  const dAModeHash = hashDAMode(nonceDataAvailabilityMode, feeDataAvailabilityMode);
+  const dataToHash = AToBI([txHashPrefix, version, senderAddress, feeFieldHash, (0, _starknet.poseidonHashMany)(AToBI(paymasterData)), chainId, nonce, dAModeHash, ...AToBI(additionalData)]);
+  return (0, _num.toHex)((0, _starknet.poseidonHashMany)(dataToHash));
+}
+function calculateDeployAccountTransactionHash(contractAddress, classHash, compiledConstructorCalldata, salt, version, chainId, nonce, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(_constants.TransactionHashPrefix.DEPLOY_ACCOUNT, version, contractAddress, chainId, nonce, tip, paymasterData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, [(0, _starknet.poseidonHashMany)(AToBI(compiledConstructorCalldata)), classHash, salt]);
+}
+function calculateDeclareTransactionHash(classHash, compiledClassHash, senderAddress, version, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(_constants.TransactionHashPrefix.DECLARE, version, senderAddress, chainId, nonce, tip, AToBI(paymasterData), nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, [(0, _starknet.poseidonHashMany)(AToBI(accountDeploymentData)), classHash, compiledClassHash]);
+}
+function calculateInvokeTransactionHash(senderAddress, version, compiledCalldata, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(_constants.TransactionHashPrefix.INVOKE, version, senderAddress, chainId, nonce, tip, paymasterData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, [(0, _starknet.poseidonHashMany)(AToBI(accountDeploymentData)), (0, _starknet.poseidonHashMany)(AToBI(compiledCalldata))]);
+}

package/dist/utils/hash/transactionHash/v3.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Calculate Hashes for v3 transactions
+ */
+import { StarknetChainId, TransactionHashPrefix } from '../../../constants';
+import { BigNumberish, Calldata } from '../../../types';
+import { EDAMode, ResourceBounds } from '../../../types/api';
+export declare function hashDAMode(nonceDAMode: BigNumberish, feeDAMode: BigNumberish): bigint;
+export declare function hashFeeField(tip: BigNumberish, bounds: ResourceBounds): bigint;
+export declare function calculateTransactionHashCommon(txHashPrefix: TransactionHashPrefix, version: BigNumberish, senderAddress: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, tip: BigNumberish, paymasterData: BigNumberish[], nonceDataAvailabilityMode: EDAMode, feeDataAvailabilityMode: EDAMode, resourceBounds: ResourceBounds, additionalData?: BigNumberish[]): string;
+/**
+ * Calculate v3 deploy_account transaction hash
+ * @returns format: hex-string
+ */
+export declare function calculateDeployAccountTransactionHash(contractAddress: BigNumberish, classHash: BigNumberish, compiledConstructorCalldata: Calldata, salt: BigNumberish, version: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, nonceDataAvailabilityMode: EDAMode, feeDataAvailabilityMode: EDAMode, resourceBounds: ResourceBounds, tip: BigNumberish, paymasterData: BigNumberish[]): string;
+/**
+ * Calculate v3 declare transaction hash
+ * @returns format: hex-string
+ */
+export declare function calculateDeclareTransactionHash(classHash: string, compiledClassHash: string, senderAddress: BigNumberish, version: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, accountDeploymentData: BigNumberish[], nonceDataAvailabilityMode: EDAMode, feeDataAvailabilityMode: EDAMode, resourceBounds: ResourceBounds, tip: BigNumberish, paymasterData: BigNumberish[]): string;
+/**
+ * Calculate v3 invoke transaction hash
+ * @returns format: hex-string
+ */
+export declare function calculateInvokeTransactionHash(senderAddress: BigNumberish, version: BigNumberish, compiledCalldata: Calldata, chainId: StarknetChainId, nonce: BigNumberish, accountDeploymentData: BigNumberish[], nonceDataAvailabilityMode: EDAMode, feeDataAvailabilityMode: EDAMode, resourceBounds: ResourceBounds, tip: BigNumberish, paymasterData: BigNumberish[]): string;

package/dist/utils/hash/transactionHash/v3.mjs

@@ -0,0 +1,80 @@
+import { poseidonHashMany } from "@scure/starknet";
+import { TransactionHashPrefix } from "../../../constants.mjs";
+import { toHex } from "../../num.mjs";
+import { encodeShortString } from "../../shortString.mjs";
+const AToBI = (array) => array.map((it) => BigInt(it));
+const DATA_AVAILABILITY_MODE_BITS = 32n;
+const MAX_AMOUNT_BITS = 64n;
+const MAX_PRICE_PER_UNIT_BITS = 128n;
+const RESOURCE_VALUE_OFFSET = MAX_AMOUNT_BITS + MAX_PRICE_PER_UNIT_BITS;
+const L1_GAS_NAME = BigInt(encodeShortString("L1_GAS"));
+const L2_GAS_NAME = BigInt(encodeShortString("L2_GAS"));
+export function hashDAMode(nonceDAMode, feeDAMode) {
+  return (BigInt(nonceDAMode) << DATA_AVAILABILITY_MODE_BITS) + BigInt(feeDAMode);
+}
+export function hashFeeField(tip, bounds) {
+  const L1Bound = (L1_GAS_NAME << RESOURCE_VALUE_OFFSET) + (BigInt(bounds.l1_gas.max_amount) << MAX_PRICE_PER_UNIT_BITS) + BigInt(bounds.l1_gas.max_price_per_unit);
+  const L2Bound = (L2_GAS_NAME << RESOURCE_VALUE_OFFSET) + (BigInt(bounds.l2_gas.max_amount) << MAX_PRICE_PER_UNIT_BITS) + BigInt(bounds.l2_gas.max_price_per_unit);
+  return poseidonHashMany([BigInt(tip), L1Bound, L2Bound]);
+}
+export function calculateTransactionHashCommon(txHashPrefix, version, senderAddress, chainId, nonce, tip, paymasterData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, additionalData = []) {
+  const feeFieldHash = hashFeeField(tip, resourceBounds);
+  const dAModeHash = hashDAMode(nonceDataAvailabilityMode, feeDataAvailabilityMode);
+  const dataToHash = AToBI([
+    txHashPrefix,
+    version,
+    senderAddress,
+    feeFieldHash,
+    poseidonHashMany(AToBI(paymasterData)),
+    chainId,
+    nonce,
+    dAModeHash,
+    ...AToBI(additionalData)
+  ]);
+  return toHex(poseidonHashMany(dataToHash));
+}
+export function calculateDeployAccountTransactionHash(contractAddress, classHash, compiledConstructorCalldata, salt, version, chainId, nonce, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.DEPLOY_ACCOUNT,
+    version,
+    contractAddress,
+    chainId,
+    nonce,
+    tip,
+    paymasterData,
+    nonceDataAvailabilityMode,
+    feeDataAvailabilityMode,
+    resourceBounds,
+    [poseidonHashMany(AToBI(compiledConstructorCalldata)), classHash, salt]
+  );
+}
+export function calculateDeclareTransactionHash(classHash, compiledClassHash, senderAddress, version, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.DECLARE,
+    version,
+    senderAddress,
+    chainId,
+    nonce,
+    tip,
+    AToBI(paymasterData),
+    nonceDataAvailabilityMode,
+    feeDataAvailabilityMode,
+    resourceBounds,
+    [poseidonHashMany(AToBI(accountDeploymentData)), classHash, compiledClassHash]
+  );
+}
+export function calculateInvokeTransactionHash(senderAddress, version, compiledCalldata, chainId, nonce, accountDeploymentData, nonceDataAvailabilityMode, feeDataAvailabilityMode, resourceBounds, tip, paymasterData) {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.INVOKE,
+    version,
+    senderAddress,
+    chainId,
+    nonce,
+    tip,
+    paymasterData,
+    nonceDataAvailabilityMode,
+    feeDataAvailabilityMode,
+    resourceBounds,
+    [poseidonHashMany(AToBI(accountDeploymentData)), poseidonHashMany(AToBI(compiledCalldata))]
+  );
+}

package/dist/utils/json.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stringifyAlwaysAsBig = exports.stringify = exports.parseAlwaysAsBig = exports.parse = void 0;
+var json = _interopRequireWildcard(require("lossless-json"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const parseIntAsNumberOrBigInt = str => {
+  if (!json.isInteger(str)) return parseFloat(str);
+  const num = parseInt(str, 10);
+  return Number.isSafeInteger(num) ? num : BigInt(str);
+};
+const parse = str => json.parse(String(str), void 0, parseIntAsNumberOrBigInt);
+exports.parse = parse;
+const parseAlwaysAsBig = str => json.parse(String(str), void 0, json.parseNumberAndBigInt);
+exports.parseAlwaysAsBig = parseAlwaysAsBig;
+const stringify = (value, replacer, space, numberStringifiers) => json.stringify(value, replacer, space, numberStringifiers);
+exports.stringify = stringify;
+const stringifyAlwaysAsBig = exports.stringifyAlwaysAsBig = stringify;

package/dist/utils/json.d.ts

@@ -0,0 +1,50 @@
+import * as json from 'lossless-json';
+/**
+ * Convert JSON string to JSON object
+ *
+ * NOTE: the String() wrapping is used so the behavior conforms to JSON.parse()
+ * which can accept simple data types but is not represented in the default typing
+ *
+ * @param str JSON string
+ * @return {object} Parsed json object
+ * @example
+ * ```typescript
+ * const str = '[123, 12.3, 11223344556677889900]';
+ * const result = parse(str);
+ * // result = [123, 12.3, 11223344556677890048n]
+ * ```
+ */
+export declare const parse: (str: string) => any;
+/**
+ * Convert JSON string to JSON object with all numbers as bigint
+ * @param str JSON string
+ * @return {object} Parsed json object
+ * @example
+ * ```typescript
+ * const str = '[123, 12.3, 1234567890]';
+ * const result = parseAlwaysAsBig(str);
+ * // result = [123n, 12.3, 1234567890n]
+ * ```
+ */
+export declare const parseAlwaysAsBig: (str: string) => any;
+/**
+ * Convert JSON object to JSON string
+ *
+ * NOTE: the not-null assertion is used so the return type conforms to JSON.stringify()
+ * which can also return undefined but is not represented in the default typing
+ *
+ * @param value JSON object
+ * @param [replacer] Function that alters the behavior of the stringification process
+ * @param [space] Used to insert white space into the output JSON string
+ * @param [numberStringifiers] Function used to stringify numbers (returning undefined will delete the property from the object)
+ * @return {string} JSON string
+ * @example
+ * ```typescript
+ * const value = [123, 12.3, 1234567890];
+ * const result = stringify(value);
+ * // result = '[123,12.3,1234567890]'
+ * ```
+ */
+export declare const stringify: (value: unknown, replacer?: any, space?: string | number | undefined, numberStringifiers?: json.NumberStringifier[] | undefined) => string;
+/** @deprecated equivalent to 'stringify', alias will be removed */
+export declare const stringifyAlwaysAsBig: (value: unknown, replacer?: any, space?: string | number | undefined, numberStringifiers?: json.NumberStringifier[] | undefined) => string;

package/dist/utils/json.mjs

@@ -0,0 +1,10 @@
+import * as json from "lossless-json";
+const parseIntAsNumberOrBigInt = (str) => {
+  if (!json.isInteger(str)) return parseFloat(str);
+  const num = parseInt(str, 10);
+  return Number.isSafeInteger(num) ? num : BigInt(str);
+};
+export const parse = (str) => json.parse(String(str), void 0, parseIntAsNumberOrBigInt);
+export const parseAlwaysAsBig = (str) => json.parse(String(str), void 0, json.parseNumberAndBigInt);
+export const stringify = (value, replacer, space, numberStringifiers) => json.stringify(value, replacer, space, numberStringifiers);
+export const stringifyAlwaysAsBig = stringify;