starknet 2.7.1 → 3.0.0

package/__tests__/utils/address.test.ts

@@ -0,0 +1,16 @@
+import { addAddressPadding, validateAndParseAddress } from '../../src/utils/address';
+// import { addHexPrefix, removeHexPrefix } from '../../src/utils/encode';
+
+describe('validateAndParseAddress', () => {
+  test('should pass when correct starknet address is passed', () => {
+    const addr = '0x7ee790591d9fa3efc87067d95a643f8455e0b8190eb8cb7bfd39e4fb7571fdf';
+
+    return expect(validateAndParseAddress(addr)).toEqual(`${addAddressPadding(addr)}`);
+  });
+
+  test('should add 0x prefix if not provided', () => {
+    const addr = '0x6eff1d71068df8e6677f59a556151c56ed13e14ad431a9bef6fcb3fc5e6fa7';
+
+    return expect(validateAndParseAddress(addr)).toEqual(`${addAddressPadding(addr)}`);
+  });
+});

package/__tests__/utils/typedData.test.ts

@@ -1,41 +1,6 @@
+import typedDataExample from '../../__mocks__/typedDataExample.json';
 import { encodeType, getMessageHash, getStructHash, getTypeHash } from '../../src/utils/typedData';
 
-const typedDataExample = {
-  types: {
-    StarkNetDomain: [
-      { name: 'name', type: 'felt' },
-      { name: 'version', type: 'felt' },
-      { name: 'chainId', type: 'felt' },
-    ],
-    Person: [
-      { name: 'name', type: 'felt' },
-      { name: 'wallet', type: 'felt' },
-    ],
-    Mail: [
-      { name: 'from', type: 'Person' },
-      { name: 'to', type: 'Person' },
-      { name: 'contents', type: 'felt' },
-    ],
-  },
-  primaryType: 'Mail',
-  domain: {
-    name: 'StarkNet Mail',
-    version: '1',
-    chainId: 1,
-  },
-  message: {
-    from: {
-      name: 'Cow',
-      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
-    },
-    to: {
-      name: 'Bob',
-      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
-    },
-    contents: 'Hello, Bob!',
-  },
-};
-
 describe('typedData', () => {
   test('should get right type encoding', () => {
     const typeEncoding = encodeType(typedDataExample, 'Mail');

package/account/default.d.ts

@@ -0,0 +1,66 @@
+import { Provider } from '../provider';
+import {
+  Abi,
+  AddTransactionResponse,
+  ExecuteInvocation,
+  InvocationsDetails,
+  KeyPair,
+  Signature,
+} from '../types';
+import { BigNumberish } from '../utils/number';
+import { TypedData } from '../utils/typedData';
+import { AccountInterface } from './interface';
+export declare class Account extends Provider implements AccountInterface {
+  address: string;
+  private signer;
+  constructor(provider: Provider, address: string, keyPair: KeyPair);
+  getNonce(): Promise<string>;
+  /**
+   * 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
+   */
+  execute(
+    transactions: ExecuteInvocation | ExecuteInvocation[],
+    abis?: Abi[],
+    transactionsDetail?: InvocationsDetails
+  ): Promise<AddTransactionResponse>;
+  /**
+   * 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
+   */
+  signMessage(typedData: TypedData): Promise<Signature>;
+  /**
+   * 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
+   */
+  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
+   */
+  verifyMessageHash(hash: BigNumberish, 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
+   */
+  verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
+}

package/account/default.js

@@ -0,0 +1,440 @@
+'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 __());
+    };
+  })();
+var __assign =
+  (this && this.__assign) ||
+  function () {
+    __assign =
+      Object.assign ||
+      function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+    return __assign.apply(this, arguments);
+  };
+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 __rest =
+  (this && this.__rest) ||
+  function (s, e) {
+    var t = {};
+    for (var p in s)
+      if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === 'function')
+      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+          t[p[i]] = s[p[i]];
+      }
+    return t;
+  };
+var __read =
+  (this && this.__read) ||
+  function (o, n) {
+    var m = typeof Symbol === 'function' && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o),
+      r,
+      ar = [],
+      e;
+    try {
+      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    } catch (error) {
+      e = { error: error };
+    } finally {
+      try {
+        if (r && !r.done && (m = i['return'])) m.call(i);
+      } finally {
+        if (e) throw e.error;
+      }
+    }
+    return ar;
+  };
+var __spreadArray =
+  (this && this.__spreadArray) ||
+  function (to, from, pack) {
+    if (pack || arguments.length === 2)
+      for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.Account = void 0;
+var contract_1 = require('../contract');
+var provider_1 = require('../provider');
+var signer_1 = require('../signer');
+var number_1 = require('../utils/number');
+var stark_1 = require('../utils/stark');
+var typedData_1 = require('../utils/typedData');
+var Account = /** @class */ (function (_super) {
+  __extends(Account, _super);
+  function Account(provider, address, keyPair) {
+    var _this = _super.call(this, provider) || this;
+    _this.signer = new signer_1.Signer(keyPair);
+    _this.address = address;
+    return _this;
+  }
+  Account.prototype.getNonce = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var result;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [
+              4 /*yield*/,
+              this.callContract({
+                contractAddress: this.address,
+                entrypoint: 'get_nonce',
+              }),
+            ];
+          case 1:
+            result = _a.sent().result;
+            return [2 /*return*/, (0, number_1.toHex)((0, number_1.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
+   */
+  Account.prototype.execute = function (transactions, abis, transactionsDetail) {
+    if (abis === void 0) {
+      abis = [];
+    }
+    if (transactionsDetail === void 0) {
+      transactionsDetail = {};
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      var _a,
+        contractAddress,
+        _b,
+        calldata,
+        entrypoint,
+        invocation,
+        nonce,
+        nonceBn,
+        _c,
+        _d,
+        calldataDecimal,
+        signature,
+        entrypointSelector;
+      return __generator(this, function (_e) {
+        switch (_e.label) {
+          case 0:
+            if (Array.isArray(transactions) && transactions.length !== 1) {
+              throw new Error('Only one transaction at a time is currently supported');
+            }
+            (_a = Array.isArray(transactions) ? transactions[0] : transactions),
+              (contractAddress = _a.contractAddress),
+              (_b = _a.calldata),
+              (calldata = _b === void 0 ? [] : _b),
+              (entrypoint = _a.entrypoint),
+              (invocation = __rest(_a, ['contractAddress', 'calldata', 'entrypoint']));
+            nonce = transactionsDetail.nonce;
+            _c = number_1.toBN;
+            if (!(nonce !== null && nonce !== void 0)) return [3 /*break*/, 1];
+            _d = nonce;
+            return [3 /*break*/, 3];
+          case 1:
+            return [4 /*yield*/, this.getNonce()];
+          case 2:
+            _d = _e.sent();
+            _e.label = 3;
+          case 3:
+            nonceBn = _c.apply(void 0, [_d]);
+            calldataDecimal = (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata);
+            return [
+              4 /*yield*/,
+              this.signer.signTransaction(
+                [
+                  __assign(__assign({}, invocation), {
+                    contractAddress: contractAddress,
+                    calldata: calldataDecimal,
+                    entrypoint: entrypoint,
+                  }),
+                ],
+                { walletAddress: this.address, nonce: nonceBn },
+                abis
+              ),
+            ];
+          case 4:
+            signature = _e.sent();
+            entrypointSelector = (0, stark_1.getSelectorFromName)(entrypoint);
+            return [
+              2 /*return*/,
+              _super.prototype.invokeFunction.call(this, {
+                contractAddress: this.address,
+                entrypoint: 'execute',
+                calldata: __spreadArray(
+                  __spreadArray(
+                    [contractAddress, entrypointSelector, calldataDecimal.length.toString()],
+                    __read(calldataDecimal),
+                    false
+                  ),
+                  [nonceBn.toString()],
+                  false
+                ),
+                signature: 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
+   */
+  Account.prototype.signMessage = function (typedData) {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        return [2 /*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
+   */
+  Account.prototype.hashMessage = function (typedData) {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        return [2 /*return*/, (0, typedData_1.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
+   */
+  Account.prototype.verifyMessageHash = function (hash, signature) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a;
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            _b.trys.push([0, 2, , 3]);
+            return [
+              4 /*yield*/,
+              this.callContract({
+                contractAddress: this.address,
+                entrypoint: 'is_valid_signature',
+                calldata: (0, contract_1.compileCalldata)({
+                  hash: (0, number_1.toBN)(hash).toString(),
+                  signature: signature.map(function (x) {
+                    return (0, number_1.toBN)(x).toString();
+                  }),
+                }),
+              }),
+            ];
+          case 1:
+            _b.sent();
+            return [2 /*return*/, true];
+          case 2:
+            _a = _b.sent();
+            return [2 /*return*/, false];
+          case 3:
+            return [2 /*return*/];
+        }
+      });
+    });
+  };
+  /**
+   * 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
+   */
+  Account.prototype.verifyMessage = function (typedData, signature) {
+    return __awaiter(this, void 0, void 0, function () {
+      var hash;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4 /*yield*/, this.hashMessage(typedData)];
+          case 1:
+            hash = _a.sent();
+            return [2 /*return*/, this.verifyMessageHash(hash, signature)];
+        }
+      });
+    });
+  };
+  return Account;
+})(provider_1.Provider);
+exports.Account = Account;

package/account/index.d.ts

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

package/account/index.js

@@ -0,0 +1,27 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        Object.defineProperty(o, k2, {
+          enumerable: true,
+          get: function () {
+            return m[k];
+          },
+        });
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p))
+        __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+__exportStar(require('./default'), exports);
+__exportStar(require('./interface'), exports);

package/account/interface.d.ts

@@ -0,0 +1,83 @@
+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 declare abstract class AccountInterface extends ProviderInterface {
+  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
+   */
+  abstract 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
+   */
+  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
+   */
+  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
+   */
+  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
+   */
+  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
+   */
+  abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
+  abstract getNonce(): Promise<string>;
+}