starknet 6.9.0 → 6.10.1

package/dist/signer/ethSigner.mjs

@@ -0,0 +1,140 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { ETransactionVersion2, ETransactionVersion3 } from "../types/api/index.mjs";
+import { CallData } from "../utils/calldata/index.mjs";
+import { addHexPrefix, buf2hex, removeHexPrefix, sanitizeHex } from "../utils/encode.mjs";
+import { ethRandomPrivateKey } from "../utils/eth.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";
+import { bnToUint256 } from "../utils/uint256.mjs";
+export class EthSigner {
+  pk;
+  // hex string without 0x and with an odd number of characters
+  constructor(pk = ethRandomPrivateKey()) {
+    this.pk = pk instanceof Uint8Array ? buf2hex(pk).padStart(64, "0") : removeHexPrefix(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 addHexPrefix(
+      buf2hex(secp256k1.getPublicKey(this.pk, false)).padStart(130, "0").slice(2)
+    );
+  }
+  async signMessage(typedData, accountAddress) {
+    const msgHash = getMessageHash(typedData, accountAddress);
+    const signature = secp256k1.sign(
+      removeHexPrefix(sanitizeHex(msgHash)),
+      this.pk
+    );
+    return this.formatEthSignature(signature);
+  }
+  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");
+    }
+    const signature = secp256k1.sign(
+      removeHexPrefix(sanitizeHex(msgHash)),
+      this.pk
+    );
+    return this.formatEthSignature(signature);
+  }
+  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");
+    }
+    const signature = secp256k1.sign(
+      removeHexPrefix(sanitizeHex(msgHash)),
+      this.pk
+    );
+    return this.formatEthSignature(signature);
+  }
+  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");
+    }
+    const signature = secp256k1.sign(
+      removeHexPrefix(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 = bnToUint256(ethSignature.r);
+    const s = bnToUint256(ethSignature.s);
+    return [
+      toHex(r.low),
+      toHex(r.high),
+      toHex(s.low),
+      toHex(s.high),
+      toHex(ethSignature.recovery)
+    ];
+  }
+}

package/dist/signer/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _interface = require("./interface.cjs");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _interface[key];
+    }
+  });
+});
+var _default = require("./default.cjs");
+Object.keys(_default).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _default[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _default[key];
+    }
+  });
+});
+var _ethSigner = require("./ethSigner.cjs");
+Object.keys(_ethSigner).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ethSigner[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ethSigner[key];
+    }
+  });
+});

package/dist/signer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './default';
+export * from './ethSigner';

package/dist/signer/index.mjs

@@ -0,0 +1,3 @@
+export * from "./interface.mjs";
+export * from "./default.mjs";
+export * from "./ethSigner.mjs";

package/dist/signer/interface.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SignerInterface = void 0;
+class SignerInterface {}
+exports.SignerInterface = SignerInterface;

package/dist/signer/interface.d.ts

