starknet 2.7.2 → 3.1.0

package/provider/interface.d.ts

@@ -1,18 +1,18 @@
 import type {
   AddTransactionResponse,
-  BlockNumber,
+  Call,
   CallContractResponse,
-  CallContractTransaction,
-  CompiledContract,
+  DeployContractPayload,
   GetBlockResponse,
   GetCodeResponse,
   GetContractAddressesResponse,
   GetTransactionResponse,
   GetTransactionStatusResponse,
-  Signature,
-  Transaction,
+  Invocation,
+  TransactionReceipt,
 } from '../types';
 import type { BigNumberish } from '../utils/number';
+import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
   abstract baseUrl: string;
   abstract feederGatewayUrl: string;
@@ -29,40 +29,35 @@ export declare abstract class ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L25-L39)
    *
-   * @param invokeTransaction - transaction to be invoked
-   * @param blockHash
-   * @param blockNumber
+   * @param invokeTransaction transaction to be invoked
+   * @param blockIdentifier block identifier
    * @returns the result of the function on the smart contract.
    */
   abstract callContract(
-    invokeTransaction: CallContractTransaction,
-    blockHash?: BigNumberish,
-    blockNumber?: BlockNumber
+    invokeTransaction: Call,
+    blockIdentifier?: BlockIdentifier
   ): Promise<CallContractResponse>;
   /**
    * Gets the block information
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L41-L53)
    *
-   * @param blockHash
-   * @param blockNumber
+   * @param blockIdentifier block identifier
    * @returns the block object { block_number, previous_block_number, state_root, status, timestamp, transaction_receipts, transactions }
    */
-  abstract getBlock(blockHash?: BigNumberish, blockNumber?: BlockNumber): Promise<GetBlockResponse>;
+  abstract getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
   /**
    * Gets the code of the deployed contract.
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L55-L68)
    *
-   * @param contractAddress
-   * @param blockHash
-   * @param blockNumber
+   * @param contractAddress - contract address
+   * @param blockIdentifier - block identifier
    * @returns Bytecode and ABI of compiled contract
    */
   abstract getCode(
     contractAddress: string,
-    blockHash?: BigNumberish,
-    blockNumber?: BlockNumber
+    blockIdentifier?: BlockIdentifier
   ): Promise<GetCodeResponse>;
   /**
    * Gets the contract's storage variable at a specific key.
@@ -71,15 +66,13 @@ export declare abstract class ProviderInterface {
    *
    * @param contractAddress
    * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-   * @param blockHash
-   * @param blockNumber
+   * @param blockIdentifier - block identifier
    * @returns the value of the storage variable
    */
   abstract getStorageAt(
     contractAddress: string,
     key: number,
-    blockHash?: BigNumberish,
-    blockNumber?: BlockNumber
+    blockIdentifier?: BlockIdentifier
   ): Promise<object>;
   /**
    * Gets the status of a transaction.
@@ -99,41 +92,35 @@ export declare abstract class ProviderInterface {
    * @returns the transacton object { transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? }
    */
   abstract getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
-  /**
-   * Invoke a function on the starknet 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
-   */
-  abstract addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
+  abstract getTransactionReceipt({
+    txHash,
+    txId,
+  }: {
+    txHash?: BigNumberish;
+    txId?: BigNumberish;
+  }): Promise<TransactionReceipt>;
   /**
    * Deploys a given compiled contract (json) to starknet
    *
-   * @param contract - a json object containing the compiled contract
-   * @param address - (optional, defaults to a random address) the address where the contract should be deployed (alpha)
+   * @param payload payload to be deployed containing:
+   * - compiled contract code
+   * - constructor calldata
+   * - address salt
    * @returns a confirmation of sending a transaction on the starknet contract
    */
-  abstract deployContract(
-    contract: CompiledContract | string,
-    constructorCalldata: string[],
-    addressSalt: BigNumberish
-  ): Promise<AddTransactionResponse>;
+  abstract deployContract(payload: DeployContractPayload): Promise<AddTransactionResponse>;
   /**
    * Invokes a function on starknet
+   * @deprecated This method wont be supported as soon as fees are mandatory
+   *
+   * @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
    *
-   * @param contractAddress - target contract address for invoke
-   * @param entrypointSelector - target entrypoint selector for
-   * @param calldata - (optional, default []) calldata
-   * @param signature - (optional) signature to send along
    * @returns response from addTransaction
    */
-  abstract invokeFunction(
-    contractAddress: string,
-    entrypointSelector: string,
-    calldata?: string[],
-    signature?: Signature
-  ): Promise<AddTransactionResponse>;
+  abstract invokeFunction(invocation: Invocation): Promise<AddTransactionResponse>;
   abstract waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/provider/utils.d.ts

