starknet 2.7.2 → 3.1.0

package/src/signer/default.ts

@@ -1,101 +1,58 @@
-import assert from 'minimalistic-assert';
-
-import { Provider } from '../provider';
-import { AddTransactionResponse, KeyPair, Signature, Transaction } from '../types';
-import { sign } from '../utils/ellipticCurve';
+import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
+import { getStarkKey, sign } from '../utils/ellipticCurve';
 import { addHexPrefix } from '../utils/encode';
 import { hashMessage } from '../utils/hash';
-import { toBN } from '../utils/number';
+import { bigNumberishArrayToDecimalStringArray, toBN } from '../utils/number';
 import { getSelectorFromName } from '../utils/stark';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
 
-export class Signer extends Provider implements SignerInterface {
-  public address: string;
-
-  private keyPair: KeyPair;
+export class Signer implements SignerInterface {
+  protected keyPair: KeyPair;
 
-  constructor(provider: Provider, address: string, keyPair: KeyPair) {
-    super(provider);
+  constructor(keyPair: KeyPair) {
     this.keyPair = keyPair;
-    this.address = address;
   }
 
-  /**
-   * 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
-   */
-  public override async addTransaction(transaction: Transaction): Promise<AddTransactionResponse> {
-    if (transaction.type === 'DEPLOY') return super.addTransaction(transaction);
-
-    assert(
-      !transaction.signature,
-      "Adding signatures to a signer transaction currently isn't supported"
-    );
+  public async getPubKey(): Promise<string> {
+    return getStarkKey(this.keyPair);
+  }
 
-    let nonceBn;
-    if (transaction.nonce) {
-      nonceBn = toBN(transaction.nonce);
-    } else {
-      const { result } = await this.callContract({
-        contract_address: this.address,
-        entry_point_selector: getSelectorFromName('get_nonce'),
-      });
-      nonceBn = toBN(result[0]);
+  public async signTransaction(
+    transactions: Invocation[],
+    transactionsDetail: InvocationsSignerDetails,
+    abis: Abi[] = []
+  ): Promise<Signature> {
+    if (transactions.length !== 1) {
+      throw new Error('Only one transaction at a time is currently supported by this signer');
     }
+    if (abis?.length !== 0 && abis.length !== transactions.length) {
+      throw new Error('ABI must be provided for each transaction or no transaction');
+    }
+    // now use abi to display decoded data somewhere, but as this signer is headless, we can't do that
+
+    const { contractAddress, entrypoint, calldata = [] } = transactions[0];
+    const { nonce, walletAddress } = transactionsDetail;
 
-    const calldataDecimal = (transaction.calldata || []).map((x) => toBN(x).toString());
+    const nonceBn = toBN(nonce);
+    const entrypointSelector = getSelectorFromName(entrypoint);
+    const calldataDecimal = bigNumberishArrayToDecimalStringArray(calldata);
 
     const msgHash = addHexPrefix(
       hashMessage(
-        this.address,
-        transaction.contract_address,
-        transaction.entry_point_selector,
+        walletAddress,
+        contractAddress,
+        entrypointSelector,
         calldataDecimal,
         nonceBn.toString()
       )
     );
 
-    const signature = sign(this.keyPair, msgHash);
-
-    return super.addTransaction({
-      type: 'INVOKE_FUNCTION',
-      entry_point_selector: getSelectorFromName('execute'),
-      calldata: [
-        transaction.contract_address,
-        transaction.entry_point_selector,
-        calldataDecimal.length.toString(),
-        ...calldataDecimal,
-        nonceBn.toString(),
-      ].map((x) => toBN(x).toString()),
-      contract_address: this.address,
-      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 sign(this.keyPair, await this.hashMessage(typedData));
+    return 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
-   */
-  public async hashMessage(typedData: TypedData): Promise<string> {
-    return getMessageHash(typedData, this.address);
+  public async signMessage(typedData: TypedData, walletAddress: string): Promise<Signature> {
+    const msgHash = getMessageHash(typedData, walletAddress);
+    return sign(this.keyPair, msgHash);
   }
 }

package/src/signer/index.ts

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

package/src/signer/interface.ts

@@ -1,20 +1,13 @@
-import { Provider } from '../provider';
-import { AddTransactionResponse, Signature, Transaction } from '../types';
-import { TypedData } from '../utils/typedData/types';
+import { Abi, Invocation, InvocationsSignerDetails, Signature } from '../types';
+import { TypedData } from '../utils/typedData';
 
-export abstract class SignerInterface extends Provider {
-  public abstract address: string;
+export 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
    */
-  public abstract override addTransaction(
-    transaction: Transaction
-  ): Promise<AddTransactionResponse>;
+  public abstract getPubKey(): Promise<string>;
 
   /**
    * Sign an JSON object for off-chain usage with the starknet private key and return the signature
@@ -24,15 +17,23 @@ export abstract class SignerInterface extends Provider {
    * @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>;
+  public 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
    */
-  public abstract hashMessage(typedData: TypedData): Promise<string>;
+  public abstract signTransaction(
+    transactions: Invocation[],
+    transactionsDetail: InvocationsSignerDetails,
+    abis?: Abi[]
+  ): Promise<Signature>;
 }

package/src/types/api.ts

@@ -0,0 +1,171 @@
+import { BlockIdentifier } from '../provider/utils';
+import { BigNumberish } from '../utils/number';
+import {
+  Abi,
+  BlockNumber,
+  CompressedCompiledContract,
+  EntryPointType,
+  RawCalldata,
+  Signature,
+  Status,
+  TransactionStatus,
+} from './lib';
+
+export type Endpoints = {
+  get_contract_addresses: {
+    QUERY: never;
+    REQUEST: never;
+    RESPONSE: GetContractAddressesResponse;
+  };
+  add_transaction: {
+    QUERY: never;
+    REQUEST: Transaction;
+    RESPONSE: AddTransactionResponse;
+  };
+  get_transaction: {
+    QUERY: {
+      transactionHash: string;
+    };
+    REQUEST: never;
+    RESPONSE: GetTransactionResponse;
+  };
+  get_transaction_status: {
+    QUERY: {
+      transactionHash: string;
+    };
+    REQUEST: never;
+    RESPONSE: GetTransactionStatusResponse;
+  };
+  get_storage_at: {
+    QUERY: {
+      contractAddress: string;
+      key: number;
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: never;
+    RESPONSE: object;
+  };
+  get_code: {
+    QUERY: {
+      contractAddress: string;
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: never;
+    RESPONSE: GetCodeResponse;
+  };
+  get_block: {
+    QUERY: {
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: never;
+    RESPONSE: GetBlockResponse;
+  };
+  call_contract: {
+    QUERY: {
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: CallContractTransaction;
+    RESPONSE: CallContractResponse;
+  };
+};
+
+export type GetContractAddressesResponse = {
+  Starknet: string;
+  GpsStatementVerifier: string;
+};
+
+export type DeployTransaction = {
+  type: 'DEPLOY';
+  contract_definition: CompressedCompiledContract;
+  contract_address_salt: BigNumberish;
+  constructor_calldata: string[];
+  nonce?: BigNumberish;
+};
+
+export type InvokeFunctionTransaction = {
+  type: 'INVOKE_FUNCTION';
+  contract_address: string;
+  signature?: Signature;
+  entry_point_type?: EntryPointType;
+  entry_point_selector: string;
+  calldata?: RawCalldata;
+  nonce?: BigNumberish;
+};
+
+export type CallContractTransaction = Omit<
+  InvokeFunctionTransaction,
+  'type' | 'entry_point_type' | 'nonce'
+>;
+
+export type Transaction = DeployTransaction | InvokeFunctionTransaction;
+
+export type CallContractResponse = {
+  result: string[];
+};
+
+export type GetBlockResponse = {
+  block_number: number;
+  state_root: string;
+  block_hash: string;
+  transactions: {
+    [txHash: string]: Transaction;
+  };
+  timestamp: number;
+  transaction_receipts: {
+    [txHash: string]: {
+      block_hash: string;
+      transaction_hash: string;
+      l2_to_l1_messages: {
+        to_address: string;
+        payload: string[];
+        from_address: string;
+      }[];
+      block_number: BlockNumber;
+      status: Status;
+      transaction_index: number;
+    };
+  };
+  previous_block_hash: string;
+  status: Status;
+};
+
+export type GetCodeResponse = {
+  bytecode: string[];
+  abi: Abi;
+};
+
+export type GetTransactionStatusResponse = {
+  tx_status: Status;
+  block_hash: string;
+};
+
+export type GetTransactionResponse = {
+  status: Status;
+  transaction: Transaction;
+  block_hash: string;
+  block_number: BlockNumber;
+  transaction_index: number;
+  transaction_hash: string;
+};
+
+export type AddTransactionResponse = {
+  code: TransactionStatus;
+  transaction_hash: string;
+  address?: string;
+};
+
+export type TransactionReceipt = {
+  status: Status;
+  transaction_hash: string;
+  transaction_index: number;
+  block_hash: string;
+  block_number: BlockNumber;
+  l2_to_l1_messages: string[];
+  events: string[];
+};
+
+export type RawArgs = {
+  [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
+};
+
+export type Calldata = string[];

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './lib';
+export * from './api';
+export * from './signer';

package/src/types/lib.ts

@@ -0,0 +1,73 @@
+import type { ec as EC } from 'elliptic';
+
+import type { BigNumberish } from '../utils/number';
+
+export type KeyPair = EC.KeyPair;
+export type Signature = BigNumberish[];
+export type RawCalldata = BigNumberish[];
+
+export type DeployContractPayload = {
+  contract: CompiledContract | string;
+  constructorCalldata?: RawCalldata;
+  addressSalt?: BigNumberish;
+};
+
+export type Invocation = {
+  contractAddress: string;
+  entrypoint: string;
+  calldata?: RawCalldata;
+  signature?: Signature;
+};
+
+export type ExecuteInvocation = Omit<Invocation, 'signature'>;
+
+export type InvocationsDetails = {
+  nonce?: BigNumberish;
+};
+
+export type Call = Omit<Invocation, 'signature' | 'nonce'>;
+
+export type Status =
+  | 'NOT_RECEIVED'
+  | 'RECEIVED'
+  | 'PENDING'
+  | 'ACCEPTED_ON_L2'
+  | 'ACCEPTED_ON_L1'
+  | 'REJECTED';
+export type TransactionStatus = 'TRANSACTION_RECEIVED';
+export type Type = 'DEPLOY' | 'INVOKE_FUNCTION';
+export type EntryPointType = 'EXTERNAL';
+export type CompressedProgram = string;
+
+export type AbiEntry = { name: string; type: 'felt' | 'felt*' | string };
+
+export type FunctionAbi = {
+  inputs: AbiEntry[];
+  name: string;
+  outputs: AbiEntry[];
+  stateMutability?: 'view';
+  type: 'function';
+};
+
+export type StructAbi = {
+  members: (AbiEntry & { offset: number })[];
+  name: string;
+  size: number;
+  type: 'struct';
+};
+
+export type Abi = Array<FunctionAbi | StructAbi>;
+
+export type EntryPointsByType = object;
+export type Program = Record<any, any>;
+export type BlockNumber = 'pending' | null | number;
+
+export type CompiledContract = {
+  abi: Abi;
+  entry_points_by_type: EntryPointsByType;
+  program: Program;
+};
+
+export type CompressedCompiledContract = Omit<CompiledContract, 'program'> & {
+  program: CompressedProgram;
+};

package/src/types/signer.ts

@@ -0,0 +1,5 @@
+import { InvocationsDetails } from './lib';
+
+export interface InvocationsSignerDetails extends Required<InvocationsDetails> {
+  walletAddress: string;
+}

package/src/utils/address.ts

@@ -0,0 +1,23 @@
+import { MASK_251, ZERO } from '../constants';
+import { addHexPrefix, removeHexPrefix } from './encode';
+import { assertInRange } from './number';
+
+export function addAddressPadding(address: string): string {
+  return addHexPrefix(removeHexPrefix(address).padStart(64, '0'));
+}
+
+export function validateAndParseAddress(address: string): string {
+  if (typeof address !== 'string') {
+    throw new Error('Invalid Address Type');
+  }
+
+  assertInRange(address, ZERO, MASK_251, 'Starknet Address');
+
+  const result = addAddressPadding(address);
+
+  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
+    throw new Error('Invalid Address Format');
+  }
+
+  return result;
+}

package/src/utils/number.ts

@@ -1,4 +1,4 @@
-import BN from 'bn.js';
+import BN, { isBN } from 'bn.js';
 import assert from 'minimalistic-assert';
 
 import { addHexPrefix, removeHexPrefix } from './encode';
@@ -23,6 +23,13 @@ export function hexToDecimalString(hex: string): string {
   return toBN(`0x${hex.replace(/^0x/, '')}`).toString();
 }
 
+export function toFelt(num: BigNumberish): string {
+  if (isBN(num)) {
+    return num.toString();
+  }
+  return toBN(num).toString();
+}
+
 /*
  Asserts input is equal to or greater then lowerBound and lower then upperBound.
  Assert message specifies inputName.
@@ -42,3 +49,7 @@ export function assertInRange(
     `Message not signable, ${messageSuffix}.`
   );
 }
+
+export function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[] {
+  return rawCalldata.map((x) => toBN(x).toString(10));
+}

package/src/utils/stark.ts

@@ -1,6 +1,6 @@
 import { gzip } from 'pako';
 
-import { CompressedProgram, Program, Signature } from '../types';
+import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../types';
 import { genKeyPair, getStarkKey } from './ellipticCurve';
 import { addHexPrefix, btoaUniversal } from './encode';
 import { starknetKeccak } from './hash';
@@ -49,3 +49,15 @@ export function formatSignature(sig?: Signature): string[] {
     return [];
   }
 }
+
+export function compileCalldata(args: RawArgs): Calldata {
+  return Object.values(args).flatMap((value) => {
+    if (Array.isArray(value))
+      return [toBN(value.length).toString(), ...value.map((x) => toBN(x).toString())];
+    if (typeof value === 'object' && 'type' in value)
+      return Object.entries(value)
+        .filter(([k]) => k !== 'type')
+        .map(([, v]) => toBN(v).toString());
+    return toBN(value).toString();
+  });
+}

package/types/api.d.ts

@@ -0,0 +1,162 @@
+import { BlockIdentifier } from '../provider/utils';
+import { BigNumberish } from '../utils/number';
+import {
+  Abi,
+  BlockNumber,
+  CompressedCompiledContract,
+  EntryPointType,
+  RawCalldata,
+  Signature,
+  Status,
+  TransactionStatus,
+} from './lib';
+export declare type Endpoints = {
+  get_contract_addresses: {
+    QUERY: never;
+    REQUEST: never;
+    RESPONSE: GetContractAddressesResponse;
+  };
+  add_transaction: {
+    QUERY: never;
+    REQUEST: Transaction;
+    RESPONSE: AddTransactionResponse;
+  };
+  get_transaction: {
+    QUERY: {
+      transactionHash: string;
+    };
+    REQUEST: never;
+    RESPONSE: GetTransactionResponse;
+  };
+  get_transaction_status: {
+    QUERY: {
+      transactionHash: string;
+    };
+    REQUEST: never;
+    RESPONSE: GetTransactionStatusResponse;
+  };
+  get_storage_at: {
+    QUERY: {
+      contractAddress: string;
+      key: number;
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: never;
+    RESPONSE: object;
+  };
+  get_code: {
+    QUERY: {
+      contractAddress: string;
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: never;
+    RESPONSE: GetCodeResponse;
+  };
+  get_block: {
+    QUERY: {
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: never;
+    RESPONSE: GetBlockResponse;
+  };
+  call_contract: {
+    QUERY: {
+      blockIdentifier: BlockIdentifier;
+    };
+    REQUEST: CallContractTransaction;
+    RESPONSE: CallContractResponse;
+  };
+};
+export declare type GetContractAddressesResponse = {
+  Starknet: string;
+  GpsStatementVerifier: string;
+};
+export declare type DeployTransaction = {
+  type: 'DEPLOY';
+  contract_definition: CompressedCompiledContract;
+  contract_address_salt: BigNumberish;
+  constructor_calldata: string[];
+  nonce?: BigNumberish;
+};
+export declare type InvokeFunctionTransaction = {
+  type: 'INVOKE_FUNCTION';
+  contract_address: string;
+  signature?: Signature;
+  entry_point_type?: EntryPointType;
+  entry_point_selector: string;
+  calldata?: RawCalldata;
+  nonce?: BigNumberish;
+};
+export declare type CallContractTransaction = Omit<
+  InvokeFunctionTransaction,
+  'type' | 'entry_point_type' | 'nonce'
+>;
+export declare type Transaction = DeployTransaction | InvokeFunctionTransaction;
+export declare type CallContractResponse = {
+  result: string[];
+};
+export declare type GetBlockResponse = {
+  block_number: number;
+  state_root: string;
+  block_hash: string;
+  transactions: {
+    [txHash: string]: Transaction;
+  };
+  timestamp: number;
+  transaction_receipts: {
+    [txHash: string]: {
+      block_hash: string;
+      transaction_hash: string;
+      l2_to_l1_messages: {
+        to_address: string;
+        payload: string[];
+        from_address: string;
+      }[];
+      block_number: BlockNumber;
+      status: Status;
+      transaction_index: number;
+    };
+  };
+  previous_block_hash: string;
+  status: Status;
+};
+export declare type GetCodeResponse = {
+  bytecode: string[];
+  abi: Abi;
+};
+export declare type GetTransactionStatusResponse = {
+  tx_status: Status;
+  block_hash: string;
+};
+export declare type GetTransactionResponse = {
+  status: Status;
+  transaction: Transaction;
+  block_hash: string;
+  block_number: BlockNumber;
+  transaction_index: number;
+  transaction_hash: string;
+};
+export declare type AddTransactionResponse = {
+  code: TransactionStatus;
+  transaction_hash: string;
+  address?: string;
+};
+export declare type TransactionReceipt = {
+  status: Status;
+  transaction_hash: string;
+  transaction_index: number;
+  block_hash: string;
+  block_number: BlockNumber;
+  l2_to_l1_messages: string[];
+  events: string[];
+};
+export declare type RawArgs = {
+  [inputName: string]:
+    | string
+    | string[]
+    | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+      };
+};
+export declare type Calldata = string[];