starknet 3.10.1 → 3.11.0

package/www/docs/API/provider.md

@@ -6,5 +6,208 @@ sidebar_position: 1
 
 The **Provider** API allows you to interface with the StarkNet network, without signing transactions or messages.
 
-Typically, these are *read* calls on the blockchain.
+Typically, these are _read_ calls on the blockchain.
 
+## Creating an instance
+
+`new starknet.Provider(optionsOrProvider)`
+
+The options for the provider depends from the network. The structure of the options object is:
+
+- options.**baseUrl** - Base URL of the network
+- options.**feederGatewayUrl** - Feeder Gateway Endpoint of the network
+- options.**gatewayUrl** - Gateway Endpoint
+
+Example:
+
+```
+const provider = new starknet.Provider({
+    baseUrl: 'https://alpha4.starknet.io',
+    feederGatewayUrl: 'feeder_gateway',
+    gatewayUrl: 'gateway',
+})
+```
+
+**This is also default options for the constructor for the **testnet\*\*\*
+
+## Methods
+
+Gets the smart contract address on the network
+
+provider.**getContractAddresses**() => _Promise < GetContractAddressesResponse >_
+
+```
+{
+  Starknet: string;
+  GpsStatementVerifier: string;
+}
+```
+
+<hr/>
+
+provider.**callContract**(call [ , options ]) => _Promise < CallContractResponse >_
+
+Calls a function on the StarkNet contract.
+
+The call object structure:
+
+- call.**contractAddress** - Address of the contract
+- call.**entrypoint** - Entrypoint of the call (method name)
+- call.**calldata** - Payload for the invoking the method
+
+The options object structure:
+
+- options.**blockIdentifier**
+
+###### CallContractResponse
+
+```
+{
+    result: string[];
+}
+```
+
+<hr/>
+
+provider.**getBlock**(blockIdentifire) => _Promise < GetBlockResponse >_
+
+Gets the block information.
+
+###### _GetBlockResponse_
+
+```
+{
+  block_hash: string;
+  parent_block_hash: string;
+  block_number: number;
+  state_root: string;
+  status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  transation: Transaction[];
+  timestamp: number;
+  transaction_receipts: [];
+}
+```
+
+<hr/>
+
+provider.**getCode**(contractAddress, blockIdentifire) => _Promise < GetCodeResponse >_
+
+Gets the code of the deployed contract.
+
+###### _GetCodeResponse_
+
+```
+{
+  bytecode: string[];
+  abi: Abi;
+}
+```
+
+<hr/>
+
+provider.**getStorageAt**(contractAddress, key, blockIdentifire) => _Promise < any >_
+
+Gets the contract's storage variable at a specific key
+
+<hr/>
+
+provider.**getTransactionStatus**(txHash) => _Promise < GetTransactionStatusResponse >_
+
+Gets the status of a transaction.
+
+###### _GetTransactionStatusResponse_
+
+```
+{
+  tx_status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  block_hash: string;
+  tx_failure_reason?: {
+    tx_id: number;
+    code: string;
+    error_message: string;
+  }
+}
+```
+
+<hr/>
+
+provider.**getTransactionReceipt**(txHash, txId) => _Promise < TransactionReceipt >_
+
+Gets the status of a transaction.
+
+###### _TransactionReceipt_
+
+```
+{
+  status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  transaction_hash: string;
+  transaction_index: number;
+  block_hash: string;
+  block_number: 'pending' | null | number;
+  l2_to_l1_messages: string[];
+  events: string[];
+}
+```
+
+<hr/>
+
+provider.**getTransaction**(txHash) => _Promise < GetTransactionResponse >_
+
+Gets the transaction information from a tx hash.
+
+###### _GetTransactionResponse_
+
+```
+{
+    status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+    transaction: Transaction;
+    block_hash: string;
+    block_number: 'pending' | null | number;
+    transaction_index: number;
+    transaction_hash: string;
+}
+```
+
+<hr/>
+
+provider.**getTransactionTrace**(txHash) => _Promise < GetTransactionTraceResponse >_
+
+Gets the transaction trace from a tx hash.
+
+###### _GetTransactionTraceResponse_
+
+```
+{
+  function_invocation: {
+    caller_address: string;
+    contract_address: string;
+    code_address: string;
+    selector: string;
+    calldata: {
+        [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
+    };
+    result: Array<any>;
+    execution_resources: any;
+    internal_call: Array<any>;
+    events: Array<any>;
+    messages: Array<any>;
+  };
+  signature: Signature;
+}
+```
+
+<hr/>
+
+provider.**deployContract**(payload [ , abi ]) => _Promise < AddTransactionResponse >_
+
+Gets the transaction trace from a tx hash.
+
+###### _AddTransactionResponse_
+
+```
+{
+  code: 'TRANSACTION_RECEIVED';
+  transaction_hash: string;
+  address?: string;
+};
+```

package/www/docs/API/signer.md

@@ -6,3 +6,38 @@ sidebar_position: 3
 
 The **Signer** API allows you to sign transactions and messages, and also allows you to get the public key.
 