@@ -0,0 +1,115 @@
+import { Call, DeclareSignerDetails, DeployAccountSignerDetails, InvocationsSignerDetails, Signature, TypedData } from '../types';
+export declare abstract class SignerInterface {
+    /**
+     * Method to get the public key of the signer
+     *
+     * @returns {string} hex-string
+     * @example
+     * ```typescript
+     * const mySigner = new Signer("0x123");
+     * const result = await mySigner.getPubKey();
+     * // result = "0x566d69d8c99f62bc71118399bab25c1f03719463eab8d6a444cd11ece131616"
+     * ```
+     */
+    abstract getPubKey(): Promise<string>;
+    /**
+     * Signs a JSON object for off-chain usage with the private key and returns the signature.
+     * This adds a message prefix so it can't be interchanged with transactions
+     *
+     * @param {TypedData} typedData JSON object to be signed
+     * @param {string} accountAddress Hex string of the account's address
+     * @returns {Promise<Signature>} the signature of the message
+     * @example
+     * ```typescript
+     * const mySigner = new Signer("0x123");
+     *     const myTypedData: TypedData = {
+     *         domain: {name: "Example DApp",
+     *           chainId: constants.StarknetChainId.SN_SEPOLIA,
+     *           version: "0.0.3"},
+     *         types: {StarkNetDomain: [
+     *             { name: "name", type: "string" },
+     *             { name: "chainId", type: "felt" },
+     *             { name: "version", type: "string" }],
+     *           Message: [{ name: "message", type: "felt" }]},
+     *         primaryType: "Message", message: {message: "1234"}};
+     *     const result = await mySigner.signMessage(myTypedData,"0x5d08a4e9188429da4e993c9bf25aafe5cd491ee2b501505d4d059f0c938f82d");
+     * // result = Signature {r: 684915484701699003335398790608214855489903651271362390249153620883122231253n,
+     * // s: 1399150959912500412309102776989465580949387575375484933432871778355496929189n, recovery: 1}
+     * ```
+  
+     */
+    abstract signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
+    /**
+     * Signs transactions with the private key and returns the signature
+     *
+     * @param {Call[]} transactions array of Call objects
+     * @param {InvocationsSignerDetails} transactionsDetail InvocationsSignerDetails object
+     * @returns {Promise<Signature>} the signature of the transaction
+     * @example
+     * ```typescript
+     * const mySigner = new Signer("0x123");
+     * const calls: Call[] = [{
+     *     contractAddress: "0x1234567890123456789012345678901234567890",
+     *     entrypoint: "functionName",
+     *     calldata: [1, 2, 3]
+     * }];
+     * const transactionsDetail: InvocationsSignerDetails = {
+     *     walletAddress: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+     *     chainId: constants.StarknetChainId.SN_MAIN,
+     *     cairoVersion: "1",
+     *     maxFee: '0x1234567890abcdef',
+     *     version: "0x0", nonce: 1};
+     * const result = await mySigner.signTransaction(calls, transactionsDetail);
+     * // result = Signature {r: 304910226421970384958146916800275294114105560641204815169249090836676768876n,
+     * //   s: 1072798866000813654190523783606274062837012608648308896325315895472901074693n, recovery: 0}
+     * ```
+     */
+    abstract signTransaction(transactions: Call[], transactionsDetail: InvocationsSignerDetails): Promise<Signature>;
+    /**
+     * Signs a DEPLOY_ACCOUNT transaction with the private key and returns the signature
+     *
+     * @param {DeployAccountSignerDetails} transaction to deploy an account contract
+     * @returns {Promise<Signature>} the signature of the transaction to deploy an account
+     * @example
+     * ```typescript
+     * const mySigner = new Signer("0x123");
+     * const myDeployAcc: DeployAccountSignerDetails = {
+     *   contractAddress: "0x65a822fbee1ae79e898688b5a4282dc79e0042cbed12f6169937fddb4c26641",
+     *   version: "0x2", chainId: constants.StarknetChainId.SN_SEPOLIA,
+     *   classHash: "0x5f3614e8671257aff9ac38e929c74d65b02d460ae966cd826c9f04a7fa8e0d4",
+     *   constructorCalldata: [1, 2],addressSalt: 1234,
+     *   nonce: 45, maxFee: 10 ** 15, tip: 0, paymasterData: [],accountDeploymentData: [],
+     *   nonceDataAvailabilityMode: RPC.EDataAvailabilityMode.L1,
+     *   feeDataAvailabilityMode: RPC.EDataAvailabilityMode.L1,
+     *   resourceBounds: stark.estimateFeeToBounds(constants.ZERO),
+     * }
+     * const result = await mySigner.signDeployAccountTransaction(myDeployAcc);
+     * // result = Signature {r: 2871311234341436528393212130310036951068553852419934781736214693308640202748n,
+     * //  s: 1746271646048888422437132495446973163454853863041370993384284773665861377605n, recovery: 1}
+     * ```
+     */
+    abstract signDeployAccountTransaction(transaction: DeployAccountSignerDetails): Promise<Signature>;
+    /**
+     * Signs a DECLARE transaction with the private key and returns the signature
+     *
+     * @param {DeclareSignerDetails} transaction to declare a class
+     * @returns {Promise<Signature>} the signature of the transaction to declare a class
+     * @example
+     * ```typescript
+     * const mySigner = new Signer("0x123");
+     * const myDeclare: DeclareSignerDetails = {
+     *   version: "0x2", chainId: constants.StarknetChainId.SN_SEPOLIA,
+     *   senderAddress: "0x65a822fbee1ae79e898688b5a4282dc79e0042cbed12f6169937fddb4c26641",
+     *   classHash: "0x5f3614e8671257aff9ac38e929c74d65b02d460ae966cd826c9f04a7fa8e0d4",
+     *   nonce: 45, maxFee: 10 ** 15, tip: 0, paymasterData: [], accountDeploymentData: [],
+     *   nonceDataAvailabilityMode: RPC.EDataAvailabilityMode.L1,
+     *   feeDataAvailabilityMode: RPC.EDataAvailabilityMode.L1,
+     *   resourceBounds: stark.estimateFeeToBounds(constants.ZERO),
+  }
+     * const result = await mySigner.signDeclareTransaction(myDeclare);
+     * // result = Signature {r: 2432056944313955951711774394836075930010416436707488863728289188289211995670n,
+     * //  s: 3407649393310177489888603098175002856596469926897298636282244411990343146307n, recovery: 1}
+     * ```
+     */
+    abstract signDeclareTransaction(transaction: DeclareSignerDetails): Promise<Signature>;
+}

package/dist/signer/interface.mjs

@@ -0,0 +1,2 @@
+export class SignerInterface {
+}

package/dist/types/account.cjs

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

package/dist/types/account.d.ts

