starknet 2.7.1 → 3.0.0

package/signer/interface.js

@@ -1,37 +1,8 @@
 'use strict';
-var __extends =
-  (this && this.__extends) ||
-  (function () {
-    var extendStatics = function (d, b) {
-      extendStatics =
-        Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array &&
-          function (d, b) {
-            d.__proto__ = b;
-          }) ||
-        function (d, b) {
-          for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
-        };
-      return extendStatics(d, b);
-    };
-    return function (d, b) {
-      if (typeof b !== 'function' && b !== null)
-        throw new TypeError('Class extends value ' + String(b) + ' is not a constructor or null');
-      extendStatics(d, b);
-      function __() {
-        this.constructor = d;
-      }
-      d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
-    };
-  })();
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.SignerInterface = void 0;
-var provider_1 = require('../provider');
-var SignerInterface = /** @class */ (function (_super) {
-  __extends(SignerInterface, _super);
-  function SignerInterface() {
-    return (_super !== null && _super.apply(this, arguments)) || this;
-  }
+var SignerInterface = /** @class */ (function () {
+  function SignerInterface() {}
   return SignerInterface;
-})(provider_1.Provider);
+})();
 exports.SignerInterface = SignerInterface;

package/src/account/default.ts

@@ -0,0 +1,152 @@
+import { compileCalldata } from '../contract';
+import { Provider } from '../provider';
+import { Signer, SignerInterface } from '../signer';
+import {
+  Abi,
+  AddTransactionResponse,
+  ExecuteInvocation,
+  InvocationsDetails,
+  KeyPair,
+  Signature,
+} from '../types';
+import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
+import { getSelectorFromName } from '../utils/stark';
+import { TypedData, getMessageHash } from '../utils/typedData';
+import { AccountInterface } from './interface';
+
+export class Account extends Provider implements AccountInterface {
+  public address: string;
+
+  private signer: SignerInterface;
+
+  constructor(provider: Provider, address: string, keyPair: KeyPair) {
+    super(provider);
+    this.signer = new Signer(keyPair);
+    this.address = address;
+  }
+
+  public async getNonce(): Promise<string> {
+    const { result } = await this.callContract({
+      contractAddress: this.address,
+      entrypoint: 'get_nonce',
+    });
+    return toHex(toBN(result[0]));
+  }
+
+  /**
+   * 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 transaction - transaction to be invoked
+   * @returns a confirmation of invoking a function on the starknet contract
+   */
+  public async execute(
+    transactions: ExecuteInvocation | ExecuteInvocation[],
+    abis: Abi[] = [],
+    transactionsDetail: InvocationsDetails = {}
+  ): Promise<AddTransactionResponse> {
+    if (Array.isArray(transactions) && transactions.length !== 1) {
+      throw new Error('Only one transaction at a time is currently supported');
+    }
+
+    const {
+      contractAddress,
+      calldata = [],
+      entrypoint,
+      ...invocation
+    } = Array.isArray(transactions) ? transactions[0] : transactions;
+    const { nonce } = transactionsDetail;
+
+    const nonceBn = toBN(nonce ?? (await this.getNonce()));
+    const calldataDecimal = bigNumberishArrayToDecimalStringArray(calldata);
+
+    const signature = await this.signer.signTransaction(
+      [
+        {
+          ...invocation,
+          contractAddress,
+          calldata: calldataDecimal,
+          entrypoint,
+        },
+      ],
+      { walletAddress: this.address, nonce: nonceBn },
+      abis
+    );
+
+    const entrypointSelector = getSelectorFromName(entrypoint);
+
+    return super.invokeFunction({
+      contractAddress: this.address,
+      entrypoint: 'execute',
+      calldata: [
+        contractAddress,
+        entrypointSelector,
+        calldataDecimal.length.toString(),
+        ...calldataDecimal,
+        nonceBn.toString(),
+      ],
+      signature,
+    });
+  }
+
+  /**
+   * 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
+   */
+  public async signMessage(typedData: TypedData): Promise<Signature> {
+    return this.signer.signMessage(typedData, this.address);
+  }
+
+  /**
+   * 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
+   */
+  public async hashMessage(typedData: TypedData): Promise<string> {
+    return getMessageHash(typedData, this.address);
+  }
+
+  /**
+   * Verify a signature of a JSON object
+   *
+   * @param json - 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
+   */
+  public async verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean> {
+    try {
+      await this.callContract({
+        contractAddress: this.address,
+        entrypoint: 'is_valid_signature',
+        calldata: compileCalldata({
+          hash: toBN(hash).toString(),
+          signature: signature.map((x) => toBN(x).toString()),
+        }),
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Verify a signature of a given hash
+   * @warning This method is not recommended, use verifyMessage instead
+   *
+   * @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
+   */
+  public async verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean> {
+    const hash = await this.hashMessage(typedData);
+    return this.verifyMessageHash(hash, signature);
+  }
+}

package/src/account/index.ts

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

package/src/account/interface.ts

@@ -0,0 +1,91 @@
+import { ProviderInterface } from '../provider';
+import {
+  Abi,
+  AddTransactionResponse,
+  DeployContractPayload,
+  ExecuteInvocation,
+  InvocationsDetails,
+  Signature,
+} from '../types';
+import { BigNumberish } from '../utils/number';
+import { TypedData } from '../utils/typedData/types';
+
+export abstract class AccountInterface extends ProviderInterface {
+  public abstract address: string;
+
+  /**
+   * Deploys a given compiled contract (json) to starknet
+   *
+   * @param payload payload to be deployed containing:
+   * - compiled contract code
+   * - constructor calldata
+   * - address salt
+   * @param abi the abi of the contract
+   * @returns a confirmation of sending a transaction on the starknet contract
+   */
+  public abstract override deployContract(
+    payload: DeployContractPayload,
+    abi?: Abi
+  ): Promise<AddTransactionResponse>;
+
+  /**
+   * Invoke execute function in account contract
+   *
+   * @param transactions the invocation object or an array of them, containing:
+   * - contractAddress - the address of the contract
+   * - entrypoint - the entrypoint of the contract
+   * - calldata - (defaults to []) the calldata
+   * - signature - (defaults to []) the signature
+   * @param abi (optional) the abi of the contract for better displaying
+   *
+   * @returns response from addTransaction
+   */
+  public abstract execute(
+    transactions: ExecuteInvocation | ExecuteInvocation[],
+    abis?: Abi[],
+    transactionsDetail?: InvocationsDetails
+  ): Promise<AddTransactionResponse>;
+
+  /**
+   * Sign an JSON object for off-chain usage with the starknet private key and return the signature
+   * This adds a message prefix so it cant be interchanged with transactions
+   *
+   * @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
+   */
+  public abstract signMessage(typedData: TypedData): Promise<Signature>;
+
+  /**
+   * Hash a JSON object with pederson hash and return the hash
+   * This adds a message prefix so it cant be interchanged with transactions
+   *
+   * @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
+   */
+  public abstract hashMessage(typedData: TypedData): Promise<string>;
+
+  /**
+   * Verify a signature of a JSON object
+   *
+   * @param json - 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
+   */
+  public abstract verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
+
+  /**
+   * Verify a signature of a given hash
+   * @warning This method is not recommended, use verifyMessage instead
+   *
+   * @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
+   */
+  public abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
+
+  public abstract getNonce(): Promise<string>;
+}

package/src/constants.ts

@@ -6,6 +6,7 @@ export const ZERO = toBN(0);
 export const ONE = toBN(1);
 export const TWO = toBN(2);
 export const MASK_250 = TWO.pow(toBN(250)).sub(ONE); // 2 ** 250 - 1
+export const MASK_251 = TWO.pow(toBN(251));
 
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
@@ -13,6 +14,7 @@ export const MASK_250 = TWO.pow(toBN(250)).sub(ONE); // 2 ** 250 - 1
  */
 export const FIELD_PRIME = '800000000000011000000000000000000000000000000000000000000000001';
 export const FIELD_GEN = '3';
+export const FIELD_SIZE = 251;
 export const EC_ORDER = '800000000000010FFFFFFFFFFFFFFFFB781126DCAE7B2321E66A241ADC64D2F';
 export const ALPHA = '1';
 export const BETA = '6F21413EFBE40DE150E596D72F7A8C5609AD26C15C915C1F4CDFCB99CEE9E89';

package/src/contract.ts

@@ -2,14 +2,13 @@ import BN from 'bn.js';
 import assert from 'minimalistic-assert';
 
 import { Provider, defaultProvider } from './provider';
-import { Abi, AbiEntry, FunctionAbi, Signature, StructAbi } from './types';
+import { BlockIdentifier } from './provider/utils';
+import { Abi, AbiEntry, FunctionAbi, RawCalldata, Signature, StructAbi } from './types';
 import { BigNumberish, toBN } from './utils/number';
-import { getSelectorFromName } from './utils/stark';
 
 export type Args = {
   [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
 };
-export type Calldata = string[];
 
 function parseFelt(candidate: string): BN {
   try {
@@ -28,7 +27,7 @@ function isFelt(candidate: string): boolean {
   }
 }
 
-export function compileCalldata(args: Args): Calldata {
+export function compileCalldata(args: Args): RawCalldata {
   return Object.values(args).flatMap((value) => {
     if (Array.isArray(value))
       return [toBN(value.length).toString(), ...value.map((x) => toBN(x).toString())];
@@ -43,7 +42,7 @@ export function compileCalldata(args: Args): Calldata {
 export class Contract {
   connectedTo: string | null = null;
 
-  abi: Abi[];
+  abi: Abi;
 
   structs: { [name: string]: StructAbi };
 
@@ -55,7 +54,7 @@ export class Contract {
    * @param abi - Abi of the contract object
    * @param address (optional) - address to connect to
    */
-  constructor(abi: Abi[], address: string | null = null, provider: Provider = defaultProvider) {
+  constructor(abi: Abi, address: string | null = null, provider: Provider = defaultProvider) {
     this.connectedTo = address;
     this.provider = provider;
     this.abi = abi;
@@ -154,19 +153,17 @@ export class Contract {
     this.validateMethodAndArgs('INVOKE', method, args);
 
     // compile calldata
-    const entrypointSelector = getSelectorFromName(method);
     const calldata = compileCalldata(args);
 
-    return this.provider.addTransaction({
-      type: 'INVOKE_FUNCTION',
-      contract_address: this.connectedTo,
+    return this.provider.invokeFunction({
+      contractAddress: this.connectedTo,
       signature,
       calldata,
-      entry_point_selector: entrypointSelector,
+      entrypoint: method,
     });
   }
 
-  public async call(method: string, args: Args = {}) {
+  public async call(method: string, args: Args = {}, blockIdentifier: BlockIdentifier = null) {
     // ensure contract is connected
     assert(this.connectedTo !== null, 'contract isnt connected to an address');
 
@@ -174,15 +171,17 @@ export class Contract {
     this.validateMethodAndArgs('CALL', method, args);
 
     // compile calldata
-    const entrypointSelector = getSelectorFromName(method);
     const calldata = compileCalldata(args);
 
     return this.provider
-      .callContract({
-        contract_address: this.connectedTo,
-        calldata,
-        entry_point_selector: entrypointSelector,
-      })
+      .callContract(
+        {
+          contractAddress: this.connectedTo,
+          entrypoint: method,
+          calldata,
+        },
+        blockIdentifier
+      )
       .then((x) => this.parseResponse(method, x.result));
   }
 }

package/src/index.ts

@@ -4,7 +4,7 @@
 export * from './types';
 export * from './contract';
 export * from './provider';
-export * from './signer';
+export * from './account';
 
 /**
  * Utils
@@ -19,3 +19,4 @@ export * as ec from './utils/ellipticCurve';
 export * as uint256 from './utils/uint256';
 export * as shortString from './utils/shortString';
 export * as typedData from './utils/typedData';
+export * from './utils/address';