starknet 4.12.0 → 4.13.0

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "starknet",
-  "version": "4.12.0",
+  "version": "4.13.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "browser": "dist/index.global.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "prepare": "npm run build && husky install",
-    "build": "tsc",
+    "build": "tsup && npm run build:esm && npm run build:iife",
+    "build:esm": "tsup --clean false --format esm --platform node",
+    "build:iife": "tsup --clean false --format iife --platform browser",
     "pretest": "npm run lint",
     "test": "jest",
     "posttest": "npm run format",
@@ -38,6 +42,7 @@
     "@semantic-release/npm": "^9.0.1",
     "@semantic-release/release-notes-generator": "^10.0.3",
     "@types/elliptic": "^6.4.14",
+    "@types/isomorphic-fetch": "^0.0.36",
     "@types/jest": "^28.1.1",
     "@types/json-bigint": "^1.0.1",
     "@types/minimalistic-assert": "^1.0.1",
@@ -59,6 +64,7 @@
     "lint-staged": "^13.0.1",
     "prettier": "^2.7.0",
     "prettier-plugin-import-sort": "^0.0.7",
+    "tsup": "^6.3.0",
     "typedoc": "^0.22.17",
     "typescript": "^4.7.3"
   },

package/src/account/default.ts

@@ -166,6 +166,38 @@ export class Account extends Provider implements AccountInterface {
     };
   }
 