@@ -1,20 +1,37 @@
 import type { BlockNumber } from '../types';
 import { BigNumberish } from '../utils/number';
 /**
- * TODO
+ *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L148-L153)
  *
  * @param hashValue
  * @param hashField
  */
-export declare function formatHash(): void;
+export declare function formatHash(hashValue: BigNumberish): string;
 /**
- * TODO
+ *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L156-L161)
  * @param txHash
  * @param txId
  */
-export declare function txIdentifier(): void;
+export declare function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string;
+export declare type BlockIdentifier = BlockNumber | BigNumberish;
+declare type BlockIdentifierObject =
+  | {
+      type: 'BLOCK_NUMBER';
+      data: BlockNumber;
+    }
+  | {
+      type: 'BLOCK_HASH';
+      data: BigNumberish;
+    };
+/**
+ * Identifies the block to be queried.
+ *
+ * @param blockIdentifier - block identifier
+ * @returns block identifier object
+ */
+export declare function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdentifierObject;
 /**
  * Gets the block identifier for API request
  *
@@ -24,7 +41,5 @@ export declare function txIdentifier(): void;
  * @param blockHash
  * @returns block identifier for API request
  */
-export declare function getFormattedBlockIdentifier(
-  blockHash?: BigNumberish,
-  blockNumber?: BlockNumber
-): string;
+export declare function getFormattedBlockIdentifier(blockIdentifier?: BlockIdentifier): string;
+export {};

package/provider/utils.js

@@ -1,23 +1,65 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.getFormattedBlockIdentifier = exports.txIdentifier = exports.formatHash = void 0;
+exports.getFormattedBlockIdentifier =
+  exports.getBlockIdentifier =
+  exports.txIdentifier =
+  exports.formatHash =
+    void 0;
+var number_1 = require('../utils/number');
 /**
- * TODO
+ *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L148-L153)
  *
  * @param hashValue
  * @param hashField
  */
-function formatHash() {}
+function formatHash(hashValue) {
+  if (typeof hashValue === 'string') return hashValue;
+  return (0, number_1.toHex)((0, number_1.toBN)(hashValue));
+}
 exports.formatHash = formatHash;
 /**
- * TODO
+ *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L156-L161)
  * @param txHash
  * @param txId
  */
-function txIdentifier() {}
+function txIdentifier(txHash, txId) {
+  if (!txHash) {
+    return 'transactionId=' + JSON.stringify(txId);
+  }
+  var hashString = formatHash(txHash);
+  return 'transactionHash=' + hashString;
+}
 exports.txIdentifier = txIdentifier;
+/**
+ * Identifies the block to be queried.
+ *
+ * @param blockIdentifier - block identifier
+ * @returns block identifier object
+ */
+function getBlockIdentifier(blockIdentifier) {
+  if (typeof blockIdentifier === 'number') {
+    return { type: 'BLOCK_NUMBER', data: blockIdentifier };
+  }
+  if (typeof blockIdentifier === 'string' && blockIdentifier.startsWith('0x')) {
+    return { type: 'BLOCK_HASH', data: blockIdentifier };
+  }
+  if (typeof blockIdentifier === 'string' && !Number.isNaN(parseInt(blockIdentifier, 10))) {
+    return { type: 'BLOCK_NUMBER', data: parseInt(blockIdentifier, 10) };
+  }
+  if (blockIdentifier === null) {
+    return { type: 'BLOCK_NUMBER', data: null };
+  }
+  if (blockIdentifier === 'pending') {
+    return { type: 'BLOCK_NUMBER', data: 'pending' };
+  }
+  if (typeof blockIdentifier === 'string') {
+    throw new Error('Invalid block identifier: ' + blockIdentifier);
+  }
+  return { type: 'BLOCK_HASH', data: blockIdentifier };
+}
+exports.getBlockIdentifier = getBlockIdentifier;
 /**
  * Gets the block identifier for API request
  *
@@ -27,13 +69,17 @@ exports.txIdentifier = txIdentifier;
  * @param blockHash
  * @returns block identifier for API request
  */
