starknet 3.18.2 → 3.19.0

package/__tests__/fixtures.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 
-import { Account, Provider, ec, json } from '../src';
+import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
 import { CompiledContract } from '../src/types';
 
 const readContract = (name: string): CompiledContract =>
@@ -18,10 +18,20 @@ const DEFAULT_TEST_ACCOUNT_ADDRESS = // run `starknet-devnet --seed 0` and this
 const DEFAULT_TEST_ACCOUNT_PRIVATE_KEY = '0xe3e70682c2094cac629f6fbed82c07cd';
 
 const BASE_URL = process.env.TEST_PROVIDER_BASE_URL || DEFAULT_TEST_PROVIDER_BASE_URL;
-export const IS_DEVNET = !BASE_URL.includes('starknet.io');
+const RPC_URL = process.env.TEST_RPC_URL;
+
+const IS_RPC = !!RPC_URL;
+const IS_RPC_DEVNET = Boolean(
+  RPC_URL && (RPC_URL.includes('localhost') || RPC_URL.includes('127.0.0.1'))
+);
+const IS_SEQUENCER = !IS_RPC;
+const IS_SEQUENCER_DEVNET = !BASE_URL.includes('starknet.io');
+export const IS_DEVNET = IS_SEQUENCER ? IS_SEQUENCER_DEVNET : IS_RPC_DEVNET;
 
 export const getTestProvider = () => {
-  const provider = new Provider({ baseUrl: BASE_URL });
+  const provider = RPC_URL
+    ? new RpcProvider({ nodeUrl: RPC_URL })
+    : new SequencerProvider({ baseUrl: BASE_URL });
 
   if (IS_DEVNET) {
     // accelerate the tests when running locally
@@ -35,16 +45,27 @@ export const getTestProvider = () => {
 };
 
 // test account with fee token balance
-export const getTestAccount = () => {
-  const provider = getTestProvider();
+export const getTestAccount = (provider: ProviderInterface) => {
+  let testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS;
+  let testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
+
+  if (!IS_DEVNET) {
+    if (!testAccountPrivateKey) {
+      throw new Error('TEST_ACCOUNT_PRIVATE_KEY is not set');
+    }
 
-  const testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS || DEFAULT_TEST_ACCOUNT_ADDRESS;
-  const testAccountPrivateKey =
-    process.env.TEST_ACCOUNT_PRIVATE_KEY || DEFAULT_TEST_ACCOUNT_PRIVATE_KEY;
+    if (!testAccountAddress) {
+      throw new Error('TEST_ACCOUNT_ADDRESS is not set');
+    }
+  } else {
+    testAccountAddress = DEFAULT_TEST_ACCOUNT_ADDRESS;
+    testAccountPrivateKey = DEFAULT_TEST_ACCOUNT_PRIVATE_KEY;
+  }
 
   return new Account(provider, testAccountAddress, ec.getKeyPair(testAccountPrivateKey));
 };
 
-export const testIf = (condition: boolean) => (condition ? test : test.skip);
-export const testIfDevnet = testIf(IS_DEVNET);
-export const testIfNotDevnet = testIf(!IS_DEVNET);
+const describeIf = (condition: boolean) => (condition ? describe : describe.skip);
+export const describeIfSequencer = describeIf(IS_DEVNET);
+export const describeIfRpc = describeIf(IS_RPC);
+export const describeIfNotDevnet = describeIf(!IS_DEVNET);

package/__tests__/rpcProvider.test.ts

@@ -0,0 +1,17 @@
+import { RpcProvider } from '../src';
+import { describeIfRpc, getTestProvider } from './fixtures';
+
+describeIfRpc('RPCProvider', () => {
+  let provider: RpcProvider;
+
+  beforeAll(async () => {
+    provider = getTestProvider() as RpcProvider;
+  });
+
+  describe('RPC methods', () => {
+    test('getChainId', async () => {
+      const chainId = await provider.getChainId();
+      expect(chainId).toBe('0x534e5f474f45524c49');
+    });
+  });
+});

package/__tests__/sequencerProvider.test.ts

@@ -0,0 +1,45 @@
+import { SequencerProvider } from '../src';
+import {
+  compiledErc20,
+  describeIfNotDevnet,
+  describeIfSequencer,
+  getTestProvider,
+} from './fixtures';
+
+describeIfSequencer('SequencerProvider', () => {
+  let provider: SequencerProvider;
+
+  beforeAll(async () => {
+    provider = getTestProvider() as SequencerProvider;
+  });
+
+  describe('Gateway specific methods', () => {
+    let exampleTransactionHash: string;
+
+    beforeAll(async () => {
+      const { transaction_hash } = await provider.deployContract({
+        contract: compiledErc20,
+      });
+      await provider.waitForTransaction(transaction_hash);
+      exampleTransactionHash = transaction_hash;
+    });
+
+    test('getTransactionStatus()', async () => {
+      return expect(provider.getTransactionStatus(exampleTransactionHash)).resolves.not.toThrow();
+    });
+
+    test('transaction trace', async () => {
+      const transactionTrace = await provider.getTransactionTrace(exampleTransactionHash);
+      expect(transactionTrace).toHaveProperty('function_invocation');
+      expect(transactionTrace).toHaveProperty('signature');
+    });
+
+    describeIfNotDevnet('which are not available on devnet', () => {
+      test('getContractAddresses()', async () => {
+        const { GpsStatementVerifier, Starknet } = await provider.getContractAddresses();
+        expect(typeof GpsStatementVerifier).toBe('string');
+        expect(typeof Starknet).toBe('string');
+      });
+    });
+  });
+});

package/account/default.d.ts

@@ -1,84 +1,61 @@
-import { Provider, ProviderInterface } from '../provider';
+import { ProviderInterface, ProviderOptions } from '../provider';
+import { Provider } from '../provider/default';
 import { SignerInterface } from '../signer';
-import {
-  Abi,
-  AddTransactionResponse,
-  Call,
-  InvocationsDetails,
-  KeyPair,
-  Signature,
-  Transaction,
-} from '../types';
+import { Abi, Call, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
 export declare class Account extends Provider implements AccountInterface {
-  address: string;
-  signer: SignerInterface;
-  constructor(
-    provider: ProviderInterface,
-    address: string,
-    keyPairOrSigner: KeyPair | SignerInterface
-  );
-  getNonce(): Promise<string>;
-  estimateFee(
-    calls: Call | Call[],
-    { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails
-  ): Promise<EstimateFee>;
-  /**
-   * Invoke execute function in account contract
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-   *
-   * @param calls - one or more calls to be executed
-   * @param abis - one or more abis which can be used to display the calls
-   * @param transactionsDetail - optional transaction details
-   * @returns a confirmation of invoking a function on the starknet contract
-   */
-  execute(
-    calls: Call | Call[],
-    abis?: Abi[] | undefined,
-    transactionsDetail?: InvocationsDetails
-  ): Promise<AddTransactionResponse>;
-  /**
-   * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
-   * @deprecated to remove ASAP
-   */
-  LEGACY_addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
-  /**
-   * Sign an JSON object with the starknet private key and return the signature
-   *
-   * @param json - JSON object to be signed
-   * @returns the signature of the JSON object
-   * @throws {Error} if the JSON object is not a valid JSON
-   */
-  signMessage(typedData: TypedData): Promise<Signature>;
-  /**
-   * Hash a JSON object with pederson hash and return the hash
-   *
-   * @param json - JSON object to be hashed
-   * @returns the hash of the JSON object
-   * @throws {Error} if the JSON object is not a valid JSON
-   */
-  hashMessage(typedData: TypedData): Promise<string>;
-  /**
-   * Verify a signature of a given hash
-   * @warning This method is not recommended, use verifyMessage instead
-   *
-   * @param hash - 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
-   */
-  verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-  /**
-   * Verify a signature of a JSON object
-   *
-   * @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
-   */
-  verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
+    address: string;
+    signer: SignerInterface;
+    constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
+    getNonce(): Promise<string>;
+    estimateFee(calls: Call | Call[], { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
+    /**
+     * Invoke execute function in account contract
+     *
+     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
+     *
+     * @param calls - one or more calls to be executed
+     * @param abis - one or more abis which can be used to display the calls
+     * @param transactionsDetail - optional transaction details
+     * @returns a confirmation of invoking a function on the starknet contract
+     */
+    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    /**
+     * Sign an JSON object with the starknet private key and return the signature
+     *
+     * @param json - JSON object to be signed
+     * @returns the signature of the JSON object
+     * @throws {Error} if the JSON object is not a valid JSON
+     */
+    signMessage(typedData: TypedData): Promise<Signature>;
+    /**
+     * Hash a JSON object with pederson hash and return the hash
+     *
+     * @param json - JSON object to be hashed
+     * @returns the hash of the JSON object
+     * @throws {Error} if the JSON object is not a valid JSON
+     */
+    hashMessage(typedData: TypedData): Promise<string>;
+    /**
+     * Verify a signature of a given hash
+     * @warning This method is not recommended, use verifyMessage instead
+     *
+     * @param hash - 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
+     */
+    verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
+    /**
+     * Verify a signature of a JSON object
+     *
+     * @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
+     */
+    verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
 }