starknet 4.9.0 → 4.11.0

package/src/provider/rpc.ts

@@ -8,7 +8,6 @@ import {
   EstimateFeeResponse,
   GetBlockResponse,
   GetCodeResponse,
-  GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
   InvocationsDetailsWithNonce,
@@ -17,8 +16,8 @@ import {
 import { RPC } from '../types/api';
 import {
   DeclareContractTransaction,
-  DeployAccountContractPayload,
   DeployAccountContractTransaction,
+  InvocationsDetails,
 } from '../types/lib';
 import fetch from '../utils/fetchPonyfill';
 import { getSelectorFromName } from '../utils/hash';
@@ -38,6 +37,7 @@ import { Block, BlockIdentifier } from './utils';
 export type RpcProviderOptions = {
   nodeUrl: string;
   retries?: number;
+  headers?: object;
 };
 
 export class RpcProvider implements ProviderInterface {
@@ -46,14 +46,17 @@ export class RpcProvider implements ProviderInterface {
   // from interface
   public chainId!: StarknetChainId;
 
+  public headers: object;
+
   private responseParser = new RPCResponseParser();
 
   private retries: number;
 
   constructor(optionsOrProvider: RpcProviderOptions) {
-    const { nodeUrl, retries } = optionsOrProvider;
+    const { nodeUrl, retries, headers } = optionsOrProvider;
     this.nodeUrl = nodeUrl;
     this.retries = retries || 200;
+    this.headers = { 'Content-Type': 'application/json', ...headers };
 
     this.getChainId().then((chainId) => {
       this.chainId = chainId;
@@ -61,10 +64,10 @@ export class RpcProvider implements ProviderInterface {
   }
 
   public fetch(method: any, params: any): Promise<any> {
-    return fetch(this.nodeUrl, {
+    return fetch(`${this.nodeUrl}/rpc/v0.2`, {
       method: 'POST',
       body: stringify({ method, jsonrpc: '2.0', params, id: 0 }),
-      headers: { 'Content-Type': 'application/json' },
+      headers: this.headers,
     });
   }
 
@@ -121,8 +124,8 @@ export class RpcProvider implements ProviderInterface {
   }
 
   public async getClassHashAt(
-    blockIdentifier: BlockIdentifier,
-    contractAddress: RPC.ContractAddress
+    contractAddress: RPC.ContractAddress,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.Felt> {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint('starknet_getClassHashAt', {
@@ -150,7 +153,9 @@ export class RpcProvider implements ProviderInterface {
     throw new Error('Pathfinder does not implement this rpc 0.1.0 method');
   }
 
-  public async getStateUpdate(blockIdentifier: BlockIdentifier): Promise<RPC.StateUpdate> {
+  public async getStateUpdate(
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<RPC.StateUpdate> {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint('starknet_getStateUpdate', { block_id });
   }
@@ -186,17 +191,21 @@ export class RpcProvider implements ProviderInterface {
     return this.fetchEndpoint('starknet_getTransactionByBlockIdAndIndex', { block_id, index });
   }
 
-  public async getTransactionReceipt(txHash: string): Promise<GetTransactionReceiptResponse> {
+  public async getTransactionReceipt(txHash: string): Promise<RPC.TransactionReceipt> {
     return this.fetchEndpoint('starknet_getTransactionReceipt', { transaction_hash: txHash });
   }
 
-  public async getClass(classHash: RPC.Felt): Promise<RPC.ContractClass> {
-    return this.fetchEndpoint('starknet_getClass', { class_hash: classHash });
+  public async getClass(
+    classHash: RPC.Felt,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<RPC.ContractClass> {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getClass', { class_hash: classHash, block_id });
   }
 
   public async getClassAt(
     contractAddress: string,
-    blockIdentifier: BlockIdentifier
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.ContractClass> {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint('starknet_getClassAt', {
@@ -209,7 +218,7 @@ export class RpcProvider implements ProviderInterface {
     _contractAddress: string,
     _blockIdentifier?: BlockIdentifier
   ): Promise<GetCodeResponse> {
-    throw new Error('RPC 0.1.0 does not implement getCode function');
+    throw new Error('RPC does not implement getCode function');
   }
 
   public async getEstimateFee(
@@ -293,46 +302,58 @@ export class RpcProvider implements ProviderInterface {
     details: InvocationsDetailsWithNonce
   ): Promise<DeclareContractResponse> {
     return this.fetchEndpoint('starknet_addDeclareTransaction', {
-      contract_class: {
-        program: contractDefinition.program,
-        entry_points_by_type: contractDefinition.entry_points_by_type,
-        abi: contractDefinition.abi, // rpc 2.0
+      declare_transaction: {
+        contract_class: {
+          program: contractDefinition.program,
+          entry_points_by_type: contractDefinition.entry_points_by_type,
+          abi: contractDefinition.abi, // rpc 2.0
+        },
+        type: 'DECLARE',
+        version: toHex(toBN(details.version || 0)),
+        max_fee: toHex(toBN(details.maxFee || 0)),
+        signature: bigNumberishArrayToHexadecimalStringArray(signature || []),
+        sender_address: senderAddress,
+        nonce: toHex(toBN(details.nonce)),
       },
-      version: toHex(toBN(details.version || 0)),
-      max_fee: toHex(toBN(details.maxFee || 0)),
-      signature: bigNumberishArrayToHexadecimalStringArray(signature || []),
-      sender_address: senderAddress,
-      nonce: toHex(toBN(details.nonce)),
     });
   }
 
-  public async deployContract({
-    contract,
-    constructorCalldata,
-    addressSalt,
-  }: DeployContractPayload): Promise<DeployContractResponse> {
+  /**
+   * @deprecated This method wont be supported soon, use Account.deploy instead
+   */
+  public async deployContract(
+    { contract, constructorCalldata, addressSalt }: DeployContractPayload,
+    details?: InvocationsDetails
+  ): Promise<DeployContractResponse> {
     const contractDefinition = parseContract(contract);
-
     return this.fetchEndpoint('starknet_addDeployTransaction', {
-      contract_address_salt: addressSalt ?? randomAddress(),
-      constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata ?? []),
-      contract_definition: {
-        program: contractDefinition.program,
-        entry_points_by_type: contractDefinition.entry_points_by_type,
-        abi: contractDefinition.abi, // rpc 2.0
+      deploy_transaction: {
+        contract_address_salt: addressSalt ?? randomAddress(),
+        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata ?? []),
+        contract_class: {
+          program: contractDefinition.program,
+          entry_points_by_type: contractDefinition.entry_points_by_type,
+          abi: contractDefinition.abi,
+        },
+        type: 'DEPLOY',
+        version: toHex(toBN(details?.version || 0)),
       },
     });
   }
 
-  public async deployAccountContract({
-    classHash,
-    constructorCalldata,
-    addressSalt,
-  }: DeployAccountContractPayload): Promise<DeployContractResponse> {
+  public async deployAccountContract(
+    { classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeployContractResponse> {
     return this.fetchEndpoint('starknet_addDeployAccountTransaction', {
       constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
       class_hash: toHex(toBN(classHash)),
       contract_address_salt: toHex(toBN(addressSalt || 0)),
+      type: 'DEPLOY',
+      max_fee: toHex(toBN(details.maxFee || 0)),
+      version: toHex(toBN(details.version || 0)),
+      signature: bigNumberishArrayToHexadecimalStringArray(signature || []),
+      nonce: toHex(toBN(details.nonce)),
     });
   }
 
@@ -341,13 +362,15 @@ export class RpcProvider implements ProviderInterface {
     details: InvocationsDetailsWithNonce
   ): Promise<InvokeFunctionResponse> {
     return this.fetchEndpoint('starknet_addInvokeTransaction', {
-      function_invocation: {
-        contract_address: functionInvocation.contractAddress,
+      invoke_transaction: {
+        sender_address: functionInvocation.contractAddress,
         calldata: parseCalldata(functionInvocation.calldata),
+        type: 'INVOKE',
+        max_fee: toHex(toBN(details.maxFee || 0)),
+        version: toHex(toBN(details.version || 0)),
+        signature: bigNumberishArrayToHexadecimalStringArray(functionInvocation.signature || []),
+        nonce: toHex(toBN(details.nonce)),
       },
-      signature: bigNumberishArrayToHexadecimalStringArray(functionInvocation.signature || []),
-      max_fee: toHex(toBN(details.maxFee || 0)),
-      version: toHex(toBN(details.version || 0)),
     });
   }
 
@@ -391,6 +414,11 @@ export class RpcProvider implements ProviderInterface {
         // eslint-disable-next-line no-await-in-loop
         const res = await this.getTransactionReceipt(txHash);
 
+        if (!('status' in res)) {
+          const error = new Error('pending transaction');
+          throw error;
+        }
+
         if (res.status && successStates.includes(res.status)) {
           onchain = true;
         } else if (res.status && errorStates.includes(res.status)) {
@@ -423,7 +451,7 @@ export class RpcProvider implements ProviderInterface {
    * @returns Number of transactions
    */
   public async getTransactionCount(
-    blockIdentifier: BlockIdentifier
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.GetTransactionCountResponse> {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint('starknet_getBlockTransactionCount', { block_id });

package/src/provider/sequencer.ts

@@ -44,7 +44,7 @@ import { GatewayError, HttpError } from './errors';
 import { ProviderInterface } from './interface';
 import { Block, BlockIdentifier } from './utils';
 
-type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
+type NetworkName = 'mainnet-alpha' | 'goerli-alpha' | 'goerli-alpha-2';
 
 function isEmptyQueryObject(obj?: Record<any, any>): obj is undefined {
   return (
@@ -62,6 +62,7 @@ export type SequencerProviderOptions =
       feederGatewayUrl?: string;
       gatewayUrl?: string;
       chainId?: StarknetChainId;
+      headers?: object;
     };
 
 export class SequencerProvider implements ProviderInterface {
@@ -73,9 +74,11 @@ export class SequencerProvider implements ProviderInterface {
 
   public chainId: StarknetChainId;
 
+  public headers: object | undefined;
+
   private responseParser = new SequencerAPIResponseParser();
 
-  constructor(optionsOrProvider: SequencerProviderOptions = { network: 'goerli-alpha' }) {
+  constructor(optionsOrProvider: SequencerProviderOptions = { network: 'goerli-alpha-2' }) {
     if ('network' in optionsOrProvider) {
       this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
       this.chainId = SequencerProvider.getChainIdFromBaseUrl(this.baseUrl);
@@ -93,6 +96,8 @@ export class SequencerProvider implements ProviderInterface {
       this.chainId =
         optionsOrProvider.chainId ??
         SequencerProvider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
+
+      this.headers = optionsOrProvider?.headers;
     }
   }
 
@@ -101,6 +106,9 @@ export class SequencerProvider implements ProviderInterface {
       case 'mainnet-alpha':
         return 'https://alpha-mainnet.starknet.io';
       case 'goerli-alpha':
+        return 'https://alpha4.starknet.io';
+      case 'goerli-alpha-2':
+        return 'https://alpha4-2.starknet.io';
       default:
         return 'https://alpha4.starknet.io';
     }
@@ -153,13 +161,14 @@ export class SequencerProvider implements ProviderInterface {
     return `?${queryString}`;
   }
 
-  private getHeaders(method: 'POST' | 'GET'): Record<string, string> | undefined {
+  private getHeaders(method: 'POST' | 'GET'): object | undefined {
     if (method === 'POST') {
       return {
         'Content-Type': 'application/json',
+        ...this.headers,
       };
     }
-    return undefined;
+    return this.headers;
   }
 
   // typesafe fetch
@@ -291,6 +300,17 @@ export class SequencerProvider implements ProviderInterface {
     );
   }
 
+  public async getClassHashAt(
+    contractAddress: string,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<string> {
+    return this.fetchEndpoint('get_class_hash_at', { blockIdentifier, contractAddress });
+  }
+
+  public async getClass(classHash: string): Promise<ContractClass> {
+    return this.fetchEndpoint('get_class_by_hash', { classHash }).then(parseContract);
+  }
+
   public async invokeFunction(
     functionInvocation: Invocation,
     details: InvocationsDetailsWithNonce

package/src/signer/default.ts

@@ -28,6 +28,11 @@ export class Signer implements SignerInterface {
     return getStarkKey(this.keyPair);
   }
 
+  public async signMessage(typedData: TypedData, accountAddress: string): Promise<Signature> {
+    const msgHash = getMessageHash(typedData, accountAddress);
+    return sign(this.keyPair, msgHash);
+  }
+
   public async signTransaction(
     transactions: Call[],
     transactionsDetail: InvocationsSignerDetails,
@@ -52,22 +57,6 @@ export class Signer implements SignerInterface {
     return sign(this.keyPair, msgHash);
   }
 
-  public async signDeclareTransaction(
-    // contractClass: ContractClass,  // Should be used once class hash is present in ContractClass
-    { classHash, senderAddress, chainId, maxFee, version, nonce }: DeclareSignerDetails
-  ) {
-    const msgHash = calculateDeclareTransactionHash(
-      classHash,
-      senderAddress,
-      version,
-      maxFee,
-      chainId,
-      nonce
-    );
-
-    return sign(this.keyPair, msgHash);
-  }
-
   public async signDeployAccountTransaction({
     classHash,
     contractAddress,
@@ -92,8 +81,19 @@ export class Signer implements SignerInterface {
     return sign(this.keyPair, msgHash);
   }
 
-  public async signMessage(typedData: TypedData, accountAddress: string): Promise<Signature> {
-    const msgHash = getMessageHash(typedData, accountAddress);
+  public async signDeclareTransaction(
+    // contractClass: ContractClass,  // Should be used once class hash is present in ContractClass
+    { classHash, senderAddress, chainId, maxFee, version, nonce }: DeclareSignerDetails
+  ) {
+    const msgHash = calculateDeclareTransactionHash(
+      classHash,
+      senderAddress,
+      version,
+      maxFee,
+      chainId,
+      nonce
+    );
+
     return sign(this.keyPair, msgHash);
   }
 }

package/src/signer/interface.ts

@@ -40,6 +40,7 @@ export abstract class SignerInterface {
 
   /**
    * Signs a DEPLOY_ACCOUNT transaction with the starknet private key and returns the signature
+   *
    * @param transaction
    * - contractAddress - the computed address of the contract
    * - constructorCalldata - calldata to be passed in deploy constructor
@@ -56,6 +57,7 @@ export abstract class SignerInterface {
 
   /**
    * Signs a DECLARE transaction with the starknet private key and returns the signature
+   *
    * @param transaction
    * - classHash - computed class hash. Will be replaced by ContractClass in future once class hash is present in CompiledContract
    * - senderAddress - the address of the sender

package/src/types/api/index.ts

@@ -1,10 +1,6 @@
 import { BigNumberish } from '../../utils/number';
 import { Signature } from '../lib';
 
-export type RawArgs = {
-  [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
-};
-
 export type Calldata = string[];
 
 export type Overrides = {