-function getFormattedBlockIdentifier(blockHash, blockNumber) {
-  if (blockNumber === void 0) {
-    blockNumber = null;
+function getFormattedBlockIdentifier(blockIdentifier) {
+  if (blockIdentifier === void 0) {
+    blockIdentifier = null;
+  }
+  var blockIdentifierObject = getBlockIdentifier(blockIdentifier);
+  if (blockIdentifierObject.type === 'BLOCK_NUMBER' && blockIdentifierObject.data === null) {
+    return '';
   }
-  if (blockHash) {
-    return '?blockHash=' + blockHash;
+  if (blockIdentifierObject.type === 'BLOCK_NUMBER') {
+    return 'blockNumber=' + blockIdentifierObject.data;
   }
-  return '?blockNumber=' + blockNumber;
+  return 'blockHash=' + (0, number_1.toHex)((0, number_1.toBN)(blockIdentifierObject.data));
 }
 exports.getFormattedBlockIdentifier = getFormattedBlockIdentifier;

package/signer/default.d.ts

@@ -1,34 +1,14 @@
-import { Provider } from '../provider';
-import { AddTransactionResponse, KeyPair, Signature, Transaction } from '../types';
+import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
 import { TypedData } from '../utils/typedData';
 import { SignerInterface } from './interface';
-export declare class Signer extends Provider implements SignerInterface {
-  address: string;
-  private keyPair;
-  constructor(provider: Provider, address: string, keyPair: KeyPair);
-  /**
-   * Invoke a function on the starknet 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
-   */
-  addTransaction(transaction: Transaction): 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>;
+export declare class Signer implements SignerInterface {
+  protected keyPair: KeyPair;
+  constructor(keyPair: KeyPair);
+  getPubKey(): Promise<string>;
+  signTransaction(
+    transactions: Invocation[],
+    transactionsDetail: InvocationsSignerDetails,
+    abis?: Abi[]
+  ): Promise<Signature>;
+  signMessage(typedData: TypedData, walletAddress: string): Promise<Signature>;
 }

package/signer/default.js

@@ -1,29 +1,4 @@
 '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 __awaiter =
   (this && this.__awaiter) ||
   function (thisArg, _arguments, P, generator) {
@@ -155,174 +130,82 @@ var __generator =
       return { value: op[0] ? op[1] : void 0, done: true };
     }
   };
-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));
-  };
-var __importDefault =
-  (this && this.__importDefault) ||
-  function (mod) {
-    return mod && mod.__esModule ? mod : { default: mod };
-  };
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.Signer = void 0;
-var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
-var provider_1 = require('../provider');
 var ellipticCurve_1 = require('../utils/ellipticCurve');
 var encode_1 = require('../utils/encode');
 var hash_1 = require('../utils/hash');
 var number_1 = require('../utils/number');
 var stark_1 = require('../utils/stark');
 var typedData_1 = require('../utils/typedData');
