Added BigNumber.toBigInt method (#1415).

packages/abi/src.ts/abi-coder.ts

@@ -91,13 +91,13 @@ export class AbiCoder {
         return new Writer(this._getWordSize());
     }
 
-    getDefaultValue(types: Array<string | ParamType>): Result {
+    getDefaultValue(types: ReadonlyArray<string | ParamType>): Result {
         const coders: Array<Coder> = types.map((type) => this._getCoder(ParamType.from(type)));
         const coder = new TupleCoder(coders, "_");
         return coder.defaultValue();
     }
 
-    encode(types: Array<string | ParamType>, values: Array<any>): string {
+    encode(types: ReadonlyArray<string | ParamType>, values: ReadonlyArray<any>): string {
         if (types.length !== values.length) {
             logger.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, {
                 count: { types: types.length, values: values.length },
@@ -113,7 +113,7 @@ export class AbiCoder {
         return writer.data;
     }
 
-    decode(types: Array<string | ParamType>, data: BytesLike, loose?: boolean): Result {
+    decode(types: ReadonlyArray<string | ParamType>, data: BytesLike, loose?: boolean): Result {
         const coders: Array<Coder> = types.map((type) => this._getCoder(ParamType.from(type)));
         const coder = new TupleCoder(coders, "_");
         return coder.decode(this._getReader(arrayify(data), loose));

packages/abi/src.ts/fragments.ts

@@ -8,26 +8,26 @@ import { version } from "./_version";
 const logger = new Logger(version);
 
 export interface JsonFragmentType {
-    name?: string;
-    indexed?: boolean;
-    type?: string;
-    components?: Array<JsonFragmentType>;
+    readonly name?: string;
+    readonly indexed?: boolean;
+    readonly type?: string;
+    readonly components?: ReadonlyArray<JsonFragmentType>;
 }
 
 export interface JsonFragment {
-    name?: string;
-    type?: string;
+    readonly name?: string;
+    readonly type?: string;
 
-    anonymous?: boolean;
+    readonly anonymous?: boolean;
 
-    payable?: boolean;
-    constant?: boolean;
-    stateMutability?: string;
+    readonly payable?: boolean;
+    readonly constant?: boolean;
+    readonly stateMutability?: string;
 
-    inputs?: Array<JsonFragmentType>;
-    outputs?: Array<JsonFragmentType>;
+    readonly inputs?: ReadonlyArray<JsonFragmentType>;
+    readonly outputs?: ReadonlyArray<JsonFragmentType>;
 
-    gas?: string;
+    readonly gas?: string;
 };
 
 
@@ -399,7 +399,7 @@ type TypeCheck<T> = { -readonly [ K in keyof T ]: T[K] };
 interface _Fragment {
     readonly type: string;
     readonly name: string;
-    readonly inputs: Array<ParamType>;
+    readonly inputs: ReadonlyArray<ParamType>;
 }
 
 export abstract class Fragment {

packages/abi/src.ts/interface.ts

@@ -63,7 +63,7 @@ function checkNames(fragment: Fragment, type: "input" | "output", params: Array<
 }
 */
 export class Interface {
-    readonly fragments: Array<Fragment>;
+    readonly fragments: ReadonlyArray<Fragment>;
 
     readonly errors: { [ name: string ]: any };
     readonly events: { [ name: string ]: EventFragment };
@@ -76,10 +76,10 @@ export class Interface {
 
     readonly _isInterface: boolean;
 
-    constructor(fragments: string | Array<Fragment | JsonFragment | string>) {
+    constructor(fragments: string | ReadonlyArray<Fragment | JsonFragment | string>) {
         logger.checkNew(new.target, Interface);
 
-        let abi: Array<Fragment | JsonFragment | string> = [ ];
+        let abi: ReadonlyArray<Fragment | JsonFragment | string> = [ ];
         if (typeof(fragments) === "string") {
             abi = JSON.parse(fragments);
         } else {
@@ -259,15 +259,15 @@ export class Interface {
     }
 
 
-    _decodeParams(params: Array<ParamType>, data: BytesLike): Result {
+    _decodeParams(params: ReadonlyArray<ParamType>, data: BytesLike): Result {
         return this._abiCoder.decode(params, data)
     }
 
-    _encodeParams(params: Array<ParamType>, values: Array<any>): string {
+    _encodeParams(params: ReadonlyArray<ParamType>, values: ReadonlyArray<any>): string {
         return this._abiCoder.encode(params, values)
     }
 
-    encodeDeploy(values?: Array<any>): string {
+    encodeDeploy(values?: ReadonlyArray<any>): string {
         return this._encodeParams(this.deploy.inputs, values || [ ]);
     }
 
@@ -287,7 +287,7 @@ export class Interface {
     }
 
     // Encode the data for a function call (e.g. tx.data)
-    encodeFunctionData(functionFragment: FunctionFragment | string, values?: Array<any>): string {
+    encodeFunctionData(functionFragment: FunctionFragment | string, values?: ReadonlyArray<any>): string {
         if (typeof(functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
@@ -332,7 +332,7 @@ export class Interface {
     }
 
     // Encode the result for a function call (e.g. for eth_call)
-    encodeFunctionResult(functionFragment: FunctionFragment | string, values?: Array<any>): string {
+    encodeFunctionResult(functionFragment: FunctionFragment | string, values?: ReadonlyArray<any>): string {
         if (typeof(functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
@@ -341,7 +341,7 @@ export class Interface {
     }
 
     // Create the filter for the event with search criteria (e.g. for eth_filterLog)
-    encodeFilterTopics(eventFragment: EventFragment, values: Array<any>): Array<string | Array<string>> {
+    encodeFilterTopics(eventFragment: EventFragment, values: ReadonlyArray<any>): Array<string | Array<string>> {
         if (typeof(eventFragment) === "string") {
             eventFragment = this.getEvent(eventFragment);
         }
@@ -398,7 +398,7 @@ export class Interface {
         return topics;
     }
 
-    encodeEventLog(eventFragment: EventFragment, values: Array<any>): { data: string, topics: Array<string> } {
+    encodeEventLog(eventFragment: EventFragment, values: ReadonlyArray<any>): { data: string, topics: Array<string> } {
         if (typeof(eventFragment) === "string") {
             eventFragment = this.getEvent(eventFragment);
         }
@@ -442,7 +442,7 @@ export class Interface {
     }
 
     // Decode a filter for the event and the search criteria
-    decodeEventLog(eventFragment: EventFragment | string, data: BytesLike, topics?: Array<string>): Result {
+    decodeEventLog(eventFragment: EventFragment | string, data: BytesLike, topics?: ReadonlyArray<string>): Result {
         if (typeof(eventFragment) === "string") {
             eventFragment = this.getEvent(eventFragment);
         }

packages/bignumber/src.ts/bignumber.ts

@@ -190,6 +190,16 @@ export class BigNumber implements Hexable {
         return null;
     }
 
+    toBigInt(): BigInt {
+        try {
+            return BigInt(this.toString());
+        } catch (e) { }
+
+        return logger.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
+            value: this.toString()
+        });
+    }
+
     toString(): string {
         // Lots of people expect this, which we do not support, so check (See: #889)
         if (arguments.length > 0) {

packages/bytes/src.ts/index.ts

@@ -136,7 +136,7 @@ export function arrayify(value: BytesLike | Hexable | number, options?: DataOpti
     return logger.throwArgumentError("invalid arrayify value", "value", value);
 }
 
-export function concat(items: Array<BytesLike>): Uint8Array {
+export function concat(items: ReadonlyArray<BytesLike>): Uint8Array {
     const objects = items.map(item => arrayify(item));
     const length = objects.reduce((accum, item) => (accum + item.length), 0);
 
@@ -275,7 +275,7 @@ export function hexDataSlice(data: BytesLike, offset: number, endOffset?: number
     return "0x" + data.substring(offset);
 }
 
-export function hexConcat(items: Array<BytesLike>): string {
+export function hexConcat(items: ReadonlyArray<BytesLike>): string {
     let result = "0x";
     items.forEach((item) => {
         result += hexlify(item).substring(2);

packages/contracts/src.ts/index.ts

@@ -578,7 +578,7 @@ class WildcardRunningEvent extends RunningEvent {
     }
 }
 
-export type ContractInterface = string | Array<Fragment | JsonFragment | string> | Interface;
+export type ContractInterface = string | ReadonlyArray<Fragment | JsonFragment | string> | Interface;
 
 type InterfaceFunc = (contractInterface: ContractInterface) => Interface;
 

packages/solidity/src.ts/index.ts

@@ -72,7 +72,7 @@ function _pack(type: string, value: any, isArray?: boolean): Uint8Array {
 
 // @TODO: Array Enum
 
-export function pack(types: Array<string>, values: Array<any>) {
+export function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>) {
     if (types.length != values.length) { throw new Error("type/value count mismatch"); }
     const tight: Array<Uint8Array> = [];
     types.forEach(function(type, index) {
@@ -81,10 +81,10 @@ export function pack(types: Array<string>, values: Array<any>) {
     return hexlify(concat(tight));
 }
 
-export function keccak256(types: Array<string>, values: Array<any>) {
+export function keccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>) {
     return hashKeccak256(pack(types, values));
 }
 
-export function sha256(types: Array<string>, values: Array<any>) {
+export function sha256(types: ReadonlyArray<string>, values: ReadonlyArray<any>) {
     return hashSha256(pack(types, values));
 }