starknet 2.7.0 → 2.9.0

package/src/provider/default.ts

@@ -3,7 +3,6 @@ import urljoin from 'url-join';
 
 import {
   AddTransactionResponse,
-  BlockNumber,
   CallContractResponse,
   CallContractTransaction,
   CompiledContract,
@@ -19,7 +18,7 @@ import { parse, stringify } from '../utils/json';
 import { BigNumberish, toBN, toHex } from '../utils/number';
 import { compressProgram, formatSignature, randomAddress } from '../utils/stark';
 import { ProviderInterface } from './interface';
-import { getFormattedBlockIdentifier } from './utils';
+import { BlockIdentifier, getFormattedBlockIdentifier } from './utils';
 
 type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
 
@@ -93,10 +92,9 @@ export class Provider implements ProviderInterface {
    */
   public async callContract(
     invokeTransaction: CallContractTransaction,
-    blockHash?: BigNumberish,
-    blockNumber: BlockNumber = null
+    blockIdentifier: BlockIdentifier = null
   ): Promise<CallContractResponse> {
-    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockHash, blockNumber);
+    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockIdentifier);
 
     const { data } = await axios.post<CallContractResponse>(
       urljoin(this.feederGatewayUrl, 'call_contract', formattedBlockIdentifier),
@@ -118,11 +116,8 @@ export class Provider implements ProviderInterface {
    * @param blockNumber
    * @returns the block object { block_number, previous_block_number, state_root, status, timestamp, transaction_receipts, transactions }
    */
-  public async getBlock(
-    blockHash?: BigNumberish,
-    blockNumber: BlockNumber = null
-  ): Promise<GetBlockResponse> {
-    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockHash, blockNumber);
+  public async getBlock(blockIdentifier: BlockIdentifier = null): Promise<GetBlockResponse> {
+    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockIdentifier);
 
     const { data } = await axios.get<GetBlockResponse>(
       urljoin(this.feederGatewayUrl, 'get_block', formattedBlockIdentifier)
@@ -142,10 +137,9 @@ export class Provider implements ProviderInterface {
    */
   public async getCode(
     contractAddress: string,
-    blockHash?: BigNumberish,
-    blockNumber: BlockNumber = null
+    blockIdentifier: BlockIdentifier = null
   ): Promise<GetCodeResponse> {
-    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockHash, blockNumber);
+    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockIdentifier);
 
     const { data } = await axios.get<GetCodeResponse>(
       urljoin(
@@ -172,10 +166,9 @@ export class Provider implements ProviderInterface {
   public async getStorageAt(
     contractAddress: string,
     key: number,
-    blockHash?: BigNumberish,
-    blockNumber: BlockNumber = null
+    blockIdentifier: BlockIdentifier = null
   ): Promise<object> {
-    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockHash, blockNumber);
+    const formattedBlockIdentifier = getFormattedBlockIdentifier(blockIdentifier);
 
     const { data } = await axios.get<object>(
       urljoin(

package/src/provider/interface.ts

@@ -1,6 +1,5 @@
 import type {
   AddTransactionResponse,
-  BlockNumber,
   CallContractResponse,
   CallContractTransaction,
   CompiledContract,
@@ -13,6 +12,7 @@ import type {
   Transaction,
 } from '../types';
 import type { BigNumberish } from '../utils/number';
+import { BlockIdentifier } from './utils';
 
 export abstract class ProviderInterface {
   public abstract baseUrl: string;
@@ -35,14 +35,12 @@ export abstract class ProviderInterface {
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L25-L39)
    *
    * @param invokeTransaction - transaction to be invoked
-   * @param blockHash
-   * @param blockNumber
+   * @param blockIdentifier - block identifier
    * @returns the result of the function on the smart contract.
    */
   public abstract callContract(
     invokeTransaction: CallContractTransaction,
-    blockHash?: BigNumberish,
-    blockNumber?: BlockNumber
+    blockIdentifier?: BlockIdentifier
   ): Promise<CallContractResponse>;
 
   /**
@@ -50,29 +48,23 @@ export abstract class ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L41-L53)
    *
-   * @param blockHash
-   * @param blockNumber
+   * @param blockIdentifier - block identifier
    * @returns the block object { block_number, previous_block_number, state_root, status, timestamp, transaction_receipts, transactions }
    */
-  public abstract getBlock(
-    blockHash?: BigNumberish,
-    blockNumber?: BlockNumber
-  ): Promise<GetBlockResponse>;
+  public abstract getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
 
   /**
    * Gets the code of the deployed contract.
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L55-L68)
    *
-   * @param contractAddress
-   * @param blockHash
-   * @param blockNumber
+   * @param contractAddress - contract address
+   * @param blockIdentifier - block identifier
    * @returns Bytecode and ABI of compiled contract
    */
   public abstract getCode(
     contractAddress: string,
-    blockHash?: BigNumberish,
-    blockNumber?: BlockNumber
+    blockIdentifier?: BlockIdentifier
   ): Promise<GetCodeResponse>;
 
   // TODO: add proper type
@@ -83,15 +75,13 @@ export abstract class ProviderInterface {
    *
    * @param contractAddress
    * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-   * @param blockHash
-   * @param blockNumber
+   * @param blockIdentifier - block identifier
    * @returns the value of the storage variable
    */
   public abstract getStorageAt(
     contractAddress: string,
     key: number,
-    blockHash?: BigNumberish,
-    blockNumber?: BlockNumber
+    blockIdentifier?: BlockIdentifier
   ): Promise<object>;
 
   /**

package/src/provider/utils.ts

@@ -1,5 +1,5 @@
 import type { BlockNumber } from '../types';
-import { BigNumberish } from '../utils/number';
+import { BigNumberish, toBN, toHex } from '../utils/number';
 
 /**
  * TODO
@@ -18,6 +18,42 @@ export function formatHash() {}
  */
 export function txIdentifier() {}
 
+// hex string and BN are detected as block hashes
+// decimal string and number are detected as block numbers
+// null appends nothing to the request url
+export type BlockIdentifier = BlockNumber | BigNumberish;
+type BlockIdentifierObject =
+  | { type: 'BLOCK_NUMBER'; data: BlockNumber }
+  | { type: 'BLOCK_HASH'; data: BigNumberish };
+
+/**
+ * Identifies the block to be queried.
+ *
+ * @param blockIdentifier - block identifier
+ * @returns block identifier object
+ */
+export function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdentifierObject {
+  if (typeof blockIdentifier === 'number') {
+    return { type: 'BLOCK_NUMBER', data: blockIdentifier };
+  }
+  if (typeof blockIdentifier === 'string' && blockIdentifier.startsWith('0x')) {
+    return { type: 'BLOCK_HASH', data: blockIdentifier };
+  }
+  if (typeof blockIdentifier === 'string' && !Number.isNaN(parseInt(blockIdentifier, 10))) {
+    return { type: 'BLOCK_NUMBER', data: parseInt(blockIdentifier, 10) };
+  }
+  if (blockIdentifier === null) {
+    return { type: 'BLOCK_NUMBER', data: null };
+  }
+  if (blockIdentifier === 'pending') {
+    return { type: 'BLOCK_NUMBER', data: 'pending' };
+  }
+  if (typeof blockIdentifier === 'string') {
+    throw new Error(`Invalid block identifier: ${blockIdentifier}`);
+  }
+  return { type: 'BLOCK_HASH', data: blockIdentifier };
+}
+
 /**
  * Gets the block identifier for API request
  *
@@ -27,12 +63,13 @@ export function txIdentifier() {}
  * @param blockHash
  * @returns block identifier for API request
  */
-export function getFormattedBlockIdentifier(
-  blockHash?: BigNumberish,
-  blockNumber: BlockNumber = null
-): string {
-  if (blockHash) {
-    return `?blockHash=${blockHash}`;
-  }
-  return `?blockNumber=${blockNumber}`;
+export function getFormattedBlockIdentifier(blockIdentifier: BlockIdentifier = null): string {
+  const blockIdentifierObject = getBlockIdentifier(blockIdentifier);
+  if (blockIdentifierObject.type === 'BLOCK_NUMBER' && blockIdentifierObject.data === null) {
+    return '';
+  }
+  if (blockIdentifierObject.type === 'BLOCK_NUMBER') {
+    return `?blockNumber=${blockIdentifierObject.data}`;
+  }
+  return `?blockHash=${toHex(toBN(blockIdentifierObject.data))}`;
 }

package/src/signer/default.ts

@@ -1,11 +1,12 @@
 import assert from 'minimalistic-assert';
 
+import { compileCalldata } from '../contract';
 import { Provider } from '../provider';
 import { AddTransactionResponse, KeyPair, Signature, Transaction } from '../types';
 import { sign } from '../utils/ellipticCurve';
 import { addHexPrefix } from '../utils/encode';
 import { hashMessage } from '../utils/hash';
-import { toBN } from '../utils/number';
+import { BigNumberish, toBN } from '../utils/number';
 import { getSelectorFromName } from '../utils/stark';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
@@ -98,4 +99,42 @@ export class Signer extends Provider implements SignerInterface {
   public async hashMessage(typedData: TypedData): Promise<string> {
     return getMessageHash(typedData, this.address);
   }
+
+  /**
+   * Verify a signature of a JSON object
+   *
+   * @param json - JSON object to be verified
+   * @param signature - signature of the JSON object
+   * @returns true if the signature is valid, false otherwise
+   * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature
+   */
+  public async verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean> {
+    try {
+      await this.callContract({
+        contract_address: this.address,
+        entry_point_selector: getSelectorFromName('is_valid_signature'),
+        calldata: compileCalldata({
+          hash: toBN(hash).toString(),
+          signature: signature.map((x) => toBN(x).toString()),
+        }),
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Verify a signature of a given hash
+   * @warning This method is not recommended, use verifyMessage instead
+   *
+   * @param hash - hash to be verified
+   * @param signature - signature of the hash
+   * @returns true if the signature is valid, false otherwise
+   * @throws {Error} if the signature is not a valid signature
+   */
+  public async verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean> {
+    const hash = await this.hashMessage(typedData);
+    return this.verifyMessageHash(hash, signature);
+  }
 }

package/src/signer/interface.ts

@@ -1,5 +1,6 @@
 import { Provider } from '../provider';
 import { AddTransactionResponse, Signature, Transaction } from '../types';
+import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 
 export abstract class SignerInterface extends Provider {
@@ -35,4 +36,25 @@ export abstract class SignerInterface extends Provider {
    * @throws {Error} if the JSON object is not a valid JSON
    */
   public abstract hashMessage(typedData: TypedData): Promise<string>;
+
+  /**
+   * Verify a signature of a JSON object
+   *
+   * @param json - JSON object to be verified
+   * @param signature - signature of the JSON object
+   * @returns true if the signature is valid, false otherwise
+   * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature
+   */
+  public abstract verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
+
+  /**
+   * Verify a signature of a given hash
+   * @warning This method is not recommended, use verifyMessage instead
+   *
+   * @param hash - hash to be verified
+   * @param signature - signature of the hash
+   * @returns true if the signature is valid, false otherwise
+   * @throws {Error} if the signature is not a valid signature
+   */
+  public abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
 }

package/src/types.ts

@@ -80,7 +80,7 @@ export type CallContractResponse = {
 };
 
 export type GetBlockResponse = {
-  sequence_number: number;
+  block_number: number;
   state_root: string;
   block_hash: string;
   transactions: {

package/src/utils/address.ts

@@ -0,0 +1,23 @@
+import { MASK_251, ZERO } from '../constants';
+import { addHexPrefix, removeHexPrefix } from './encode';
+import { assertInRange } from './number';
+
+export function addAddressPadding(address: string): string {
+  return addHexPrefix(removeHexPrefix(address).padStart(64, '0'));
+}
+
+export function validateAndParseAddress(address: string): string {
+  if (typeof address !== 'string') {
+    throw new Error('Invalid Address Type');
+  }
+
+  assertInRange(address, ZERO, MASK_251, 'Starknet Address');
+
+  const result = addAddressPadding(address);
+
+  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
+    throw new Error('Invalid Address Format');
+  }
+
+  return result;
+}

package/types.d.ts

@@ -69,7 +69,7 @@ export declare type CallContractResponse = {
   result: string[];
 };
 export declare type GetBlockResponse = {
-  sequence_number: number;
+  block_number: number;
   state_root: string;
   block_hash: string;
   transactions: {

package/utils/address.d.ts

@@ -0,0 +1,2 @@
+export declare function addAddressPadding(address: string): string;
+export declare function validateAndParseAddress(address: string): string;

package/utils/address.js

@@ -0,0 +1,22 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.validateAndParseAddress = exports.addAddressPadding = void 0;
+var constants_1 = require('../constants');
+var encode_1 = require('./encode');
+var number_1 = require('./number');
+function addAddressPadding(address) {
+  return (0, encode_1.addHexPrefix)((0, encode_1.removeHexPrefix)(address).padStart(64, '0'));
+}
+exports.addAddressPadding = addAddressPadding;
+function validateAndParseAddress(address) {
+  if (typeof address !== 'string') {
+    throw new Error('Invalid Address Type');
+  }
+  (0, number_1.assertInRange)(address, constants_1.ZERO, constants_1.MASK_251, 'Starknet Address');
+  var result = addAddressPadding(address);
+  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
+    throw new Error('Invalid Address Format');
+  }
+  return result;
+}
+exports.validateAndParseAddress = validateAndParseAddress;