cairo-lang 0.13.0a1__zip → 0.13.0a3__zip

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.13.0a1
+Version: 0.13.0a3
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/cairo_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.13.0a1
+Version: 0.13.0a3
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/services/external_api/client.py

@@ -116,9 +116,11 @@ class ClientBase(HasUriPrefix):
         retry_config: Optional[RetryConfig] = None,
         request_timeout: Optional[int] = None,
         headers: Optional[Mapping[str, str]] = None,
+        log_errors: bool = True,
     ):
         self.url = url
         self.ssl_context: Optional[ssl.SSLContext] = None
+        self.log_errors = log_errors
 
         self.retry_config = RetryConfig() if retry_config is None else retry_config
         assert (
@@ -216,7 +218,8 @@ class ClientBase(HasUriPrefix):
                         f"{error_message} "
                         f"Status code: {exception.status_code}; text: {exception.text}."
                     )
-                    logger.error(full_error_message, exc_info=True)
+                    if self.log_errors:
+                        logger.error(full_error_message, exc_info=True)
                     raise
 
                 logger.debug(f"{error_message}, retrying...")
@@ -224,7 +227,8 @@ class ClientBase(HasUriPrefix):
                 error_message = f"Got {type(exception).__name__} while trying to access {url}."
 
                 if limited_retries and n_retries_left == 0:
-                    logger.error(error_message, exc_info=True)
+                    if self.log_errors:
+                        logger.error(error_message, exc_info=True)
                     raise
 
                 logger.debug(f"{error_message}, retrying...")

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/starkware/cairo/common/cairo_secp/ec.cairo

@@ -1,3 +1,4 @@
+from starkware.cairo.common.alloc import alloc
 from starkware.cairo.common.cairo_secp.bigint import nondet_bigint3
 from starkware.cairo.common.cairo_secp.bigint3 import BigInt3, SumBigInt3, UnreducedBigInt3
 from starkware.cairo.common.cairo_secp.ec_point import EcPoint
@@ -7,6 +8,7 @@ from starkware.cairo.common.cairo_secp.field import (
     unreduced_sqr,
     verify_zero,
 )
+from starkware.cairo.common.math import assert_nn_le
 from starkware.cairo.common.uint256 import Uint256
 
 // Computes the negation of a point on the elliptic curve, which is a point with the same x value
