@shapeshiftoss/hdwallet-native 1.19.1 → 1.20.0

package/dist/crypto/isolation/core/digest/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/crypto/isolation/core/digest/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/crypto/isolation/core/digest/types.ts"],"names":[],"mappings":"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"}

package/dist/crypto/isolation/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crypto/isolation/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC,qBAAa,cAAe,SAAQ,KAAK;gBACzB,IAAI,EAAE,MAAM;CAG3B;AAED,MAAM,WAAW,SAAS;IACtB,MAAM,IAAI,IAAI,CAAA;IACd,UAAU,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CACvC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crypto/isolation/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,IAAI,EAAE,MAAM;CAGzB;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,IAAI,IAAI,CAAC;IACf,UAAU,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;CACtC"}

package/dist/crypto/isolation/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/crypto/isolation/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAiC;AACjC,iDAAiC;AACjC,mDAAmC;AACnC,yDAAyC;AAEzC,MAAa,cAAe,SAAQ,KAAK;IACrC,YAAY,IAAY;QACpB,KAAK,CAAC,8BAA8B,IAAI,WAAW,CAAC,CAAC;IACzD,CAAC;CACJ;AAJD,wCAIC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/crypto/isolation/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAiC;AACjC,iDAAiC;AACjC,mDAAmC;AACnC,yDAAyC;AAEzC,MAAa,cAAe,SAAQ,KAAK;IACvC,YAAY,IAAY;QACtB,KAAK,CAAC,8BAA8B,IAAI,WAAW,CAAC,CAAC;IACvD,CAAC;CACF;AAJD,wCAIC"}

package/dist/crypto/isolation/core/secp256k1/interfaces.d.ts

@@ -1,6 +1,6 @@
 import { ByteArray, Uint32 } from "../../types";
-import { CurvePoint, RecoverableSignature, Signature } from "./types";
 import * as Digest from "../digest";
+import { CurvePoint, RecoverableSignature, Signature } from "./types";
 export interface ECDSAKey {
     getPublicKey(): Promise<CurvePoint>;
     ecdsaSign(digestAlgorithm: null, message: ByteArray<32>): Promise<NonNullable<Signature>>;

package/dist/crypto/isolation/core/secp256k1/interfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/isolation/core/secp256k1/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,KAAK,MAAM,MAAM,WAAW,CAAC;AAEpC,MAAM,WAAW,QAAQ;IACrB,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IASpC,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC;IAC1F,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,CAAC;IACvH,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC;IAC3G,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,CAAC;CAC3I;AAED,MAAM,WAAW,mBAAoB,SAAQ,QAAQ;IACjD,oBAAoB,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAChH,oBAAoB,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAC,CAAC;IAC7I,oBAAoB,CAAC,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,CAAC;IACjI,oBAAoB,CAAC,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAC,CAAC;CACjK;AAED,MAAM,WAAW,OAAO;IACpB,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAQpC,IAAI,CAAC,SAAS,EAAE,UAAU,EAAE,eAAe,CAAC,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7G,OAAO,CAAC,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;CACrE"}
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/isolation/core/secp256k1/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,MAAM,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEtE,MAAM,WAAW,QAAQ;IACvB,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IASpC,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC;IAC1F,SAAS,CACP,eAAe,EAAE,IAAI,EACrB,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,CAAC;IAC/C,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC;IAC3G,SAAS,CACP,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EACzC,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,mBAAoB,SAAQ,QAAQ;IACnD,oBAAoB,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAChH,oBAAoB,CAClB,eAAe,EAAE,IAAI,EACrB,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAC,CAAC;IAC1D,oBAAoB,CAClB,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EACzC,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAC9C,oBAAoB,CAClB,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,EACzC,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,OAAO;IACtB,YAAY,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAQpC,IAAI,CAAC,SAAS,EAAE,UAAU,EAAE,eAAe,CAAC,EAAE,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7G,OAAO,CAAC,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;CACnE"}

package/dist/crypto/isolation/core/secp256k1/types.d.ts

@@ -1,14 +1,14 @@
 import { Literal, Object as Obj, Static, Union } from "funtypes";
-import * as Digest from "../digest";
 import { BigEndianInteger } from "../../types";
+import * as Digest from "../digest";
 import { ECDSAKey } from "./interfaces";
-declare const fieldElementBase: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+declare const _fieldElementBase: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<32>;
 }, false>]>, Uint8Array & {
     length: 32;
 }, unknown>;
-export declare type FieldElement = Static<typeof fieldElementBase>;
-declare const fieldElement: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare type FieldElement = Static<typeof _fieldElementBase>;
+declare const _fieldElement: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<32>;
 }, false>]>, Uint8Array & {
     length: 32;
@@ -22,37 +22,8 @@ declare const fieldElement: import("funtypes").Constraint<import("funtypes").Int
     isHigh: <T_2 extends number>(x: BigEndianInteger<T_2>) => boolean;
     isOdd: <T_3 extends number>(x: BigEndianInteger<T_3>) => boolean;
 };
