starknet 6.9.0 → 6.10.1

package/dist/utils/transaction.d.ts

@@ -0,0 +1,185 @@
+import { BigNumberish, CairoVersion, Call, CallStruct, Calldata, ParsedStruct, UniversalDeployerContractPayload } from '../types';
+/**
+ * Transforms a list of Calls, each with their own calldata, into
+ * two arrays: one with the entry points, and one with the concatenated calldata
+ * @param {Call[]} calls the list of calls to transform.
+ * @returns {callArray: ParsedStruct[], calldata: BigNumberish[]} An object containing two arrays: callArray and calldata.
+ * @example
+ * ```typescript
+ * const calls: Call[] = [
+ * 	{
+ * 		contractAddress: "0x1234567890123456789012345678901234567890",
+ * 		entrypoint: "functionName",
+ * 		calldata: [1,2,3]
+ * 	},
+ * 	{
+ * 		contractAddress: "0x0987654321098765432109876543210987654321",
+ * 		entrypoint: "anotherFunction",
+ * 		calldata: [4,5,6]
+ * 	}
+ * ];
+ * const result = transaction.transformCallsToMulticallArrays(calls);
+ * // result = {
+ * // callArray: [
+ * // { to: "0x1234567890123456789012345678901234567890", selector: "1234567890",
+ * // data_offset: "0", data_len: "3" },
+ * // { to: "0x0987654321098765432109876543210987654321", selector: "1234567890",
+ * // data_offset: "0987654321", data_offset: "3", data_len: "3"}
+ * // ], calldata: [1, 2, 3, 4, 5, 6]
+ * // }
+ * ```
+ */
+export declare const transformCallsToMulticallArrays: (calls: Call[]) => {
+    callArray: ParsedStruct[];
+    calldata: Calldata;
+};
+/**
+ * Transforms a list of calls into the Cairo 0 `__execute__` calldata.
+ * @param {Call[]} calls the list of calls to transform
+ * @returns {Calldata} the Cairo 0 `__execute__` calldata
+ * @example
+ * ```typescript
+ * const calls: Call[] = [
+ * 	{
+ * 		contractAddress: "0x1234567890123456789012345678901234567890",
+ * 		entrypoint: "functionName",
+ * 		calldata: [1, 2, 3]
+ * 	},
+ * 	{
+ * 		contractAddress: "0x0987654321098765432109876543210987654321",
+ * 		entrypoint: "anotherFunction",
+ * 		calldata: [4, 5, 6]
+ * 	}
+ * ];
+ * const result = transaction.fromCallsToExecuteCalldata(calls);
+ * // result = ['2', '103929005307130220006098923584552504982110632080',
+ * //   '784552248838722632831848474045274978537388011177294206940059575485454596699', '0',
+ * //   '3', '54400338722927882010739357306608455014511100705',
+ * //   '836430224577382061379420368022192503799782058803937958828224424676927281484',
+ * //   '3', '3', '6', '1', '2', '3', '4', '5', '6']
+ * ```
+ */
+export declare const fromCallsToExecuteCalldata: (calls: Call[]) => Calldata;
+/**
+ * Transforms a list of calls into the Cairo 0 `__execute__` calldata including nonce.
+ * @deprecated
+ */
+export declare const fromCallsToExecuteCalldataWithNonce: (calls: Call[], nonce: BigNumberish) => Calldata;
+/**
+ * Format Data inside Calls
+ * @deprecated Not required for getting execute Calldata
+ */
+export declare const transformCallsToMulticallArrays_cairo1: (calls: Call[]) => CallStruct[];
+/**
+ * Transforms a list of calls into the Cairo 1 `__execute__` calldata.
+ * @param {Call[]} calls the list of calls to transform.
+ * @returns {Calldata} the Cairo 1 `__execute__` calldata.
+ * @example
+ * ```typescript
+ * const calls: Call[] = [
+ * 	{
+ * 		contractAddress: "0x1234567890123456789012345678901234567890",
+ * 		entrypoint: "functionName",
+ * 		calldata: [1, 2, 3]
+ * 	},
+ * 	{
+ * 		contractAddress: "0x0987654321098765432109876543210987654321",
+ * 		entrypoint: "anotherFunction",
+ * 		calldata: [4, 5, 6]
+ * 	}
+ * ];
+ * const result = transaction.fromCallsToExecuteCalldata_cairo1(calls);
+ * // result = ['2', '103929005307130220006098923584552504982110632080',
+ * //   '784552248838722632831848474045274978537388011177294206940059575485454596699',
+ * //   '3', '1', '2', '3', '54400338722927882010739357306608455014511100705',
+ * //   '836430224577382061379420368022192503799782058803937958828224424676927281484',
+ * //   '3', '4', '5', '6']
+ * ```
+ */
+export declare const fromCallsToExecuteCalldata_cairo1: (calls: Call[]) => Calldata;
+/**
+ * Create `__execute__` Calldata from Calls based on Cairo versions.
+ * @param {Call[]} calls the list of calls to transform
+ * @param {CairoVersion} cairoVersion the Cairo version
+ * @returns {Calldata} the `__execute__` calldata.
+ * @example
+ * ```typescript
+ * const calls: Call[] = [
+ * 	{
+ * 		contractAddress: "0x1234567890123456789012345678901234567890",
+ * 		entrypoint: "functionName",
+ * 		calldata: [1, 2, 3]
+ * 	},
+ * 	{
+ * 		contractAddress: "0x0987654321098765432109876543210987654321",
+ * 		entrypoint: "anotherFunction",
+ * 		calldata: [4, 5, 6]
+ * 	}
+ * ];
+ * const result = transaction.getExecuteCalldata(calls, '1');
+ * // result = ['2', '103929005307130220006098923584552504982110632080',
+ * //   '784552248838722632831848474045274978537388011177294206940059575485454596699',
+ * //   '3', '1', '2', '3', '54400338722927882010739357306608455014511100705',
+ * //   '836430224577382061379420368022192503799782058803937958828224424676927281484',
+ * //   '3', '4', '5', '6']
+ * ```
+ */
+export declare const getExecuteCalldata: (calls: Call[], cairoVersion?: CairoVersion) => Calldata;
+/**
+ * Builds a UDCCall object.
+ *
+ * @param {UniversalDeployerContractPayload | UniversalDeployerContractPayload[]} payload the payload data for the UDCCall. Can be a single payload object or an array of payload objects.
+ * @param {string} address the address to be used in the UDCCall
+ * @returns { calls: Call[], addresses: string[] } the UDCCall object containing an array of calls and an array of addresses.
+ * @example
+ * ```typescript
+ * const payload: UniversalDeployerContractPayload = {
+ * classHash: "0x1234567890123456789012345678901234567890",
+ * salt: "0x0987654321098765432109876543210987654321",
+ * unique:true,
+ * constructorCalldata: [1, 2, 3]
+ * };
+ * const address = "0xABCDEF1234567890ABCDEF1234567890ABCDEF12";
+ * const result  = transaction.buildUDCCall(payload, address);
+ * // result = {
+ * // 	calls: [
+ * //			{
+ * //			contractAddress: "0xABCDEF1234567890ABCDEF1234567890ABCDEF12",
+ * //			entrypoint: "functionName",
+ * //			calldata: [classHash, salt, true, 3, 1, 2, 3]
+ * //		}],
+ * //	addresses: ["0x6fD084B56a7EDc5C06B3eB40f97Ae5A0C707A865"]
+ * // }
+ * ```
+ */
+export declare function buildUDCCall(payload: UniversalDeployerContractPayload | UniversalDeployerContractPayload[], address: string): {
+    calls: {
+        contractAddress: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf";
+        entrypoint: "deployContract";
+        calldata: BigNumberish[];
+    }[];
+    addresses: string[];
+};
+/**
+ * Return transaction versions based on version type, default version type is 'transaction'.
+ * @param {'fee' | 'transaction'} [versionType] the type of version ("fee" or "transaction")
+ * @returns {v1: ETransactionVersion, v2: ETransactionVersion, v3: ETransactionVersion} an object containing the transaction versions.
+ * @example
+ * ```typescript
+ * const result = transaction.getVersionsByType('fee');
+ * // result = {
+ * //   v1: '0x100000000000000000000000000000001',
+ * //   v2: '0x100000000000000000000000000000002',
+ * //   v3: '0x100000000000000000000000000000003'
+ * // }
+ * ```
+ */
+export declare function getVersionsByType(versionType?: 'fee' | 'transaction'): {
+    v1: "0x100000000000000000000000000000001";
+    v2: "0x100000000000000000000000000000002";
+    v3: "0x100000000000000000000000000000003";
+} | {
+    v1: "0x1";
+    v2: "0x2";
+    v3: "0x3";
+};

