starknet 4.1.0 → 4.3.1

package/src/provider/sequencer.ts

@@ -2,7 +2,6 @@ import urljoin from 'url-join';
 
 import { ONE, StarknetChainId, ZERO } from '../constants';
 import {
-  BlockTag,
   Call,
   CallContractResponse,
   ContractClass,
@@ -31,6 +30,7 @@ import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from
 import { parseContract, wait } from '../utils/provider';
 import { SequencerAPIResponseParser } from '../utils/responseParser/sequencer';
 import { randomAddress } from '../utils/stark';
+import { buildUrl } from '../utils/url';
 import { GatewayError, HttpError } from './errors';
 import { ProviderInterface } from './interface';
 import { BlockIdentifier, getFormattedBlockIdentifier } from './utils';
@@ -74,9 +74,13 @@ export class SequencerProvider implements ProviderInterface {
       this.gatewayUrl = urljoin(this.baseUrl, 'gateway');
     } else {
       this.baseUrl = optionsOrProvider.baseUrl;
-      this.feederGatewayUrl =
-        optionsOrProvider.feederGatewayUrl ?? urljoin(this.baseUrl, 'feeder_gateway');
-      this.gatewayUrl = optionsOrProvider.gatewayUrl ?? urljoin(this.baseUrl, 'gateway');
+      this.feederGatewayUrl = buildUrl(
+        this.baseUrl,
+        'feeder_gateway',
+        optionsOrProvider.feederGatewayUrl
+      );
+      this.gatewayUrl = buildUrl(this.baseUrl, 'gateway', optionsOrProvider.gatewayUrl);
+
       this.chainId =
         optionsOrProvider.chainId ??
         SequencerProvider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
@@ -228,11 +232,11 @@ export class SequencerProvider implements ProviderInterface {
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockHashOrTag: BlockTag | BigNumberish = 'pending'
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
     const parsedKey = toBN(key).toString(10);
     return this.fetchEndpoint('get_storage_at', {
-      blockIdentifier: blockHashOrTag,
+      blockIdentifier,
       contractAddress,
       key: parsedKey,
     });
@@ -327,9 +331,7 @@ export class SequencerProvider implements ProviderInterface {
     contractAddress: string,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<Sequencer.GetCodeResponse> {
-    return this.fetchEndpoint('get_code', { contractAddress, blockIdentifier }).then(
-      this.responseParser.parseGetCodeResponse
-    );
+    return this.fetchEndpoint('get_code', { contractAddress, blockIdentifier });
   }
 
   public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {

package/src/provider/utils.ts

@@ -1,5 +1,5 @@
 import type { BlockNumber } from '../types';
-import { BigNumberish, toBN, toHex } from '../utils/number';
+import { BigNumberish, isHex, toBN, toHex } from '../utils/number';
 
 /**
  *
@@ -31,11 +31,32 @@ export function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string
 // hex string and BN are detected as block hashes
 // decimal string and number are detected as block numbers
 // null appends nothing to the request url
+
 export type BlockIdentifier = BlockNumber | BigNumberish;
 type BlockIdentifierObject =
   | { type: 'BLOCK_NUMBER'; data: BlockNumber }
   | { type: 'BLOCK_HASH'; data: BigNumberish };
 
+export class BlockIdentifierClass {
+  blockIdentifier: BlockIdentifier;
+
+  constructor(blockIdentifier: BlockIdentifier) {
+    this.blockIdentifier = blockIdentifier;
+  }
+
+  getIdentifier() {
+    if (typeof this.blockIdentifier === 'string' && isHex(this.blockIdentifier)) {
+      return { block_hash: this.blockIdentifier };
+    }
+
+    if (typeof this.blockIdentifier === 'number') {
+      return { block_number: this.blockIdentifier };
+    }
+
+    return this.blockIdentifier;
+  }
+}
+
 /**
  * Identifies the block to be queried.
  *

package/src/types/api/openrpc.ts

@@ -0,0 +1,168 @@
+/**
+ * Starknet RPC version 0.1.0
+ * starknet_api_openrpc version 0.31.0
+ *
+ * TypeScript Representation of OpenRpc protocol types | results
+ * errors are not implemented here only results
+ */
+
+/**
+ * "type": "string",
+ * "title": "Field element",
+ * "$comment": "A field element, represented as a string of hex digits",
+ * "description": "A field element. Represented as up to 63 hex digits and leading 4 bits zeroed.",
+ * "pattern": "^0x0[a-fA-F0-9]{1,63}$"
+ */
+type FELT = string;
+type BLOCK_NUMBER = number;
+type BLOCK_HASH = FELT;
+type TXN_HASH = FELT;
+type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'INVOKE' | 'L1_HANDLER';
+type MSG_TO_L1 = {
+  to_address: FELT;
+  payload: Array<FELT>;
+};
+type EVENT = {
+  from_address: FELT;
+  keys: Array<FELT>;
+  data: Array<FELT>;
+};
+type COMMON_RECEIPT_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  actual_fee: FELT;
+  status: TXN_STATUS;
+  block_hash: BLOCK_HASH;
+  block_number: BLOCK_NUMBER;
+  type?: TXN_TYPE;
+};
+type INVOKE_TXN_RECEIPT_PROPERTIES = {
+  messages_sent: MSG_TO_L1;
+  events: EVENT;
+};
+type PENDING_COMMON_RECEIPT_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  actual_fee: FELT;
+  type?: TXN_TYPE;
+};
+type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DEPLOY_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type PENDING_INVOKE_TXN_RECEIPT = PENDING_COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+type PENDING_TXN_RECEIPT = PENDING_INVOKE_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
+type TXN_RECEIPT =
+  | INVOKE_TXN_RECEIPT
+  | L1_HANDLER_TXN_RECEIPT
+  | DECLARE_TXN_RECEIPT
+  | DEPLOY_TXN_RECEIPT
+  | PENDING_TXN_RECEIPT;
+
+export namespace RPC_1 {
+  export type GetTransactionReceiptResponse = TXN_RECEIPT;
+
+  export type Methods = {
+    starknet_getTransactionReceipt: {
+      QUERY: never;
+      REQUEST: any[];
+      RESPONSE: GetTransactionReceiptResponse;
+    };
+  };
+}
+
+// starknet_getBlockWithTxHashes
+type BLOCK_HEADER = {
+  block_hash: BLOCK_HASH;
+  parent_hash: BLOCK_HASH;
+  block_number: BLOCK_NUMBER;
+  new_root: FELT;
+  timestamp: number;
+  sequencer_address: FELT;
+};
+type BLOCK_BODY_WITH_TX_HASHES = {
+  transactions: Array<TXN_HASH>;
+};
+type BLOCK_WITH_TX_HASHES = {
+  status: TXN_STATUS;
+} & BLOCK_HEADER &
+  BLOCK_BODY_WITH_TX_HASHES;
+type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
+  timestamp: number;
+  sequencer_address: FELT;
+  parent_hash: BLOCK_HASH;
+};
+
+// starknet_getBlockWithTx
+type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+/**
+ * "title": "An integer number in hex format (0x...)",
+ * "pattern": "^0x[a-fA-F0-9]+$"
+ */
+type NUM_AS_HEX = string;
+type SIGNATURE = Array<FELT>;
+type COMMON_TXN_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  max_fee: FELT;
+  version: NUM_AS_HEX;
+  signature: SIGNATURE;
+  nonce: FELT;
+  type: TXN_TYPE;
+};
+type ADDRESS = FELT;
+type FUNCTION_CALL = {
+  contract_address: ADDRESS;
+  entry_point_selector: FELT;
+  calldata: Array<FELT>;
+};
+type INVOKE_TXN = COMMON_TXN_PROPERTIES & FUNCTION_CALL;
+type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
+  class_hash: FELT;
+  sender_address: ADDRESS;
+};
+type DEPLOY_TXN = {
+  transaction_hash: TXN_HASH;
+  class_hash: FELT;
+  version: NUM_AS_HEX;
+  type: TXN_TYPE;
+  contract_address: FELT;
+  contract_address_salt: FELT;
+  constructor_calldata: Array<FELT>;
+};
+type TXN = INVOKE_TXN | DECLARE_TXN | DEPLOY_TXN;
+type BLOCK_BODY_WITH_TXS = {
+  transactions: Array<TXN>;
+};
+type BLOCK_WITH_TXS = {
+  status: BLOCK_STATUS;
+} & BLOCK_HEADER &
+  BLOCK_BODY_WITH_TXS;
+
+type PENDING_BLOCK_WITH_TXS = BLOCK_BODY_WITH_TXS & {
+  timestamp: number;
+  sequencer_address: FELT;
+  parent_hash: BLOCK_HASH;
+};
+
+type CONTRACT_CLASS = {
+  program: string; // A base64 representation of the compressed program code
+  entry_points_by_type: {
+    CONSTRUCTOR: CONTRACT_ENTRY_POINT_LIST;
+    EXTERNAL: CONTRACT_ENTRY_POINT_LIST;
+    L1_HANDLER: CONTRACT_ENTRY_POINT_LIST;
+  };
+};
+
+type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
+type CONTRACT_ENTRY_POINT = {
+  offset: NUM_AS_HEX;
+  selector: FELT;
+};
+
+export namespace OPENRPC {
+  export type GetBlockWithTxHashesResponse = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
+  export type GetBlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
+  export type GetStorageAtResponse = FELT;
+  export type GetTransactionByHashResponse = TXN;
+  export type GetTransactionByBlockIdAndIndex = TXN;
+  export type GetClassResponse = CONTRACT_CLASS;
+}