-export declare const FieldElement: typeof fieldElement;
-declare const compressedPointBase: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
-    length: Literal<33>;
-}, false>]>, Obj<{
-    0: Union<[Literal<2>, Literal<3>]>;
-}, false>]>, Uint8Array & {
-    length: 33;
-} & {
-    0: 2 | 3;
-}, unknown>;
-export declare type CompressedPoint = Static<typeof compressedPointBase>;
-declare const compressedPoint: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
-    length: Literal<33>;
-}, false>]>, Obj<{
-    0: Union<[Literal<2>, Literal<3>]>;
-}, false>]>, Uint8Array & {
-    length: 33;
-} & {
-    0: 2 | 3;
-}, unknown> & (<T extends number | undefined = undefined>(length?: T | undefined) => T extends undefined ? import("funtypes").InstanceOf<Uint8Array> : unknown extends T ? import("funtypes").InstanceOf<Uint8Array> : import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
-    length: Literal<T>;
-}, false>]>) & {
-    equal(lhs: Uint8Array, rhs: Uint8Array): boolean;
-} & {
-    from: (p: CurvePoint) => CompressedPoint;
-    fromUncompressed: (p: UncompressedPoint) => CompressedPoint;
-    x: (p: CompressedPoint) => FieldElement;
-    yIsOdd: (p: CompressedPoint) => boolean;
-};
-export declare const CompressedPoint: typeof compressedPoint;
-declare const uncompressedPointBase: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare const FieldElement: typeof _fieldElement;
+declare const _uncompressedPointBase: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<65>;
 }, false>]>, Obj<{
     0: Literal<4>;
@@ -65,8 +36,18 @@ declare const uncompressedPointBase: import("funtypes").Constraint<import("funty
 } & {
     0: 4;
 }, unknown>;
-export declare type UncompressedPoint = Static<typeof uncompressedPointBase>;
-declare const uncompressedPoint: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare type UncompressedPoint = Static<typeof _uncompressedPointBase>;
+declare const _compressedPointBase: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+    length: Literal<33>;
+}, false>]>, Obj<{
+    0: Union<[Literal<2>, Literal<3>]>;
+}, false>]>, Uint8Array & {
+    length: 33;
+} & {
+    0: 2 | 3;
+}, unknown>;
+export declare type CompressedPoint = Static<typeof _compressedPointBase>;
+declare const _uncompressedPoint: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<65>;
 }, false>]>, Obj<{
     0: Literal<4>;
@@ -89,9 +70,28 @@ declare const uncompressedPoint: import("funtypes").Constraint<import("funtypes"
     y: (p: UncompressedPoint) => FieldElement;
     yIsOdd: (p: UncompressedPoint) => boolean;
 };
-export declare const UncompressedPoint: typeof uncompressedPoint;
+export declare const UncompressedPoint: typeof _uncompressedPoint;
+declare const _compressedPoint: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+    length: Literal<33>;
+}, false>]>, Obj<{
+    0: Union<[Literal<2>, Literal<3>]>;
+}, false>]>, Uint8Array & {
+    length: 33;
+} & {
+    0: 2 | 3;
+}, unknown> & (<T extends number | undefined = undefined>(length?: T | undefined) => T extends undefined ? import("funtypes").InstanceOf<Uint8Array> : unknown extends T ? import("funtypes").InstanceOf<Uint8Array> : import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+    length: Literal<T>;
+}, false>]>) & {
+    equal(lhs: Uint8Array, rhs: Uint8Array): boolean;
+} & {
+    from: (p: CurvePoint) => CompressedPoint;
+    fromUncompressed: (p: UncompressedPoint) => CompressedPoint;
+    x: (p: CompressedPoint) => FieldElement;
+    yIsOdd: (p: CompressedPoint) => boolean;
+};
+export declare const CompressedPoint: typeof _compressedPoint;
 export declare type CurvePoint = CompressedPoint | UncompressedPoint;
