starknet 2.1.1 → 2.4.0

package/src/provider/default.ts

@@ -1,4 +1,5 @@
 import axios from 'axios';
+import urljoin from 'url-join';
 
 import {
   AddTransactionResponse,
@@ -49,15 +50,15 @@ export class Provider implements ProviderInterface {
           ? optionsOrProvider.baseUrl
           : Provider.getNetworkFromName(optionsOrProvider.network);
       this.baseUrl = baseUrl;
-      this.feederGatewayUrl = `${baseUrl}/feeder_gateway`;
-      this.gatewayUrl = `${baseUrl}/gateway`;
+      this.feederGatewayUrl = urljoin(baseUrl, 'feeder_gateway');
+      this.gatewayUrl = urljoin(baseUrl, 'gateway');
     }
   }
 
   protected static getNetworkFromName(name: NetworkName) {
     switch (name) {
       case 'mainnet-alpha':
-        return 'http://alpha-mainnet.starknet.io/';
+        return 'https://alpha-mainnet.starknet.io';
       case 'georli-alpha':
       default:
         return 'https://alpha4.starknet.io';
@@ -72,7 +73,7 @@ export class Provider implements ProviderInterface {
    */
   public async getContractAddresses(): Promise<GetContractAddressesResponse> {
     const { data } = await axios.get<GetContractAddressesResponse>(
-      `${this.feederGatewayUrl}/get_contract_addresses`
+      urljoin(this.feederGatewayUrl, 'get_contract_addresses')
     );
     return data;
   }
@@ -82,20 +83,20 @@ export class Provider implements ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L17-L25)
    *
-   * @param invokeTx - transaction to be invoked
+   * @param invokeTransaction - transaction to be invoked
    * @param blockId
    * @returns the result of the function on the smart contract.
    */
   public async callContract(
-    invokeTx: CallContractTransaction,
+    invokeTransaction: CallContractTransaction,
     blockId?: number
   ): Promise<CallContractResponse> {
     const { data } = await axios.post<CallContractResponse>(
-      `${this.feederGatewayUrl}/call_contract?blockId=${blockId ?? 'null'}`,
+      urljoin(this.feederGatewayUrl, 'call_contract', `?blockId=${blockId ?? 'null'}`),
       {
         signature: [],
         calldata: [],
-        ...invokeTx,
+        ...invokeTransaction,
       }
     );
     return data;
@@ -111,7 +112,7 @@ export class Provider implements ProviderInterface {
    */
   public async getBlock(blockId?: number): Promise<GetBlockResponse> {
     const { data } = await axios.get<GetBlockResponse>(
-      `${this.feederGatewayUrl}/get_block?blockId=${blockId ?? 'null'}`
+      urljoin(this.feederGatewayUrl, 'get_block', `?blockId=${blockId ?? 'null'}`)
     );
     return data;
   }
@@ -127,9 +128,11 @@ export class Provider implements ProviderInterface {
    */
   public async getCode(contractAddress: string, blockId?: number): Promise<GetCodeResponse> {
     const { data } = await axios.get<GetCodeResponse>(
-      `${this.feederGatewayUrl}/get_code?contractAddress=${contractAddress}&blockId=${
-        blockId ?? 'null'
-      }`
+      urljoin(
+        this.feederGatewayUrl,
+        'get_code',
+        `?contractAddress=${contractAddress}&blockId=${blockId ?? 'null'}`
+      )
     );
     return data;
   }
@@ -151,9 +154,11 @@ export class Provider implements ProviderInterface {
     blockId?: number
   ): Promise<object> {
     const { data } = await axios.get<object>(
-      `${
-        this.feederGatewayUrl
-      }/get_storage_at?contractAddress=${contractAddress}&key=${key}&blockId=${blockId ?? 'null'}`
+      urljoin(
+        this.feederGatewayUrl,
+        'get_storage_at',
+        `?contractAddress=${contractAddress}&key=${key}&blockId=${blockId ?? 'null'}`
+      )
     );
     return data;
   }
@@ -169,7 +174,11 @@ export class Provider implements ProviderInterface {
   public async getTransactionStatus(txHash: BigNumberish): Promise<GetTransactionStatusResponse> {
     const txHashBn = toBN(txHash);
     const { data } = await axios.get<GetTransactionStatusResponse>(
-      `${this.feederGatewayUrl}/get_transaction_status?transactionHash=${toHex(txHashBn)}`
+      urljoin(
+        this.feederGatewayUrl,
+        'get_transaction_status',
+        `?transactionHash=${toHex(txHashBn)}`
+      )
     );
     return data;
   }
@@ -185,7 +194,7 @@ export class Provider implements ProviderInterface {
   public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {
     const txHashBn = toBN(txHash);
     const { data } = await axios.get<GetTransactionResponse>(
-      `${this.feederGatewayUrl}/get_transaction?transactionHash=${toHex(txHashBn)}`
+      urljoin(this.feederGatewayUrl, 'get_transaction', `?transactionHash=${toHex(txHashBn)}`)
     );
     return data;
   }
@@ -195,17 +204,19 @@ export class Provider implements ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
    *
-   * @param tx - transaction to be invoked
+   * @param transaction - transaction to be invoked
    * @returns a confirmation of invoking a function on the starknet contract
    */
-  public async addTransaction(tx: Transaction): Promise<AddTransactionResponse> {
-    const signature = tx.type === 'INVOKE_FUNCTION' && formatSignature(tx.signature);
-    const contract_address_salt = tx.type === 'DEPLOY' && toHex(toBN(tx.contract_address_salt));
+  public async addTransaction(transaction: Transaction): Promise<AddTransactionResponse> {
+    const signature =
+      transaction.type === 'INVOKE_FUNCTION' && formatSignature(transaction.signature);
+    const contract_address_salt =
+      transaction.type === 'DEPLOY' && toHex(toBN(transaction.contract_address_salt));
 
     const { data } = await axios.post<AddTransactionResponse>(
-      `${this.gatewayUrl}/add_transaction`,
+      urljoin(this.gatewayUrl, 'add_transaction'),
       stringify({
-        ...tx, // the tx can contain BigInts, so we use our own `stringify`
+        ...transaction, // the tx can contain BigInts, so we use our own `stringify`
         ...(Array.isArray(signature) && { signature }), // not needed on deploy tx
         ...(contract_address_salt && { contract_address_salt }), // not needed on invoke tx
       }),

package/src/provider/interface.ts

@@ -32,12 +32,12 @@ export abstract class ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L17-L25)
    *
-   * @param invokeTx - transaction to be invoked
+   * @param invokeTransaction - transaction to be invoked
    * @param blockId
    * @returns the result of the function on the smart contract.
    */
   public abstract callContract(
-    invokeTx: CallContractTransaction,
+    invokeTransaction: CallContractTransaction,
     blockId?: number
   ): Promise<CallContractResponse>;
 
@@ -104,10 +104,10 @@ export abstract class ProviderInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
    *
-   * @param tx - transaction to be invoked
+   * @param transaction - transaction to be invoked
    * @returns a confirmation of invoking a function on the starknet contract
    */
-  public abstract addTransaction(tx: Transaction): Promise<AddTransactionResponse>;
+  public abstract addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
 
   /**
    * Deploys a given compiled contract (json) to starknet

package/src/signer/default.ts

@@ -25,26 +25,35 @@ export class Signer extends Provider implements SignerInterface {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
    *
-   * @param tx - transaction to be invoked
+   * @param transaction - transaction to be invoked
    * @returns a confirmation of invoking a function on the starknet contract
    */
-  public override async addTransaction(tx: Transaction): Promise<AddTransactionResponse> {
-    if (tx.type === 'DEPLOY') return super.addTransaction(tx);
+  public override async addTransaction(transaction: Transaction): Promise<AddTransactionResponse> {
+    if (transaction.type === 'DEPLOY') return super.addTransaction(transaction);
 
-    assert(!tx.signature, "Adding signatures to a signer tx currently isn't supported");
+    assert(
+      !transaction.signature,
+      "Adding signatures to a signer transaction currently isn't supported"
+    );
 
-    const { result } = await this.callContract({
-      contract_address: this.address,
-      entry_point_selector: getSelectorFromName('get_nonce'),
-    });
-    const nonceBn = toBN(result[0]);
-    const calldataDecimal = (tx.calldata || []).map((x) => toBN(x).toString());
+    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]);
+    }
+
+    const calldataDecimal = (transaction.calldata || []).map((x) => toBN(x).toString());
 
     const msgHash = addHexPrefix(
       hashMessage(
         this.address,
-        tx.contract_address,
-        tx.entry_point_selector,
+        transaction.contract_address,
+        transaction.entry_point_selector,
         calldataDecimal,
         nonceBn.toString()
       )
@@ -56,8 +65,8 @@ export class Signer extends Provider implements SignerInterface {
       type: 'INVOKE_FUNCTION',
       entry_point_selector: getSelectorFromName('execute'),
       calldata: [
-        tx.contract_address,
-        tx.entry_point_selector,
+        transaction.contract_address,
+        transaction.entry_point_selector,
         calldataDecimal.length.toString(),
         ...calldataDecimal,
         nonceBn.toString(),

package/src/signer/interface.ts

@@ -8,8 +8,10 @@ export abstract class SignerInterface extends Provider {
    *
    * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
    *
-   * @param tx - transaction to be invoked
+   * @param transaction - transaction to be invoked
    * @returns a confirmation of invoking a function on the starknet contract
    */
-  public abstract override addTransaction(tx: Transaction): Promise<AddTransactionResponse>;
+  public abstract override addTransaction(
+    transaction: Transaction
+  ): Promise<AddTransactionResponse>;
 }

package/src/types.ts

@@ -11,7 +11,7 @@ export type GetContractAddressesResponse = {
 };
 
 export type Status = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'REJECTED' | 'ACCEPTED_ONCHAIN';
-export type TxStatus = 'TRANSACTION_RECEIVED';
+export type TransactionStatus = 'TRANSACTION_RECEIVED';
 export type Type = 'DEPLOY' | 'INVOKE_FUNCTION';
 export type EntryPointType = 'EXTERNAL';
 export type CompressedProgram = string;
@@ -51,6 +51,7 @@ export type DeployTransaction = {
   contract_definition: CompressedCompiledContract;
   contract_address_salt: BigNumberish;
   constructor_calldata: string[];
+  nonce?: BigNumberish;
 };
 
 export type InvokeFunctionTransaction = {
@@ -60,6 +61,7 @@ export type InvokeFunctionTransaction = {
   entry_point_type?: EntryPointType;
   entry_point_selector: string;
   calldata?: string[];
+  nonce?: BigNumberish;
 };
 
 export type CallContractTransaction = Omit<InvokeFunctionTransaction, 'type'>;
@@ -116,7 +118,7 @@ export type GetTransactionResponse = {
 };
 
 export type AddTransactionResponse = {
-  code: TxStatus;
+  code: TransactionStatus;
   transaction_hash: string;
   address?: string;
 };

package/src/utils/shortString.ts

@@ -0,0 +1,21 @@
+import { addHexPrefix, removeHexPrefix } from './encode';
+
+export function isASCII(str: string) {
+  // eslint-disable-next-line no-control-regex
+  return /^[\x00-\x7F]*$/.test(str);
+}
+
+// function to check if string has less or equal 31 characters
+export function isShortString(str: string) {
+  return str.length <= 31;
+}
+
+export function encodeShortString(str: string) {
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
+  if (!isShortString(str)) throw new Error(`${str} is too long`);
+  return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
+}
+
+export function decodeShortString(str: string) {
+  return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+}

package/src/utils/uint256.ts

@@ -0,0 +1,32 @@
+import { addHexPrefix } from './encode';
+import { BigNumberish, toBN } from './number';
+
+// Represents an integer in the range [0, 2^256).
+export interface Uint256 {
+  // The low 128 bits of the value.
+  low: BigNumberish;
+  // The high 128 bits of the value.
+  high: BigNumberish;
+}
+
+// function to convert Uint256 to BN
+export function uint256ToBN(uint256: Uint256) {
+  return toBN(uint256.high).shln(128).add(toBN(uint256.low));
+}
+
+export const UINT_128_MAX = toBN(1).shln(128).sub(toBN(1));
+export const UINT_256_MAX = toBN(1).shln(256).sub(toBN(1));
+// function to check if BN is smaller or equal 2**256-1
+export function isUint256(bn: BigNumberish): boolean {
+  return toBN(bn).lte(UINT_256_MAX);
+}
+
+// function to convert BN to Uint256
+export function bnToUint256(bignumber: BigNumberish): Uint256 {
+  const bn = toBN(bignumber);
+  if (!isUint256(bn)) throw new Error('Number is too large');
+  return {
+    low: addHexPrefix(bn.maskn(128).toString(16)),
+    high: addHexPrefix(bn.shrn(128).toString(16)),
+  };
+}

package/types.d.ts

@@ -13,7 +13,7 @@ export declare type Status =
   | 'PENDING'
   | 'REJECTED'
   | 'ACCEPTED_ONCHAIN';
-export declare type TxStatus = 'TRANSACTION_RECEIVED';
+export declare type TransactionStatus = 'TRANSACTION_RECEIVED';
 export declare type Type = 'DEPLOY' | 'INVOKE_FUNCTION';
 export declare type EntryPointType = 'EXTERNAL';
 export declare type CompressedProgram = string;
@@ -50,6 +50,7 @@ export declare type DeployTransaction = {
   contract_definition: CompressedCompiledContract;
   contract_address_salt: BigNumberish;
   constructor_calldata: string[];
+  nonce?: BigNumberish;
 };
 export declare type InvokeFunctionTransaction = {
   type: 'INVOKE_FUNCTION';
@@ -58,6 +59,7 @@ export declare type InvokeFunctionTransaction = {
   entry_point_type?: EntryPointType;
   entry_point_selector: string;
   calldata?: string[];
+  nonce?: BigNumberish;
 };
 export declare type CallContractTransaction = Omit<InvokeFunctionTransaction, 'type'>;
 export declare type Transaction = DeployTransaction | InvokeFunctionTransaction;
@@ -106,7 +108,7 @@ export declare type GetTransactionResponse = {
   transaction_hash: string;
 };
 export declare type AddTransactionResponse = {
-  code: TxStatus;
+  code: TransactionStatus;
   transaction_hash: string;
   address?: string;
 };

package/utils/shortString.d.ts

@@ -0,0 +1,4 @@
+export declare function isASCII(str: string): boolean;
+export declare function isShortString(str: string): boolean;
+export declare function encodeShortString(str: string): string;
+export declare function decodeShortString(str: string): string;

package/utils/shortString.js

@@ -0,0 +1,34 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.decodeShortString =
+  exports.encodeShortString =
+  exports.isShortString =
+  exports.isASCII =
+    void 0;
+var encode_1 = require('./encode');
+function isASCII(str) {
+  // eslint-disable-next-line no-control-regex
+  return /^[\x00-\x7F]*$/.test(str);
+}
+exports.isASCII = isASCII;
+// function to check if string has less or equal 31 characters
+function isShortString(str) {
+  return str.length <= 31;
+}
+exports.isShortString = isShortString;
+function encodeShortString(str) {
+  if (!isASCII(str)) throw new Error(str + ' is not an ASCII string');
+  if (!isShortString(str)) throw new Error(str + ' is too long');
+  return (0, encode_1.addHexPrefix)(
+    str.replace(/./g, function (char) {
+      return char.charCodeAt(0).toString(16);
+    })
+  );
+}
+exports.encodeShortString = encodeShortString;
+function decodeShortString(str) {
+  return (0, encode_1.removeHexPrefix)(str).replace(/.{2}/g, function (hex) {
+    return String.fromCharCode(parseInt(hex, 16));
+  });
+}
+exports.decodeShortString = decodeShortString;

package/utils/uint256.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BigNumberish } from './number';
+export interface Uint256 {
+  low: BigNumberish;
+  high: BigNumberish;
+}
+export declare function uint256ToBN(uint256: Uint256): import('bn.js');
+export declare const UINT_128_MAX: import('bn.js');
+export declare const UINT_256_MAX: import('bn.js');
+export declare function isUint256(bn: BigNumberish): boolean;
+export declare function bnToUint256(bignumber: BigNumberish): Uint256;

package/utils/uint256.js

@@ -0,0 +1,38 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.bnToUint256 =
+  exports.isUint256 =
+  exports.UINT_256_MAX =
+  exports.UINT_128_MAX =
+  exports.uint256ToBN =
+    void 0;
+var encode_1 = require('./encode');
+var number_1 = require('./number');
+// function to convert Uint256 to BN
+function uint256ToBN(uint256) {
+  return (0, number_1.toBN)(uint256.high)
+    .shln(128)
+    .add((0, number_1.toBN)(uint256.low));
+}
+exports.uint256ToBN = uint256ToBN;
+exports.UINT_128_MAX = (0, number_1.toBN)(1)
+  .shln(128)
+  .sub((0, number_1.toBN)(1));
+exports.UINT_256_MAX = (0, number_1.toBN)(1)
+  .shln(256)
+  .sub((0, number_1.toBN)(1));
+// function to check if BN is smaller or equal 2**256-1
+function isUint256(bn) {
+  return (0, number_1.toBN)(bn).lte(exports.UINT_256_MAX);
+}
+exports.isUint256 = isUint256;
+// function to convert BN to Uint256
+function bnToUint256(bignumber) {
+  var bn = (0, number_1.toBN)(bignumber);
+  if (!isUint256(bn)) throw new Error('Number is too large');
+  return {
+    low: (0, encode_1.addHexPrefix)(bn.maskn(128).toString(16)),
+    high: (0, encode_1.addHexPrefix)(bn.shrn(128).toString(16)),
+  };
+}
+exports.bnToUint256 = bnToUint256;