package/dist/utils/transaction.mjs

@@ -0,0 +1,98 @@
+import { UDC } from "../constants.mjs";
+import { ETransactionVersion } from "../types/api/index.mjs";
+import { CallData } from "./calldata/index.mjs";
+import { starkCurve } from "./ec.mjs";
+import { calculateContractAddressFromHash, getSelectorFromName } from "./hash/index.mjs";
+import { toBigInt, toCairoBool } from "./num.mjs";
+import { randomAddress } from "./stark.mjs";
+export const transformCallsToMulticallArrays = (calls) => {
+  const callArray = [];
+  const calldata = [];
+  calls.forEach((call) => {
+    const data = CallData.compile(call.calldata || []);
+    callArray.push({
+      to: toBigInt(call.contractAddress).toString(10),
+      selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
+      data_offset: calldata.length.toString(),
+      data_len: data.length.toString()
+    });
+    calldata.push(...data);
+  });
+  return {
+    callArray,
+    calldata: CallData.compile({ calldata })
+  };
+};
+export const fromCallsToExecuteCalldata = (calls) => {
+  const { callArray, calldata } = transformCallsToMulticallArrays(calls);
+  const compiledCalls = CallData.compile({ callArray });
+  return [...compiledCalls, ...calldata];
+};
+export const fromCallsToExecuteCalldataWithNonce = (calls, nonce) => {
+  return [...fromCallsToExecuteCalldata(calls), toBigInt(nonce).toString()];
+};
+export const transformCallsToMulticallArrays_cairo1 = (calls) => {
+  const callArray = calls.map((call) => ({
+    to: toBigInt(call.contractAddress).toString(10),
+    selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
+    calldata: CallData.compile(call.calldata || [])
+  }));
+  return callArray;
+};
+export const fromCallsToExecuteCalldata_cairo1 = (calls) => {
+  const orderCalls = calls.map((call) => ({
+    contractAddress: call.contractAddress,
+    entrypoint: call.entrypoint,
+    calldata: Array.isArray(call.calldata) && "__compiled__" in call.calldata ? call.calldata : CallData.compile(call.calldata)
+    // RawArgsObject | RawArgsArray type
+  }));
+  return CallData.compile({ orderCalls });
+};
+export const getExecuteCalldata = (calls, cairoVersion = "0") => {
+  if (cairoVersion === "1") {
+    return fromCallsToExecuteCalldata_cairo1(calls);
+  }
+  return fromCallsToExecuteCalldata(calls);
+};
+export function buildUDCCall(payload, address) {
+  const params = [].concat(payload).map((it) => {
+    const {
+      classHash,
+      salt,
+      unique = true,
+      constructorCalldata = []
+    } = it;
+    const compiledConstructorCallData = CallData.compile(constructorCalldata);
+    const deploySalt = salt ?? randomAddress();
+    return {
+      call: {
+        contractAddress: UDC.ADDRESS,
+        entrypoint: UDC.ENTRYPOINT,
+        calldata: [
+          classHash,
+          deploySalt,
+          toCairoBool(unique),
+          compiledConstructorCallData.length,
+          ...compiledConstructorCallData
+        ]
+      },
+      address: calculateContractAddressFromHash(
+        unique ? starkCurve.pedersen(address, deploySalt) : deploySalt,
+        classHash,
+        compiledConstructorCallData,
+        unique ? UDC.ADDRESS : 0
+      )
+    };
+  });
+  return {
+    calls: params.map((it) => it.call),
+    addresses: params.map((it) => it.address)
+  };
+}
+export function getVersionsByType(versionType) {
+  return versionType === "fee" ? {
+    v1: ETransactionVersion.F1,
+    v2: ETransactionVersion.F2,
+    v3: ETransactionVersion.F3
+  } : { v1: ETransactionVersion.V1, v2: ETransactionVersion.V2, v3: ETransactionVersion.V3 };
+}

