starknet 6.9.0 → 6.10.1

package/dist/types/calldata.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidateType = exports.Uint = exports.Literal = void 0;
+const ValidateType = exports.ValidateType = {
+  DEPLOY: "DEPLOY",
+  CALL: "CALL",
+  INVOKE: "INVOKE"
+};
+const Uint = exports.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
+};
+const Literal = exports.Literal = {
+  ClassHash: "core::starknet::class_hash::ClassHash",
+  ContractAddress: "core::starknet::contract_address::ContractAddress",
+  Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point"
+};

package/dist/types/calldata.d.ts

@@ -0,0 +1,23 @@
+import { ValuesType } from './helpers/valuesType';
+export declare const ValidateType: {
+    readonly DEPLOY: "DEPLOY";
+    readonly CALL: "CALL";
+    readonly INVOKE: "INVOKE";
+};
+export type ValidateType = ValuesType<typeof ValidateType>;
+export declare const Uint: {
+    readonly u8: "core::integer::u8";
+    readonly u16: "core::integer::u16";
+    readonly u32: "core::integer::u32";
+    readonly u64: "core::integer::u64";
+    readonly u128: "core::integer::u128";
+    readonly u256: "core::integer::u256";
+    readonly u512: "core::integer::u512";
+};
+export type Uint = ValuesType<typeof Uint>;
+export declare const Literal: {
+    readonly ClassHash: "core::starknet::class_hash::ClassHash";
+    readonly ContractAddress: "core::starknet::contract_address::ContractAddress";
+    readonly Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point";
+};
+export type Literal = ValuesType<typeof Literal>;

package/dist/types/calldata.mjs

@@ -0,0 +1,21 @@
+export const ValidateType = {
+  DEPLOY: "DEPLOY",
+  CALL: "CALL",
+  INVOKE: "INVOKE"
+};
+export const 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
+};
+export const Literal = {
+  ClassHash: "core::starknet::class_hash::ClassHash",
+  ContractAddress: "core::starknet::contract_address::ContractAddress",
+  Secp256k1Point: "core::starknet::secp256k1::Secp256k1Point"
+};

package/dist/types/contract.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/contract.d.ts

@@ -0,0 +1,27 @@
+import { CairoEnum } from './cairoEnum';
+import { BigNumberish, BlockIdentifier, Calldata, ParsedStruct, RawArgsArray, Signature } from './lib';
+export type AsyncContractFunction<T = any> = (...args: ArgsOrCalldataWithOptions) => Promise<T>;
+export type ContractFunction = (...args: ArgsOrCalldataWithOptions) => any;
+export type Result = {
+    [key: string]: any;
+} | Result[] | bigint | string | boolean | CairoEnum;
+export type ArgsOrCalldata = RawArgsArray | [Calldata] | Calldata;
+export type ArgsOrCalldataWithOptions = ArgsOrCalldata & ContractOptions;
+export type ContractOptions = {
+    blockIdentifier?: BlockIdentifier;
+    parseRequest?: boolean;
+    parseResponse?: boolean;
+    formatResponse?: {
+        [key: string]: any;
+    };
+    maxFee?: BigNumberish;
+    nonce?: BigNumberish;
+    signature?: Signature;
+    addressSalt?: string;
+};
+export type CallOptions = Pick<ContractOptions, 'blockIdentifier' | 'parseRequest' | 'parseResponse' | 'formatResponse'>;
+export type InvokeOptions = Pick<ContractOptions, 'maxFee' | 'nonce' | 'signature' | 'parseRequest'>;
+export type ParsedEvent = {
+    [name: string]: ParsedStruct;
+};
+export type ParsedEvents = Array<ParsedEvent>;

package/dist/types/helpers/valuesType.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/helpers/valuesType.d.ts

@@ -0,0 +1 @@
+export type ValuesType<T extends ReadonlyArray<any> | ArrayLike<any> | Record<any, any>> = T extends ReadonlyArray<any> ? T[number] : T extends ArrayLike<any> ? T[number] : T extends object ? T[keyof T] : never;