+## Creating an instance
+
+`new starknet.Signer(keyPair)`
+
+## Signer Methods
+
+signer.**getPubKey**() => _Promise < string >_
+
+Returns public key of the signer
+
+<hr />
+
+signer.**signTransaction**(transactions, transactionsDetail [ , abi ]) => _Promise < Signature >_
+
+Returns signature of the transaction
+
+###### Signature
+
+```
+string[]
+```
+
+<hr />
+
+signer.**signMessage**(typedData, accountAddress) => _Promise < Signature >_
+
+Returns signature of the transaction
+
+###### Signature
+
+```
+string[]
+```
+
+<hr />

package/www/docs/API/utils.md

@@ -0,0 +1,34 @@
+---
+sidebar_position: 6
+---
+
+# Utils
+
+Util functions are provided so you can use low level functions in your application.
+
+## `address`
+
+the address helpers can be imported using:
+
+```js
+import { address } from 'starknet.js';
+```
+
+### `getChecksumAddress(address: BigNumberish): string`
+
+This function accepts an address as a `BigNumberish` and returns the checksummed address as a string.
+An example:
+
+```js
+import { address } from 'starknet.js';
+
+const addressToCheck = '0x2fd23d9182193775423497fc0c472e156c57c69e4089a1967fb288a2d84e914';
+
+const checksummedAddress = address.getChecksumAddress(addressToCheck);
+
+console.log(checksummedAddress); // 0x02FD23D9182193775423497Fc0c472E156C57C69E4089a1967fb288a2D84e914
+```
+
+### `validateChecksumAddress(address: string): boolean`
+
+This function validates the checksum address. It returns true if the address is valid, false otherwise.

package/www/docusaurus.config.js