+  public async estimateDeployFee(
+    {
+      classHash,
+      salt,
+      unique = true,
+      constructorCalldata = [],
+      additionalCalls = [],
+    }: UniversalDeployerContractPayload,
+    transactionsDetail?: InvocationsDetails | undefined
+  ): Promise<EstimateFee> {
+    const compiledConstructorCallData = compileCalldata(constructorCalldata);
+
+    const callsArray = Array.isArray(additionalCalls) ? additionalCalls : [additionalCalls];
+    return this.estimateInvokeFee(
+      [
+        {
+          contractAddress: UDC.ADDRESS,
+          entrypoint: UDC.ENTRYPOINT,
+          calldata: [
+            classHash,
+            salt,
+            toCairoBool(unique),
+            compiledConstructorCallData.length,
+            ...compiledConstructorCallData,
+          ],
+        },
+        ...callsArray,
+      ],
+      transactionsDetail
+    );
+  }
+
   public async execute(
     calls: AllowArray<Call>,
     abis: Abi[] | undefined = undefined,
@@ -243,9 +275,8 @@ export class Account extends Provider implements AccountInterface {
       salt,
       unique = true,
       constructorCalldata = [],
-      isDevnet = false,
+      additionalCalls = [],
     }: UniversalDeployerContractPayload,
-    additionalCalls: AllowArray<Call> = [], // support multicall
     transactionsDetail: InvocationsDetails = {}
   ): Promise<InvokeFunctionResponse> {
     const compiledConstructorCallData = compileCalldata(constructorCalldata);
@@ -255,7 +286,7 @@ export class Account extends Provider implements AccountInterface {
     return this.execute(
       [
         {
-          contractAddress: isDevnet ? UDC.ADDRESS_DEVNET : UDC.ADDRESS,
+          contractAddress: UDC.ADDRESS,
           entrypoint: UDC.ENTRYPOINT,
           calldata: [
             classHash,
@@ -350,22 +381,26 @@ export class Account extends Provider implements AccountInterface {
   }
 
   public async getSuggestedMaxFee(
-    estimateFeeAction: EstimateFeeAction,
+    { type, payload }: EstimateFeeAction,
     details: EstimateFeeDetails
   ) {
     let feeEstimate: EstimateFee;
 
-    switch (estimateFeeAction.type) {
+    switch (type) {
       case 'INVOKE':
-        feeEstimate = await this.estimateInvokeFee(estimateFeeAction.payload, details);
+        feeEstimate = await this.estimateInvokeFee(payload, details);
         break;
 
       case 'DECLARE':
-        feeEstimate = await this.estimateDeclareFee(estimateFeeAction.payload, details);
+        feeEstimate = await this.estimateDeclareFee(payload, details);
         break;
 
       case 'DEPLOY_ACCOUNT':
-        feeEstimate = await this.estimateAccountDeployFee(estimateFeeAction.payload, details);
+        feeEstimate = await this.estimateAccountDeployFee(payload, details);
+        break;
+
+      case 'DEPLOY':
+        feeEstimate = await this.estimateDeployFee(payload, details);
         break;
 
       default:

package/src/account/interface.ts

@@ -86,6 +86,27 @@ export abstract class AccountInterface extends ProviderInterface {
     estimateFeeDetails?: EstimateFeeDetails
   ): Promise<EstimateFeeResponse>;
 
+  /**
+   * Estimate Fee for executing a UDC DEPLOY transaction on starknet
+   * This is different from the normal DEPLOY transaction as it goes through the Universal Deployer Contract (UDC)
+   
+  * @param deployContractPayload containing
+   * - classHash: computed class hash of compiled contract
+   * - salt: address salt
+   * - unique: bool if true ensure unique salt
+   * - calldata: constructor calldata
+   * - additionalCalls - optional additional calls array to support multicall
+   * 
+   * @param transactionsDetail Invocation Details containing:
+   *  - optional nonce
+   *  - optional version
+   *  - optional maxFee
+   */
+  public abstract estimateDeployFee(
+    deployContractPayload: UniversalDeployerContractPayload,
+    transactionsDetail?: InvocationsDetails
+  ): Promise<EstimateFeeResponse>;
+
   /**
    * Invoke execute function in account contract
    *
@@ -123,12 +144,15 @@ export abstract class AccountInterface extends ProviderInterface {
   ): Promise<DeclareContractResponse>;
 
   /**
+   * Deploys a given compiled contract (json) to starknet using Universal Deployer Contract (UDC)
+   * This is different from the normal DEPLOY transaction as it goes through the Universal Deployer Contract (UDC)
+   *
    * @param deployContractPayload containing
    * - classHash: computed class hash of compiled contract
    * - salt: address salt
    * - unique: bool if true ensure unique salt
    * - calldata: constructor calldata
-   * @param additionalCalls - optional additional calls array to support multicall
+   * - additionalCalls - optional additional calls array to support multicall
    * @param transactionsDetail Invocation Details containing:
    *  - optional nonce
    *  - optional version
@@ -136,7 +160,6 @@ export abstract class AccountInterface extends ProviderInterface {
    */
   public abstract deploy(
     deployContractPayload: UniversalDeployerContractPayload,
-    additionalCalls?: AllowArray<Call>,
     transactionsDetail?: InvocationsDetails
   ): Promise<InvokeFunctionResponse>;
 

package/src/constants.ts

@@ -24,7 +24,6 @@ export enum TransactionHashPrefix {
 export const UDC = {
   ADDRESS: '0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf',
   ENTRYPOINT: 'deployContract',
-  ADDRESS_DEVNET: '0x25fcb74260022bd8ed7e8d542408941826b53345e478b8303d6f31744838a36',
 };
 
 /**

package/src/provider/default.ts

@@ -133,6 +133,9 @@ export class Provider implements ProviderInterface {
     return this.provider.invokeFunction(functionInvocation, details);
   }
 
+  /**
+   * @deprecated This method won't be supported, use Account.deploy instead
+   */
   public async deployContract(
     payload: DeployContractPayload,
     details: InvocationsDetails

package/src/provider/interface.ts

@@ -140,6 +140,8 @@ export abstract class ProviderInterface {
   /**
    * Deploys a given compiled contract (json) to starknet
    *
+   * @deprecated This method won't be supported, use Account.deploy instead
+   *
    * @param payload payload to be deployed containing:
    * - compiled contract code
    * - constructor calldata

package/src/provider/rpc.ts

@@ -64,10 +64,10 @@ export class RpcProvider implements ProviderInterface {
   }
 
   public fetch(method: any, params: any): Promise<any> {
-    return fetch(`${this.nodeUrl}/rpc/v0.2`, {
+    return fetch(this.nodeUrl, {
       method: 'POST',
       body: stringify({ method, jsonrpc: '2.0', params, id: 0 }),
-      headers: this.headers,
+      headers: this.headers as Record<string, string>,
     });
   }
 
@@ -242,7 +242,7 @@ export class RpcProvider implements ProviderInterface {
     return this.fetchEndpoint('starknet_estimateFee', {
       request: {
         type: 'INVOKE',
-        contract_address: invocation.contractAddress,
+        sender_address: invocation.contractAddress,
         calldata: parseCalldata(invocation.calldata),
         signature: bigNumberishArrayToHexadecimalStringArray(invocation.signature || []),
         version: toHex(toBN(invocationDetails?.version || 0)),
@@ -323,7 +323,7 @@ export class RpcProvider implements ProviderInterface {
   }
 
   /**
-   * @deprecated This method wont be supported soon, use Account.deploy instead
+   * @deprecated This method won't be supported, use Account.deploy instead
    */
   public async deployContract(
     { contract, constructorCalldata, addressSalt }: DeployContractPayload,

package/src/provider/sequencer.ts

@@ -193,7 +193,7 @@ export class SequencerProvider implements ProviderInterface {
       const res = await fetch(url, {
         method,
         body: stringify(request),
-        headers,
+        headers: headers as Record<string, string>,
       });
       const textResponse = await res.text();
       if (!res.ok) {
@@ -326,6 +326,9 @@ export class SequencerProvider implements ProviderInterface {
     }).then(this.responseParser.parseInvokeFunctionResponse);
   }
 
+  /**
+   * @deprecated This method won't be supported, use Account.deploy instead
+   */
   public async deployContract({
     contract,
     constructorCalldata,

package/src/types/lib.ts

@@ -24,7 +24,7 @@ export type UniversalDeployerContractPayload = {
   salt: string;
   unique: boolean;
   constructorCalldata?: RawArgs;
-  isDevnet?: boolean;
+  additionalCalls?: AllowArray<Call>; // support multicall
 };
 
 export type DeployContractPayload = {

package/src/types/provider.ts

@@ -12,6 +12,7 @@ import {
   RawCalldata,
   Signature,
   Status,
+  UniversalDeployerContractPayload,
 } from './lib';
 
 export interface GetBlockResponse {
@@ -131,4 +132,8 @@ export type EstimateFeeAction =
   | {
       type: 'DEPLOY_ACCOUNT';
       payload: DeployAccountContractPayload;
+    }
+  | {
+      type: 'DEPLOY';
+      payload: UniversalDeployerContractPayload;
     };

package/src/utils/ellipticCurve.ts

@@ -1,4 +1,4 @@
-import { ec as EC, curves } from 'elliptic';
+import elliptic from 'elliptic';
 import hashJS from 'hash.js';
 import assert from 'minimalistic-assert';
 
@@ -7,6 +7,8 @@ import { KeyPair, Signature } from '../types';
 import { addHexPrefix, removeHexPrefix, sanitizeBytes } from './encode';
 import { BigNumberish, assertInRange, toBN, toHex } from './number';
 
+const { ec: EC, curves } = elliptic;
+
 export const ec = new EC(
   new curves.PresetCurve({
     type: 'short',

package/src/utils/fetchPonyfill.ts

@@ -1,4 +1,5 @@
+import isomorphicFetch from 'isomorphic-fetch';
+
 export default (typeof window !== 'undefined' && window.fetch) || // use buildin fetch in browser if available
   (typeof global !== 'undefined' && global.fetch) || // use buildin fetch in node, react-native and service worker if available
-  // eslint-disable-next-line global-require
-  require('isomorphic-fetch'); // ponyfill fetch in node and browsers that don't have it
+  isomorphicFetch; // ponyfill fetch in node and browsers that don't have it

package/src/utils/hash.ts

@@ -1,6 +1,7 @@
+/* eslint-disable import/extensions */
 import BN from 'bn.js';
-import { keccak256 } from 'ethereum-cryptography/keccak';
-import { hexToBytes } from 'ethereum-cryptography/utils';
+import { keccak256 } from 'ethereum-cryptography/keccak.js';
+import { hexToBytes } from 'ethereum-cryptography/utils.js';
 import assert from 'minimalistic-assert';
 
 import {

package/src/utils/number.ts

@@ -1,4 +1,4 @@
-import BN, { isBN } from 'bn.js';
+import BN from 'bn.js';
 import assert from 'minimalistic-assert';
 
 import { addHexPrefix, removeHexPrefix } from './encode';
@@ -28,7 +28,7 @@ export function hexToDecimalString(hex: string): string {
 }
 
 export function toFelt(num: BigNumberish): string {
-  if (isBN(num)) {
+  if (BN.isBN(num)) {
     return num.toString();
   }
   return toBN(num).toString();

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  format: ['cjs'],
+  globalName: 'starknet',
+});

package/account/default.d.ts

@@ -1,30 +0,0 @@
-import { ProviderInterface, ProviderOptions } from '../provider';
-import { Provider } from '../provider/default';
-import { BlockIdentifier } from '../provider/utils';
-import { SignerInterface } from '../signer';
-import { Abi, Call, DeclareContractResponse, DeployContractResponse, EstimateFeeAction, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
-import { EstimateFee, EstimateFeeDetails } from '../types/account';
-import { AllowArray, DeclareContractPayload, DeployAccountContractPayload, UniversalDeployerContractPayload } from '../types/lib';
-import { BigNumberish } from '../utils/number';
-import { TypedData } from '../utils/typedData';
-import { AccountInterface } from './interface';
-export declare class Account extends Provider implements AccountInterface {
-    signer: SignerInterface;
-    address: string;
-    constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
-    getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
-    estimateFee(calls: AllowArray<Call>, estimateFeeDetails?: EstimateFeeDetails | undefined): Promise<EstimateFee>;
-    estimateInvokeFee(calls: AllowArray<Call>, { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
-    estimateDeclareFee({ classHash, contract }: DeclareContractPayload, { blockIdentifier, nonce: providedNonce }?: EstimateFeeDetails): Promise<EstimateFee>;
-    estimateAccountDeployFee({ classHash, addressSalt, constructorCalldata, contractAddress: providedContractAddress, }: DeployAccountContractPayload, { blockIdentifier, nonce: providedNonce }?: EstimateFeeDetails): Promise<EstimateFee>;
-    execute(calls: AllowArray<Call>, abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
-    declare({ classHash, contract }: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
-    deploy({ classHash, salt, unique, constructorCalldata, isDevnet, }: UniversalDeployerContractPayload, additionalCalls?: AllowArray<Call>, // support multicall
-    transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
-    deployAccount({ classHash, constructorCalldata, addressSalt, contractAddress: providedContractAddress, }: DeployAccountContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeployContractResponse>;
-    signMessage(typedData: TypedData): Promise<Signature>;
-    hashMessage(typedData: TypedData): Promise<string>;
-    verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-    verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
-    getSuggestedMaxFee(estimateFeeAction: EstimateFeeAction, details: EstimateFeeDetails): Promise<string>;
-}