starknet 4.11.0 → 4.12.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+# [4.12.0](https://github.com/0xs34n/starknet.js/compare/v4.11.0...v4.12.0) (2022-11-17)
+
+### Bug Fixes
+
+- **tests:** refactor udc tests ([01a6eef](https://github.com/0xs34n/starknet.js/commit/01a6eef11b2f32e05d2aea4ab185536e3fdb1a71))
+- use method name similar to gateway endpoint ([79641b3](https://github.com/0xs34n/starknet.js/commit/79641b3076412d71fa4e5ccbdb018c4f3ecab938))
+
+### Features
+
+- create getClass RPC alias ([1003534](https://github.com/0xs34n/starknet.js/commit/10035341dd26e23b59d3dd764936a7d8eaa3f3b0))
+
 # [4.11.0](https://github.com/0xs34n/starknet.js/compare/v4.10.0...v4.11.0) (2022-11-14)
 
 ### Bug Fixes

package/__tests__/account.test.ts

@@ -4,9 +4,13 @@ import typedDataExample from '../__mocks__/typedDataExample.json';
 import { Account, Contract, Provider, number, stark } from '../src';
 import { feeTransactionVersion } from '../src/utils/hash';
 import { toBN } from '../src/utils/number';
+import { encodeShortString } from '../src/utils/shortString';
+import { randomAddress } from '../src/utils/stark';
 import {
+  IS_DEVNET,
   compiledErc20,
   compiledTestDapp,
+  erc20ClassHash,
   getERC20DeployPayload,
   getTestAccount,
   getTestProvider,
@@ -159,4 +163,38 @@ describe('deploy and test Wallet', () => {
       expect(declareTx.class_hash).toBeDefined();
     });
   });
+
+  describe('Declare and UDC Deploy Flow', () => {
+    test('ERC20 Declare', async () => {
+      const declareTx = await account.declare({
+        classHash: erc20ClassHash,
+        contract: compiledErc20,
+      });
+
+      await provider.waitForTransaction(declareTx.transaction_hash);
+
+      expect(declareTx).toHaveProperty('class_hash');
+      expect(declareTx.class_hash).toEqual(erc20ClassHash);
+    });
+
+    test('UDC Deploy', async () => {
+      const salt = randomAddress(); // use random salt
+
+      const deployment = await account.deploy({
+        classHash: erc20ClassHash,
+        constructorCalldata: [
+          encodeShortString('Token'),
+          encodeShortString('ERC20'),
+          account.address,
+        ],
+        salt,
+        unique: true, // Using true here so as not to clash with normal erc20 deploy in account and provider test
+        isDevnet: IS_DEVNET,
+      });
+
+      await provider.waitForTransaction(deployment.transaction_hash);
+
+      expect(deployment).toHaveProperty('transaction_hash');
+    });
+  });
 });

package/__tests__/defaultProvider.test.ts

@@ -1,6 +1,6 @@
 import { BlockNumber, GetBlockResponse, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { getERC20DeployPayload, getTestProvider } from './fixtures';
+import { erc20ClassHash, getERC20DeployPayload, getTestProvider } from './fixtures';
 
 const { compileCalldata } = stark;
 
@@ -8,7 +8,7 @@ const testProvider = getTestProvider();
 
 describe('defaultProvider', () => {
   let exampleTransactionHash: string;
-  let exampleContractAddress: string;
+  let erc20ContractAddress: string;
 
   let exampleBlock: GetBlockResponse;
   let exampleBlockNumber: BlockNumber;
@@ -23,7 +23,7 @@ describe('defaultProvider', () => {
     );
     await testProvider.waitForTransaction(transaction_hash);
     exampleTransactionHash = transaction_hash;
-    exampleContractAddress = contract_address;
+    erc20ContractAddress = contract_address;
 
     exampleBlock = await testProvider.getBlock('latest');
     exampleBlockHash = exampleBlock.block_hash;
@@ -32,7 +32,7 @@ describe('defaultProvider', () => {
 
   describe('endpoints', () => {
     test('deployContract()', () => {
-      expect(exampleContractAddress).toBeTruthy();
+      expect(erc20ContractAddress).toBeTruthy();
       expect(exampleTransactionHash).toBeTruthy();
     });
 
@@ -75,43 +75,41 @@ describe('defaultProvider', () => {
     });
 
     test('getNonce()', async () => {
-      const nonce = await testProvider.getNonce(exampleContractAddress);
+      const nonce = await testProvider.getNonce(erc20ContractAddress);
       return expect(nonce).toEqual('0x0');
     });
 
     test('getClassAt(contractAddress, blockNumber="latest")', async () => {
-      const classResponse = await testProvider.getClassAt(exampleContractAddress);
+      const classResponse = await testProvider.getClassAt(erc20ContractAddress);
 
       expect(classResponse).toHaveProperty('program');
       expect(classResponse).toHaveProperty('entry_points_by_type');
     });
 
     // TODO see if feasible to split
-    describe('getClassHashAt & GetClass', () => {
+    describe('GetClassByHash', () => {
       test('responses', async () => {
-        const classHash = await testProvider.getClassHashAt(exampleContractAddress);
-        expect(typeof classHash).toBe('string');
-
-        const classResponse = await testProvider.getClass(classHash);
+        const classResponse = await testProvider.getClassByHash(erc20ClassHash);
         expect(classResponse).toHaveProperty('program');
         expect(classResponse).toHaveProperty('entry_points_by_type');
+        expect(classResponse).toHaveProperty('abi');
       });
     });
 
     describe('getStorageAt', () => {
       test('with "key" type of number', () => {
-        return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
+        return expect(testProvider.getStorageAt(erc20ContractAddress, 0)).resolves.not.toThrow();
       });
 
       test('"key" type of string', () => {
         return expect(
-          testProvider.getStorageAt(exampleContractAddress, '0x0')
+          testProvider.getStorageAt(erc20ContractAddress, '0x0')
         ).resolves.not.toThrow();
       });
 
       test('with "key" type of BN', () => {
         return expect(
-          testProvider.getStorageAt(exampleContractAddress, toBN('0x0'))
+          testProvider.getStorageAt(erc20ContractAddress, toBN('0x0'))
         ).resolves.not.toThrow();
       });
     });
@@ -135,7 +133,7 @@ describe('defaultProvider', () => {
       test('callContract()', () => {
         return expect(
           testProvider.callContract({
-            contractAddress: exampleContractAddress,
+            contractAddress: erc20ContractAddress,
             entrypoint: 'balanceOf',
             calldata: compileCalldata({
               user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
@@ -148,7 +146,7 @@ describe('defaultProvider', () => {
         return expect(
           testProvider
             .callContract({
-              contractAddress: exampleContractAddress,
+              contractAddress: erc20ContractAddress,
               entrypoint: 'balanceOf',
               calldata: compileCalldata({
                 user: wallet,
@@ -163,7 +161,7 @@ describe('defaultProvider', () => {
       test('callContract() - gateway error', async () => {
         return expect(
           testProvider.callContract({
-            contractAddress: exampleContractAddress,
+            contractAddress: erc20ContractAddress,
             entrypoint: 'non_existent_entrypoint',
             calldata: compileCalldata({
               user: '0xdeadbeef',

package/__tests__/fixtures.ts

@@ -73,6 +73,8 @@ export const describeIfSequencer = describeIf(IS_DEVNET);
 export const describeIfRpc = describeIf(IS_RPC);
 export const describeIfNotDevnet = describeIf(!IS_DEVNET);
 
+export const erc20ClassHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
+
 export const getERC20DeployPayload = (recipient: string): DeployContractPayload => {
   return {
     contract: compiledErc20,

package/dist/provider/default.d.ts

@@ -18,7 +18,7 @@ export declare class Provider implements ProviderInterface {
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
-    getClass(classHash: string): Promise<ContractClass>;
+    getClassByHash(classHash: string): Promise<ContractClass>;
     getEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getInvokeEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;

package/dist/provider/default.js

@@ -92,8 +92,8 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.getClass = function (classHash) {
-        return this.provider.getClass(classHash);
+    Provider.prototype.getClassByHash = function (classHash) {
+        return this.provider.getClassByHash(classHash);
     };
     Provider.prototype.getEstimateFee = function (invocationWithTxType, invocationDetails, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }

package/dist/provider/interface.d.ts

@@ -52,7 +52,7 @@ export declare abstract class ProviderInterface {
      * @param classHash - class hash
      * @returns Contract class of compiled contract
      */
-    abstract getClass(classHash: string): Promise<ContractClass>;
+    abstract getClassByHash(classHash: string): Promise<ContractClass>;
     /**
      * Gets the nonce of a contract with respect to a specific block
      *

package/dist/provider/rpc.d.ts

@@ -35,6 +35,7 @@ export declare class RpcProvider implements ProviderInterface {
     getTransactionByHash(txHash: string): Promise<RPC.GetTransactionByHashResponse>;
     getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
     getTransactionReceipt(txHash: string): Promise<RPC.TransactionReceipt>;
+    getClassByHash(classHash: RPC.Felt): Promise<RPC.ContractClass>;
     getClass(classHash: RPC.Felt, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
     getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;

package/dist/provider/rpc.js

@@ -249,6 +249,13 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    RpcProvider.prototype.getClassByHash = function (classHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getClass(classHash)];
+            });
+        });
+    };
     RpcProvider.prototype.getClass = function (classHash, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {

package/dist/provider/sequencer.d.ts

@@ -39,7 +39,7 @@ export declare class SequencerProvider implements ProviderInterface {
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
-    getClass(classHash: string): Promise<ContractClass>;
+    getClassByHash(classHash: string): Promise<ContractClass>;
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
     deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;

package/dist/provider/sequencer.js

@@ -334,7 +334,7 @@ var SequencerProvider = /** @class */ (function () {
             });
         });
     };
-    SequencerProvider.prototype.getClass = function (classHash) {
+    SequencerProvider.prototype.getClassByHash = function (classHash) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, this.fetchEndpoint('get_class_by_hash', { classHash: classHash }).then(provider_1.parseContract)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "4.11.0",
+  "version": "4.12.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/provider/default.d.ts

@@ -18,7 +18,7 @@ export declare class Provider implements ProviderInterface {
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
-    getClass(classHash: string): Promise<ContractClass>;
+    getClassByHash(classHash: string): Promise<ContractClass>;
     getEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getInvokeEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;

package/provider/default.js

@@ -92,8 +92,8 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.getClass = function (classHash) {
-        return this.provider.getClass(classHash);
+    Provider.prototype.getClassByHash = function (classHash) {
+        return this.provider.getClassByHash(classHash);
     };
     Provider.prototype.getEstimateFee = function (invocationWithTxType, invocationDetails, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }

package/provider/interface.d.ts

@@ -52,7 +52,7 @@ export declare abstract class ProviderInterface {
      * @param classHash - class hash
      * @returns Contract class of compiled contract
      */
-    abstract getClass(classHash: string): Promise<ContractClass>;
+    abstract getClassByHash(classHash: string): Promise<ContractClass>;
     /**
      * Gets the nonce of a contract with respect to a specific block
      *

package/provider/rpc.d.ts

@@ -35,6 +35,7 @@ export declare class RpcProvider implements ProviderInterface {
     getTransactionByHash(txHash: string): Promise<RPC.GetTransactionByHashResponse>;
     getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
     getTransactionReceipt(txHash: string): Promise<RPC.TransactionReceipt>;
+    getClassByHash(classHash: RPC.Felt): Promise<RPC.ContractClass>;
     getClass(classHash: RPC.Felt, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
     getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;

package/provider/rpc.js

@@ -249,6 +249,13 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    RpcProvider.prototype.getClassByHash = function (classHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getClass(classHash)];
+            });
+        });
+    };
     RpcProvider.prototype.getClass = function (classHash, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {

package/provider/sequencer.d.ts

@@ -39,7 +39,7 @@ export declare class SequencerProvider implements ProviderInterface {
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getClassHashAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<string>;
-    getClass(classHash: string): Promise<ContractClass>;
+    getClassByHash(classHash: string): Promise<ContractClass>;
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<InvokeFunctionResponse>;
     deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
     deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;

package/provider/sequencer.js

@@ -334,7 +334,7 @@ var SequencerProvider = /** @class */ (function () {
             });
         });
     };
-    SequencerProvider.prototype.getClass = function (classHash) {
+    SequencerProvider.prototype.getClassByHash = function (classHash) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, this.fetchEndpoint('get_class_by_hash', { classHash: classHash }).then(provider_1.parseContract)];

package/src/provider/default.ts

@@ -72,8 +72,8 @@ export class Provider implements ProviderInterface {
     return this.provider.getClassHashAt(contractAddress, blockIdentifier);
   }
 
-  public getClass(classHash: string): Promise<ContractClass> {
-    return this.provider.getClass(classHash);
+  public getClassByHash(classHash: string): Promise<ContractClass> {
+    return this.provider.getClassByHash(classHash);
   }
 
   public async getEstimateFee(

package/src/provider/interface.ts

@@ -92,7 +92,7 @@ export abstract class ProviderInterface {
    * @param classHash - class hash
    * @returns Contract class of compiled contract
    */
-  public abstract getClass(classHash: string): Promise<ContractClass>;
+  public abstract getClassByHash(classHash: string): Promise<ContractClass>;
 
   /**
    * Gets the nonce of a contract with respect to a specific block

package/src/provider/rpc.ts

@@ -195,6 +195,10 @@ export class RpcProvider implements ProviderInterface {
     return this.fetchEndpoint('starknet_getTransactionReceipt', { transaction_hash: txHash });
   }
 
+  public async getClassByHash(classHash: RPC.Felt): Promise<RPC.ContractClass> {
+    return this.getClass(classHash);
+  }
+
   public async getClass(
     classHash: RPC.Felt,
     blockIdentifier: BlockIdentifier = 'pending'

package/src/provider/sequencer.ts

@@ -307,7 +307,7 @@ export class SequencerProvider implements ProviderInterface {
     return this.fetchEndpoint('get_class_hash_at', { blockIdentifier, contractAddress });
   }
 
-  public async getClass(classHash: string): Promise<ContractClass> {
+  public async getClassByHash(classHash: string): Promise<ContractClass> {
     return this.fetchEndpoint('get_class_by_hash', { classHash }).then(parseContract);
   }
 

package/__tests__/udc.test.ts

@@ -1,41 +0,0 @@
-import { encodeShortString } from '../src/utils/shortString';
-import { randomAddress } from '../src/utils/stark';
-import { IS_DEVNET, compiledErc20, getTestAccount, getTestProvider } from './fixtures';
-
-describe('Declare and UDC Deploy Flow', () => {
-  const provider = getTestProvider();
-  const account = getTestAccount(provider);
-  const erc20ClassHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
-
-  test('ERC20 Declare', async () => {
-    const declareTx = await account.declare({
-      classHash: erc20ClassHash,
-      contract: compiledErc20,
-    });
-
-    await provider.waitForTransaction(declareTx.transaction_hash);
-
-    expect(declareTx).toHaveProperty('class_hash');
-    expect(declareTx.class_hash).toEqual(erc20ClassHash);
-  });
-
-  test('UDC Deploy', async () => {
-    const salt = randomAddress(); // use random salt
-
-    const deployment = await account.deploy({
-      classHash: erc20ClassHash,
-      constructorCalldata: [
-        encodeShortString('Token'),
-        encodeShortString('ERC20'),
-        account.address,
-      ],
-      salt,
-      unique: true, // Using true here so as not to clash with normal erc20 deploy in account and provider test
-      isDevnet: IS_DEVNET,
-    });
-
-    await provider.waitForTransaction(deployment.transaction_hash);
-
-    expect(deployment).toHaveProperty('transaction_hash');
-  });
-});