starknet 3.5.1 → 3.8.0

package/signer/ledger.js

@@ -0,0 +1,243 @@
+'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 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 msgHash;
+      return __generator(this, function (_a) {
+        msgHash = (0, hash_1.hashMulticall)(
+          transactionsDetail.walletAddress,
+          transactions,
+          transactionsDetail.nonce.toString(),
+          transactionsDetail.maxFee.toString()
+        );
+        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/src/account/default.ts

@@ -1,11 +1,13 @@
 import assert from 'minimalistic-assert';
 
 import { Provider } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import { Signer, SignerInterface } from '../signer';
 import {
   Abi,
   AddTransactionResponse,
   Call,
+  EstimateFeeResponse,
   InvocationsDetails,
   InvokeFunctionTransaction,
   KeyPair,
@@ -30,9 +32,10 @@ export class Account extends Provider implements AccountInterface {
 
   private signer: SignerInterface;
 
-  constructor(provider: Provider, address: string, keyPair: KeyPair) {
+  constructor(provider: Provider, address: string, keyPairOrSigner: KeyPair | SignerInterface) {
     super(provider);
-    this.signer = new Signer(keyPair);
+    this.signer =
+      'getPubKey' in keyPairOrSigner ? keyPairOrSigner : new Signer(keyPairOrSigner as KeyPair);
     this.address = address;
   }
 
@@ -44,6 +47,35 @@ export class Account extends Provider implements AccountInterface {
     return toHex(toBN(result[0]));
   }
 
+  public async estimateFee(
+    calls: Call | Call[],
+    {
+      nonce: providedNonce,
+      blockIdentifier = 'pending',
+    }: { nonce?: BigNumberish; blockIdentifier?: BlockIdentifier } = {}
+  ): Promise<EstimateFeeResponse> {
+    const transactions = Array.isArray(calls) ? calls : [calls];
+    const nonce = providedNonce ?? (await this.getNonce());
+    const signerDetails = {
+      walletAddress: this.address,
+      nonce: toBN(nonce),
+      maxFee: toBN('0'),
+    };
+    const signature = await this.signer.signTransaction(transactions, signerDetails);
+
+    const calldata = [...fromCallsToExecuteCalldata(transactions), signerDetails.nonce.toString()];
+    return this.fetchEndpoint(
+      'estimate_fee',
+      { blockIdentifier },
+      {
+        contract_address: this.address,
+        entry_point_selector: getSelectorFromName('__execute__'),
+        calldata,
+        signature: bigNumberishArrayToDecimalStringArray(signature),
+      }
+    );
+  }
+
   /**
    * Invoke execute function in account contract
    *
@@ -58,23 +90,25 @@ export class Account extends Provider implements AccountInterface {
     transactionsDetail: InvocationsDetails = {}
   ): Promise<AddTransactionResponse> {
     const transactions = Array.isArray(calls) ? calls : [calls];
-
+    const nonce = toBN(transactionsDetail.nonce ?? (await this.getNonce()));
+    const maxFee =
+      transactionsDetail.maxFee ?? (await this.estimateFee(transactions, { nonce })).amount;
     const signerDetails = {
       walletAddress: this.address,
-      nonce: toBN(transactionsDetail.nonce ?? (await this.getNonce())),
-      maxFee: toBN(transactionsDetail.maxFee ?? '0'),
+      nonce,
+      maxFee,
     };
 
     const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
 
     const calldata = [...fromCallsToExecuteCalldata(transactions), signerDetails.nonce.toString()];
-
     return this.fetchEndpoint('add_transaction', undefined, {
       type: 'INVOKE_FUNCTION',
       contract_address: this.address,
       entry_point_selector: getSelectorFromName('__execute__'),
       calldata,
       signature: bigNumberishArrayToDecimalStringArray(signature),
+      max_fee: toHex(toBN(maxFee)),
     });
   }
 

package/src/account/interface.ts

@@ -4,6 +4,8 @@ import {
   AddTransactionResponse,
   Call,
   DeployContractPayload,
+  EstimateFeeResponse,
+  Invocation,
   InvocationsDetails,
   Signature,
 } from '../types';
@@ -28,6 +30,19 @@ export abstract class AccountInterface extends ProviderInterface {
     abi?: Abi
   ): Promise<AddTransactionResponse>;
 
+  /**
+   * Estimate Fee for a method on starknet
+   *
+   * @param invocation the invocation object containing:
+   * - contractAddress - the address of the contract
+   * - entrypoint - the entrypoint of the contract
+   * - calldata - (defaults to []) the calldata
+   * - signature - (defaults to []) the signature
+   *
+   * @returns response from addTransaction
+   */
+  public abstract estimateFee(invocation: Invocation): Promise<EstimateFeeResponse>;
+
   /**
    * Invoke execute function in account contract
    *

package/src/contract/default.ts

@@ -3,6 +3,7 @@ import assert from 'minimalistic-assert';
 
 import { AccountInterface } from '../account';
 import { ProviderInterface, defaultProvider } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import {
   Abi,
   AbiEntry,
@@ -13,11 +14,11 @@ import {
   ContractFunction,
   FunctionAbi,
   Invocation,
+  Overrides,
   ParsedStruct,
   Result,
   StructAbi,
 } from '../types';
-import { getSelectorFromName } from '../utils/hash';
 import { BigNumberish, toBN, toFelt } from '../utils/number';
 import { ContractInterface } from './interface';
 
@@ -528,7 +529,11 @@ export class Contract implements ContractInterface {
     }, [] as Result);
   }
 
-  public invoke(method: string, args: Array<any> = []): Promise<AddTransactionResponse> {
+  public invoke(
+    method: string,
+    args: Array<any> = [],
+    options: Overrides = {}
+  ): Promise<AddTransactionResponse> {
     // ensure contract is connected
     assert(this.address !== null, 'contract isnt connected to an address');
     // validate method and args
@@ -541,10 +546,7 @@ export class Contract implements ContractInterface {
       }
       return acc;
     }, 0);
-    const signature = [];
-    if (args.length === inputsLength + 1 && Array.isArray(args[args.length - 1])) {
-      signature.push(...args.pop());
-    }
+
     if (args.length !== inputsLength) {
       throw Error(
         `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
@@ -559,28 +561,34 @@ export class Contract implements ContractInterface {
       entrypoint: method,
     };
     if ('execute' in this.providerOrAccount) {
-      return this.providerOrAccount.execute(invocation);
+      return this.providerOrAccount.execute(invocation, undefined, {
+        maxFee: options.maxFee,
+        nonce: options.nonce,
+      });
     }
+
     return this.providerOrAccount.invokeFunction({
       ...invocation,
-      signature,
+      signature: options.signature || [],
     });
   }
 
-  public async call(method: string, args: Array<any> = []): Promise<Result> {
+  public async call(
+    method: string,
+    args: Array<any> = [],
+    {
+      blockIdentifier = 'pending',
+    }: {
+      blockIdentifier?: BlockIdentifier;
+    } = {}
+  ): Promise<Result> {
     // ensure contract is connected
     assert(this.address !== null, 'contract isnt connected to an address');
 
     // validate method and args
     this.validateMethodAndArgs('CALL', method, args);
     const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-    const inputsLength = inputs.length;
-    const options = {
-      blockIdentifier: null,
-    };
-    if (args.length === inputsLength + 1 && typeof args[args.length - 1] === 'object') {
-      Object.assign(options, args.pop());
-    }
+
     // compile calldata
     const calldata = this.compileCalldata(args, inputs);
     return this.providerOrAccount
@@ -590,35 +598,30 @@ export class Contract implements ContractInterface {
           calldata,
           entrypoint: method,
         },
-        options
+        { blockIdentifier }
       )
       .then((x) => this.parseResponse(method, x.result));
   }
 
-  public async estimate(_method: string, _args: Array<any> = []) {
+  public async estimate(method: string, args: Array<any> = []) {
     //  TODO; remove error as soon as estimate fees are supported
-    throw Error('Estimation of the fees are not yet supported');
-    // // ensure contract is connected
-    // assert(this.address !== null, 'contract isnt connected to an address');
-
-    // // validate method and args
-    // // this.validateMethodAndArgs('CALL', method, args);
-    // const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-
-    // // compile calldata
-    // const calldata = this.compileCalldata(args, inputs);
-    // return this.providerOrAccount.estimateFee({
-    //   contractAddress: this.address as string,
-    //   calldata,
-    //   entrypoint: method,
-    // });
+    // ensure contract is connected
+    assert(this.address !== null, 'contract isnt connected to an address');
+
+    // validate method and args
+    this.validateMethodAndArgs('INVOKE', method, args);
+    const invocation = this.populateTransaction[method](...args);
+    if ('estimateFee' in this.providerOrAccount) {
+      return this.providerOrAccount.estimateFee(invocation);
+    }
+    throw Error('Contract must be connected to the account contract to estimate');
   }
 
   public populate(method: string, args: Array<any> = []): Invocation {
     const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
     return {
       contractAddress: this.address,
-      entrypoint: getSelectorFromName(method),
+      entrypoint: method,
       calldata: this.compileCalldata(args, inputs),
       signature: [],
     };

package/src/contract/interface.ts

@@ -1,11 +1,13 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import {
   Abi,
   AddTransactionResponse,
   AsyncContractFunction,
   ContractFunction,
   Invocation,
+  Overrides,
   Result,
 } from '../types';
 
@@ -57,7 +59,13 @@ export abstract class ContractInterface {
    * @param args Array of the arguments for the call
    * @returns Result of the call as an array with key value pars
    */
-  public abstract call(method: string, args?: Array<any>): Promise<Result>;
+  public abstract call(
+    method: string,
+    args?: Array<any>,
+    options?: {
+      blockIdentifier?: BlockIdentifier;
+    }
+  ): Promise<Result>;
 
   /**
    * Invokes a method on a contract
@@ -66,7 +74,11 @@ export abstract class ContractInterface {
    * @param args Array of the arguments for the invoke
    * @returns Add Transaction Response
    */
-  public abstract invoke(method: string, args?: Array<any>): Promise<AddTransactionResponse>;
+  public abstract invoke(
+    method: string,
+    args?: Array<any>,
+    options?: Overrides
+  ): Promise<AddTransactionResponse>;
 
   /**
    * Calls a method on a contract
@@ -74,7 +86,13 @@ export abstract class ContractInterface {
    * @param method name of the method
    * @param args Array of the arguments for the call
    */
-  public abstract estimate(method: string, args?: Array<any>): Promise<any>;
+  public abstract estimate(
+    method: string,
+    args?: Array<any>,
+    options?: {
+      blockIdentifier?: BlockIdentifier;
+    }
+  ): Promise<any>;
 
   /**
    * Calls a method on a contract

package/src/provider/default.ts

@@ -14,6 +14,7 @@ import {
   GetContractAddressesResponse,
   GetTransactionResponse,
   GetTransactionStatusResponse,
+  GetTransactionTraceResponse,
   Invocation,
   TransactionReceipt,
 } from '../types';
@@ -167,14 +168,18 @@ export class Provider implements ProviderInterface {
    */
   public async callContract(
     { contractAddress, entrypoint, calldata = [] }: Call,
-    options: { blockIdentifier: BlockIdentifier } = { blockIdentifier: null }
+    { blockIdentifier = 'pending' }: { blockIdentifier?: BlockIdentifier } = {}
   ): Promise<CallContractResponse> {
-    return this.fetchEndpoint('call_contract', options, {
-      signature: [],
-      contract_address: contractAddress,
-      entry_point_selector: getSelectorFromName(entrypoint),
-      calldata,
-    });
+    return this.fetchEndpoint(
+      'call_contract',
+      { blockIdentifier },
+      {
+        signature: [],
+        contract_address: contractAddress,
+        entry_point_selector: getSelectorFromName(entrypoint),
+        calldata,
+      }
+    );
   }
 
   /**
@@ -202,7 +207,7 @@ export class Provider implements ProviderInterface {
    */
   public async getCode(
     contractAddress: string,
-    blockIdentifier: BlockIdentifier = null
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<GetCodeResponse> {
     return this.fetchEndpoint('get_code', { blockIdentifier, contractAddress });
   }
@@ -222,7 +227,7 @@ export class Provider implements ProviderInterface {
   public async getStorageAt(
     contractAddress: string,
     key: number,
-    blockIdentifier: BlockIdentifier = null
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<object> {
     return this.fetchEndpoint('get_storage_at', { blockIdentifier, contractAddress, key });
   }
@@ -277,6 +282,18 @@ export class Provider implements ProviderInterface {
     return this.fetchEndpoint('get_transaction', { transactionHash: txHashHex });
   }
 
+  /**
+   * Gets the transaction trace from a tx id.
+   *
+   *
+   * @param txHash
+   * @returns the transaction trace
+   */
+  public async getTransactionTrace(txHash: BigNumberish): Promise<GetTransactionTraceResponse> {
+    const txHashHex = toHex(toBN(txHash));
+    return this.fetchEndpoint('get_transaction_trace', { transactionHash: txHashHex });
+  }
+
   /**
    * Deploys a given compiled contract (json) to starknet
    *
@@ -325,20 +342,8 @@ export class Provider implements ProviderInterface {
     });
   }
 
-  public estimateFee(invocation: Invocation): Promise<any> {
-    return this.fetchEndpoint('estimate_fee', undefined, {
-      // TODO: change the TYPE of the call
-      type: 'INVOKE_FUNCTION',
-      contract_address: invocation.contractAddress,
-      entry_point_selector: getSelectorFromName(invocation.entrypoint),
-      calldata: bigNumberishArrayToDecimalStringArray(invocation.calldata ?? []),
-      signature: bigNumberishArrayToDecimalStringArray(invocation.signature ?? []),
-    });
-  }
-
   public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
     let onchain = false;
-    await wait(retryInterval);
 
     while (!onchain) {
       // eslint-disable-next-line no-await-in-loop
@@ -346,9 +351,12 @@ export class Provider implements ProviderInterface {
       // eslint-disable-next-line no-await-in-loop
       const res = await this.getTransactionStatus(txHash);
 
-      if (res.tx_status === 'ACCEPTED_ON_L1' || res.tx_status === 'ACCEPTED_ON_L2') {
+      const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
+      const errorStates = ['REJECTED', 'NOT_RECEIVED'];
+
+      if (successStates.includes(res.tx_status)) {
         onchain = true;
-      } else if (res.tx_status === 'REJECTED' || res.tx_status === 'NOT_RECEIVED') {
+      } else if (errorStates.includes(res.tx_status)) {
         const message = res.tx_failure_reason
           ? `${res.tx_status}: ${res.tx_failure_reason.code}\n${res.tx_failure_reason.error_message}`
           : res.tx_status;