@@ -318,7 +320,104 @@ func ec_mul{range_check_ptr}(point: EcPoint, scalar: BigInt3) -> (res: EcPoint)
 // Given a point and a 256-bit scalar, returns scalar * point.
 func ec_mul_by_uint256{range_check_ptr}(point: EcPoint, scalar: Uint256) -> (res: EcPoint) {
     alloc_locals;
-    let (pow2_0: EcPoint, local res0: EcPoint) = ec_mul_inner(point, scalar.low, 128);
-    let (pow2_1: EcPoint, res1: EcPoint) = ec_mul_inner(pow2_0, scalar.high, 128);
-    return ec_add(res0, res1);
+    let (local table: EcPoint*) = alloc();
+    build_ec_mul_table(point, table);
+
+    local first_nibble;
+    local last_nibble;
+    %{
+        num = (ids.scalar.high << 128) + ids.scalar.low
+        nibbles = [(num >> i) & 0xf for i in range(0, 256, 4)]
+        ids.first_nibble = nibbles.pop()
+        ids.last_nibble = nibbles[0]
+    %}
+    assert_nn_le(first_nibble, 15);
+    let (res, scalar_high) = fast_ec_mul_inner(table, table[first_nibble], first_nibble, 124);
+    assert scalar_high = scalar.high;
+
+    // The last addition must be done with `ec_add` rather then `fast_ec_add` so we do it
+    // separately from the rest of the additions in `fast_ec_mul_inner`.
+    let (res, scalar_low) = fast_ec_mul_inner(table, res, 0, 124);
+    assert scalar.low = 16 * scalar_low + last_nibble;
+    assert_nn_le(last_nibble, 15);
+    let (res) = ec_double(res);
+    let (res) = ec_double(res);
+    let (res) = ec_double(res);
+    let (res) = ec_double(res);
+    return ec_add(res, table[last_nibble]);
+}
+
+// Given a point on the curve computes a table of size 16 where table[i] = i * point.
+// The table is allocated in the caller to avoid local variables in this function.
+func build_ec_mul_table{range_check_ptr}(point: EcPoint, table: EcPoint*) {
+    assert table[0] = EcPoint(BigInt3(0, 0, 0), BigInt3(0, 0, 0));
+    assert table[1] = point;
+    let (t2) = ec_double(point);
+    assert table[2] = t2;
+    let (t3) = fast_ec_add(t2, point);
+    assert table[3] = t3;
+    let (t4) = fast_ec_add(t3, point);
+    assert table[4] = t4;
+    let (t5) = fast_ec_add(t4, point);
+    assert table[5] = t5;
+    let (t6) = fast_ec_add(t5, point);
+    assert table[6] = t6;
+    let (t7) = fast_ec_add(t6, point);
+    assert table[7] = t7;
+    let (t8) = fast_ec_add(t7, point);
+    assert table[8] = t8;
+    let (t9) = fast_ec_add(t8, point);
+    assert table[9] = t9;
+    let (t10) = fast_ec_add(t9, point);
+    assert table[10] = t10;
+    let (t11) = fast_ec_add(t10, point);
+    assert table[11] = t11;
+    let (t12) = fast_ec_add(t11, point);
+    assert table[12] = t12;
+    let (t13) = fast_ec_add(t12, point);
+    assert table[13] = t13;
+    let (t14) = fast_ec_add(t13, point);
+    assert table[14] = t14;
+    let (t15) = fast_ec_add(t14, point);
+    assert table[15] = t15;
+
+    return ();
+}
+
+// An inner helper function for ec_mul_by_uint256.
+// The function gets a table (see `build_ec_mul_table`) for some point `P`, a point `point` and two
+// scalars 'scalar' and 'm' and a hint variable nibbles (represented as a list of nibbles where the
+// last one is the most significant).
+// It verifies that 0 <= nibbles < 2**m.
+// It returns a point 'point_out' and a scalar 'scalar_out' such that:
+//   scalar_out = scalar * 2**m + nibbles,
+//   point_out = point * 2**m + P * nibbles.
+// The caller must add a constraint that `scalar_out` was constructed correctly.
+// Assumption: `point = i * P` for some `0 <= i < 2**248`.
+func fast_ec_mul_inner{range_check_ptr}(table: EcPoint*, point: EcPoint, scalar: felt, m: felt) -> (
+    point_out: EcPoint, scalar_out: felt
+) {
+    alloc_locals;
+    if (m == 0) {
+        return (point, scalar);
+    }
+
+    // Compute 16 * point.
+    let (point) = ec_double(point);
+    let (point) = ec_double(point);
+    let (point) = ec_double(point);
+    let (point) = ec_double(point);
+
+    local nibble = nondet %{ nibbles.pop() %};
+    assert_nn_le(nibble, 15);
+
+    // Note that we can use `fast_ec_add` instead of `ec_add`:
+    // Assume that `16 * point = +/- nibble * P` and `nibble * P != 0`.
+    // This implies `16 * i + nibble = 0 (mod N)` or `16 * i - nibble = 0 (mod N)`
+    // where `N` is the size of the elliptic curve.
+    // Since `i < 2**248`, `16 * i < 2**252` and so one of the equalities must be true as integers.
+    // But `16 * i + nibble > 0` and `16 * i != nibble` since `1 <= nibble <= 15`.
+    let (point) = fast_ec_add(point, table[nibble]);
+
+    return fast_ec_mul_inner(table=table, point=point, scalar=16 * scalar + nibble, m=m - 4);
 }

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/starkware/cairo/common/secp256r1/ec.cairo

@@ -1,3 +1,4 @@
+from starkware.cairo.common.alloc import alloc
 from starkware.cairo.common.cairo_secp.bigint3 import BigInt3, SumBigInt3, UnreducedBigInt3
 from starkware.cairo.common.cairo_secp.ec_point import EcPoint
 from starkware.cairo.common.math import assert_nn, assert_nn_le
