@1inch/byte-utils

Contains helpers to work with bytes

Installation

``shell
npm install @1inch/byte-utils
`

Docs

:toolbox: Functions

- isHexString
- isHexBytes

$3

Check that string starts with 0x and has only valid hex symbols

| Function | Type |
| ---------- | ---------- |
| isHexString | (val: string) => boolean |

$3

Check that string is valid hex with 0x prefix and length is even

| Function | Type |
| ---------- | ---------- |
| isHexBytes | (val: string) => boolean |




:wrench: Constants

- UINT_8_MAX
- UINT_24_MAX
- UINT_32_MAX
- UINT_40_MAX
- UINT_48_MAX
- UINT_80_MAX
- UINT_160_MAX
- UINT_128_MAX
- UINT_256_MAX

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_8_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_24_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_32_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_40_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_48_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_80_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_160_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_128_MAX | bigint |

$3

| Constant | Type |
| ---------- | ---------- |
| UINT_256_MAX | bigint |




:factory: BitMask

Class to define bit mask: new BitMask(16, 32) is for bits from 16, 32) => 0xffff0000

$3

- [toString
- toBigInt

#### :gear: toString

| Method | Type |
| ---------- | ---------- |
| toString | () => string |

#### :gear: toBigInt

| Method | Type |
| ---------- | ---------- |
| toBigInt | () => bigint |




:factory: BN

Class to work with bits in bignumber
Immutable, all methods return new value

$3

- fromNumber
- fromHex
- add
- sub
- setBit
- getBit
- shiftLeft
- shiftRight
- and
- or
- xor
- isZero
- isOne
- getMask
- setMask
- clearMask
- toHex
- toNumber

#### :gear: fromNumber

| Method | Type |
| ---------- | ---------- |
| fromNumber | (n: number) => BN |

#### :gear: fromHex

| Method | Type |
| ---------- | ---------- |
| fromHex | (hex: string) => BN |

#### :gear: add

Add value

| Method | Type |
| ---------- | ---------- |
| add | (other: BN) => BN |

#### :gear: sub

Subtract value

| Method | Type |
| ---------- | ---------- |
| sub | (other: BN) => BN |

#### :gear: setBit

| Method | Type |
| ---------- | ---------- |
| setBit | (n: bigint, value: 0 or 1) => BN |

#### :gear: getBit

| Method | Type |
| ---------- | ---------- |
| getBit | (n: bigint) => 0 or 1 |

#### :gear: shiftLeft

| Method | Type |
| ---------- | ---------- |
| shiftLeft | (n: bigint) => BN |

#### :gear: shiftRight

| Method | Type |
| ---------- | ---------- |
| shiftRight | (n: bigint) => BN |

#### :gear: and

| Method | Type |
| ---------- | ---------- |
| and | (other: bigint or BN) => BN |

#### :gear: or

| Method | Type |
| ---------- | ---------- |
| or | (other: bigint or BN) => BN |

#### :gear: xor

| Method | Type |
| ---------- | ---------- |
| xor | (other: bigint or BN) => BN |

#### :gear: isZero

| Method | Type |
| ---------- | ---------- |
| isZero | () => boolean |

#### :gear: isOne

| Method | Type |
| ---------- | ---------- |
| isOne | () => boolean |

#### :gear: getMask

Return bits defined in mask as BN

| Method | Type |
| ---------- | ---------- |
| getMask | (mask: BitMask) => BN |

#### :gear: setMask

Set bits defined in mask to value
if value is bigger than mask then error will be thrown

| Method | Type |
| ---------- | ---------- |
| setMask | (mask: BitMask, value: bigint or BN) => BN |

#### :gear: clearMask

Set bits defined in mask to 0s

| Method | Type |
| ---------- | ---------- |
| clearMask | (mask: BitMask) => BN |

#### :gear: toHex

Return 0x prefixed string with hex representation of BN, padded with '0s' if padNum specified

| Method | Type |
| ---------- | ---------- |
| toHex | (padNum?: number) => string |

#### :gear: toNumber

Convert BN to Number

Caution: value will be rounded for numbers > Number.MAX_SAFE_INTEGER

| Method | Type |
| ---------- | ---------- |
| toNumber | () => number |




:factory: BytesIter

Class to iterate through bytes string by parsing individual bytes

$3

- BigInt
- String
- rest
- isEmpty
- nextByte
- nextBytes
- nextAddress
- nextUint8
- nextUint16
- nextUint24
- nextUint32
- nextUint128
- nextUint160
- nextUint256

#### :gear: BigInt

| Method | Type |
| ---------- | ---------- |
| BigInt | (bytes: string) => BytesIter |

#### :gear: String

| Method | Type |
| ---------- | ---------- |
| String | (bytes: string) => BytesIter |

#### :gear: rest

Returns all not consumed bytes

| Method | Type |
| ---------- | ---------- |
| rest | () => T |

#### :gear: isEmpty

| Method | Type |
| ---------- | ---------- |
| isEmpty | () => boolean |

#### :gear: nextByte

| Method | Type |
| ---------- | ---------- |
| nextByte | (side?: Side) => T |

#### :gear: nextBytes

| Method | Type |
| ---------- | ---------- |
| nextBytes | (n: number, side?: Side) => T |

#### :gear: nextAddress

| Method | Type |
| ---------- | ---------- |
| nextAddress | (side?: Side) => T |

#### :gear: nextUint8

| Method | Type |
| ---------- | ---------- |
| nextUint8 | (side?: Side) => T |

#### :gear: nextUint16

| Method | Type |
| ---------- | ---------- |
| nextUint16 | (side?: Side) => T |

#### :gear: nextUint24

| Method | Type |
| ---------- | ---------- |
| nextUint24 | (side?: Side) => T |

#### :gear: nextUint32

| Method | Type |
| ---------- | ---------- |
| nextUint32 | (side?: Side) => T |

#### :gear: nextUint128

| Method | Type |
| ---------- | ---------- |
| nextUint128 | (side?: Side) => T |

#### :gear: nextUint160

| Method | Type |
| ---------- | ---------- |
| nextUint160 | (side?: Side) => T |

#### :gear: nextUint256

| Method | Type |
| ---------- | ---------- |
| nextUint256 | (side?: Side) => T |




:factory: BytesBuilder

Helper class to build an arbitrary bytes sequence

$3

- addAddress
- addBytes
- addByte
- addUint8
- addUint16
- addUint24
- addUint32
- addUint64
- addUint128
- addUint160
- addUint256
- asBigInt
- asHex

#### :gear: addAddress

| Method | Type |
| ---------- | ---------- |
| addAddress | (address: string or bigint or BN) => this |

#### :gear: addBytes

| Method | Type |
| ---------- | ---------- |
| addBytes | (bytes: string) => this |

#### :gear: addByte

| Method | Type |
| ---------- | ---------- |
| addByte | (byte: string or bigint or BN) => this |

#### :gear: addUint8

| Method | Type |
| ---------- | ---------- |
| addUint8 | (val: string or bigint or BN) => this |

#### :gear: addUint16

| Method | Type |
| ---------- | ---------- |
| addUint16 | (val: string or bigint or BN) => this |

#### :gear: addUint24

| Method | Type |
| ---------- | ---------- |
| addUint24 | (val: string or bigint or BN) => this |

#### :gear: addUint32

| Method | Type |
| ---------- | ---------- |
| addUint32 | (val: string or bigint or BN) => this |

#### :gear: addUint64

| Method | Type |
| ---------- | ---------- |
| addUint64 | (val: string or bigint or BN) => this |

#### :gear: addUint128

| Method | Type |
| ---------- | ---------- |
| addUint128 | (val: string or bigint or BN) => this |

#### :gear: addUint160

| Method | Type |
| ---------- | ---------- |
| addUint160 | (val: string or bigint or BN) => this |

#### :gear: addUint256

| Method | Type |
| ---------- | ---------- |
| addUint256 | (val: string or bigint or BN) => this |

#### :gear: asBigInt

Returns bytes as single bigint value

| Method | Type |
| ---------- | ---------- |
| asBigInt | () => bigint |

#### :gear: asHex

Returns hex string

| Method | Type |
| ---------- | ---------- |
| asHex | (prefixed?: boolean) => string |

Parameters:

* prefixed`: should be string prefixed with 0x or not, true by default