package/dist/types/index.cjs

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  RPC: true
+};
+exports.RPC = void 0;
+var _account = require("./account.cjs");
+Object.keys(_account).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _account[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _account[key];
+    }
+  });
+});
+var _calldata = require("./calldata.cjs");
+Object.keys(_calldata).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _calldata[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _calldata[key];
+    }
+  });
+});
+var _contract = require("./contract.cjs");
+Object.keys(_contract).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _contract[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _contract[key];
+    }
+  });
+});
+var _lib = require("./lib/index.cjs");
+Object.keys(_lib).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _lib[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _lib[key];
+    }
+  });
+});
+var _provider = require("./provider/index.cjs");
+Object.keys(_provider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _provider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _provider[key];
+    }
+  });
+});
+var _signer = require("./signer.cjs");
+Object.keys(_signer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _signer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _signer[key];
+    }
+  });
+});
+var _typedData = require("./typedData.cjs");
+Object.keys(_typedData).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _typedData[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _typedData[key];
+    }
+  });
+});
+var _cairoEnum = require("./cairoEnum.cjs");
+Object.keys(_cairoEnum).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _cairoEnum[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cairoEnum[key];
+    }
+  });
+});
+var _transactionReceipt = require("./transactionReceipt.cjs");
+Object.keys(_transactionReceipt).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _transactionReceipt[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _transactionReceipt[key];
+    }
+  });
+});
+var _RPC = _interopRequireWildcard(require("./api/index.cjs"));
+exports.RPC = _RPC;
+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; }

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from './account';
+export * from './calldata';
+export * from './contract';
+export * from './lib';
+export * from './provider';
+export * from './signer';
+export * from './typedData';
+export * from './cairoEnum';
+export * from './transactionReceipt';
+export * as RPC from './api';

package/dist/types/index.mjs

@@ -0,0 +1,10 @@
+export * from "./account.mjs";
+export * from "./calldata.mjs";
+export * from "./contract.mjs";
+export * from "./lib/index.mjs";
+export * from "./provider/index.mjs";
+export * from "./signer.mjs";
+export * from "./typedData.mjs";
+export * from "./cairoEnum.mjs";
+export * from "./transactionReceipt.mjs";
+export * as RPC from "./api/index.mjs";

package/dist/types/lib/contract/abi.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/lib/contract/abi.d.ts

@@ -0,0 +1,71 @@
+import type { ENUM_EVENT, EVENT_FIELD, STRUCT_EVENT } from 'starknet-types-07';
+/** ABI */
+export type Abi = ReadonlyArray<FunctionAbi | AbiEvent | AbiStruct | InterfaceAbi | any>;
+export type AbiEntry = {
+    name: string;
+    type: 'felt' | 'felt*' | string;
+};
+export type EventEntry = {
+    name: string;
+    type: 'felt' | 'felt*' | string;
+    kind: 'key' | 'data';
+};
+type FunctionAbiType = 'function' | 'l1_handler' | 'constructor';
+export type FunctionAbi = {
+    inputs: AbiEntry[];
+    name: string;
+    outputs: AbiEntry[];
+    stateMutability?: 'view';
+    state_mutability?: string;
+    type: FunctionAbiType;
+};
+export type AbiStructs = {
+    [name: string]: AbiStruct;
+};
+export type AbiStruct = {
+    members: (AbiEntry & {
+        offset: number;
+    })[];
+    name: string;
+    size: number;
+    type: 'struct';
+};
+export type AbiInterfaces = {
+    [name: string]: InterfaceAbi;
+};
+export type InterfaceAbi = {
+    items: FunctionAbi[];
+    name: string;
+    type: 'interface';
+};
+export type AbiEnums = {
+    [name: string]: AbiEnum;
+};
+export type AbiEnum = {
+    variants: (AbiEntry & {
+        offset: number;
+    })[];
+    name: string;
+    size: number;
+    type: 'enum';
+};
+export type AbiEvents = {
+    [hash: string]: AbiEvent;
+};
+export type AbiEvent = CairoEvent | LegacyEvent;
+export type CairoEvent = CairoEventDefinition | AbiEvents;
+export type CairoEventDefinition = STRUCT_EVENT & {
+    name: string;
+    type: 'event';
+};
+export type CairoEventVariant = ENUM_EVENT & {
+    name: string;
+    type: string;
+};
+export type LegacyEvent = {
+    name: string;
+    type: 'event';
+    data: EVENT_FIELD[];
+    keys: EVENT_FIELD[];
+};
+export {};

