starknet 3.5.1 → 3.6.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

@@ -6,6 +6,7 @@ import {
   Abi,
   AddTransactionResponse,
   Call,
+  EstimateFeeResponse,
   InvocationsDetails,
   InvokeFunctionTransaction,
   KeyPair,
@@ -44,6 +45,25 @@ export class Account extends Provider implements AccountInterface {
     return toHex(toBN(result[0]));
   }
 
+  public async estimateFee(calls: Call | Call[]): Promise<EstimateFeeResponse> {
+    const transactions = Array.isArray(calls) ? calls : [calls];
+    const nonce = 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', undefined, {
+      contract_address: this.address,
+      entry_point_selector: getSelectorFromName('__execute__'),
+      calldata,
+      signature: bigNumberishArrayToDecimalStringArray(signature),
+    });
+  }
+
   /**
    * Invoke execute function in account contract
    *
@@ -58,23 +78,24 @@ 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)).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

@@ -13,11 +13,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';
 
@@ -541,10 +541,12 @@ export class Contract implements ContractInterface {
       }
       return acc;
     }, 0);
-    const signature = [];
+
+    const overrides: Overrides = {};
     if (args.length === inputsLength + 1 && Array.isArray(args[args.length - 1])) {
-      signature.push(...args.pop());
+      Object.assign(overrides, args.pop());
     }
+
     if (args.length !== inputsLength) {
       throw Error(
         `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
@@ -559,11 +561,15 @@ export class Contract implements ContractInterface {
       entrypoint: method,
     };
     if ('execute' in this.providerOrAccount) {
-      return this.providerOrAccount.execute(invocation);
+      return this.providerOrAccount.execute(invocation, undefined, {
+        maxFee: overrides.maxFee,
+        nonce: overrides.nonce,
+      });
     }
+
     return this.providerOrAccount.invokeFunction({
       ...invocation,
-      signature,
+      signature: overrides.signature || [],
     });
   }
 
@@ -595,30 +601,25 @@ export class Contract implements ContractInterface {
       .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/provider/default.ts

@@ -14,6 +14,7 @@ import {
   GetContractAddressesResponse,
   GetTransactionResponse,
   GetTransactionStatusResponse,
+  GetTransactionTraceResponse,
   Invocation,
   TransactionReceipt,
 } from '../types';
@@ -277,6 +278,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,17 +338,6 @@ 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);

package/src/signer/index.ts

@@ -1,2 +1,3 @@
 export * from './interface';
 export * from './default';
+export * from './ledger';

package/src/signer/ledger.ts

@@ -0,0 +1,81 @@
+import Eth from '@ledgerhq/hw-app-eth';
+import Transport from '@ledgerhq/hw-transport';
+import TransportWebHID from '@ledgerhq/hw-transport-webhid';
+
+import { Invocation, InvocationsSignerDetails, Signature } from '../types';
+import { addHexPrefix } from '../utils/encode';
+import { hashMulticall } from '../utils/hash';
+import { TypedData, getMessageHash } from '../utils/typedData';
+import { SignerInterface } from './interface';
+
+function hexZeroPad(hash: string, length: number): string {
+  let 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;
+}
+
+export class LedgerBlindSigner implements SignerInterface {
+  public derivationPath = "/2645'/579218131'/1148870696'/0'/0'/0";
+
+  private transport: Transport | undefined;
+
+  private async getEthApp(): Promise<Eth> {
+    if (!this.transport) {
+      try {
+        this.transport = await TransportWebHID.create();
+      } catch {
+        throw new Error('Device connection error');
+      }
+    }
+    return new Eth(this.transport);
+  }
+
+  public async getPubKey(): Promise<string> {
+    const eth = await this.getEthApp();
+    const response = await eth.starkGetPublicKey(this.derivationPath);
+    const starkPub = `0x${response.slice(1, 1 + 32).toString('hex')}`;
+    return starkPub;
+  }
+
+  public async signTransaction(
+    transactions: Invocation[],
+    transactionsDetail: InvocationsSignerDetails
+  ): Promise<Signature> {
+    const msgHash = hashMulticall(
+      transactionsDetail.walletAddress,
+      transactions,
+      transactionsDetail.nonce.toString(),
+      transactionsDetail.maxFee.toString()
+    );
+
+    return this.sign(msgHash);
+  }
+
+  public async signMessage(typedData: TypedData, accountAddress: string): Promise<Signature> {
+    const msgHash = getMessageHash(typedData, accountAddress);
+
+    return this.sign(msgHash);
+  }
+
+  protected async sign(msgHash: string): Promise<Signature> {
+    const eth = await this.getEthApp();
+
+    const {
+      r,
+      s,
+    }: {
+      r: string;
+      s: string;
+    } = (await eth.starkUnsafeSign(this.derivationPath, hexZeroPad(msgHash, 32))) as {
+      r: string;
+      s: string;
+    };
+
+    return [addHexPrefix(r), addHexPrefix(s)];
+  }
+}

package/src/types/api.ts

@@ -36,6 +36,13 @@ export type Endpoints = {
     REQUEST: never;
     RESPONSE: GetTransactionStatusResponse;
   };
+  get_transaction_trace: {
+    QUERY: {
+      transactionHash: string;
+    };
+    REQUEST: never;
+    RESPONSE: GetTransactionTraceResponse;
+  };
   get_storage_at: {
     QUERY: {
       contractAddress: string;
@@ -69,7 +76,7 @@ export type Endpoints = {
   };
   estimate_fee: {
     QUERY: never;
-    REQUEST: Transaction;
+    REQUEST: CallContractTransaction;
     RESPONSE: EstimateFeeResponse;
   };
 };
@@ -95,6 +102,33 @@ export type InvokeFunctionTransaction = {
   entry_point_selector: string;
   calldata?: RawCalldata;
   nonce?: BigNumberish;
+  max_fee?: BigNumberish;
+};
+
+export type InvokeFunctionTrace = {
+  caller_address: string;
+  contract_address: string;
+  code_address: string;
+  selector: string;
+  calldata: RawCalldata;
+  result: Array<any>;
+  execution_resources: ExecutionResources;
+  internal_call: Array<InvokeFunctionTrace>;
+  events: Array<any>;
+  messages: Array<any>;
+};
+
+export type ExecutionResources = {
+  n_steps: number;
+  builtin_instance_counter: {
+    pedersen_builtin: number;
+    range_check_builtin: number;
+    bitwise_builtin: number;
+    output_builtin: number;
+    ecdsa_builtin: number;
+    ec_op_builtin: number;
+  };
+  n_memory_holes: number;
 };
 
 export type CallContractTransaction = Omit<
@@ -149,6 +183,22 @@ export type GetTransactionStatusResponse = {
   };
 };
 
+export type GetTransactionTraceResponse = {
+  function_invocation: {
+    caller_address: string;
+    contract_address: string;
+    code_address: string;
+    selector: string;
+    calldata: RawArgs;
+    result: Array<any>;
+    execution_resources: any;
+    internal_call: Array<any>;
+    events: Array<any>;
+    messages: Array<any>;
+  };
+  signature: Signature;
+};
+
 export type GetTransactionResponse = {
   status: Status;
   transaction: Transaction;
@@ -173,11 +223,20 @@ export type TransactionReceipt = {
   l2_to_l1_messages: string[];
   events: string[];
 };
-// TODO: Add response data
-export type EstimateFeeResponse = {};
+
+export type EstimateFeeResponse = {
+  amount: number;
+  unit: string;
+};
 
 export type RawArgs = {
   [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
 };
 
 export type Calldata = string[];
+
+export type Overrides = {
+  maxFee?: BigNumberish;
+  nonce?: BigNumberish;
+  signature?: Signature;
+};

package/tsconfig.json

@@ -103,14 +103,5 @@
     "skipLibCheck": true /* Skip type checking all .d.ts files. */
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules"],
-  "typedocOptions": {
-    "entryPoints": "src/index.ts",
-    "entryPointStrategy": "expand",
-    "out": "docs",
-    "githubPages": false,
-    "readme": "./README.md",
-    "name": "StarkNet.js Docs",
-    "sort": "required-first"
-  }
+  "exclude": ["node_modules"]
 }