-var Signer = /** @class */ (function (_super) {
-  __extends(Signer, _super);
-  function Signer(provider, address, keyPair) {
-    var _this = _super.call(this, provider) || this;
-    _this.keyPair = keyPair;
-    _this.address = address;
-    return _this;
+var Signer = /** @class */ (function () {
+  function Signer(keyPair) {
+    this.keyPair = keyPair;
   }
-  /**
-   * Invoke a function on the starknet 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
-   */
-  Signer.prototype.addTransaction = function (transaction) {
+  Signer.prototype.getPubKey = function () {
     return __awaiter(this, void 0, void 0, function () {
-      var nonceBn, result, calldataDecimal, msgHash, signature;
       return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            if (transaction.type === 'DEPLOY')
-              return [2 /*return*/, _super.prototype.addTransaction.call(this, transaction)];
-            (0,
-            minimalistic_assert_1.default)(!transaction.signature, "Adding signatures to a signer transaction currently isn't supported");
-            if (!transaction.nonce) return [3 /*break*/, 1];
-            nonceBn = (0, number_1.toBN)(transaction.nonce);
-            return [3 /*break*/, 3];
-          case 1:
-            return [
-              4 /*yield*/,
-              this.callContract({
-                contract_address: this.address,
-                entry_point_selector: (0, stark_1.getSelectorFromName)('get_nonce'),
-              }),
-            ];
-          case 2:
-            result = _a.sent().result;
-            nonceBn = (0, number_1.toBN)(result[0]);
-            _a.label = 3;
-          case 3:
-            calldataDecimal = (transaction.calldata || []).map(function (x) {
-              return (0, number_1.toBN)(x).toString();
-            });
-            msgHash = (0, encode_1.addHexPrefix)(
-              (0, hash_1.hashMessage)(
-                this.address,
-                transaction.contract_address,
-                transaction.entry_point_selector,
-                calldataDecimal,
-                nonceBn.toString()
-              )
-            );
-            signature = (0, ellipticCurve_1.sign)(this.keyPair, msgHash);
-            return [
-              2 /*return*/,
-              _super.prototype.addTransaction.call(this, {
-                type: 'INVOKE_FUNCTION',
-                entry_point_selector: (0, stark_1.getSelectorFromName)('execute'),
-                calldata: __spreadArray(
-                  __spreadArray(
-                    [
-                      transaction.contract_address,
-                      transaction.entry_point_selector,
-                      calldataDecimal.length.toString(),
-                    ],
-                    __read(calldataDecimal),
-                    false
-                  ),
-                  [nonceBn.toString()],
-                  false
-                ).map(function (x) {
-                  return (0, number_1.toBN)(x).toString();
-                }),
-                contract_address: this.address,
-                signature: signature,
-              }),
-            ];
-        }
+        return [2 /*return*/, (0, ellipticCurve_1.getStarkKey)(this.keyPair)];
       });
     });
   };
-  /**
-   * 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
-   */
-  Signer.prototype.signMessage = function (typedData) {
+  Signer.prototype.signTransaction = function (transactions, transactionsDetail, abis) {
+    if (abis === void 0) {
+      abis = [];
+    }
     return __awaiter(this, void 0, void 0, function () {
-      var _a, _b;
+      var _a,
+        contractAddress,
+        entrypoint,
+        _b,
+        calldata,
+        nonce,
+        walletAddress,
+        nonceBn,
+        entrypointSelector,
+        calldataDecimal,
+        msgHash;
       return __generator(this, function (_c) {
-        switch (_c.label) {
-          case 0:
-            _a = ellipticCurve_1.sign;
-            _b = [this.keyPair];
-            return [4 /*yield*/, this.hashMessage(typedData)];
-          case 1:
-            return [2 /*return*/, _a.apply(void 0, _b.concat([_c.sent()]))];
+        if (transactions.length !== 1) {
+          throw new Error('Only one transaction at a time is currently supported by this signer');
+        }
+        if (
+          (abis === null || abis === void 0 ? void 0 : abis.length) !== 0 &&
+          abis.length !== transactions.length
+        ) {
+          throw new Error('ABI must be provided for each transaction or no transaction');
         }
+        (_a = transactions[0]),
+          (contractAddress = _a.contractAddress),
+          (entrypoint = _a.entrypoint),
+          (_b = _a.calldata),
+          (calldata = _b === void 0 ? [] : _b);
+        (nonce = transactionsDetail.nonce), (walletAddress = transactionsDetail.walletAddress);
+        nonceBn = (0, number_1.toBN)(nonce);
+        entrypointSelector = (0, stark_1.getSelectorFromName)(entrypoint);
+        calldataDecimal = (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata);
+        msgHash = (0, encode_1.addHexPrefix)(
+          (0, hash_1.hashMessage)(
+            walletAddress,
+            contractAddress,
+            entrypointSelector,
+            calldataDecimal,
+            nonceBn.toString()
+          )
+        );
+        return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
       });
     });
   };
-  /**
-   * 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
-   */
-  Signer.prototype.hashMessage = function (typedData) {
+  Signer.prototype.signMessage = function (typedData, walletAddress) {
     return __awaiter(this, void 0, void 0, function () {
+      var msgHash;
       return __generator(this, function (_a) {
-        return [2 /*return*/, (0, typedData_1.getMessageHash)(typedData, this.address)];
+        msgHash = (0, typedData_1.getMessageHash)(typedData, walletAddress);
+        return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
       });
     });
   };
   return Signer;
-})(provider_1.Provider);
+})();
 exports.Signer = Signer;

package/signer/index.d.ts

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

package/signer/index.js

@@ -23,5 +23,5 @@ var __exportStar =
         __createBinding(exports, m, p);
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-__exportStar(require('./default'), exports);
 __exportStar(require('./interface'), exports);
+__exportStar(require('./default'), exports);

package/signer/interface.d.ts

@@ -1,17 +1,12 @@
-import { Provider } from '../provider';
-import { AddTransactionResponse, Signature, Transaction } from '../types';
-import { TypedData } from '../utils/typedData/types';
-export declare abstract class SignerInterface extends Provider {
-  abstract address: string;
+import { Abi, Invocation, InvocationsSignerDetails, Signature } from '../types';
+import { TypedData } from '../utils/typedData';
+export declare abstract class SignerInterface {
   /**
-   * Invoke a function on the starknet contract
+   * Method to get the public key of the signer
    *
-   * [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
+   * @returns public key of signer as hex string with 0x prefix
    */
-  abstract addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
+  abstract getPubKey(): Promise<string>;
   /**
    * 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
@@ -20,14 +15,22 @@ export declare abstract class SignerInterface extends Provider {
    * @returns the signature of the JSON object
    * @throws {Error} if the JSON object is not a valid JSON
    */
-  abstract signMessage(typedData: TypedData): Promise<Signature>;
+  abstract signMessage(typedData: TypedData, walletAddress: string): 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
+   * Signs a transaction with the starknet private key and returns the signature
    *
-   * @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
+   * @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
+   * @param abi (optional) the abi of the contract for better displaying
+   *
+   * @returns signature
    */
-  abstract hashMessage(typedData: TypedData): Promise<string>;
+  abstract signTransaction(
+    transactions: Invocation[],
+    transactionsDetail: InvocationsSignerDetails,
+    abis?: Abi[]
+  ): Promise<Signature>;
 }