package/src/types/api/rpc.ts

@@ -1,5 +1,7 @@
 import { StarknetChainId } from '../../constants';
+import { BlockIdentifier } from '../../provider/utils';
 import { Status } from '../lib';
+import { OPENRPC } from './openrpc';
 
 export namespace RPC {
   export type Response = {
@@ -32,25 +34,9 @@ export namespace RPC {
     gas_price: number;
   };
 
-  export type GetBlockResponse = {
-    block_hash: string;
-    parent_hash: string;
-    block_number: number;
-    status: Status;
-    sequencer: string;
-    new_root: string;
-    old_root: string;
-    accepted_time: number;
-    gas_price: string;
-    transactions: string[];
-  };
-
-  export type GetCodeResponse = {
-    bytecode: string[];
-    abi: string;
-  };
-
-  export type GetStorageAtResponse = string;
+  export type GetBlockWithTxHashesResponse = OPENRPC.GetBlockWithTxHashesResponse;
+  export type GetBlockWithTxs = OPENRPC.GetBlockWithTxs;
+  export type GetStorageAtResponse = OPENRPC.GetStorageAtResponse;
 
   export type GetTransactionReceiptResponse = {
     txn_hash: string;
@@ -81,7 +67,8 @@ export namespace RPC {
     sender_address?: string;
   }
 
-  export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+  export type GetTransactionByHashResponse = OPENRPC.GetTransactionByHashResponse;
+  export type GetTransactionByBlockIdAndIndex = OPENRPC.GetTransactionByBlockIdAndIndex;
 
   export type GetTransactionCountResponse = number;
 
@@ -99,8 +86,8 @@ export namespace RPC {
     | boolean;
 
   export type EventFilter = {
-    fromBlock: string;
-    toBlock: string;
+    fromBlock: BlockIdentifier;
+    toBlock: BlockIdentifier;
     address: string;
     keys: string[];
     page_size: number;
@@ -143,56 +130,46 @@ export namespace RPC {
   };
 
   export type Methods = {
-    starknet_getBlockByHash: {
+    starknet_getBlockWithTxHashes: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetBlockResponse;
+      RESPONSE: GetBlockWithTxHashesResponse;
     };
-    starknet_getBlockByNumber: {
+    starknet_getBlockWithTxs: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetBlockResponse;
+      RESPONSE: GetBlockWithTxs;
     };
-    starknet_getStorageAt: {
+    starknet_getNonce: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetStorageAtResponse;
+      RESPONSE: string;
     };
-    starknet_getTransactionByHash: {
+    starknet_getStorageAt: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetTransactionResponse;
+      RESPONSE: GetStorageAtResponse;
     };
-    starknet_getTransactionByBlockHashAndIndex: {
+    starknet_getTransactionByHash: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetTransactionResponse;
+      RESPONSE: GetTransactionByHashResponse;
     };
-    starknet_getTransactionByBlockNumberAndIndex: {
+    starknet_getTransactionByBlockIdAndIndex: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetTransactionResponse;
+      RESPONSE: GetTransactionByBlockIdAndIndex;
     };
     starknet_getTransactionReceipt: {
       QUERY: never;
       REQUEST: any[];
       RESPONSE: GetTransactionReceiptResponse;
     };
-    starknet_getBlockTransactionCountByHash: {
-      QUERY: never;
-      REQUEST: any[];
-      RESPONSE: GetTransactionCountResponse;
-    };
-    starknet_getBlockTransactionCountByNumber: {
+    starknet_getBlockTransactionCount: {
       QUERY: never;
       REQUEST: any[];
       RESPONSE: GetTransactionCountResponse;
     };
-    starknet_getCode: {
-      QUERY: never;
-      REQUEST: any[];
-      RESPONSE: GetCodeResponse;
-    };
     starknet_call: {
       QUERY: never;
       REQUEST: any[];

package/src/types/provider.ts

@@ -1,19 +1,19 @@
+/**
+ * Common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import BN from 'bn.js';
 
 import { Abi, CompressedProgram, EntryPointsByType, RawCalldata, Signature, Status } from './lib';
 
 export interface GetBlockResponse {
-  accepted_time: number;
+  timestamp: number;
   block_hash: string;
   block_number: number;
-  gas_price: string;
   new_root: string;
-  old_root?: string;
   parent_hash: string;
-  sequencer: string;
   status: Status;
   transactions: Array<string>;
-  starknet_version?: string;
 }
 
 export interface GetCodeResponse {

package/src/utils/address.ts

@@ -3,7 +3,7 @@ import { arrayify } from '@ethersproject/bytes';
 
 import { MASK_251, ZERO } from '../constants';
 import { addHexPrefix, removeHexPrefix } from './encode';
-import { pedersen } from './hash';
+import { keccakBn } from './hash';
 import { BigNumberish, assertInRange, toBN, toHex } from './number';
 
 export function addAddressPadding(address: BigNumberish): string {
@@ -25,7 +25,7 @@ export function validateAndParseAddress(address: BigNumberish): string {
 // from https://github.com/ethers-io/ethers.js/blob/fc1e006575d59792fa97b4efb9ea2f8cca1944cf/packages/address/src.ts/index.ts#L12
 export function getChecksumAddress(address: BigNumberish): string {
   const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split('');
-  const hashed = arrayify(pedersen([0, address]), { hexPad: 'left' }); // as the hash will be 251 bits (63 chars) we need to pad it to 64 chars without changing the number value ("left")
+  const hashed = arrayify(keccakBn(address), { hexPad: 'left' }); // in case the hash is 251 bits (63 chars) we need to pad it to 64 chars without changing the number value ("left")
 
   for (let i = 0; i < chars.length; i += 2) {
     if (hashed[i >> 1] >> 4 >= 8) {

package/src/utils/ellipticCurve.ts

@@ -21,11 +21,13 @@ export const ec = new EC(
   })
 );
 
-/*
- The function _truncateToN in lib/elliptic/ec/index.js does a shift-right of 4 bits
- in some cases. This function does the opposite operation so that
-   _truncateToN(fixMessage(msg)) == msg.
-*/
+/**
+ * The function _truncateToN in lib/elliptic/ec/index.js does a shift-right of 4 bits
+ * in some cases. This function does the opposite operation so that
+ * _truncateToN(fixMessage(msg)) == msg.
+ *
+ * @param msg
+ */
 function fixMessage(msg: string) {
   const pureHex = msg.replace(/^0x0*/, '');
 
@@ -64,11 +66,12 @@ export function getKeyPairFromPublicKey(publicKey: BigNumberish): KeyPair {
   return ec.keyFromPublic(removeHexPrefix(toHex(publicKeyBn)), 'hex');
 }
 
-/*
- Signs a message using the provided key.
- key should be an KeyPair with a valid private key.
- Returns an Signature.
-*/
+/**
+ * Signs a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid private key.
+ * @returns an Signature.
+ */
 export function sign(keyPair: KeyPair, msgHash: string): Signature {
   const msgHashBN = toBN(addHexPrefix(msgHash));
   // Verify message hash has valid length.
@@ -89,12 +92,13 @@ function chunkArray(arr: any[], n: number): any[][] {
     .map((_, i) => arr.slice(i * n, i * n + n));
 }
 
-/*
-   Verifies a message using the provided key.
-   key should be an KeyPair with a valid public key.
-   msgSignature should be an Signature.
-   Returns a boolean true if the verification succeeds.
-  */
+/**
+ * Verifies a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid public key.
+ * @param sig should be an Signature.
+ * @returns true if the verification succeeds.
+ */
 export function verify(keyPair: KeyPair | KeyPair[], msgHash: string, sig: Signature): boolean {
   const keyPairArray = Array.isArray(keyPair) ? keyPair : [keyPair];
   const msgHashBN = toBN(addHexPrefix(msgHash));

package/src/utils/hash.ts

@@ -1,5 +1,6 @@
 import BN from 'bn.js';
 import { keccak256 } from 'ethereum-cryptography/keccak';
+import { hexToBytes } from 'ethereum-cryptography/utils';
 import assert from 'minimalistic-assert';
 
 import {
@@ -13,12 +14,18 @@ import {
 } from '../constants';
 import { RawCalldata } from '../types/lib';
 import { ec } from './ellipticCurve';
-import { addHexPrefix, buf2hex, utf8ToArray } from './encode';
+import { addHexPrefix, buf2hex, removeHexPrefix, utf8ToArray } from './encode';
 import { BigNumberish, toBN, toFelt, toHex } from './number';
 
 export const transactionVersion = 0;
 export const feeTransactionVersion = toBN(2).pow(toBN(128)).add(toBN(transactionVersion));
 
+export function keccakBn(value: BigNumberish): string {
+  const hexWithoutPrefix = removeHexPrefix(toHex(toBN(value)));
+  const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+  return addHexPrefix(buf2hex(keccak256(hexToBytes(evenHex))));
+}
+
 function keccakHex(value: string): string {
   return addHexPrefix(buf2hex(keccak256(utf8ToArray(value))));
 }

package/src/utils/responseParser/rpc.ts

@@ -1,3 +1,7 @@
+/**
+ * Map RPC Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import {
   CallContractResponse,
   DeclareContractResponse,
@@ -12,33 +16,36 @@ import { RPC } from '../../types/api';
 import { toBN } from '../number';
 import { ResponseParser } from '.';
 
+type RpcGetBlockResponse = RPC.GetBlockWithTxHashesResponse & {
+  [key: string]: any;
+};
+
+type GetTransactionByHashResponse = RPC.GetTransactionByHashResponse & {
+  [key: string]: any;
+};
+
 export class RPCResponseParser extends ResponseParser {
-  public parseGetBlockResponse(res: RPC.GetBlockResponse): GetBlockResponse {
+  public parseGetBlockResponse(res: RpcGetBlockResponse): GetBlockResponse {
     return {
-      accepted_time: res.accepted_time,
+      timestamp: res.timestamp,
       block_hash: res.block_hash,
       block_number: res.block_number,
-      gas_price: res.gas_price,
       new_root: res.new_root,
-      old_root: res.old_root,
       parent_hash: res.parent_hash,
-      sequencer: res.sequencer,
       status: res.status,
       transactions: res.transactions,
     };
   }
 
-  public parseGetTransactionResponse(res: RPC.GetTransactionResponse): GetTransactionResponse {
+  public parseGetTransactionResponse(res: GetTransactionByHashResponse): GetTransactionResponse {
     return {
       calldata: res.calldata || [],
       contract_address: res.contract_address,
-      contract_class: res.contract_class,
       entry_point_selector: res.entry_point_selector,
       max_fee: res.max_fee,
       nonce: res.nonce,
-      sender_address: res.sender_address,
       signature: res.signature || [],
-      transaction_hash: res.txn_hash,
+      transaction_hash: res.transaction_hash,
       version: res.version,
     };
   }
@@ -57,10 +64,6 @@ export class RPCResponseParser extends ResponseParser {
     };
   }
 
-  public parseGetCodeResponse(res: RPC.GetCodeResponse): RPC.GetCodeResponse {
-    return res;
-  }
-
   public parseFeeEstimateResponse(res: RPC.EstimateFeeResponse): EstimateFeeResponse {
     return {
       overall_fee: toBN(res.overall_fee),

package/src/utils/responseParser/sequencer.ts

@@ -1,3 +1,7 @@
+/**
+ * Map Sequencer Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import {
   CallContractResponse,
   DeclareContractResponse,
@@ -15,14 +19,11 @@ import { ResponseParser } from '.';
 export class SequencerAPIResponseParser extends ResponseParser {
   public parseGetBlockResponse(res: Sequencer.GetBlockResponse): GetBlockResponse {
     return {
-      accepted_time: res.timestamp,
+      timestamp: res.timestamp,
       block_hash: res.block_hash,
       block_number: res.block_number,
-      gas_price: res.gas_price,
       new_root: res.state_root,
-      old_root: undefined,
       parent_hash: res.parent_block_hash,
-      sequencer: res.sequencer_address,
       status: res.status,
       transactions: Object.values(res.transactions)
         .map((value) => 'transaction_hash' in value && value.transaction_hash)
@@ -70,10 +71,6 @@ export class SequencerAPIResponseParser extends ResponseParser {
     };
   }
 
-  public parseGetCodeResponse(res: Sequencer.GetCodeResponse): Sequencer.GetCodeResponse {
-    return res;
-  }
-
   public parseFeeEstimateResponse(res: Sequencer.EstimateFeeResponse): EstimateFeeResponse {
     if ('overall_fee' in res) {
       let gasInfo = {};

package/src/utils/url.ts

@@ -0,0 +1,53 @@
+import urljoin from 'url-join';
+
+/**
+ * Inspired from https://github.com/segmentio/is-url
+ */
+
+/**
+ * RegExps.
+ * A URL must match #1 and then at least one of #2/#3.
+ * Use two levels of REs to avoid REDOS.
+ */
+const protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
+
+const localhostDomainRE = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
+const nonLocalhostDomainRE = /^[^\s.]+\.\S{2,}$/;
+
+/**
+ * Loosely validate a URL `string`.
+ * @param {String} s
+ * @return {Boolean}
+ */
+export function isUrl(s?: string): boolean {
+  if (!s) {
+    return false;
+  }
+
+  if (typeof s !== 'string') {
+    return false;
+  }
+
+  const match = s.match(protocolAndDomainRE);
+  if (!match) {
+    return false;
+  }
+
+  const everythingAfterProtocol = match[1];
+  if (!everythingAfterProtocol) {
+    return false;
+  }
+
+  if (
+    localhostDomainRE.test(everythingAfterProtocol) ||
+    nonLocalhostDomainRE.test(everythingAfterProtocol)
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+export function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string) {
+  return isUrl(urlOrPath) ? urlOrPath! : urljoin(baseUrl, urlOrPath ?? defaultPath);
+}