-declare const curvePoint: Union<[import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+declare const _curvePoint: Union<[import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<33>;
 }, false>]>, Obj<{
     0: Union<[Literal<2>, Literal<3>]>;
@@ -135,12 +135,12 @@ declare const curvePoint: Union<[import("funtypes").Constraint<import("funtypes"
     yIsOdd: (p: CurvePoint) => boolean;
     equal: (lhs: CurvePoint, rhs: CurvePoint) => boolean;
 };
-export declare const CurvePoint: typeof curvePoint;
-declare const recoveryParamBase: Union<[Literal<0>, Literal<1>, Literal<2>, Literal<3>]>;
-export declare type RecoveryParam = Static<typeof recoveryParamBase>;
-declare const recoveryParam: Union<[Literal<0>, Literal<1>, Literal<2>, Literal<3>]>;
-export declare const RecoveryParam: typeof recoveryParam;
-declare const messageWithPreimageBase: import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare const CurvePoint: typeof _curvePoint;
+declare const _recoveryParamBase: Union<[Literal<0>, Literal<1>, Literal<2>, Literal<3>]>;
+export declare type RecoveryParam = Static<typeof _recoveryParamBase>;
+declare const _recoveryParam: Union<[Literal<0>, Literal<1>, Literal<2>, Literal<3>]>;
+export declare const RecoveryParam: typeof _recoveryParam;
+declare const _messageWithPreimageBase: import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<32>;
 }, false>]>, import("funtypes").Constraint<import("funtypes").Runtype<(Uint8Array & {
     length: 20;
@@ -213,8 +213,8 @@ declare const messageWithPreimageBase: import("funtypes").Intersect<[import("fun
     preimage: Uint8Array;
     algorithm: "sha512";
 }), unknown>]>;
-export declare type MessageWithPreimage = Static<typeof messageWithPreimageBase>;
-declare const messageWithPreimage: import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare type MessageWithPreimage = Static<typeof _messageWithPreimageBase>;
+declare const _messageWithPreimage: import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<32>;
 }, false>]>, import("funtypes").Constraint<import("funtypes").Runtype<(Uint8Array & {
     length: 20;
@@ -291,8 +291,8 @@ declare const messageWithPreimage: import("funtypes").Intersect<[import("funtype
 }, false>]>) & {
     equal(lhs: Uint8Array, rhs: Uint8Array): boolean;
 };
-export declare const MessageWithPreimage: typeof messageWithPreimage;
-declare const messageBase: Union<[import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare const MessageWithPreimage: typeof _messageWithPreimage;
+declare const _messageBase: Union<[import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<32>;
 }, false>]>, import("funtypes").Constraint<import("funtypes").Runtype<(Uint8Array & {
     length: 20;
@@ -369,8 +369,8 @@ declare const messageBase: Union<[import("funtypes").Intersect<[import("funtypes
 }, false>]>) & {
     equal(lhs: Uint8Array, rhs: Uint8Array): boolean;
 }, import("funtypes").InstanceOf<Uint8Array>]>;
-export declare type Message = Static<typeof messageBase>;
-declare const message: Union<[import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare type Message = Static<typeof _messageBase>;
+declare const _message: Union<[import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<32>;
 }, false>]>, import("funtypes").Constraint<import("funtypes").Runtype<(Uint8Array & {
     length: 20;
@@ -451,16 +451,16 @@ declare const message: Union<[import("funtypes").Intersect<[import("funtypes").I
 }, false>]>) & {
     equal(lhs: Uint8Array, rhs: Uint8Array): boolean;
 };
-export declare const Message: typeof message;
-declare const signatureBase: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare const Message: typeof _message;
+declare const _signatureBase: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<64>;
 }, false>]>, Uint8Array & {
     length: 64;
 }, unknown>, Uint8Array & {
     length: 64;
 }, unknown>;
-export declare type Signature = Static<typeof signatureBase>;
-declare const signature: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare type Signature = Static<typeof _signatureBase>;
+declare const _signature: import("funtypes").Constraint<import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<64>;
 }, false>]>, Uint8Array & {
     length: 64;
@@ -479,8 +479,8 @@ declare const signature: import("funtypes").Constraint<import("funtypes").Constr
     signCanonically: (x: ECDSAKey, digestAlgorithm: Digest.AlgorithmName<32> | null, message: Uint8Array, counter?: number | undefined) => Promise<Signature>;
     verify: (x: Signature, digestAlgorithm: Digest.AlgorithmName<32> | null, message: Uint8Array, publicKey: CurvePoint) => boolean;
 };
