starknet 11.1.0 → 11.2.0

package/dist/index.mjs

@@ -48,6 +48,7 @@ __export(constants_exports, {
   RANGE_I32: () => RANGE_I32,
   RANGE_I64: () => RANGE_I64,
   RANGE_I8: () => RANGE_I8,
+  RANGE_STORAGE_ADDRESS: () => RANGE_STORAGE_ADDRESS,
   RANGE_U128: () => RANGE_U128,
   RANGE_U16: () => RANGE_U16,
   RANGE_U32: () => RANGE_U32,
@@ -280,6 +281,7 @@ var RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
 var RANGE_ETH_ADDRESS = range(ZERO, 2n ** 160n - 1n);
 var RANGE_CONTRACT_ADDRESS = range(ZERO, ADDR_BOUND - 1n);
 var RANGE_CLASS_HASH = range(ZERO, 2n ** 251n - 1n);
+var RANGE_STORAGE_ADDRESS = range(ZERO, 2n ** 251n - 1n);
 var LegacyUDC = {
   ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
   ENTRYPOINT: "deployContract"
@@ -961,6 +963,7 @@ var Literal = {
   ClassHash: "core::starknet::class_hash::ClassHash",
   ContractAddress: "core::starknet::contract_address::ContractAddress",
   Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point",
+  StorageAddress: "core::starknet::storage_access::StorageAddress",
   U96: "core::internal::bounded_int::BoundedInt::<0, 79228162514264337593543950335>"
 };
 var ETH_ADDRESS = "core::starknet::eth_address::EthAddress";
@@ -8074,6 +8077,169 @@ var CairoContractAddress = class _CairoContractAddress {
   }
 };
 
+// src/utils/cairoDataTypes/storageAddress.ts
+var CairoStorageAddress = class _CairoStorageAddress {
+  /**
+   * The address, always as a bigint.
+   * @example
+   * ```typescript
+   * const result = new CairoStorageAddress('0x1234').data;
+   * // result = 4660n
+   * ```
+   */
+  data;
+  /**
+   * The abi type this class serializes.
+   * @example
+   * ```typescript
+   * const result = CairoStorageAddress.abiSelector;
+   * // result = "core::starknet::storage_access::StorageAddress"
+   * ```
+   */
+  static abiSelector = Literal.StorageAddress;
+  /**
+   * Build from a number or a numeric string, refusing text and anything outside the
+   * StorageAddress range.
+   * @param {BigNumberish | boolean} data the address to carry, within [0, 2^251 - 1]
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the StorageAddress range
+   * @example
+   * ```typescript
+   * const result = new CairoStorageAddress('0x1234').toApiRequest();
+   * // result = ["4660"]
+   * ```
+   */
+  constructor(data) {
+    _CairoStorageAddress.validate(data);
+    this.data = new CairoFelt252(data).toBigInt();
+  }
+  /**
+   * Serialize to the single felt a contract call carries.
+   * @returns {string[]} one decimal-string felt, flagged as compiled
+   * @example
+   * ```typescript
+   * const result = new CairoStorageAddress('0x1234').toApiRequest();
+   * // result = ["4660"]
+   * ```
+   */
+  toApiRequest() {
+    return addCompiledFlag([this.toBigInt().toString()]);
+  }
+  /**
+   * The address as a number.
+   * @returns {bigint} the number this address holds
+   * @example
+   * ```typescript
+   * const result = new CairoStorageAddress('0x1234').toBigInt();
+   * // result = 4660n
+   * ```
+   */
+  toBigInt() {
+    return this.data;
+  }
+  /**
+   * The address in hexadecimal, without padding.
+   *
+   * Leading zeros are dropped, as they are everywhere else in the library.
+   * @returns {string} the address as a 0x-prefixed hex string
+   * @example
+   * ```typescript
+   * const result = new CairoStorageAddress(4660).toHexString();
+   * // result = "0x1234"
+   * const result2 = new CairoStorageAddress('0x0034').toHexString();
+   * // result2 = "0x34"     (four digits in, two out)
+   * ```
+   */
+  toHexString() {
+    return addHexPrefix(this.toBigInt().toString(16));
+  }
+  /**
+   * Throw unless the value can be carried by a StorageAddress.
+   *
+   * Text is refused first, then a number with a decimal part. A number or a bigint is read as it
+   * is, so that a negative one reaches the range check. Anything else is read as a felt252 — which
+   * is what refuses a null, an object or an unsupported type. The value is finally checked against
+   * the range of the Cairo `StorageAddress` type, [0, 2^251), which is narrower than the field.
+   * @param {BigNumberish | boolean} data the value to check
+   * @throws {Error} when the value is text, a decimal number, not a felt252 input, or out of the StorageAddress range
+   * @example
+   * ```typescript
+   * CairoStorageAddress.validate('0x1234'); // passes
+   * CairoStorageAddress.validate('abc');
+   * // throws Error("Invalid input: a StorageAddress cannot be built from text")
+   * CairoStorageAddress.validate(2n ** 251n);
+   * // throws Error("Value is out of StorageAddress range [0, 3618502788666131106986593281521497120414687020801267626233049500247285301247]")
+   * CairoStorageAddress.validate(-1);
+   * // throws Error("Value is out of StorageAddress range [0, 3618502788666131106986593281521497120414687020801267626233049500247285301247]")
+   * ```
+   */
+  static validate(data) {
+    assert(!isText(data), "Invalid input: a StorageAddress cannot be built from text");
+    assert(
+      !isNumber(data) || Number.isInteger(data),
+      "Invalid input: decimal numbers are not supported, only integers"
+    );
+    const value = isNumber(data) || isBigInt(data) ? BigInt(data) : new CairoFelt252(data).toBigInt();
+    assert(
+      value >= RANGE_STORAGE_ADDRESS.min && value <= RANGE_STORAGE_ADDRESS.max,
+      `Value is out of StorageAddress range [${RANGE_STORAGE_ADDRESS.min}, ${RANGE_STORAGE_ADDRESS.max}]`
+    );
+  }
+  /**
+   * Can this value be carried by a StorageAddress?
+   *
+   * The non-throwing form of {@link CairoStorageAddress.validate}, so it answers false for every
+   * input that one refuses, whatever the reason.
+   * @param {BigNumberish | boolean} data the value to test
+   * @returns {boolean} true when the value fits in a StorageAddress
+   * @example
+   * ```typescript
+   * const result = CairoStorageAddress.is('0x1234');
+   * // result = true
+   * const result2 = CairoStorageAddress.is('abc');
+   * // result2 = false     (text, not a number)
+   * ```
+   */
+  static is(data) {
+    try {
+      _CairoStorageAddress.validate(data);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Is this abi type the one this class serializes?
+   * @param {string} abiType the abi type to test
+   * @returns {boolean} true for `core::starknet::storage_access::StorageAddress`
+   * @example
+   * ```typescript
+   * const result = CairoStorageAddress.isAbiType(
+   *   'core::starknet::storage_access::StorageAddress'
+   * );
+   * // result = true
+   * const result2 = CairoStorageAddress.isAbiType('core::felt252');
+   * // result2 = false
+   * ```
+   */
+  static isAbiType(abiType) {
+    return abiType === _CairoStorageAddress.abiSelector;
+  }
+  /**
+   * Read one StorageAddress off a contract response, advancing the iterator past it.
+   * @param {Iterator<string>} responseIterator the response felts, positioned on this address
+   * @returns {CairoStorageAddress} the address that was read
+   * @example
+   * ```typescript
+   * const response = ['0x1234'];
+   * const result = CairoStorageAddress.factoryFromApiResponse(response.values()).toBigInt();
+   * // result = 4660n
+   * ```
+   */
+  static factoryFromApiResponse(responseIterator) {
+    return new _CairoStorageAddress(getNext(responseIterator));
+  }
+};
+
 // src/utils/cairoDataTypes/ethAddress.ts
 var CairoEthAddress = class _CairoEthAddress {
   /**
@@ -10480,6 +10646,7 @@ var LEAF_TYPES = [
   CairoEthAddress,
   CairoClassHash,
   CairoContractAddress,
+  CairoStorageAddress,
   CairoBytes31,
   CairoByteArray,
   CairoSecp256k1Point,
@@ -10553,6 +10720,7 @@ var cairoTypeStrategy = {
     [CairoEthAddress.abiSelector]: (instance) => instance.toBigInt(),
     [CairoClassHash.abiSelector]: (instance) => instance.toBigInt(),
     [CairoContractAddress.abiSelector]: (instance) => instance.toBigInt(),
+    [CairoStorageAddress.abiSelector]: (instance) => instance.toBigInt(),
     [CairoBytes31.abiSelector]: (instance) => instance.decodeUtf8(),
     [CairoByteArray.abiSelector]: (instance) => instance.decodeUtf8(),
     [CairoSecp256k1Point.abiSelector]: (instance) => instance.toBigInt(),
@@ -17332,6 +17500,9 @@ if (typeof Symbol.dispose !== "undefined") {
   WebSocketProvider.prototype[Symbol.dispose] = WebSocketProvider.prototype.dispose;
 }
 
+// src/provider/index.ts
+var Provider = RpcProvider;
+
 // src/signer/interface.ts
 var SignerInterface = class {
 };
@@ -17799,13 +17970,13 @@ var LedgerSigner221 = class extends LedgerSigner111 {
    *
    * If you are using APP v2.2.1 with an account created with the v1.1.1, you need to use :
    * ```typescript
-   * const myLedgerSigner = new LedgerSigner211(myNodeTransport, 0, undefined, getLedgerPathBuffer111);
+   * const myLedgerSigner = new LedgerSigner221(myNodeTransport, 0, undefined, getLedgerPathBuffer111);
    * ```
    * @example
    * ```typescript
    * import TransportNodeHid from "@ledgerhq/hw-transport-node-hid";
    * const myNodeTransport = await TransportNodeHid.create();
-   * const myLedgerSigner = new LedgerSigner211(myNodeTransport, 0);
+   * const myLedgerSigner = new LedgerSigner221(myNodeTransport, 0);
    * ```
    */
   constructor(transport, accountID, eip2645application = "LedgerW", pathFunction = getLedgerPathBuffer221) {
@@ -21322,6 +21493,7 @@ export {
   CairoResult,
   CairoResultVariant,
   CairoSecp256k1Point,
+  CairoStorageAddress,
   CairoStruct,
   CairoTuple,
   CairoTypeCustomEnum,
@@ -21368,7 +21540,7 @@ export {
   PaymasterInterface,
   PaymasterRpc,
   PluginManager,
-  RpcProvider as Provider,
+  Provider,
   ProviderInterface,
   api_exports as RPC,
   v0_10_2_exports as RPC0102,