@@ -41,8 +41,7 @@ const config = {
         blog: {
           showReadingTime: true,
           // Please change this to your repo.
-          editUrl:
-            'https://github.com/0xs34n/starknet.js',
+          editUrl: 'https://github.com/0xs34n/starknet.js',
         },
         theme: {
           customCss: require.resolve('./src/css/custom.css'),
@@ -70,11 +69,11 @@ const config = {
           {
             position: 'left',
             label: 'Guides',
-            to: '/guides/intro'
+            to: '/guides/intro',
           },
           // {to: '/blog', label: 'Blog', position: 'left'},
           {
-            href: 'https://github.com/facebook/docusaurus',
+            href: 'https://github.com/0xs34n/starknet.js',
             label: 'GitHub',
             position: 'right',
           },

package/www/guides/account.md

@@ -17,7 +17,7 @@ import fs from "fs";
 import * as starknet from "starknet";
 ```
 
-##  Generate random key pair.
+## Generate random key pair.
 
 You can also get a key pair from a private key using `getKeyPair(pk: BigNumberish)`
 

package/www/guides/erc20.md

@@ -1,6 +1,7 @@
 ---
 sidebar_position: 3
 ---
+
 # Deploy an ERC20 Contract
 
 Dpeploy the contract and wait for deployment transaction to be accepted on StarkNet
@@ -15,13 +16,16 @@ const erc20Response = await defaultProvider.deployContract({
 console.log("Waiting for Tx to be Accepted on Starknet - ERC20 Deployment...");
 await defaultProvider.waitForTransaction(erc20Response.transaction_hash);
 ```
+
 ## Get the erc20 contract address and create the contact object
+
 ```javascript
 const erc20Address = erc20Response.address;
 const erc20 = new Contract(compiledErc20.abi, erc20Address);
 ```
 
 ## Mint tokens to an account address
+
 ```javascript
 const { transaction_hash: mintTxHash } = await erc20.mint(
   accountContract.address,
@@ -32,6 +36,7 @@ await defaultProvider.waitForTransaction(mintTxHash);
 ```
 
 ## Check balance after mint
+
 ```javascript
 console.log(`Calling StarkNet for accountContract balance...`);
 const balanceBeforeTransfer = await erc20.balance_of(accountContract.address);
@@ -43,6 +48,7 @@ console.log(
 ```
 
 ## Transfer tokens
+
 ```javascript
 // Get the nonce of the account and prepare transfer tx
 console.log(`Calling StarkNet for accountContract nonce...`);
@@ -76,6 +82,7 @@ await defaultProvider.waitForTransaction(transferTxHash);
 ```
 
 ## Check balance after transfer
+
 ```javascript
 // Check balance after transfer - should be 990
 console.log(`Calling StarkNet for accountContract balance...`);

package/www/guides/intro.md

@@ -17,4 +17,5 @@ npm install starknet@next
 Please check the StarkNet documentation <ins>[here](https://www.cairo-lang.org/docs/hello_starknet/intro.html)</ins> to compile starknet contracts.
 
 ## Full example with account & erc20
+
 Please see workshop <ins>[here](https://github.com/0xs34n/starknet.js-workshop)</ins>

package/www/sidebars.js

@@ -14,7 +14,7 @@
 /** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
 const sidebars = {
   // By default, Docusaurus generates a sidebar from the docs folder structure
-  tutorialSidebar: [{type: 'autogenerated', dirName: '.'}],
+  tutorialSidebar: [{ type: 'autogenerated', dirName: '.' }],
 
   // But you can create a sidebar manually
   /*

package/dist/signer/ledger.d.ts

@@ -1,12 +0,0 @@
-import { Invocation, InvocationsSignerDetails, Signature } from '../types';
-import { TypedData } from '../utils/typedData';
-import { SignerInterface } from './interface';
-export declare class LedgerBlindSigner implements SignerInterface {
-    derivationPath: string;
-    private transport;
-    private getEthApp;
-    getPubKey(): Promise<string>;
-    signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails): Promise<Signature>;
-    signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
-    protected sign(msgHash: string): Promise<Signature>;
-}

package/dist/signer/ledger.js

@@ -1,140 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LedgerBlindSigner = void 0;
-var hw_app_eth_1 = __importDefault(require("@ledgerhq/hw-app-eth"));
-var hw_transport_webhid_1 = __importDefault(require("@ledgerhq/hw-transport-webhid"));
-var encode_1 = require("../utils/encode");
-var hash_1 = require("../utils/hash");
-var transaction_1 = require("../utils/transaction");
-var typedData_1 = require("../utils/typedData");
-function hexZeroPad(hash, length) {
-    var value = hash;
-    if (value.length > 2 * length + 2) {
-        throw new Error('value out of range');
-    }
-    while (value.length < 2 * length + 2) {
-        value = "0x0" + value.substring(2);
-    }
-    return value;
-}
-var LedgerBlindSigner = /** @class */ (function () {
-    function LedgerBlindSigner() {
-        this.derivationPath = "/2645'/579218131'/1148870696'/0'/0'/0";
-    }
-    LedgerBlindSigner.prototype.getEthApp = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!!this.transport) return [3 /*break*/, 4];
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        _a = this;
-                        return [4 /*yield*/, hw_transport_webhid_1.default.create()];
-                    case 2:
-                        _a.transport = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _b = _c.sent();
-                        throw new Error('Device connection error');
-                    case 4: return [2 /*return*/, new hw_app_eth_1.default(this.transport)];
-                }
-            });
-        });
-    };
-    LedgerBlindSigner.prototype.getPubKey = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var eth, response, starkPub;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getEthApp()];
-                    case 1:
-                        eth = _a.sent();
-                        return [4 /*yield*/, eth.starkGetPublicKey(this.derivationPath)];
-                    case 2:
-                        response = _a.sent();
-                        starkPub = "0x" + response.slice(1, 1 + 32).toString('hex');
-                        return [2 /*return*/, starkPub];
-                }
-            });
-        });
-    };
-    LedgerBlindSigner.prototype.signTransaction = function (transactions, transactionsDetail) {
-        return __awaiter(this, void 0, void 0, function () {
-            var calldata, msgHash;
-            return __generator(this, function (_a) {
-                calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, transactionsDetail.nonce);
-                msgHash = (0, hash_1.calculcateTransactionHash)(transactionsDetail.walletAddress, transactionsDetail.version, (0, hash_1.getSelectorFromName)('__execute__'), calldata, transactionsDetail.maxFee, transactionsDetail.chainId);
-                return [2 /*return*/, this.sign(msgHash)];
-            });
-        });
-    };
-    LedgerBlindSigner.prototype.signMessage = function (typedData, accountAddress) {
-        return __awaiter(this, void 0, void 0, function () {
-            var msgHash;
-            return __generator(this, function (_a) {
-                msgHash = (0, typedData_1.getMessageHash)(typedData, accountAddress);
-                return [2 /*return*/, this.sign(msgHash)];
-            });
-        });
-    };
-    LedgerBlindSigner.prototype.sign = function (msgHash) {
-        return __awaiter(this, void 0, void 0, function () {
-            var eth, _a, r, s;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getEthApp()];
-                    case 1:
-                        eth = _b.sent();
-                        return [4 /*yield*/, eth.starkUnsafeSign(this.derivationPath, hexZeroPad(msgHash, 32))];
-                    case 2:
-                        _a = (_b.sent()), r = _a.r, s = _a.s;
-                        return [2 /*return*/, [(0, encode_1.addHexPrefix)(r), (0, encode_1.addHexPrefix)(s)]];
-                }
-            });
-        });
-    };
-    return LedgerBlindSigner;
-}());
-exports.LedgerBlindSigner = LedgerBlindSigner;

package/signer/ledger.d.ts

@@ -1,15 +0,0 @@
-import { Invocation, InvocationsSignerDetails, Signature } from '../types';
-import { TypedData } from '../utils/typedData';
-import { SignerInterface } from './interface';
-export declare class LedgerBlindSigner implements SignerInterface {
-  derivationPath: string;
-  private transport;
-  private getEthApp;
-  getPubKey(): Promise<string>;
-  signTransaction(
-    transactions: Invocation[],
-    transactionsDetail: InvocationsSignerDetails
-  ): Promise<Signature>;
-  signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
-  protected sign(msgHash: string): Promise<Signature>;
-}