package/dist/types/lib/contract/index.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  EntryPointType: true
+};
+exports.EntryPointType = void 0;
+var _abi = require("./abi.cjs");
+Object.keys(_abi).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _abi[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _abi[key];
+    }
+  });
+});
+var _legacy = require("./legacy.cjs");
+Object.keys(_legacy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _legacy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _legacy[key];
+    }
+  });
+});
+var _sierra = require("./sierra.cjs");
+Object.keys(_sierra).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _sierra[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sierra[key];
+    }
+  });
+});
+const EntryPointType = exports.EntryPointType = {
+  EXTERNAL: "EXTERNAL",
+  L1_HANDLER: "L1_HANDLER",
+  CONSTRUCTOR: "CONSTRUCTOR"
+};

package/dist/types/lib/contract/index.d.ts

@@ -0,0 +1,26 @@
+import { ValuesType } from '../../helpers/valuesType';
+import { LegacyCompiledContract, LegacyContractClass } from './legacy';
+import { CompiledSierra, SierraContractClass } from './sierra';
+/**
+ * format produced after compressing compiled contract
+ *
+ * CompressedCompiledContract
+ */
+export type ContractClass = LegacyContractClass | SierraContractClass;
+/**
+ * format produced after compile .cairo to .json
+ */
+export type CompiledContract = LegacyCompiledContract | CompiledSierra;
+/**
+ * Compressed or decompressed Cairo0 or Cairo1 Contract
+ */
+export type CairoContract = ContractClass | CompiledContract;
+export declare const EntryPointType: {
+    readonly EXTERNAL: "EXTERNAL";
+    readonly L1_HANDLER: "L1_HANDLER";
+    readonly CONSTRUCTOR: "CONSTRUCTOR";
+};
+export type EntryPointType = ValuesType<typeof EntryPointType>;
+export * from './abi';
+export * from './legacy';
+export * from './sierra';

package/dist/types/lib/contract/index.mjs

@@ -0,0 +1,8 @@
+export const EntryPointType = {
+  EXTERNAL: "EXTERNAL",
+  L1_HANDLER: "L1_HANDLER",
+  CONSTRUCTOR: "CONSTRUCTOR"
+};
+export * from "./abi.mjs";
+export * from "./legacy.mjs";
+export * from "./sierra.mjs";

package/dist/types/lib/contract/legacy.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/lib/contract/legacy.d.ts

@@ -0,0 +1,33 @@
+import { Abi } from './abi';
+/** LEGACY CONTRACT */
+/**
+ * format produced after compressing 'program' property
+ */
+export type LegacyContractClass = {
+    program: CompressedProgram;
+    entry_points_by_type: EntryPointsByType;
+    abi: Abi;
+};
+/**
+ * format produced after compiling .cairo to .json
+ */
+export type LegacyCompiledContract = Omit<LegacyContractClass, 'program'> & {
+    program: Program;
+};
+/** SUBTYPES */
+export type Builtins = string[];
+export type CompressedProgram = string;
+export type EntryPointsByType = {
+    CONSTRUCTOR: ContractEntryPointFields[];
+    EXTERNAL: ContractEntryPointFields[];
+    L1_HANDLER: ContractEntryPointFields[];
+};
+export type ContractEntryPointFields = {
+    selector: string;
+    offset: string | number;
+    builtins?: Builtins;
+};
+export interface Program extends Record<string, any> {
+    builtins: string[];
+    data: string[];
+}