@@ -319,9 +320,31 @@ func ec_mul{range_check_ptr}(point: EcPoint, scalar: BigInt3) -> (res: EcPoint)
 // Given a point and a 256-bit scalar, returns scalar * point.
 func ec_mul_by_uint256{range_check_ptr}(point: EcPoint, scalar: Uint256) -> (res: EcPoint) {
     alloc_locals;
-    let (pow2_0: EcPoint, local res0: EcPoint) = ec_mul_inner(point, scalar.low, 128);
-    let (pow2_1: EcPoint, res1: EcPoint) = ec_mul_inner(pow2_0, scalar.high, 128);
-    return ec_add(res0, res1);
+    let (local table: EcPoint*) = alloc();
+    build_ec_mul_table(point, table);
+
+    local first_nibble;
+    local last_nibble;
+    %{
+        num = (ids.scalar.high << 128) + ids.scalar.low
+        nibbles = [(num >> i) & 0xf for i in range(0, 256, 4)]
+        ids.first_nibble = nibbles.pop()
+        ids.last_nibble = nibbles[0]
+    %}
+    assert_nn_le(first_nibble, 15);
+    let (res, scalar_high) = fast_ec_mul_inner(table, table[first_nibble], first_nibble, 124);
+    assert scalar_high = scalar.high;
+
+    // The last addition must be done with `ec_add` rather then `fast_ec_add` so we do it
+    // separately from the rest of the additions in `fast_ec_mul_inner`.
+    let (res, scalar_low) = fast_ec_mul_inner(table, res, 0, 124);
+    assert scalar.low = 16 * scalar_low + last_nibble;
+    assert_nn_le(last_nibble, 15);
+    let (res) = ec_double(res);
+    let (res) = ec_double(res);
+    let (res) = ec_double(res);
+    let (res) = ec_double(res);
+    return ec_add(res, table[last_nibble]);
 }
 
 // Returns a point on the secp256r1 curve with the given x coordinate. Chooses the y that has the
@@ -407,3 +430,78 @@ func try_get_point_from_x{range_check_ptr}(x: BigInt3, v: felt, result: EcPoint*
         return (is_on_curve=0);
     }
 }
+
+// Given a point on the curve computes a table of size 16 where table[i] = i * point.
+// The table is allocated in the caller to avoid local variables in this function.
+func build_ec_mul_table{range_check_ptr}(point: EcPoint, table: EcPoint*) {
+    assert table[0] = EcPoint(BigInt3(0, 0, 0), BigInt3(0, 0, 0));
+    assert table[1] = point;
+    let (t2) = ec_double(point);
+    assert table[2] = t2;
+    let (t3) = fast_ec_add(t2, point);
+    assert table[3] = t3;
+    let (t4) = fast_ec_add(t3, point);
+    assert table[4] = t4;
+    let (t5) = fast_ec_add(t4, point);
+    assert table[5] = t5;
+    let (t6) = fast_ec_add(t5, point);
+    assert table[6] = t6;
+    let (t7) = fast_ec_add(t6, point);
+    assert table[7] = t7;
+    let (t8) = fast_ec_add(t7, point);
+    assert table[8] = t8;
+    let (t9) = fast_ec_add(t8, point);
+    assert table[9] = t9;
+    let (t10) = fast_ec_add(t9, point);
+    assert table[10] = t10;
+    let (t11) = fast_ec_add(t10, point);
+    assert table[11] = t11;
+    let (t12) = fast_ec_add(t11, point);
+    assert table[12] = t12;
+    let (t13) = fast_ec_add(t12, point);
+    assert table[13] = t13;
+    let (t14) = fast_ec_add(t13, point);
+    assert table[14] = t14;
+    let (t15) = fast_ec_add(t14, point);
+    assert table[15] = t15;
+
+    return ();
+}
+
+// An inner helper function for ec_mul_by_uint256.
+// The function gets a table (see `build_ec_mul_table`) for some point `P`, a point `point` and two
+// scalars 'scalar' and 'm' and a hint variable nibbles (represented as a list of nibbles where the
+// last one is the most significant).
+// It verifies that 0 <= nibbles < 2**m.
+// It returns a point 'point_out' and a scalar 'scalar_out' such that:
+//   scalar_out = scalar * 2**m + nibbles,
+//   point_out = point * 2**m + P * nibbles.
+// The caller must add a constraint that `scalar_out` was constructed correctly.
+// Assumption: `point = i * P` for some `0 <= i < 2**248`.
+func fast_ec_mul_inner{range_check_ptr}(table: EcPoint*, point: EcPoint, scalar: felt, m: felt) -> (
+    point_out: EcPoint, scalar_out: felt
+) {
+    alloc_locals;
+    if (m == 0) {
+        return (point, scalar);
+    }
+
+    // Compute 16 * point.
+    let (point) = ec_double(point);
+    let (point) = ec_double(point);
+    let (point) = ec_double(point);
+    let (point) = ec_double(point);
+
+    local nibble = nondet %{ nibbles.pop() %};
+    assert_nn_le(nibble, 15);
+
+    // Note that we can use `fast_ec_add` instead of `ec_add`:
+    // Assume that `16 * point = +/- nibble * P` and `nibble * P != 0`.
+    // This implies `16 * i + nibble = 0 (mod N)` or `16 * i - nibble = 0 (mod N)`
+    // where `N` is the size of the elliptic curve.
+    // Since `i < 2**248`, `16 * i < 2**252` and so one of the equalities must be true as integers.
+    // But `16 * i + nibble > 0` and `16 * i != nibble` since `1 <= nibble <= 15`.
+    let (point) = fast_ec_add(point, table[nibble]);
+
+    return fast_ec_mul_inner(table=table, point=point, scalar=16 * scalar + nibble, m=m - 4);
+}