-export declare const Signature: typeof signature;
-declare const recoverableSignatureBase: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare const Signature: typeof _signature;
+declare const _recoverableSignatureBase: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<65>;
 }, false>]>, Obj<{
     64: Union<[Literal<0>, Literal<1>, Literal<2>, Literal<3>]>;
@@ -489,8 +489,8 @@ declare const recoverableSignatureBase: import("funtypes").Constraint<import("fu
 } & {
     64: 0 | 2 | 3 | 1;
 }, unknown>;
-export declare type RecoverableSignature = Static<typeof recoverableSignatureBase>;
-declare const recoverableSignature: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
+export declare type RecoverableSignature = Static<typeof _recoverableSignatureBase>;
+declare const _recoverableSignature: import("funtypes").Constraint<import("funtypes").Intersect<[import("funtypes").Intersect<[import("funtypes").InstanceOf<Uint8Array>, Obj<{
     length: Literal<65>;
 }, false>]>, Obj<{
     64: Union<[Literal<0>, Literal<1>, Literal<2>, Literal<3>]>;
@@ -513,6 +513,6 @@ declare const recoverableSignature: import("funtypes").Constraint<import("funtyp
     isLowS: (x: RecoverableSignature) => boolean;
     verify: (x: RecoverableSignature, digestAlgorithm: Digest.AlgorithmName<32> | null, message: Uint8Array, publicKey: CurvePoint) => boolean;
 };
-export declare const RecoverableSignature: typeof recoverableSignature;
+export declare const RecoverableSignature: typeof _recoverableSignature;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/crypto/isolation/core/secp256k1/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/isolation/core/secp256k1/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/isolation/core/secp256k1/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGjE,OAAO,EAAc,gBAAgB,EAAgD,MAAM,aAAa,CAAC;AACzG,OAAO,KAAK,MAAM,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAuB,MAAM,cAAc,CAAC;AAI7D,QAAA,MAAM,iBAAiB;;;;WAGtB,CAAC;AACF,oBAAY,YAAY,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,QAAA,MAAM,aAAa;;;;;;;;;;;;;CAA0E,CAAC;AAC9F,eAAO,MAAM,YAAY,EAAE,OAAO,aAA6B,CAAC;AAEhE,QAAA,MAAM,sBAAsB;;;;;;;;;;;;WAkBzB,CAAC;AACJ,oBAAY,iBAAiB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,QAAA,MAAM,oBAAoB;;;;;;;;WAQtB,CAAC;AACL,oBAAY,eAAe,GAAG,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAmBlE,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;cAhBZ,UAAU,KAAG,iBAAiB;wBAGpB,eAAe,KAAG,iBAAiB;WAGhD,iBAAiB,KAAG,YAAY;WAGhC,iBAAiB,KAAG,YAAY;gBAG3B,iBAAiB,KAAG,OAAO;CAI4D,CAAC;AACtG,eAAO,MAAM,iBAAiB,EAAE,OAAO,kBAAuC,CAAC;AAoB/E,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;cAjBV,UAAU,KAAG,eAAe;0BAGhB,iBAAiB,KAAG,eAAe;WAOlD,eAAe,KAAG,YAAY;gBAGzB,eAAe,KAAG,OAAO;CAIwD,CAAC;AAChG,eAAO,MAAM,eAAe,EAAE,OAAO,gBAAmC,CAAC;AAGzE,oBAAY,UAAU,GAAG,eAAe,GAAG,iBAAiB,CAAC;AAQ7D,QAAA,MAAM,WAAW;;;;;;;;;;;;;cA7BL,UAAU,KAAG,eAAe;0BAGhB,iBAAiB,KAAG,eAAe;WAOlD,eAAe,KAAG,YAAY;gBAGzB,eAAe,KAAG,OAAO;;;;;;;;;;;;;;;;;;cAjC3B,UAAU,KAAG,iBAAiB;wBAGpB,eAAe,KAAG,iBAAiB;WAGhD,iBAAiB,KAAG,YAAY;WAGhC,iBAAiB,KAAG,YAAY;gBAG3B,iBAAiB,KAAG,OAAO;;WA+BhC,UAAU,KAAG,YAAY;gBACpB,UAAU,KAAG,OAAO;iBAEnB,UAAU,OAAO,UAAU;CAG2B,CAAC;AACtE,eAAO,MAAM,UAAU,EAAE,OAAO,WAAyB,CAAC;AAE1D,QAAA,MAAM,kBAAkB,yDAAwD,CAAC;AACjF,oBAAY,aAAa,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,QAAA,MAAM,cAAc,yDAA0D,CAAC;AAC/E,eAAO,MAAM,aAAa,EAAE,OAAO,cAA+B,CAAC;AAEnE,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAqC,CAAC;AACpE,oBAAY,mBAAmB,GAAG,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiF,CAAC;AAC5G,eAAO,MAAM,mBAAmB,EAAE,OAAO,oBAA2C,CAAC;AAErF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAAsC,CAAC;AACzD,oBAAY,OAAO,GAAG,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqF,CAAC;AACpG,eAAO,MAAM,OAAO,EAAE,OAAO,QAAmB,CAAC;AAEjD,QAAA,MAAM,cAAc;;;;;;WAMhB,CAAC;AACL,oBAAY,SAAS,GAAG,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AA4DtD,QAAA,MAAM,UAAU;;;;;;;;;;;WA1DP,SAAS,KAAG,YAAY;WAGxB,SAAS,KAAG,YAAY;gBAGnB,SAAS,KAAG,OAAO;gBAGnB,SAAS,KAAG,OAAO;qBAGd,SAAS,KAAG,OAAO;yBAI/B,QAAQ,mBACM,OAAO,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,WACvC,UAAU,mCAElB,QAAQ,SAAS,CAAC;gBA0BhB,SAAS,mBACK,OAAO,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,WACvC,UAAU,aACR,UAAU,KACpB,OAAO;CAQiE,CAAC;AAC9E,eAAO,MAAM,SAAS,EAAE,OAAO,UAAuB,CAAC;AAEvD,QAAA,MAAM,yBAAyB;;;;;;;;WAQ3B,CAAC;AACL,oBAAY,oBAAoB,GAAG,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAiH5E,QAAA,MAAM,qBAAqB;;;;;;;;;cA/Gf,SAAS,iBAAiB,aAAa,KAAG,oBAAoB;uBAInE,SAAS,mBACK,OAAO,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,WACvC,UAAU,aACR,UAAU,KACpB,QAAQ,oBAAoB,CAAC;aAWvB,oBAAoB,KAAG,SAAS;uBACtB,oBAAoB,KAAG,aAAa;4BAC/B,oBAAoB;qBAC3B,oBAAoB,KAAG,OAAO;yBAI1C,QAAQ,mBACM,OAAO,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,WACvC,UAAU,mCAElB,QAAQ,oBAAoB,CAAC;0BAkD3B,oBAAoB,mBACN,OAAO,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,WACvC,UAAU,KAClB,QAAQ,UAAU,CAAC;WAef,oBAAoB,KAAG,YAAY;WACnC,oBAAoB,KAAG,YAAY;gBAC9B,oBAAoB,KAAG,OAAO;gBAC9B,oBAAoB,KAAG,OAAO;gBAErC,oBAAoB,mBACN,OAAO,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,WACvC,UAAU,aACR,UAAU,KACpB,OAAO;CAIuF,CAAC;AACpG,eAAO,MAAM,oBAAoB,EAAE,OAAO,qBAA6C,CAAC"}

package/dist/crypto/isolation/core/secp256k1/types.js

@@ -28,39 +28,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecoverableSignature = exports.Signature = exports.Message = exports.MessageWithPreimage = exports.RecoveryParam = exports.CurvePoint = exports.UncompressedPoint = exports.CompressedPoint = exports.FieldElement = void 0;
+exports.RecoverableSignature = exports.Signature = exports.Message = exports.MessageWithPreimage = exports.RecoveryParam = exports.CurvePoint = exports.CompressedPoint = exports.UncompressedPoint = exports.FieldElement = void 0;
 const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
 const funtypes_1 = require("funtypes");
 const tinyecc = __importStar(require("tiny-secp256k1"));
-const Digest = __importStar(require("../digest"));
 const types_1 = require("../../types");
+const Digest = __importStar(require("../digest"));
 const ethers = Promise.resolve().then(() => __importStar(require("ethers")));
-const fieldElementBase = types_1.BigEndianInteger(32).withConstraint(x => tinyecc.isPrivate(types_1.safeBufferFrom(x)) || `expected ${x} to be within the order of the curve`, { name: "FieldElement" });
-const fieldElementStatic = {};
-const fieldElement = Object.assign(fieldElementBase, types_1.BigEndianInteger, fieldElementStatic);
-exports.FieldElement = fieldElement;
-const compressedPointBase = types_1.ByteArray(33).And(funtypes_1.Object({
-    0: funtypes_1.Literal(0x02).Or(funtypes_1.Literal(0x03)),
-})).withConstraint(p => exports.FieldElement.test(p.slice(1)) || `expected ${p}.x to be within the order of the curve`, { name: "CompressedPoint.x" });
-const compressedPointStatic = {
-    from: (p) => {
-        return (p.length === 33 ? p : exports.CompressedPoint.fromUncompressed(types_1.checkType(exports.UncompressedPoint, p)));
-    },
-    fromUncompressed: (p) => {
-        const out = new Uint8Array(33);
-        out[0] = (exports.UncompressedPoint.yIsOdd(p) ? 0x03 : 0x02);
-        out.set(exports.UncompressedPoint.x(p), 1);
-        exports.CompressedPoint.assert(out);
-        return out;
-    },
-    x: (p) => { return types_1.checkType(exports.FieldElement, p.slice(1)); },
-    yIsOdd: (p) => { return p[0] === 0x03; }
-};
-const compressedPoint = Object.assign(compressedPointBase, types_1.ByteArray, compressedPointStatic);
-exports.CompressedPoint = compressedPoint;
-const uncompressedPointBase = types_1.ByteArray(65).And(funtypes_1.Object({
+const _fieldElementBase = types_1.BigEndianInteger(32).withConstraint((x) => tinyecc.isPrivate(types_1.safeBufferFrom(x)) || `expected ${x} to be within the order of the curve`, { name: "FieldElement" });
+const _fieldElementStatic = {};
+const _fieldElement = Object.assign(_fieldElementBase, types_1.BigEndianInteger, _fieldElementStatic);
+exports.FieldElement = _fieldElement;
+const _uncompressedPointBase = types_1.ByteArray(65)
+    .And(funtypes_1.Object({
     0: funtypes_1.Literal(0x04),
-})).withConstraint(p => exports.FieldElement.test(p.slice(1, 33)) || `expected ${p}.x to be within the order of the curve`, { name: "UncompressedPoint.x" }).withConstraint(p => {
+}))
+    .withConstraint((p) => exports.FieldElement.test(p.slice(1, 33)) || `expected ${p}.x to be within the order of the curve`, {
+    name: "UncompressedPoint.x",
+})
+    .withConstraint((p) => {
     if (!exports.FieldElement.test(p.slice(33, 65)))
         return `expected ${p}.y to be within the order of the curve`;
     const pBuf = Buffer.from(p);
@@ -68,47 +54,96 @@ const uncompressedPointBase = types_1.ByteArray(65).And(funtypes_1.Object({
         return `expected ${p} to be on the curve`;
     return true;
 }, { name: "UncompressedPoint.y" });
-const uncompressedPointStatic = {
+const _compressedPointBase = types_1.ByteArray(33)
+    .And(funtypes_1.Object({
+    0: funtypes_1.Literal(0x02).Or(funtypes_1.Literal(0x03)),
+}))
+    .withConstraint((p) => exports.FieldElement.test(p.slice(1)) || `expected ${p}.x to be within the order of the curve`, {
+    name: "CompressedPoint.x",
+});
+const _uncompressedPointStatic = {
     from: (p) => {
-        return (p.length === 65 ? p : exports.UncompressedPoint.fromCompressed(types_1.checkType(exports.CompressedPoint, p)));
+        return p.length === 65 ? p : exports.UncompressedPoint.fromCompressed(types_1.checkType(exports.CompressedPoint, p));
     },
     fromCompressed: (p) => {
         return types_1.checkType(exports.UncompressedPoint, tinyecc.pointCompress(Buffer.from(p), false));
     },
-    x: (p) => { return types_1.checkType(exports.FieldElement, p.slice(1, 33)); },
-    y: (p) => { return types_1.checkType(exports.FieldElement, p.slice(33, 65)); },
-    yIsOdd: (p) => { return exports.FieldElement.isOdd(exports.UncompressedPoint.y(p)); },
+    x: (p) => {
+        return types_1.checkType(exports.FieldElement, p.slice(1, 33));
+    },
+    y: (p) => {
+        return types_1.checkType(exports.FieldElement, p.slice(33, 65));
+    },
+    yIsOdd: (p) => {
+        return exports.FieldElement.isOdd(exports.UncompressedPoint.y(p));
+    },
+};
+const _uncompressedPoint = Object.assign(_uncompressedPointBase, types_1.ByteArray, _uncompressedPointStatic);
+exports.UncompressedPoint = _uncompressedPoint;
+const _compressedPointStatic = {
+    from: (p) => {
+        return p.length === 33 ? p : exports.CompressedPoint.fromUncompressed(types_1.checkType(exports.UncompressedPoint, p));
+    },
+    fromUncompressed: (p) => {
+        const out = new Uint8Array(33);
+        out[0] = exports.UncompressedPoint.yIsOdd(p) ? 0x03 : 0x02;
+        out.set(exports.UncompressedPoint.x(p), 1);
+        exports.CompressedPoint.assert(out);
+        return out;
+    },
+    x: (p) => {
+        return types_1.checkType(exports.FieldElement, p.slice(1));
+    },
+    yIsOdd: (p) => {
+        return p[0] === 0x03;
+    },
 };
-const uncompressedPoint = Object.assign(uncompressedPointBase, types_1.ByteArray, uncompressedPointStatic);
-exports.UncompressedPoint = uncompressedPoint;
-const curvePointBase = exports.CompressedPoint.Or(exports.UncompressedPoint);
-const curvePointStatic = {
+const _compressedPoint = Object.assign(_compressedPointBase, types_1.ByteArray, _compressedPointStatic);
+exports.CompressedPoint = _compressedPoint;
+const _curvePointBase = exports.CompressedPoint.Or(exports.UncompressedPoint);
+const _curvePointStatic = {
     x: (p) => (p[0] === 0x04 ? exports.UncompressedPoint.x(p) : exports.CompressedPoint.x(p)),
     yIsOdd: (p) => (p[0] === 0x04 ? exports.UncompressedPoint.yIsOdd(p) : exports.CompressedPoint.yIsOdd(p)),
     // Equivalent to CompressedPoint.equal(CompressedPoint.from(lhs), CompressedPoint.from(rhs)), but avoids allocations
     equal: (lhs, rhs) => exports.CurvePoint.yIsOdd(lhs) === exports.CurvePoint.yIsOdd(rhs) && exports.FieldElement.equal(exports.CurvePoint.x(lhs), exports.CurvePoint.x(rhs)),
 };
-const curvePoint = Object.assign(curvePointBase, curvePointStatic);
-exports.CurvePoint = curvePoint;
-const recoveryParamBase = funtypes_1.Union(funtypes_1.Literal(0), funtypes_1.Literal(1), funtypes_1.Literal(2), funtypes_1.Literal(3));
-const recoveryParamStatic = {};
-const recoveryParam = Object.assign(recoveryParamBase, recoveryParamStatic);
-exports.RecoveryParam = recoveryParam;
-const messageWithPreimageBase = types_1.ByteArray(32).And(Digest.Digest());
-const messageWithPreimageStatic = {};
-const messageWithPreimage = Object.assign(messageWithPreimageBase, types_1.ByteArray, messageWithPreimageStatic);
-exports.MessageWithPreimage = messageWithPreimage;
-const messageBase = exports.MessageWithPreimage.Or(types_1.ByteArray());
-const messageStatic = {};
-const message = Object.assign(messageBase, types_1.ByteArray, messageWithPreimageStatic, messageStatic);
-exports.Message = message;
-const signatureBase = types_1.ByteArray(64).withConstraint(x => exports.FieldElement.test(x.slice(0, 32)) || `expected ${x}.r to be within the order of the curve`, { name: "Signature.r" }).withConstraint(x => exports.FieldElement.test(x.slice(32, 64)) || `expected ${x}.s to be within the order of the curve`, { name: "Signature.s" });
-const signatureStatic = {
-    r: (x) => { return types_1.checkType(exports.FieldElement, x.slice(0, 32)); },
-    s: (x) => { return types_1.checkType(exports.FieldElement, x.slice(32, 64)); },
-    isLowR: (x) => { return !exports.FieldElement.isHigh(exports.Signature.r(x)); },
-    isLowS: (x) => { return !exports.FieldElement.isHigh(exports.Signature.s(x)); },
-    isCanonical: (x) => { return exports.Signature.isLowR(x) && exports.Signature.isLowS(x); },
+const _curvePoint = Object.assign(_curvePointBase, _curvePointStatic);
+exports.CurvePoint = _curvePoint;
+const _recoveryParamBase = funtypes_1.Union(funtypes_1.Literal(0), funtypes_1.Literal(1), funtypes_1.Literal(2), funtypes_1.Literal(3));
+const _recoveryParamStatic = {};
+const _recoveryParam = Object.assign(_recoveryParamBase, _recoveryParamStatic);
+exports.RecoveryParam = _recoveryParam;
+const _messageWithPreimageBase = types_1.ByteArray(32).And(Digest.Digest());
+const _messageWithPreimageStatic = {};
+const _messageWithPreimage = Object.assign(_messageWithPreimageBase, types_1.ByteArray, _messageWithPreimageStatic);
+exports.MessageWithPreimage = _messageWithPreimage;
+const _messageBase = exports.MessageWithPreimage.Or(types_1.ByteArray());
+const _messageStatic = {};
+const _message = Object.assign(_messageBase, types_1.ByteArray, _messageWithPreimageStatic, _messageStatic);
+exports.Message = _message;
+const _signatureBase = types_1.ByteArray(64)
+    .withConstraint((x) => exports.FieldElement.test(x.slice(0, 32)) || `expected ${x}.r to be within the order of the curve`, {
+    name: "Signature.r",
+})
+    .withConstraint((x) => exports.FieldElement.test(x.slice(32, 64)) || `expected ${x}.s to be within the order of the curve`, {
+    name: "Signature.s",
+});
+const _signatureStatic = {
+    r: (x) => {
+        return types_1.checkType(exports.FieldElement, x.slice(0, 32));
+    },
+    s: (x) => {
+        return types_1.checkType(exports.FieldElement, x.slice(32, 64));
+    },
+    isLowR: (x) => {
+        return !exports.FieldElement.isHigh(exports.Signature.r(x));
+    },
+    isLowS: (x) => {
+        return !exports.FieldElement.isHigh(exports.Signature.s(x));
+    },
+    isCanonical: (x) => {
+        return exports.Signature.isLowR(x) && exports.Signature.isLowS(x);
+    },
     signCanonically: (x, digestAlgorithm, message, counter) => __awaiter(void 0, void 0, void 0, function* () {
         types_1.assertType(types_1.ByteArray(), message);
         counter === undefined || types_1.Uint32.assert(counter);
@@ -116,10 +151,14 @@ const signatureStatic = {
             const sig = yield (() => __awaiter(void 0, void 0, void 0, function* () {
                 if (digestAlgorithm === null) {
                     types_1.assertType(types_1.ByteArray(32), message);
-                    return i === undefined ? yield x.ecdsaSign(digestAlgorithm, message) : yield x.ecdsaSign(digestAlgorithm, message, i);
+                    return i === undefined
+                        ? yield x.ecdsaSign(digestAlgorithm, message)
+                        : yield x.ecdsaSign(digestAlgorithm, message, i);
                 }
                 else {
-                    return i === undefined ? yield x.ecdsaSign(digestAlgorithm, message) : yield x.ecdsaSign(digestAlgorithm, message, i);
+                    return i === undefined
+                        ? yield x.ecdsaSign(digestAlgorithm, message)
+                        : yield x.ecdsaSign(digestAlgorithm, message, i);
                 }
             }))();
             if (sig === undefined)
@@ -132,16 +171,22 @@ const signatureStatic = {
         throw new Error(`Unable to generate canonical signature with public key ${x} over message ${message}; is your key implementation broken?`);
     }),
     verify: (x, digestAlgorithm, message, publicKey) => {
-        const msgOrDigest = digestAlgorithm === null ? types_1.checkType(types_1.ByteArray(32), message) : Digest.Algorithms[digestAlgorithm](types_1.checkType(types_1.ByteArray(), message));
+        const msgOrDigest = digestAlgorithm === null
+            ? types_1.checkType(types_1.ByteArray(32), message)
+            : Digest.Algorithms[digestAlgorithm](types_1.checkType(types_1.ByteArray(), message));
         return tinyecc.verify(Buffer.from(msgOrDigest), Buffer.from(publicKey), Buffer.from(x));
     },
 };
-const signature = Object.assign(signatureBase, types_1.ByteArray, signatureStatic);
-exports.Signature = signature;
-const recoverableSignatureBase = types_1.ByteArray(65).And(funtypes_1.Object({
+const _signature = Object.assign(_signatureBase, types_1.ByteArray, _signatureStatic);
+exports.Signature = _signature;
+const _recoverableSignatureBase = types_1.ByteArray(65)
+    .And(funtypes_1.Object({
     64: exports.RecoveryParam,
-})).withConstraint(x => exports.Signature.test(x.slice(0, 64)) || `expected ${x}.sig to be a valid signature`, { name: "Signature" });
-const recoverableSignatureStatic = {
+}))
+    .withConstraint((x) => exports.Signature.test(x.slice(0, 64)) || `expected ${x}.sig to be a valid signature`, {
+    name: "Signature",
+});
+const _recoverableSignatureStatic = {
     from: (x, recoveryParam) => {
         return types_1.checkType(exports.RecoverableSignature, core.compatibleBufferConcat([x, new Uint8Array([recoveryParam])]));
     },
@@ -157,28 +202,39 @@ const recoverableSignatureStatic = {
     sig: (x) => types_1.checkType(exports.Signature, x.slice(0, 64)),
     recoveryParam: (x) => types_1.checkType(exports.RecoveryParam, x[64]),
     isLowRecoveryParam: (x) => [0, 1].includes(exports.RecoverableSignature.recoveryParam(x)),
-    isCanonical: (x) => exports.Signature.isCanonical(types_1.checkType(exports.Signature, exports.RecoverableSignature.sig(x))) && exports.RecoverableSignature.isLowRecoveryParam(x),
+    isCanonical: (x) => exports.Signature.isCanonical(types_1.checkType(exports.Signature, exports.RecoverableSignature.sig(x))) &&
+        exports.RecoverableSignature.isLowRecoveryParam(x),
     signCanonically: (x, digestAlgorithm, message, counter) => __awaiter(void 0, void 0, void 0, function* () {
         const publicKey = yield x.getPublicKey();
         types_1.assertType(types_1.ByteArray(), message);
         counter === undefined || types_1.Uint32.assert(counter);
+        // eslint-disable-next-line @typescript-eslint/no-shadow
         const isIndexable = (x) => x !== null && ["object", "function"].includes(typeof x);
+        // eslint-disable-next-line @typescript-eslint/no-shadow
         const isECDSARecoverableKey = (x) => isIndexable(x) && "ecdsaSignRecoverable" in x && typeof x.ecdsaSignRecoverable === "function";
-        const ecdsaSignRecoverable = isECDSARecoverableKey(x) ? (digestAlgorithm, message, counter) => __awaiter(void 0, void 0, void 0, function* () {
-            if (digestAlgorithm === null) {
-                types_1.assertType(types_1.ByteArray(32), message);
-                return counter === undefined ? yield x.ecdsaSignRecoverable(digestAlgorithm, message) : yield x.ecdsaSignRecoverable(digestAlgorithm, message, counter);
-            }
-            else {
-                return counter === undefined ? yield x.ecdsaSignRecoverable(digestAlgorithm, message) : yield x.ecdsaSignRecoverable(digestAlgorithm, message, counter);
-            }
-        }) : (digestAlgorithm, message, counter) => __awaiter(void 0, void 0, void 0, function* () {
-            const sig = yield exports.Signature.signCanonically(x, digestAlgorithm, message, counter);
-            if (sig === undefined)
-                return undefined;
-            return yield exports.RecoverableSignature.fromSignature(sig, digestAlgorithm, message, publicKey);
-        });
-        // Technically, this may waste cycles; if Signature.signCanonically grinds the counter to find a canonical signature which then 
+        const ecdsaSignRecoverable = isECDSARecoverableKey(x)
+            ? // eslint-disable-next-line @typescript-eslint/no-shadow
+                (digestAlgorithm, message, counter) => __awaiter(void 0, void 0, void 0, function* () {
+                    if (digestAlgorithm === null) {
+                        types_1.assertType(types_1.ByteArray(32), message);
+                        return counter === undefined
+                            ? yield x.ecdsaSignRecoverable(digestAlgorithm, message)
+                            : yield x.ecdsaSignRecoverable(digestAlgorithm, message, counter);
+                    }
+                    else {
+                        return counter === undefined
+                            ? yield x.ecdsaSignRecoverable(digestAlgorithm, message)
+                            : yield x.ecdsaSignRecoverable(digestAlgorithm, message, counter);
+                    }
+                })
+            : // eslint-disable-next-line @typescript-eslint/no-shadow
+                (digestAlgorithm, message, counter) => __awaiter(void 0, void 0, void 0, function* () {
+                    const sig = yield exports.Signature.signCanonically(x, digestAlgorithm, message, counter);
+                    if (sig === undefined)
+                        return undefined;
+                    return yield exports.RecoverableSignature.fromSignature(sig, digestAlgorithm, message, publicKey);
+                });
+        // Technically, this may waste cycles; if Signature.signCanonically grinds the counter to find a canonical signature which then
         // ends up to have a non-canonical recovery parameter, those values will all be re-ground. However, signatures can have
         // non-canonical recovery parameters only with negligible probability, so optimization for that case would be silly.
         for (let i = counter; i === undefined || i < (counter !== null && counter !== void 0 ? counter : 0) + 128; i = (i !== null && i !== void 0 ? i : -1) + 1) {
@@ -194,7 +250,9 @@ const recoverableSignatureStatic = {
     }),
     recoverPublicKey: (x, digestAlgorithm, message) => __awaiter(void 0, void 0, void 0, function* () {
         // TODO: do this better
-        const msgOrDigest = digestAlgorithm === null ? types_1.checkType(types_1.ByteArray(32), message) : Digest.Algorithms[digestAlgorithm](types_1.checkType(types_1.ByteArray(), message));
+        const msgOrDigest = digestAlgorithm === null
+            ? types_1.checkType(types_1.ByteArray(32), message)
+            : Digest.Algorithms[digestAlgorithm](types_1.checkType(types_1.ByteArray(), message));
         const sig = exports.RecoverableSignature.sig(x);
         const recoveryParam = exports.RecoverableSignature.recoveryParam(x);
         const ethSig = core.compatibleBufferConcat([sig, Buffer.from([recoveryParam])]);
@@ -209,6 +267,6 @@ const recoverableSignatureStatic = {
         return exports.Signature.verify(exports.RecoverableSignature.sig(x), digestAlgorithm, message, publicKey);
     },
 };
-const recoverableSignature = Object.assign(recoverableSignatureBase, recoverableSignatureStatic);
-exports.RecoverableSignature = recoverableSignature;
+const _recoverableSignature = Object.assign(_recoverableSignatureBase, _recoverableSignatureStatic);
+exports.RecoverableSignature = _recoverableSignature;
 //# sourceMappingURL=types.js.map