package/dist/types/lib/contract/sierra.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/lib/contract/sierra.d.ts

@@ -0,0 +1,52 @@
+import { Abi } from './abi';
+import { EntryPointsByType } from './legacy';
+/** SYSTEM TYPES */
+export type CairoAssembly = {
+    prime: string;
+    compiler_version: string;
+    bytecode: ByteCode;
+    hints: any[];
+    pythonic_hints?: PythonicHints;
+    bytecode_segment_lengths?: number[];
+    entry_points_by_type: EntryPointsByType;
+};
+/** COMPILED CONTRACT */
+/**
+ * format produced after starknet-compile .cairo to .json
+ *
+ * sierra_program is hex array
+ */
+export type CompiledSierra = {
+    sierra_program: ByteCode;
+    sierra_program_debug_info?: SierraProgramDebugInfo;
+    contract_class_version: string;
+    entry_points_by_type: SierraEntryPointsByType;
+    abi: Abi;
+};
+/**
+ * format produced after compressing 'sierra_program', stringifies 'abi' property and omit sierra_program_debug_info
+ *
+ * CompressedCompiledSierra
+ */
+export type SierraContractClass = Omit<CompiledSierra, 'abi' | 'sierra_program_debug_info'> & {
+    sierra_program: string;
+    abi: string;
+};
+export type CompiledSierraCasm = CairoAssembly;
+/** SUBTYPES */
+export type ByteCode = string[];
+export type PythonicHints = [number, string[]][];
+export type SierraProgramDebugInfo = {
+    type_names: [number, string][];
+    libfunc_names: [number, string][];
+    user_func_names: [number, string][];
+};
+export type SierraEntryPointsByType = {
+    CONSTRUCTOR: SierraContractEntryPointFields[];
+    EXTERNAL: SierraContractEntryPointFields[];
+    L1_HANDLER: SierraContractEntryPointFields[];
+};
+export type SierraContractEntryPointFields = {
+    selector: string;
+    function_idx: number;
+};

package/dist/types/lib/index.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  TransactionType: true,
+  TransactionStatus: true,
+  TransactionFinalityStatus: true,
+  TransactionExecutionStatus: true,
+  BlockStatus: true,
+  BlockTag: true
+};
+exports.TransactionType = exports.TransactionStatus = exports.TransactionFinalityStatus = exports.TransactionExecutionStatus = exports.BlockTag = exports.BlockStatus = void 0;
+var _contract = require("./contract/index.cjs");
+Object.keys(_contract).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _contract[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _contract[key];
+    }
+  });
+});
+const TransactionType = exports.TransactionType = {
+  DECLARE: "DECLARE",
+  DEPLOY: "DEPLOY",
+  DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+  INVOKE: "INVOKE_FUNCTION"
+};
+const TransactionStatus = exports.TransactionStatus = {
+  NOT_RECEIVED: "NOT_RECEIVED",
+  RECEIVED: "RECEIVED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+  REJECTED: "REJECTED",
+  REVERTED: "REVERTED"
+};
+const TransactionFinalityStatus = exports.TransactionFinalityStatus = {
+  NOT_RECEIVED: "NOT_RECEIVED",
+  RECEIVED: "RECEIVED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+const TransactionExecutionStatus = exports.TransactionExecutionStatus = {
+  REJECTED: "REJECTED",
+  REVERTED: "REVERTED",
+  SUCCEEDED: "SUCCEEDED"
+};
+const BlockStatus = exports.BlockStatus = {
+  PENDING: "PENDING",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  REJECTED: "REJECTED"
+};
+const BlockTag = exports.BlockTag = {
+  PENDING: "pending",
+  LATEST: "latest"
+};