@@ -0,0 +1,79 @@
+import { EDataAvailabilityMode, ETransactionVersion, ResourceBounds } from './api';
+import { AllowArray, BigNumberish, BlockIdentifier, Call, DeclareContractPayload, DeployAccountContractPayload, TransactionType, UniversalDeployerContractPayload, V3TransactionDetails } from './lib';
+import { DeclareTransactionReceiptResponse, EstimateFeeResponse } from './provider';
+export interface EstimateFee extends EstimateFeeResponse {
+}
+export type EstimateFeeBulk = Array<EstimateFee>;
+export type AccountInvocationsFactoryDetails = {
+    versions: Array<`${ETransactionVersion}`>;
+    nonce?: BigNumberish;
+    blockIdentifier?: BlockIdentifier;
+    skipValidate?: boolean;
+} & Partial<V3TransactionDetails>;
+export interface UniversalDetails {
+    nonce?: BigNumberish;
+    blockIdentifier?: BlockIdentifier;
+    maxFee?: BigNumberish;
+    tip?: BigNumberish;
+    paymasterData?: BigNumberish[];
+    accountDeploymentData?: BigNumberish[];
+    nonceDataAvailabilityMode?: EDataAvailabilityMode;
+    feeDataAvailabilityMode?: EDataAvailabilityMode;
+    version?: BigNumberish;
+    resourceBounds?: ResourceBounds;
+    skipValidate?: boolean;
+}
+export interface EstimateFeeDetails extends UniversalDetails {
+}
+export interface DeployContractResponse {
+    contract_address: string;
+    transaction_hash: string;
+}
+export type MultiDeployContractResponse = {
+    contract_address: Array<string>;
+    transaction_hash: string;
+};
+export type DeployContractUDCResponse = {
+    contract_address: string;
+    transaction_hash: string;
+    address: string;
+    deployer: string;
+    unique: string;
+    classHash: string;
+    calldata_len: string;
+    calldata: Array<string>;
+    salt: string;
+};
+export type DeclareDeployUDCResponse = {
+    declare: {
+        class_hash: BigNumberish;
+    } & Partial<DeclareTransactionReceiptResponse>;
+    deploy: DeployContractUDCResponse;
+};
+export type SimulateTransactionDetails = {
+    nonce?: BigNumberish;
+    blockIdentifier?: BlockIdentifier;
+    skipValidate?: boolean;
+    skipExecute?: boolean;
+} & Partial<V3TransactionDetails>;
+export type EstimateFeeAction = {
+    type: typeof TransactionType.INVOKE;
+    payload: AllowArray<Call>;
+} | {
+    type: typeof TransactionType.DECLARE;
+    payload: DeclareContractPayload;
+} | {
+    type: typeof TransactionType.DEPLOY_ACCOUNT;
+    payload: DeployAccountContractPayload;
+} | {
+    type: typeof TransactionType.DEPLOY;
+    payload: UniversalDeployerContractPayload;
+};
+export type StarkProfile = {
+    name?: string;
+    profilePicture?: string;
+    discord?: string;
+    twitter?: string;
+    github?: string;
+    proofOfPersonhood?: boolean;
+};

package/dist/types/api/index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  JRPC: true,
+  RPCSPEC06: true,
+  RPCSPEC07: true
+};
+exports.RPCSPEC07 = exports.RPCSPEC06 = exports.JRPC = void 0;
+var _JRPC = _interopRequireWildcard(require("./jsonrpc/index.cjs"));
+exports.JRPC = _JRPC;
+var _RPCSPEC = _interopRequireWildcard(require("./rpcspec_0_6/index.cjs"));
+exports.RPCSPEC06 = _RPCSPEC;
+var _RPCSPEC2 = _interopRequireWildcard(require("starknet-types-07"));
+exports.RPCSPEC07 = _RPCSPEC2;
+Object.keys(_RPCSPEC2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _RPCSPEC2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _RPCSPEC2[key];
+    }
+  });
+});
+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/api/index.d.ts

@@ -0,0 +1,4 @@
+export * as JRPC from './jsonrpc';
+export * as RPCSPEC06 from './rpcspec_0_6';
+export * as RPCSPEC07 from 'starknet-types-07';
+export * from 'starknet-types-07';

package/dist/types/api/index.mjs

@@ -0,0 +1,4 @@
+export * as JRPC from "./jsonrpc/index.mjs";
+export * as RPCSPEC06 from "./rpcspec_0_6/index.mjs";
+export * as RPCSPEC07 from "starknet-types-07";
+export * from "starknet-types-07";

package/dist/types/api/jsonrpc/index.cjs

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

package/dist/types/api/jsonrpc/index.d.ts

@@ -0,0 +1,21 @@
+export type RequestBody = {
+    id: number | string;
+    jsonrpc: '2.0';
+    method: string;
+    params?: {};
+};
+export type ResponseBody = {
+    id: number | string;
+    jsonrpc: '2.0';
+} & (SuccessResponseBody | ErrorResponseBody);
+export type SuccessResponseBody = {
+    result: unknown;
+};
+export type ErrorResponseBody = {
+    error: Error;
+};
+export type Error = {
+    code: number;
+    message: string;
+    data?: unknown;
+};

package/dist/types/api/rpcspec_0_6/components.cjs

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