package/dist/utils/transactionReceipt.cjs

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReceiptTx = void 0;
+var _types = require("../types/index.cjs");
+class ReceiptTx {
+  statusReceipt;
+  value;
+  constructor(receipt) {
+    [this.statusReceipt, this.value] = ReceiptTx.isSuccess(receipt) ? ["success", receipt] : ReceiptTx.isReverted(receipt) ? ["reverted", receipt] : ReceiptTx.isRejected(receipt) ? ["rejected", receipt] : ["error", new Error("Unknown response type")];
+    for (const [key] of Object.entries(this)) {
+      Object.defineProperty(this, key, {
+        enumerable: false
+      });
+    }
+    for (const [key, value] of Object.entries(receipt)) {
+      Object.defineProperty(this, key, {
+        enumerable: true,
+        writable: false,
+        value
+      });
+    }
+  }
+  match(callbacks) {
+    if (this.statusReceipt in callbacks) {
+      return callbacks[this.statusReceipt](this.value);
+    }
+    return callbacks._();
+  }
+  isSuccess() {
+    return this.statusReceipt === "success";
+  }
+  isReverted() {
+    return this.statusReceipt === "reverted";
+  }
+  isRejected() {
+    return this.statusReceipt === "rejected";
+  }
+  isError() {
+    return this.statusReceipt === "error";
+  }
+  static isSuccess(transactionReceipt) {
+    return transactionReceipt.execution_status === _types.TransactionExecutionStatus.SUCCEEDED;
+  }
+  static isReverted(transactionReceipt) {
+    return transactionReceipt.execution_status === _types.TransactionExecutionStatus.REVERTED;
+  }
+  static isRejected(transactionReceipt) {
+    return transactionReceipt.status === _types.TransactionExecutionStatus.REJECTED;
+  }
+}
+exports.ReceiptTx = ReceiptTx;

