feat: get_compiled_class_by_class_hash, get_class_by_hash, ContractCl…

…ass, rpc hotfix

__tests__/fixtures.ts

@@ -2,10 +2,10 @@ import fs from 'fs';
 import path from 'path';
 
 import { Account, ProviderInterface, RpcProvider, SequencerProvider, json } from '../src';
-import { CompiledContract, waitForTransactionOptions } from '../src/types';
+import { LegacyCompiledContract, waitForTransactionOptions } from '../src/types';
 import { toHex } from '../src/utils/number';
 
-const readContract = (name: string): CompiledContract =>
+const readContract = (name: string): LegacyCompiledContract =>
   json.parse(
     fs.readFileSync(path.resolve(__dirname, `../__mocks__/${name}.json`)).toString('ascii')
   );

src/account/default.ts

@@ -309,6 +309,8 @@ export class Account extends Provider implements AccountInterface {
 
     const classHash = providedClassHash ?? computeContractClassHash(contract);
 
+    if (!classHash) throw new Error('declare classHash is undefined');
+
     const maxFee =
       transactionsDetail.maxFee ??
       (await this.getSuggestedMaxFee(
@@ -527,6 +529,7 @@ export class Account extends Provider implements AccountInterface {
   ): Promise<DeclareContractTransaction> {
     const contractDefinition = parseContract(contract);
     const classHash = providedClassHash ?? computeContractClassHash(contract);
+    if (!classHash) throw new Error('buildDeclarePayload classHash is undefined');
     const signature = await this.signer.signDeclareTransaction({
       classHash,
       senderAddress: walletAddress,

src/provider/default.ts

@@ -17,6 +17,7 @@ import {
   InvocationBulk,
   InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
+  RPC,
   StateUpdateResponse,
   TransactionSimulationResponse,
   waitForTransactionOptions,
@@ -69,7 +70,7 @@ export class Provider implements ProviderInterface {
   public async getClassAt(
     contractAddress: string,
     blockIdentifier?: BlockIdentifier
-  ): Promise<ContractClass> {
+  ): Promise<ContractClass | RPC.ContractClass> {
     return this.provider.getClassAt(contractAddress, blockIdentifier);
   }
 
@@ -80,7 +81,7 @@ export class Provider implements ProviderInterface {
     return this.provider.getClassHashAt(contractAddress, blockIdentifier);
   }
 
-  public getClassByHash(classHash: string): Promise<ContractClass> {
+  public getClassByHash(classHash: string): Promise<ContractClass | RPC.ContractClass> {
     return this.provider.getClassByHash(classHash);
   }
 

src/provider/interface.ts

@@ -18,6 +18,7 @@ import type {
   InvocationBulk,
   InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
+  RPC,
   StateUpdateResponse,
   TransactionSimulationResponse,
   waitForTransactionOptions,
@@ -71,7 +72,7 @@ export abstract class ProviderInterface {
   public abstract getClassAt(
     contractAddress: string,
     blockIdentifier?: BlockIdentifier
-  ): Promise<ContractClass>;
+  ): Promise<ContractClass | RPC.ContractClass>;
 
   /**
    * Returns the class hash deployed under the given address.
@@ -91,7 +92,7 @@ export abstract class ProviderInterface {
    * @param classHash - class hash
    * @returns Contract class of compiled contract
    */
-  public abstract getClassByHash(classHash: string): Promise<ContractClass>;
+  public abstract getClassByHash(classHash: string): Promise<ContractClass | RPC.ContractClass>;
 
   /**
    * Gets the nonce of a contract with respect to a specific block

src/provider/rpc.ts

@@ -268,22 +268,26 @@ export class RpcProvider implements ProviderInterface {
     blockIdentifier: BlockIdentifier = this.blockIdentifier
   ): Promise<EstimateFeeResponse> {
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint('starknet_estimateFee', {
-      request: {
-        type: RPC.TransactionType.DECLARE,
-        contract_class: {
-          program: contractDefinition.program,
-          entry_points_by_type: contractDefinition.entry_points_by_type,
-          abi: contractDefinition.abi, // rpc 2.0
+    if ('program' in contractDefinition) {
+      return this.fetchEndpoint('starknet_estimateFee', {
+        request: {
+          type: RPC.TransactionType.DECLARE,
+          contract_class: {
+            program: contractDefinition.program,
+            entry_points_by_type: contractDefinition.entry_points_by_type,
+            abi: contractDefinition.abi, // rpc 2.0
+          },
+          sender_address: senderAddress,
+          signature: signatureToHexArray(signature),
+          version: toHex(details?.version || 0),
+          nonce: toHex(details.nonce),
+          max_fee: toHex(details?.maxFee || 0),
         },
-        sender_address: senderAddress,
-        signature: signatureToHexArray(signature),
-        version: toHex(details?.version || 0),
-        nonce: toHex(details.nonce),
-        max_fee: toHex(details?.maxFee || 0),
-      },
-      block_id,
-    }).then(this.responseParser.parseFeeEstimateResponse);
+        block_id,
+      }).then(this.responseParser.parseFeeEstimateResponse);
+    }
+    // TODO: When RPC Update implement Siera
+    throw new Error('RPC do not support Siera Contracts yet');
   }
 
   public async getDeployAccountEstimateFee(
@@ -319,21 +323,25 @@ export class RpcProvider implements ProviderInterface {
     { contractDefinition, signature, senderAddress }: DeclareContractTransaction,
     details: InvocationsDetailsWithNonce
   ): Promise<DeclareContractResponse> {
-    return this.fetchEndpoint('starknet_addDeclareTransaction', {
-      declare_transaction: {
-        contract_class: {
-          program: contractDefinition.program,
-          entry_points_by_type: contractDefinition.entry_points_by_type,
-          abi: contractDefinition.abi, // rpc 2.0
+    if ('program' in contractDefinition) {
+      return this.fetchEndpoint('starknet_addDeclareTransaction', {
+        declare_transaction: {
+          contract_class: {
+            program: contractDefinition.program,
+            entry_points_by_type: contractDefinition.entry_points_by_type,
+            abi: contractDefinition.abi, // rpc 2.0
+          },
+          type: RPC.TransactionType.DECLARE,
+          version: toHex(details.version || 0),
+          max_fee: toHex(details.maxFee || 0),
+          signature: signatureToHexArray(signature),
+          sender_address: senderAddress,
+          nonce: toHex(details.nonce),
         },
-        type: RPC.TransactionType.DECLARE,
-        version: toHex(details.version || 0),
-        max_fee: toHex(details.maxFee || 0),
-        signature: signatureToHexArray(signature),
-        sender_address: senderAddress,
-        nonce: toHex(details.nonce),
-      },
-    });
+      });
+    }
+    // TODO: When RPC Update implement Siera
+    throw new Error('RPC do not support Siera Contracts yet');
   }
 
   public async deployAccountContract(

src/provider/sequencer.ts

@@ -2,6 +2,7 @@ import urljoin from 'url-join';
 
 import { BaseUrl, NetworkName, StarknetChainId } from '../constants';
 import {
+  CairoAssembly,
   Call,
   CallContractResponse,
   CallL1Handler,
@@ -336,8 +337,20 @@ export class SequencerProvider implements ProviderInterface {
     return this.fetchEndpoint('get_class_hash_at', { blockIdentifier, contractAddress });
   }
 
-  public async getClassByHash(classHash: string): Promise<ContractClass> {
-    return this.fetchEndpoint('get_class_by_hash', { classHash }).then(parseContract);
+  public async getClassByHash(
+    classHash: string,
+    blockIdentifier: BlockIdentifier = this.blockIdentifier
+  ): Promise<ContractClass> {
+    return this.fetchEndpoint('get_class_by_hash', { classHash, blockIdentifier }).then(
+      parseContract
+    );
+  }
+
+  public async getCompiledClassByClassHash(
+    classHash: string,
+    blockIdentifier: BlockIdentifier = this.blockIdentifier
+  ): Promise<CairoAssembly> {
+    return this.fetchEndpoint('get_compiled_class_by_class_hash', { classHash, blockIdentifier });
   }
 
   public async invokeFunction(

src/types/api/sequencer.ts

@@ -4,6 +4,9 @@ import {
   Abi,
   AllowArray,
   BlockNumber,
+  ByteCode,
+  CairoAssembly,
+  CompiledContract,
   ContractClass,
   EntryPointType,
   RawCalldata,
@@ -144,7 +147,7 @@ export namespace Sequencer {
   };
 
   export type GetCodeResponse = {
-    bytecode: string[];
+    bytecode: ByteCode;
     abi: Abi;
   };
 
@@ -385,9 +388,10 @@ export namespace Sequencer {
     get_class_by_hash: {
       QUERY: {
         classHash: string;
+        blockIdentifier?: BlockIdentifier;
       };
       REQUEST: never;
-      RESPONSE: any;
+      RESPONSE: CompiledContract;
     };
     get_class_hash_at: {
       QUERY: {
@@ -411,7 +415,7 @@ export namespace Sequencer {
         blockIdentifier?: BlockIdentifier;
       };
       REQUEST: never;
-      RESPONSE: any;
+      RESPONSE: CompiledContract;
     };
     estimate_message_fee: {
       QUERY: any;
@@ -440,5 +444,13 @@ export namespace Sequencer {
       REQUEST: never;
       RESPONSE: BlockTransactionTracesResponse;
     };
+    get_compiled_class_by_class_hash: {
+      QUERY: {
+        classHash: string;
+        blockIdentifier?: BlockIdentifier;
+      };
+      REQUEST: any;
+      RESPONSE: CairoAssembly;
+    };
   };
 }

src/types/lib.ts

@@ -1,6 +1,5 @@
 import { weierstrass } from '../utils/ec';
 import type { BigNumberish } from '../utils/number';
-import { RPC } from './api/rpc';
 
 // Common Signature Type which needs to be imported from weierstrass
 // and imported at many places
@@ -18,11 +17,30 @@ export type RawArgs =
     }
   | BigNumberish[];
 
-export interface ContractClass {
+// Cairo Contract Class
+export type ContractClass = LegacyContractClass | SieraContractClass;
+
+// TODO: Clean this mess with types
+
+export type SieraContractClass = {
+  sierra_program: ByteCode;
+  sierra_program_debug_info: SieraProgramDebugInfo;
+  contract_class_version: string;
+  entry_points_by_type: EntryPointsByType;
+  abi: Abi;
+};
+
+export type SieraProgramDebugInfo = {
+  type_names: [number, string][];
+  libfunc_names: [number, string][];
+  user_func_names: [number, string][];
+};
+
+export type LegacyContractClass = {
   program: CompressedProgram;
-  entry_points_by_type: RPC.ContractClass['entry_points_by_type'];
-  abi?: Abi;
-}
+  entry_points_by_type: EntryPointsByType;
+  abi: Abi;
+};
 
 export type UniversalDeployerContractPayload = {
   classHash: BigNumberish;
@@ -170,18 +188,15 @@ export type EntryPointsByType = {
 export interface Program extends Record<string, any> {
   builtins: string[];
   data: string[];
+  // TODO: Add missing properties
 }
 export type BlockTag = 'pending' | 'latest';
 export type BlockNumber = BlockTag | null | number;
 
-export type CompiledContract = {
-  abi: Abi;
-  entry_points_by_type: EntryPointsByType;
-  program: Program;
-};
+export type CompiledContract = LegacyCompiledContract | SieraContractClass;
 
-export type CompressedCompiledContract = Omit<CompiledContract, 'program'> & {
-  program: CompressedProgram;
+export type LegacyCompiledContract = Omit<LegacyContractClass, 'program'> & {
+  program: Program;
 };
 
 export type Struct = {
@@ -199,3 +214,13 @@ export type waitForTransactionOptions = {
   retryInterval?: number;
   successStates?: Array<TransactionStatus>;
 };
+
+export type CairoAssembly = {
+  prime: string;
+  compiler_version: string;
+  bytecode: ByteCode;
+  hints: any[];
+  entry_points_by_type: EntryPointsByType;
+};
+
+export type ByteCode = string[];

src/types/provider.ts

@@ -11,6 +11,7 @@ import {
 } from './api/sequencer';
 import {
   AllowArray,
+  ByteCode,
   Call,
   DeclareContractPayload,
   DeployAccountContractPayload,
@@ -36,7 +37,7 @@ export interface GetBlockResponse {
 }
 
 export interface GetCodeResponse {
-  bytecode: string[];
+  bytecode: ByteCode;
   // abi: string; // is not consistent between rpc and sequencer (is it?), therefore not included in the provider interface
 }