starknet 6.9.0 → 6.10.1

package/dist/provider/rpc.mjs

@@ -0,0 +1,302 @@
+import { bytesToHex } from "@noble/curves/abstract/utils";
+import { keccak_256 } from "@noble/hashes/sha3";
+import { RPC06, RpcChannel } from "../channel/index.mjs";
+import {
+  BlockTag,
+  TransactionType
+} from "../types/index.mjs";
+import assert from "../utils/assert.mjs";
+import { getAbiContractVersion } from "../utils/calldata/cairo.mjs";
+import { isSierra } from "../utils/contract.mjs";
+import { addHexPrefix, removeHexPrefix } from "../utils/encode.mjs";
+import { hexToBytes, toHex } from "../utils/num.mjs";
+import { wait } from "../utils/provider.mjs";
+import { RPCResponseParser } from "../utils/responseParser/rpc.mjs";
+import { ReceiptTx } from "../utils/transactionReceipt.mjs";
+import { LibraryError } from "./errors.mjs";
+export class RpcProvider {
+  responseParser;
+  channel;
+  constructor(optionsOrProvider) {
+    if (optionsOrProvider && "channel" in optionsOrProvider) {
+      this.channel = optionsOrProvider.channel;
+      this.responseParser = "responseParser" in optionsOrProvider ? optionsOrProvider.responseParser : new RPCResponseParser();
+    } else {
+      this.channel = new RpcChannel({ ...optionsOrProvider, waitMode: false });
+      this.responseParser = new RPCResponseParser(optionsOrProvider?.feeMarginPercentage);
+    }
+  }
+  fetch(method, params, id = 0) {
+    return this.channel.fetch(method, params, id);
+  }
+  async getChainId() {
+    return this.channel.getChainId();
+  }
+  async getSpecVersion() {
+    return this.channel.getSpecVersion();
+  }
+  async getNonceForAddress(contractAddress, blockIdentifier) {
+    return this.channel.getNonceForAddress(contractAddress, blockIdentifier);
+  }
+  async getBlock(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseGetBlockResponse);
+  }
+  /**
+   * Get the most recent accepted block hash and number
+   */
+  async getBlockLatestAccepted() {
+    return this.channel.getBlockLatestAccepted();
+  }
+  /**
+   * Get the most recent accepted block number
+   * redundant use getBlockLatestAccepted();
+   * @returns Number of the latest block
+   */
+  async getBlockNumber() {
+    return this.channel.getBlockNumber();
+  }
+  async getBlockWithTxHashes(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier);
+  }
+  async getBlockWithTxs(blockIdentifier) {
+    return this.channel.getBlockWithTxs(blockIdentifier);
+  }
+  /**
+   * Pause the execution of the script until a specified block is created.
+   * @param {BlockIdentifier} blockIdentifier bloc number (BigNumberisk) or 'pending' or 'latest'.
+   * Use of 'latest" or of a block already created will generate no pause.
+   * @param {number} [retryInterval] number of milliseconds between 2 requests to the node
+   * @example
+   * ```typescript
+   * await myProvider.waitForBlock();
+   * // wait the creation of the pending block
+   * ```
+   */
+  async waitForBlock(blockIdentifier = "pending", retryInterval = 5e3) {
+    if (blockIdentifier === BlockTag.LATEST) return;
+    const currentBlock = await this.getBlockNumber();
+    const targetBlock = blockIdentifier === BlockTag.PENDING ? currentBlock + 1 : Number(toHex(blockIdentifier));
+    if (targetBlock <= currentBlock) return;
+    const { retries } = this.channel;
+    let retriesCount = retries;
+    let isTargetBlock = false;
+    while (!isTargetBlock) {
+      const currBlock = await this.getBlockNumber();
+      if (currBlock === targetBlock) {
+        isTargetBlock = true;
+      } else {
+        await wait(retryInterval);
+      }
+      retriesCount -= 1;
+      if (retriesCount <= 0) {
+        throw new Error(`waitForBlock() timed-out after ${retries} tries.`);
+      }
+    }
+  }
+  async getL1GasPrice(blockIdentifier) {
+    return this.channel.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseL1GasPriceResponse);
+  }
+  async getL1MessageHash(l2TxHash) {
+    const transaction = await this.channel.getTransactionByHash(l2TxHash);
+    assert(transaction.type === "L1_HANDLER", "This L2 transaction is not a L1 message.");
+    const { calldata, contract_address, entry_point_selector, nonce } = transaction;
+    const params = [
+      calldata[0],
+      contract_address,
+      nonce,
+      entry_point_selector,
+      calldata.length - 1,
+      ...calldata.slice(1)
+    ];
+    const myEncode = addHexPrefix(
+      params.reduce(
+        (res, par) => res + removeHexPrefix(toHex(par)).padStart(64, "0"),
+        ""
+      )
+    );
+    return addHexPrefix(bytesToHex(keccak_256(hexToBytes(myEncode))));
+  }
+  async getBlockWithReceipts(blockIdentifier) {
+    if (this.channel instanceof RPC06.RpcChannel)
+      throw new LibraryError("Unsupported method for RPC version");
+    return this.channel.getBlockWithReceipts(blockIdentifier);
+  }
+  getStateUpdate = this.getBlockStateUpdate;
+  async getBlockStateUpdate(blockIdentifier) {
+    return this.channel.getBlockStateUpdate(blockIdentifier);
+  }
+  async getBlockTransactionsTraces(blockIdentifier) {
+    return this.channel.getBlockTransactionsTraces(blockIdentifier);
+  }
+  async getBlockTransactionCount(blockIdentifier) {
+    return this.channel.getBlockTransactionCount(blockIdentifier);
+  }
+  /**
+   * Return transactions from pending block
+   * @deprecated Instead use getBlock(BlockTag.PENDING); (will be removed in next minor version)
+   * Utility method, same result can be achieved using getBlockWithTxHashes(BlockTag.pending);
+   */
+  async getPendingTransactions() {
+    const { transactions } = await this.getBlockWithTxHashes(BlockTag.PENDING).then(
+      this.responseParser.parseGetBlockResponse
+    );
+    return Promise.all(transactions.map((it) => this.getTransactionByHash(it)));
+  }
+  async getTransaction(txHash) {
+    return this.channel.getTransactionByHash(txHash);
+  }
+  async getTransactionByHash(txHash) {
+    return this.channel.getTransactionByHash(txHash);
+  }
+  async getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+    return this.channel.getTransactionByBlockIdAndIndex(blockIdentifier, index);
+  }
+  async getTransactionReceipt(txHash) {
+    const txReceiptWoHelper = await this.channel.getTransactionReceipt(txHash);
+    const txReceiptWoHelperModified = this.responseParser.parseTransactionReceipt(txReceiptWoHelper);
+    return new ReceiptTx(txReceiptWoHelperModified);
+  }
+  async getTransactionTrace(txHash) {
+    return this.channel.getTransactionTrace(txHash);
+  }
+  /**
+   * Get the status of a transaction
+   */
+  async getTransactionStatus(transactionHash) {
+    return this.channel.getTransactionStatus(transactionHash);
+  }
+  /**
+   * @param invocations AccountInvocations
+   * @param options blockIdentifier and flags to skip validation and fee charge<br/>
+   * - blockIdentifier<br/>
+   * - skipValidate (default false)<br/>
+   * - skipFeeCharge (default true)<br/>
+   */
+  async getSimulateTransaction(invocations, options) {
+    return this.channel.simulateTransaction(invocations, options).then((r) => this.responseParser.parseSimulateTransactionResponse(r));
+  }
+  async waitForTransaction(txHash, options) {
+    const receiptWoHelper = await this.channel.waitForTransaction(
+      txHash,
+      options
+    );
+    return new ReceiptTx(receiptWoHelper);
+  }
+  async getStorageAt(contractAddress, key, blockIdentifier) {
+    return this.channel.getStorageAt(contractAddress, key, blockIdentifier);
+  }
+  async getClassHashAt(contractAddress, blockIdentifier) {
+    return this.channel.getClassHashAt(contractAddress, blockIdentifier);
+  }
+  async getClassByHash(classHash) {
+    return this.getClass(classHash);
+  }
+  async getClass(classHash, blockIdentifier) {
+    return this.channel.getClass(classHash, blockIdentifier).then(this.responseParser.parseContractClassResponse);
+  }
+  async getClassAt(contractAddress, blockIdentifier) {
+    return this.channel.getClassAt(contractAddress, blockIdentifier).then(this.responseParser.parseContractClassResponse);
+  }
+  async getContractVersion(contractAddress, classHash, {
+    blockIdentifier = this.channel.blockIdentifier,
+    compiler = true
+  } = {}) {
+    let contractClass;
+    if (contractAddress) {
+      contractClass = await this.getClassAt(contractAddress, blockIdentifier);
+    } else if (classHash) {
+      contractClass = await this.getClass(classHash, blockIdentifier);
+    } else {
+      throw Error("getContractVersion require contractAddress or classHash");
+    }
+    if (isSierra(contractClass)) {
+      if (compiler) {
+        const abiTest = getAbiContractVersion(contractClass.abi);
+        return { cairo: "1", compiler: abiTest.compiler };
+      }
+      return { cairo: "1", compiler: void 0 };
+    }
+    return { cairo: "0", compiler: "0" };
+  }
+  /**
+   * @deprecated use get*type*EstimateFee (will be refactored based on type after sequencer deprecation)
+   */
+  async getEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate) {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate);
+  }
+  async getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier, skipValidate) {
+    return this.channel.getEstimateFee(
+      [
+        {
+          type: TransactionType.INVOKE,
+          ...invocation,
+          ...invocationDetails
+        }
+      ],
+      { blockIdentifier, skipValidate }
+    ).then((r) => this.responseParser.parseFeeEstimateResponse(r));
+  }
+  async getDeclareEstimateFee(invocation, details, blockIdentifier, skipValidate) {
+    return this.channel.getEstimateFee(
+      [
+        {
+          type: TransactionType.DECLARE,
+          ...invocation,
+          ...details
+        }
+      ],
+      { blockIdentifier, skipValidate }
+    ).then((r) => this.responseParser.parseFeeEstimateResponse(r));
+  }
+  async getDeployAccountEstimateFee(invocation, details, blockIdentifier, skipValidate) {
+    return this.channel.getEstimateFee(
+      [
+        {
+          type: TransactionType.DEPLOY_ACCOUNT,
+          ...invocation,
+          ...details
+        }
+      ],
+      { blockIdentifier, skipValidate }
+    ).then((r) => this.responseParser.parseFeeEstimateResponse(r));
+  }
+  async getEstimateFeeBulk(invocations, options) {
+    return this.channel.getEstimateFee(invocations, options).then((r) => this.responseParser.parseFeeEstimateBulkResponse(r));
+  }
+  async invokeFunction(functionInvocation, details) {
+    return this.channel.invoke(functionInvocation, details);
+  }
+  async declareContract(transaction, details) {
+    return this.channel.declare(transaction, details);
+  }
+  async deployAccountContract(transaction, details) {
+    return this.channel.deployAccount(
+      transaction,
+      details
+    );
+  }
+  async callContract(call, blockIdentifier) {
+    return this.channel.callContract(call, blockIdentifier);
+  }
+  /**
+   * NEW: Estimate the fee for a message from L1
+   * @param message Message From L1
+   */
+  async estimateMessageFee(message, blockIdentifier) {
+    return this.channel.estimateMessageFee(message, blockIdentifier);
+  }
+  /**
+   * Returns an object about the sync status, or false if the node is not synching
+   * @returns Object with the stats data
+   */
+  async getSyncingStats() {
+    return this.channel.getSyncingStats();
+  }
+  /**
+   * Returns all events matching the given filter
+   * @returns events and the pagination of the events
+   */
+  async getEvents(eventFilter) {
+    return this.channel.getEvents(eventFilter);
+  }
+}