package/dist/utils/transactionReceipt.d.ts

@@ -0,0 +1,33 @@
+import { GetTxReceiptResponseWithoutHelper, RejectedTransactionReceiptResponse, RevertedTransactionReceiptResponse, SuccessfulTransactionReceiptResponse } from '../types';
+import type { TransactionReceiptCallbacks, TransactionReceiptStatus, TransactionReceiptUtilityInterface, TransactionReceiptValue } from '../types/transactionReceipt';
+/**
+ * Utility that analyses transaction receipt response and provides helpers to process it
+ * @example
+ * ```typescript
+ * const responseTx = new ReceiptTx(receipt);
+ * responseTx.match({
+ *   success: (txR: SuccessfulTransactionReceiptResponse) => { },
+ *   rejected: (txR: RejectedTransactionReceiptResponse) => { },
+ *   reverted: (txR: RevertedTransactionReceiptResponse) => { },
+ *   error: (err: Error) => { },
+ * });
+ * responseTx.match({
+ *   success: (txR: SuccessfulTransactionReceiptResponse) => { },
+ *   _: () => { },
+ * }
+ * ```
+ */
+export declare class ReceiptTx implements TransactionReceiptUtilityInterface {
+    readonly statusReceipt: TransactionReceiptStatus;
+    readonly value: TransactionReceiptValue;
+    constructor(receipt: GetTxReceiptResponseWithoutHelper);
+    match(callbacks: TransactionReceiptCallbacks): void;
+    isSuccess(): this is SuccessfulTransactionReceiptResponse;
+    isReverted(): this is RevertedTransactionReceiptResponse;
+    isRejected(): this is RejectedTransactionReceiptResponse;
+    isError(): boolean;
+    static isSuccess(transactionReceipt: GetTxReceiptResponseWithoutHelper): transactionReceipt is SuccessfulTransactionReceiptResponse;
+    static isReverted(transactionReceipt: GetTxReceiptResponseWithoutHelper): transactionReceipt is RevertedTransactionReceiptResponse;
+    static isRejected(transactionReceipt: GetTxReceiptResponseWithoutHelper): transactionReceipt is RejectedTransactionReceiptResponse;
+}
+export type GetTransactionReceiptResponse = GetTxReceiptResponseWithoutHelper & ReceiptTx;

package/dist/utils/transactionReceipt.mjs

@@ -0,0 +1,49 @@
+import {
+  TransactionExecutionStatus
+} from "../types/index.mjs";
+export class ReceiptTx {
+  statusReceipt;
+  value;
+  constructor(receipt) {
+    [this.statusReceipt, this.value] = ReceiptTx.isSuccess(receipt) ? ["success", receipt] : ReceiptTx.isReverted(receipt) ? ["reverted", receipt] : ReceiptTx.isRejected(receipt) ? ["rejected", receipt] : ["error", new Error("Unknown response type")];
+    for (const [key] of Object.entries(this)) {
+      Object.defineProperty(this, key, {
+        enumerable: false
+      });
+    }
+    for (const [key, value] of Object.entries(receipt)) {
+      Object.defineProperty(this, key, {
+        enumerable: true,
+        writable: false,
+        value
+      });
+    }
+  }
+  match(callbacks) {
+    if (this.statusReceipt in callbacks) {
+      return callbacks[this.statusReceipt](this.value);
+    }
+    return callbacks._();
+  }
+  isSuccess() {
+    return this.statusReceipt === "success";
+  }
+  isReverted() {
+    return this.statusReceipt === "reverted";
+  }
+  isRejected() {
+    return this.statusReceipt === "rejected";
+  }
+  isError() {
+    return this.statusReceipt === "error";
+  }
+  static isSuccess(transactionReceipt) {
+    return transactionReceipt.execution_status === TransactionExecutionStatus.SUCCEEDED;
+  }
+  static isReverted(transactionReceipt) {
+    return transactionReceipt.execution_status === TransactionExecutionStatus.REVERTED;
+  }
+  static isRejected(transactionReceipt) {
+    return transactionReceipt.status === TransactionExecutionStatus.REJECTED;
+  }
+}