cairo-lang-0.13.0a3/starkware/cairo/lang/VERSION

@@ -0,0 +1 @@
+0.13.0a3

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/starkware/starknet/business_logic/execution/os_resources.json

@@ -132,10 +132,10 @@
         },
         "secp256k1_mul": {
             "builtin_instance_counter": {
-                "range_check_builtin": 10739
+                "range_check_builtin": 7045
             },
             "n_memory_holes": 0,
-            "n_steps": 121956
+            "n_steps": 76401
         },
         "secp256k1_new": {
             "builtin_instance_counter": {
@@ -167,10 +167,10 @@
         },
         "secp256r1_mul": {
             "builtin_instance_counter": {
-                "range_check_builtin": 21477
+                "range_check_builtin": 13961
             },
             "n_memory_holes": 0,
-            "n_steps": 195595
+            "n_steps": 125240
         },
         "secp256r1_new": {
             "builtin_instance_counter": {

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/starkware/starknet/business_logic/transaction/deprecated_objects.py

@@ -6,7 +6,6 @@ from typing import Any, ClassVar, Dict, Iterable, List, Optional, Tuple, Type, c
 
 import marshmallow
 import marshmallow_dataclass
-from marshmallow_oneofschema import OneOfSchema
 
 from services.everest.api.gateway.transaction import EverestTransaction
 from services.everest.business_logic.internal_transaction import EverestInternalStateTransaction
@@ -26,11 +25,7 @@ from starkware.starknet.business_logic.state.state import UpdatesTrackerState
 from starkware.starknet.business_logic.state.state_api import SyncState
 from starkware.starknet.business_logic.state.state_api_objects import BlockInfo
 from starkware.starknet.business_logic.transaction.fee import calculate_tx_fee, execute_fee_transfer
-from starkware.starknet.business_logic.transaction.objects import (
-    BaseInternalTransactionSchema,
-    InternalTransaction,
-    InternalTransactionSchema,
-)
+from starkware.starknet.business_logic.transaction.objects import InternalTransaction
 from starkware.starknet.business_logic.transaction.state_objects import (
     FeeInfo,
     InternalStateTransaction,
@@ -61,12 +56,7 @@ from starkware.starknet.definitions.data_availability_mode import DataAvailabili
 from starkware.starknet.definitions.error_codes import StarknetErrorCode
 from starkware.starknet.definitions.execution_mode import ExecutionMode
 from starkware.starknet.definitions.general_config import StarknetGeneralConfig
-from starkware.starknet.definitions.transaction_type import (
-    DEPRECATED_DECLARE_SCHEMA_NAME,
-    DEPRECATED_DEPLOY_ACCOUNT_SCHEMA_NAME,
-    DEPRECATED_INVOKE_FUNCTION_SCHEMA_NAME,
-    TransactionType,
-)
+from starkware.starknet.definitions.transaction_type import TransactionType
 from starkware.starknet.public import abi as starknet_abi
 from starkware.starknet.services.api.contract_class.contract_class import (
     CompiledClassBase,
@@ -1629,53 +1619,3 @@ class InternalL1Handler(DeprecatedInternalTransaction):
         # The calldata includes the "from" field, which is not a part of the payload.
         # We thus subtract 1.
         return len(self.calldata) - 1
-
-
-class DeprecatedInternalTransactionSchema(BaseInternalTransactionSchema):
-    """
-    Schema for transaction.
-    OneOfSchema adds a "type" field.
-
-    Allows the use of load / dump of different transaction type data directly via the
-    `DeprecatedInternalTransaction` class (e.g.,
-    `DeprecatedInternalTransaction.load(invoke_function_dict)`,
-    where {"type": "INVOKE_FUNCTION"} is in `invoke_function_dict`, will produce a
-    `DeprecatedInternalInvokeFunction` object).
-    """
-
-    type_schemas: Dict[str, Type[marshmallow.Schema]] = {
-        DEPRECATED_DECLARE_SCHEMA_NAME: DeprecatedInternalDeclare.Schema,
-        DEPRECATED_DEPLOY_ACCOUNT_SCHEMA_NAME: DeprecatedInternalDeployAccount.Schema,
-        DEPRECATED_INVOKE_FUNCTION_SCHEMA_NAME: DeprecatedInternalInvokeFunction.Schema,
-        TransactionType.DEPLOY.name: InternalDeploy.Schema,
-        TransactionType.L1_HANDLER.name: InternalL1Handler.Schema,
-    }
-
-    InternalTransactionSchema.type_schemas.update(type_schemas)
-
-
-# Note that the line that assigns a schema to a class must appear in the same file as the
-# class definition, since they are coupled.
-DeprecatedInternalTransaction.Schema = DeprecatedInternalTransactionSchema
-
-
-class SyntheticTransactionSchema(OneOfSchema):
-    """
-    Schema for synthetic transaction.
-    OneOfSchema adds a "type" field.
-
-    Allows the use of load / dump of different transaction type data directly via the
-    DeprecatedTransaction class.
-    """
-
-    type_schemas: Dict[str, Type[marshmallow.Schema]] = {
-        TransactionType.INITIALIZE_BLOCK_INFO.name: InitializeBlockInfo.Schema
-    }
-
-    def get_obj_type(self, obj: SyntheticTransaction) -> str:
-        return obj.tx_type.name
-
-
-# Note that the line that assigns a schema to a class must appear in the same file as the
-# class definition, since they are coupled.
-SyntheticTransaction.Schema = SyntheticTransactionSchema

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/starkware/starknet/business_logic/transaction/internal_account_transaction.py

@@ -1,20 +1,15 @@
 import dataclasses
 from abc import abstractmethod
 from dataclasses import field
-from typing import ClassVar, Dict, List, Optional, Type
+from typing import ClassVar, List, Optional, Type
 
-import marshmallow
 import marshmallow_dataclass
 
 import starkware.starknet.public.abi as abi_constants
 from services.everest.business_logic.state_api import StateProxy
 from services.everest.business_logic.transaction_execution_objects import TransactionExecutionInfo
 from starkware.starknet.business_logic.fact_state.contract_state_objects import StateSelector
-from starkware.starknet.business_logic.transaction.objects import (
-    BaseInternalTransactionSchema,
-    InternalTransaction,
-    InternalTransactionSchema,
-)
+from starkware.starknet.business_logic.transaction.objects import InternalTransaction
 from starkware.starknet.business_logic.utils import verify_version, write_class_facts
 from starkware.starknet.core.os.contract_address.contract_address import (
     calculate_contract_address_from_hash,
@@ -600,30 +595,3 @@ class InternalInvokeFunction(InternalAccountTransaction):
     @property
     def entry_point_selector(self) -> int:
         return abi_constants.EXECUTE_ENTRY_POINT_SELECTOR
-
-
-class InternalAccountTransactionSchema(BaseInternalTransactionSchema):
-
-    """
-    Schema for transaction.
-    OneOfSchema adds a "type" field.
-
-    Allows the use of load / dump of different transaction type data directly via the
-    `InternalAccountTransaction` class (e.g.,
-    `InternalAccountTransaction.load(invoke_function_dict)`,
-    where {"type": "INVOKE_FUNCTION"} is in `invoke_function_dict`, will produce a
-    `InternalInvokeFunction` object).
-    """
-
-    type_schemas: Dict[str, Type[marshmallow.Schema]] = {
-        TransactionType.DECLARE.name: InternalDeclare.Schema,
-        TransactionType.DEPLOY_ACCOUNT.name: InternalDeployAccount.Schema,
-        TransactionType.INVOKE_FUNCTION.name: InternalInvokeFunction.Schema,
-    }
-
-    InternalTransactionSchema.type_schemas.update(type_schemas)
-
-
-# Note that the line that assigns a schema to a class must appear in the same file as the
-# class definition, since they are coupled.
-InternalAccountTransaction.Schema = InternalAccountTransactionSchema

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/starkware/starknet/business_logic/transaction/objects.py

@@ -2,10 +2,7 @@ import dataclasses
 import inspect
 from abc import abstractmethod
 from dataclasses import field
-from typing import Any, ClassVar, Dict, Iterable, Set, Type, cast
-
-import marshmallow
-from marshmallow_oneofschema import OneOfSchema
+from typing import ClassVar, Dict, Iterable, Set, Type, cast
 
 from services.everest.api.gateway.transaction import EverestTransaction
 from services.everest.business_logic.internal_transaction import (
@@ -17,10 +14,6 @@ from starkware.starknet.definitions import fields
 from starkware.starknet.definitions.general_config import StarknetGeneralConfig
 from starkware.starknet.definitions.transaction_type import TransactionType
 from starkware.starknet.services.api.gateway.transaction import Transaction
-from starkware.starknet.services.api.gateway.transaction_utils import (
-    DEPRECATED_TX_TYPES_FOR_SCHEMA,
-    is_deprecated_tx,
-)
 from starkware.starkware_utils.config_base import Config
 
 # Do not use `__post_init__` on internal transactions.
@@ -163,73 +156,3 @@ class InternalTransaction(EverestInternalTransaction):
         Returns an internal transaction generated based on an external one, where the input
         arguments are downcasted to application-specific types.
         """
-
-
-class BaseInternalTransactionSchema(OneOfSchema):
-    """
-    Represents the base class of Starknet internal transaction marshmallow schema class.
-    Contains custom logic of selecting the appropriate transaction class to de/serialize from/into.
-
-    Note that externally there are four transaction types, even though internally there are more.
-    Hence, we need to manually “wire” the given transaction data to the corresponding type.
-    """
-
-    def get_obj_type(self, obj: InternalTransaction) -> str:
-        """
-        Returns the name of key of type-to-schema mapping,
-        which will be used while loading the object currently dumped.
-        """
-        obj_type = obj.tx_type.name
-
-        if obj_type in DEPRECATED_TX_TYPES_FOR_SCHEMA and type(obj).__name__.startswith(
-            "Deprecated"
-        ):
-            return f"DEPRECATED_{obj_type}"
-
-        return obj_type
-
-    def get_data_type(self, data: Dict[str, Any]) -> str:
-        """
-        Returns the name of key of type-to-schema mapping,
-        for the raw data currently being loaded into an object.
-        """
-        raw_tx_type = cast(str, data.get(self.type_field))
-
-        # Version field may be missing in old transactions.
-        raw_version = data.get("version", "0x0")
-        version = fields.TransactionVersionField.load_value(value=raw_version)
-
-        if (
-            raw_tx_type == TransactionType.INVOKE_FUNCTION.name
-            and data.get("entry_point_type") == TransactionType.L1_HANDLER.name
-        ):
-            data.pop(self.type_field)
-            return TransactionType.L1_HANDLER.name
-
-        if is_deprecated_tx(raw_tx_type=raw_tx_type, version=version):
-            data.pop(self.type_field)
-            return f"DEPRECATED_{raw_tx_type}"
-
-        return super().get_data_type(data=data)
-
-
-class InternalTransactionSchema(BaseInternalTransactionSchema):
-
-    """
-    Schema for transaction.
-    OneOfSchema adds a "type" field.
-
-    Allows the use of load / dump of different transaction type data directly via the
-    `InternalAccountTransaction` class (e.g.,
-    `InternalAccountTransaction.load(invoke_function_dict)`,
-    where {"type": "INVOKE_FUNCTION"} is in `invoke_function_dict`, will produce a
-    `InternalInvokeFunction` object).
-    """
-
-    # This is filled afterwards, together with derived class definition.
-    type_schemas: Dict[str, Type[marshmallow.Schema]] = {}
-
-
-# Note that the line that assigns a schema to a class must appear in the same file as the
-# class definition, since they are coupled.
-InternalTransaction.Schema = InternalTransactionSchema

{cairo-lang-0.13.0a1 → cairo-lang-0.13.0a3}/starkware/starknet/common/new_syscalls.cairo

@@ -88,9 +88,9 @@ struct TxInfo {
     paymaster_data_start: felt*,
     paymaster_data_end: felt*,
     // The data availability mode for the nonce.
-    nonce_data_availabilty_mode: felt,
+    nonce_data_availability_mode: felt,
     // The data availability mode for the account balance from which fee will be taken.
-    fee_data_availabilty_mode: felt,
+    fee_data_availability_mode: felt,
     // If nonempty, will contain the required data for deploying and initializing an account
     // contract: its class hash, address salt and constructor calldata.
     account_deployment_data_start: felt*,