package/dist/service/types.cjs

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

package/dist/service/types.d.ts

@@ -0,0 +1,5 @@
+import { BlockIdentifier } from '../types';
+export type getEstimateFeeBulkOptions = {
+    blockIdentifier?: BlockIdentifier;
+    skipValidate?: boolean;
+};

package/dist/signer/default.cjs

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Signer = void 0;
+var _api = require("../types/api/index.cjs");
+var _calldata = require("../utils/calldata/index.cjs");
+var _ec = require("../utils/ec.cjs");
+var _encode = require("../utils/encode.cjs");
+var _hash = require("../utils/hash/index.cjs");
+var _num = require("../utils/num.cjs");
+var _stark = require("../utils/stark.cjs");
+var _transaction = require("../utils/transaction.cjs");
+var _typedData = require("../utils/typedData.cjs");
+class Signer {
+  pk;
+  constructor(pk = _ec.starkCurve.utils.randomPrivateKey()) {
+    this.pk = pk instanceof Uint8Array ? (0, _encode.buf2hex)(pk) : (0, _num.toHex)(pk);
+  }
+  async getPubKey() {
+    return _ec.starkCurve.getStarkKey(this.pk);
+  }
+  async signMessage(typedData, accountAddress) {
+    const msgHash = (0, _typedData.getMessageHash)(typedData, accountAddress);
+    return this.signRaw(msgHash);
+  }
+  async signTransaction(transactions, details) {
+    const compiledCalldata = (0, _transaction.getExecuteCalldata)(transactions, details.cairoVersion);
+    let msgHash;
+    if (Object.values(_api.ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateInvokeTransactionHash)({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version
+      });
+    } else if (Object.values(_api.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateInvokeTransactionHash)({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: (0, _stark.intDAM)(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: (0, _stark.intDAM)(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signDeployAccountTransaction(details) {
+    const compiledConstructorCalldata = _calldata.CallData.compile(details.constructorCalldata);
+    let msgHash;
+    if (Object.values(_api.ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeployAccountTransactionHash)({
+        ...det,
+        salt: det.addressSalt,
+        constructorCalldata: compiledConstructorCalldata,
+        version: det.version
+      });
+    } else if (Object.values(_api.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeployAccountTransactionHash)({
+        ...det,
+        salt: det.addressSalt,
+        compiledConstructorCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: (0, _stark.intDAM)(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: (0, _stark.intDAM)(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeployAccountTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signDeclareTransaction(details) {
+    let msgHash;
+    if (Object.values(_api.ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeclareTransactionHash)({
+        ...det,
+        version: det.version
+      });
+    } else if (Object.values(_api.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeclareTransactionHash)({
+        ...det,
+        version: det.version,
+        nonceDataAvailabilityMode: (0, _stark.intDAM)(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: (0, _stark.intDAM)(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeclareTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signRaw(msgHash) {
+    return _ec.starkCurve.sign(msgHash, this.pk);
+  }
+}
+exports.Signer = Signer;

package/dist/signer/default.d.ts

@@ -0,0 +1,12 @@
+import { Call, DeclareSignerDetails, DeployAccountSignerDetails, InvocationsSignerDetails, Signature, TypedData } from '../types';
+import { SignerInterface } from './interface';
+export declare class Signer implements SignerInterface {
+    protected pk: Uint8Array | string;
+    constructor(pk?: Uint8Array | string);
+    getPubKey(): Promise<string>;
+    signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
+    signTransaction(transactions: Call[], details: InvocationsSignerDetails): Promise<Signature>;
+    signDeployAccountTransaction(details: DeployAccountSignerDetails): Promise<Signature>;
+    signDeclareTransaction(details: DeclareSignerDetails): Promise<Signature>;
+    protected signRaw(msgHash: string): Promise<Signature>;
+}

package/dist/signer/default.mjs

@@ -0,0 +1,102 @@
+import { ETransactionVersion2, ETransactionVersion3 } from "../types/api/index.mjs";
+import { CallData } from "../utils/calldata/index.mjs";
+import { starkCurve } from "../utils/ec.mjs";
+import { buf2hex } from "../utils/encode.mjs";
+import {
+  calculateDeclareTransactionHash,
+  calculateDeployAccountTransactionHash,
+  calculateInvokeTransactionHash
+} from "../utils/hash/index.mjs";
+import { toHex } from "../utils/num.mjs";
+import { intDAM } from "../utils/stark.mjs";
+import { getExecuteCalldata } from "../utils/transaction.mjs";
+import { getMessageHash } from "../utils/typedData.mjs";
+export class Signer {
+  pk;
+  constructor(pk = starkCurve.utils.randomPrivateKey()) {
+    this.pk = pk instanceof Uint8Array ? buf2hex(pk) : toHex(pk);
+  }
+  async getPubKey() {
+    return starkCurve.getStarkKey(this.pk);
+  }
+  async signMessage(typedData, accountAddress) {
+    const msgHash = getMessageHash(typedData, accountAddress);
+    return this.signRaw(msgHash);
+  }
+  async signTransaction(transactions, details) {
+    const compiledCalldata = getExecuteCalldata(transactions, details.cairoVersion);
+    let msgHash;
+    if (Object.values(ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = calculateInvokeTransactionHash({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version
+      });
+    } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = calculateInvokeTransactionHash({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: intDAM(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: intDAM(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signDeployAccountTransaction(details) {
+    const compiledConstructorCalldata = CallData.compile(details.constructorCalldata);
+    let msgHash;
+    if (Object.values(ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeployAccountTransactionHash({
+        ...det,
+        salt: det.addressSalt,
+        constructorCalldata: compiledConstructorCalldata,
+        version: det.version
+      });
+    } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeployAccountTransactionHash({
+        ...det,
+        salt: det.addressSalt,
+        compiledConstructorCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: intDAM(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: intDAM(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeployAccountTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signDeclareTransaction(details) {
+    let msgHash;
+    if (Object.values(ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeclareTransactionHash({
+        ...det,
+        version: det.version
+      });
+    } else if (Object.values(ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = calculateDeclareTransactionHash({
+        ...det,
+        version: det.version,
+        nonceDataAvailabilityMode: intDAM(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: intDAM(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeclareTransaction version");
+    }
+    return this.signRaw(msgHash);
+  }
+  async signRaw(msgHash) {
+    return starkCurve.sign(msgHash, this.pk);
+  }
+}

package/dist/signer/ethSigner.cjs

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EthSigner = void 0;
+var _secp256k = require("@noble/curves/secp256k1");
+var _api = require("../types/api/index.cjs");
+var _calldata = require("../utils/calldata/index.cjs");
+var _encode = require("../utils/encode.cjs");
+var _eth = require("../utils/eth.cjs");
+var _hash = require("../utils/hash/index.cjs");
+var _num = require("../utils/num.cjs");
+var _stark = require("../utils/stark.cjs");
+var _transaction = require("../utils/transaction.cjs");
+var _typedData = require("../utils/typedData.cjs");
+var _uint = require("../utils/uint256.cjs");
+class EthSigner {
+  pk;
+  // hex string without 0x and with an odd number of characters
+  constructor(pk = (0, _eth.ethRandomPrivateKey)()) {
+    this.pk = pk instanceof Uint8Array ? (0, _encode.buf2hex)(pk).padStart(64, "0") : (0, _encode.removeHexPrefix)((0, _num.toHex)(pk)).padStart(64, "0");
+  }
+  /**
+   * provides the Ethereum full public key (without parity prefix)
+   * @returns an hex string : 64 first characters are Point X coordinate. 64 last characters are Point Y coordinate.
+   */
+  async getPubKey() {
+    return (0, _encode.addHexPrefix)((0, _encode.buf2hex)(_secp256k.secp256k1.getPublicKey(this.pk, false)).padStart(130, "0").slice(2));
+  }
+  async signMessage(typedData, accountAddress) {
+    const msgHash = (0, _typedData.getMessageHash)(typedData, accountAddress);
+    const signature = _secp256k.secp256k1.sign((0, _encode.removeHexPrefix)((0, _encode.sanitizeHex)(msgHash)), this.pk);
+    return this.formatEthSignature(signature);
+  }
+  async signTransaction(transactions, details) {
+    const compiledCalldata = (0, _transaction.getExecuteCalldata)(transactions, details.cairoVersion);
+    let msgHash;
+    if (Object.values(_api.ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateInvokeTransactionHash)({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version
+      });
+    } else if (Object.values(_api.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateInvokeTransactionHash)({
+        ...det,
+        senderAddress: det.walletAddress,
+        compiledCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: (0, _stark.intDAM)(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: (0, _stark.intDAM)(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signTransaction version");
+    }
+    const signature = _secp256k.secp256k1.sign((0, _encode.removeHexPrefix)((0, _encode.sanitizeHex)(msgHash)), this.pk);
+    return this.formatEthSignature(signature);
+  }
+  async signDeployAccountTransaction(details) {
+    const compiledConstructorCalldata = _calldata.CallData.compile(details.constructorCalldata);
+    let msgHash;
+    if (Object.values(_api.ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeployAccountTransactionHash)({
+        ...det,
+        salt: det.addressSalt,
+        constructorCalldata: compiledConstructorCalldata,
+        version: det.version
+      });
+    } else if (Object.values(_api.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeployAccountTransactionHash)({
+        ...det,
+        salt: det.addressSalt,
+        compiledConstructorCalldata,
+        version: det.version,
+        nonceDataAvailabilityMode: (0, _stark.intDAM)(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: (0, _stark.intDAM)(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeployAccountTransaction version");
+    }
+    const signature = _secp256k.secp256k1.sign((0, _encode.removeHexPrefix)((0, _encode.sanitizeHex)(msgHash)), this.pk);
+    return this.formatEthSignature(signature);
+  }
+  async signDeclareTransaction(details) {
+    let msgHash;
+    if (Object.values(_api.ETransactionVersion2).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeclareTransactionHash)({
+        ...det,
+        version: det.version
+      });
+    } else if (Object.values(_api.ETransactionVersion3).includes(details.version)) {
+      const det = details;
+      msgHash = (0, _hash.calculateDeclareTransactionHash)({
+        ...det,
+        version: det.version,
+        nonceDataAvailabilityMode: (0, _stark.intDAM)(det.nonceDataAvailabilityMode),
+        feeDataAvailabilityMode: (0, _stark.intDAM)(det.feeDataAvailabilityMode)
+      });
+    } else {
+      throw Error("unsupported signDeclareTransaction version");
+    }
+    const signature = _secp256k.secp256k1.sign((0, _encode.removeHexPrefix)((0, _encode.sanitizeHex)(msgHash)), this.pk);
+    return this.formatEthSignature(signature);
+  }
+  /**
+   * Serialize the signature in conformity with starknet::eth_signature::Signature
+   * @param ethSignature secp256k1 signature from Noble curves library
+   * @return an array of felts, representing a Cairo Eth Signature.
+   */
+  formatEthSignature(ethSignature) {
+    const r = (0, _uint.bnToUint256)(ethSignature.r);
+    const s = (0, _uint.bnToUint256)(ethSignature.s);
+    return [(0, _num.toHex)(r.low), (0, _num.toHex)(r.high), (0, _num.toHex)(s.low), (0, _num.toHex)(s.high), (0, _num.toHex)(ethSignature.recovery)];
+  }
+}
+exports.EthSigner = EthSigner;

package/dist/signer/ethSigner.d.ts

@@ -0,0 +1,25 @@
+import type { RecoveredSignatureType } from '@noble/curves/abstract/weierstrass';
+import { ArraySignatureType, Call, DeclareSignerDetails, DeployAccountSignerDetails, InvocationsSignerDetails, Signature, TypedData } from '../types';
+import { SignerInterface } from './interface';
+/**
+ * Signer for accounts using Ethereum signature
+ */
+export declare class EthSigner implements SignerInterface {
+    protected pk: string;
+    constructor(pk?: Uint8Array | string);
+    /**
+     * provides the Ethereum full public key (without parity prefix)
+     * @returns an hex string : 64 first characters are Point X coordinate. 64 last characters are Point Y coordinate.
+     */
+    getPubKey(): Promise<string>;
+    signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
+    signTransaction(transactions: Call[], details: InvocationsSignerDetails): Promise<Signature>;
+    signDeployAccountTransaction(details: DeployAccountSignerDetails): Promise<Signature>;
+    signDeclareTransaction(details: DeclareSignerDetails): Promise<Signature>;
+    /**
+     * Serialize the signature in conformity with starknet::eth_signature::Signature
+     * @param ethSignature secp256k1 signature from Noble curves library
+     * @return an array of felts, representing a Cairo Eth Signature.
+     */
+    protected formatEthSignature(ethSignature: RecoveredSignatureType): ArraySignatureType;
+}