@alephium/web3 1.4.0 → 1.5.1

package/dist/src/codec/compact-int-codec.d.ts

@@ -1,47 +1,68 @@
-import { Parser } from 'binary-parser';
 import { Codec } from './codec';
-export declare class CompactInt {
-    static readonly oneBytePrefix = 0;
-    static readonly oneByteNegPrefix = 192;
-    static readonly twoBytePrefix = 64;
-    static readonly twoByteNegPrefix = 128;
-    static readonly fourBytePrefix = 128;
-    static readonly fourByteNegPrefix = 64;
-    static readonly multiBytePrefix = 192;
+import { Reader } from './reader';
+type FixedWidthMode = {
+    type: 'SingleByte' | 'TwoByte' | 'FourByte';
+    prefix: number;
+    negPrefix: number;
+};
+type MultiByteMode = {
+    type: 'MultiByte';
+    prefix: number;
+};
+type Mode = FixedWidthMode | MultiByteMode;
+export declare class UnSigned {
+    static readonly oneByteBound: bigint;
+    static readonly twoByteBound: bigint;
+    static readonly fourByteBound: bigint;
+    static readonly u256UpperBound: bigint;
+    static readonly u32UpperBound: number;
+    static encodeU32(value: number): Uint8Array;
+    static encodeU256(value: bigint): Uint8Array;
+    static decodeInt(mode: FixedWidthMode, body: Uint8Array): number;
+    static decodeU32(mode: Mode, body: Uint8Array): number;
+    static decodeU256(mode: Mode, body: Uint8Array): bigint;
 }
-export interface DecodedCompactInt {
-    mode: number;
-    rest: Uint8Array;
+export declare const u256Codec: {
+    encode(input: bigint): Uint8Array;
+    _decode(input: Reader): bigint;
+    decode(input: Uint8Array): bigint;
+    bimap<R>(from: (v: bigint) => R, to: (v: R) => bigint): Codec<R>;
+};
+export declare const u32Codec: {
+    encode(input: number): Uint8Array;
+    _decode(input: Reader): number;
+    decode(input: Uint8Array): number;
+    bimap<R>(from: (v: number) => R, to: (v: R) => number): Codec<R>;
+};
+export declare class Signed {
+    static readonly signFlag = 32;
+    static readonly oneByteBound: bigint;
+    static readonly twoByteBound: bigint;
+    static readonly fourByteBound: bigint;
+    static readonly i256UpperBound: bigint;
+    static readonly i256LowerBound: bigint;
+    static readonly i32UpperBound: number;
+    static readonly i32LowerBound: number;
+    static encodeI32(value: number): Uint8Array;
+    static encodePositiveI32(value: number): Uint8Array;
+    static encodeNegativeI32(value: number): Uint8Array;
+    static encodeI256(value: bigint): Uint8Array;
+    static decodeInt(mode: FixedWidthMode, body: Uint8Array): number;
+    static decodePositiveInt(mode: FixedWidthMode, body: Uint8Array): number;
+    static decodeNegativeInt(mode: FixedWidthMode, body: Uint8Array): number;
+    static decodeI32(mode: Mode, body: Uint8Array): number;
+    static decodeI256(mode: Mode, body: Uint8Array): bigint;
 }
-export declare class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
-    private oneByteBound;
-    private twoByteBound;
-    private fourByteBound;
-    parser: Parser;
-    encode(input: DecodedCompactInt): Uint8Array;
-    encodeU32(value: number): Uint8Array;
-    encodeU256(value: bigint): Uint8Array;
-    decodeU256(input: Uint8Array): bigint;
-    decode(input: Uint8Array): DecodedCompactInt;
-    toU256(value: DecodedCompactInt): bigint;
-    fromU256(value: bigint): DecodedCompactInt;
-}
-export declare const compactUnsignedIntCodec: CompactUnsignedIntCodec;
-export declare class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
-    private signFlag;
-    private oneByteBound;
-    private twoByteBound;
-    private fourByteBound;
-    parser: Parser;
-    encode(input: DecodedCompactInt): Uint8Array;
-    decode(input: Uint8Array): DecodedCompactInt;
-    decodeI32(input: Uint8Array): number;
-    encodeI32(value: number): Uint8Array;
-    encodeI256(value: bigint): Uint8Array;
-    decodeI256(input: Uint8Array): bigint;
-    toI32(value: DecodedCompactInt): number;
-    fromI32(value: number): DecodedCompactInt;
-    toI256(value: DecodedCompactInt): bigint;
-    fromI256(value: bigint): DecodedCompactInt;
-}
-export declare const compactSignedIntCodec: CompactSignedIntCodec;
+export declare const i256Codec: {
+    encode(input: bigint): Uint8Array;
+    _decode(input: Reader): bigint;
+    decode(input: Uint8Array): bigint;
+    bimap<R>(from: (v: bigint) => R, to: (v: R) => bigint): Codec<R>;
+};
+export declare const i32Codec: {
+    encode(input: number): Uint8Array;
+    _decode(input: Reader): number;
+    decode(input: Uint8Array): number;
+    bimap<R>(from: (v: number) => R, to: (v: R) => number): Codec<R>;
+};
+export {};

package/dist/src/codec/compact-int-codec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compactSignedIntCodec = exports.CompactSignedIntCodec = exports.compactUnsignedIntCodec = exports.CompactUnsignedIntCodec = exports.CompactInt = void 0;
+exports.i32Codec = exports.i256Codec = exports.Signed = exports.u32Codec = exports.u256Codec = exports.UnSigned = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,60 +18,42 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-const binary_parser_1 = require("binary-parser");
 const codec_1 = require("./codec");
 const bigint_codec_1 = require("./bigint-codec");
-const utils_1 = require("../utils");
-class CompactInt {
-}
-exports.CompactInt = CompactInt;
-CompactInt.oneBytePrefix = 0x00;
-CompactInt.oneByteNegPrefix = 0xc0;
-CompactInt.twoBytePrefix = 0x40;
-CompactInt.twoByteNegPrefix = 0x80;
-CompactInt.fourBytePrefix = 0x80;
-CompactInt.fourByteNegPrefix = 0x40;
-CompactInt.multiBytePrefix = 0xc0;
 const maskRest = 0xc0;
 const maskMode = 0x3f;
 const maskModeNeg = 0xffffffc0;
-const signFlag = 0x20; // 0b00100000
-const compactIntParser = new binary_parser_1.Parser().uint8('mode').buffer('rest', {
-    length: function (ctx) {
-        const rawMode = this['mode'];
-        const mode = rawMode & maskRest;
-        switch (mode) {
-            case CompactInt.oneBytePrefix:
-                return 0;
-            case CompactInt.twoBytePrefix:
-                return 1;
-            case CompactInt.fourBytePrefix:
-                return 3;
-            default:
-                return (rawMode & maskMode) + 4;
+const SingleByteMode = { type: 'SingleByte', prefix: 0x00, negPrefix: 0xc0 };
+const TwoByteMode = { type: 'TwoByte', prefix: 0x40, negPrefix: 0x80 };
+const FourByteMode = { type: 'FourByte', prefix: 0x80, negPrefix: 0x40 };
+const MultiByte = { type: 'MultiByte', prefix: 0xc0 };
+function decodeMode(input) {
+    const byte = input.consumeByte();
+    switch (byte & maskRest) {
+        case SingleByteMode.prefix:
+            return { mode: SingleByteMode, body: new Uint8Array([byte]) };
+        case TwoByteMode.prefix:
+            return { mode: TwoByteMode, body: new Uint8Array([byte, ...input.consumeBytes(1)]) };
+        case FourByteMode.prefix:
+            return { mode: FourByteMode, body: new Uint8Array([byte, ...input.consumeBytes(3)]) };
+        default: {
+            const length = (byte & maskMode) + 4;
+            return { mode: MultiByte, body: new Uint8Array([byte, ...input.consumeBytes(length)]) };
         }
     }
-});
-class CompactUnsignedIntCodec {
-    constructor() {
-        this.oneByteBound = 0x40;
-        this.twoByteBound = this.oneByteBound << 8;
-        this.fourByteBound = this.oneByteBound << (8 * 3);
-        this.parser = compactIntParser;
-    }
-    encode(input) {
-        return new Uint8Array([input.mode, ...input.rest]);
-    }
-    encodeU32(value) {
-        if (value < this.oneByteBound) {
-            return new Uint8Array([(CompactInt.oneBytePrefix + value) & 0xff]);
+}
+class UnSigned {
+    static encodeU32(value) {
+        (0, codec_1.assert)(value >= 0 && value < UnSigned.u32UpperBound, `Invalid u32 value: ${value}`);
+        if (value < UnSigned.oneByteBound) {
+            return new Uint8Array([(SingleByteMode.prefix + value) & 0xff]);
         }
-        else if (value < this.twoByteBound) {
-            return new Uint8Array([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
+        else if (value < UnSigned.twoByteBound) {
+            return new Uint8Array([(TwoByteMode.prefix + (value >> 8)) & 0xff, value & 0xff]);
         }
-        else if (value < this.fourByteBound) {
+        else if (value < UnSigned.fourByteBound) {
             return new Uint8Array([
-                (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
+                (FourByteMode.prefix + (value >> 24)) & 0xff,
                 (value >> 16) & 0xff,
                 (value >> 8) & 0xff,
                 value & 0xff
@@ -79,7 +61,7 @@ class CompactUnsignedIntCodec {
         }
         else {
             return new Uint8Array([
-                CompactInt.multiBytePrefix,
+                MultiByte.prefix,
                 (value >> 24) & 0xff,
                 (value >> 16) & 0xff,
                 (value >> 8) & 0xff,
@@ -87,204 +69,240 @@ class CompactUnsignedIntCodec {
             ]);
         }
     }
-    encodeU256(value) {
-        (0, codec_1.assert)(value >= 0n, 'Value should be positive');
-        if (value < this.fourByteBound) {
-            return this.encodeU32(Number(value));
+    static encodeU256(value) {
+        (0, codec_1.assert)(value >= 0n && value < UnSigned.u256UpperBound, `Invalid u256 value: ${value}`);
+        if (value < UnSigned.fourByteBound) {
+            return UnSigned.encodeU32(Number(value));
         }
         else {
             let bytes = bigint_codec_1.BigIntCodec.encode(value);
             if (bytes[0] === 0) {
                 bytes = bytes.slice(1);
             }
-            (0, codec_1.assert)(bytes.length <= 32, 'Expect <= 32 bytes for U256');
-            const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff;
+            const header = (bytes.length - 4 + MultiByte.prefix) & 0xff;
             return new Uint8Array([header, ...bytes]);
         }
     }
-    decodeU256(input) {
-        const decoded = this.decode(input);
-        return this.toU256(decoded);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-    toU256(value) {
-        const mode = value.mode & maskRest;
-        if (fixedSize(mode)) {
-            const body = new Uint8Array([value.mode, ...value.rest]);
-            return BigInt(decodePositiveInt(value.mode, body));
+    static decodeInt(mode, body) {
+        switch (mode.type) {
+            case 'SingleByte':
+                (0, codec_1.assert)(body.length === 1, 'Length should be 2');
+                return body[0];
+            case 'TwoByte':
+                (0, codec_1.assert)(body.length === 2, 'Length should be 2');
+                return ((body[0] & maskMode) << 8) | (body[1] & 0xff);
+            case 'FourByte':
+                (0, codec_1.assert)(body.length === 4, 'Length should be 4');
+                return ((((body[0] & maskMode) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff)) >>> 0);
         }
-        else {
-            (0, codec_1.assert)(value.rest.length <= 32, 'Expect <= 32 bytes for U256');
-            return bigint_codec_1.BigIntCodec.decode(value.rest, false);
+    }
+    static decodeU32(mode, body) {
+        switch (mode.type) {
+            case 'SingleByte':
+            case 'TwoByte':
+            case 'FourByte':
+                return UnSigned.decodeInt(mode, body);
+            case 'MultiByte':
+                (0, codec_1.assert)(body.length >= 5, 'Length should be greater than 5');
+                if (body.length === 5) {
+                    return ((body[1] << 24) | ((body[2] & 0xff) << 16) | ((body[3] & 0xff) << 8) | (body[4] & 0xff)) >>> 0;
+                }
+                else {
+                    throw new Error(`Expect 4 bytes int, but get ${body.length - 1} bytes int`);
+                }
         }
     }
-    fromU256(value) {
-        return this.decode(this.encodeU256(value));
+    static decodeU256(mode, body) {
+        switch (mode.type) {
+            case 'SingleByte':
+            case 'TwoByte':
+            case 'FourByte':
+                return BigInt(UnSigned.decodeInt(mode, body));
+            case 'MultiByte':
+                return bigint_codec_1.BigIntCodec.decodeUnsigned(body.slice(1, body.length));
+        }
     }
 }
-exports.CompactUnsignedIntCodec = CompactUnsignedIntCodec;
-exports.compactUnsignedIntCodec = new CompactUnsignedIntCodec();
-class CompactSignedIntCodec {
-    constructor() {
-        this.signFlag = 0x20; // 0b00100000
-        this.oneByteBound = 0x20; // 0b00100000
-        this.twoByteBound = this.oneByteBound << 8;
-        this.fourByteBound = this.oneByteBound << (8 * 3);
-        this.parser = compactIntParser;
-    }
+exports.UnSigned = UnSigned;
+UnSigned.oneByteBound = BigInt(0x40);
+UnSigned.twoByteBound = UnSigned.oneByteBound << BigInt(8);
+UnSigned.fourByteBound = UnSigned.oneByteBound << BigInt(8 * 3);
+UnSigned.u256UpperBound = BigInt(1) << BigInt(256);
+UnSigned.u32UpperBound = 2 ** 32;
+exports.u256Codec = new (class extends codec_1.Codec {
     encode(input) {
-        return new Uint8Array([input.mode, ...input.rest]);
+        return UnSigned.encodeU256(input);
+    }
+    _decode(input) {
+        const { mode, body } = decodeMode(input);
+        return UnSigned.decodeU256(mode, body);
     }
-    decode(input) {
-        return this.parser.parse(input);
+})();
+exports.u32Codec = new (class extends codec_1.Codec {
+    encode(input) {
+        return UnSigned.encodeU32(input);
     }
-    decodeI32(input) {
-        const decoded = this.decode(input);
-        return this.toI32(decoded);
+    _decode(input) {
+        const { mode, body } = decodeMode(input);
+        return UnSigned.decodeU32(mode, body);
     }
-    encodeI32(value) {
+})();
+class Signed {
+    static encodeI32(value) {
+        (0, codec_1.assert)(value >= Signed.i32LowerBound && value < Signed.i32UpperBound, `Invalid i32 value: ${value}`);
         if (value >= 0) {
-            if (value < this.oneByteBound) {
-                return new Uint8Array([(CompactInt.oneBytePrefix + value) & 0xff]);
-            }
-            else if (value < this.twoByteBound) {
-                return new Uint8Array([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff]);
-            }
-            else if (value < this.fourByteBound) {
-                return new Uint8Array([
-                    (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
-                    (value >> 16) & 0xff,
-                    (value >> 8) & 0xff,
-                    value & 0xff
-                ]);
-            }
-            else {
-                return new Uint8Array([
-                    CompactInt.multiBytePrefix,
-                    (value >> 24) & 0xff,
-                    (value >> 16) & 0xff,
-                    (value >> 8) & 0xff,
-                    value & 0xff
-                ]);
-            }
+            return Signed.encodePositiveI32(value);
         }
         else {
-            if (value >= -this.oneByteBound) {
-                return new Uint8Array([(value ^ CompactInt.oneByteNegPrefix) & 0xff]);
-            }
-            else if (value >= -this.twoByteBound) {
-                return new Uint8Array([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff]);
-            }
-            else if (value >= -this.fourByteBound) {
-                return new Uint8Array([
-                    ((value >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
-                    (value >> 16) & 0xff,
-                    (value >> 8) & 0xff,
-                    value & 0xff
-                ]);
-            }
-            else {
-                return new Uint8Array([
-                    CompactInt.multiBytePrefix,
-                    (value >> 24) & 0xff,
-                    (value >> 16) & 0xff,
-                    (value >> 8) & 0xff,
-                    value & 0xff
-                ]);
-            }
+            return Signed.encodeNegativeI32(value);
         }
     }
-    encodeI256(value) {
+    static encodePositiveI32(value) {
+        if (value < this.oneByteBound) {
+            return new Uint8Array([(SingleByteMode.prefix + value) & 0xff]);
+        }
+        else if (value < this.twoByteBound) {
+            return new Uint8Array([(TwoByteMode.prefix + (value >> 8)) & 0xff, value & 0xff]);
+        }
+        else if (value < this.fourByteBound) {
+            return new Uint8Array([
+                (FourByteMode.prefix + (value >> 24)) & 0xff,
+                (value >> 16) & 0xff,
+                (value >> 8) & 0xff,
+                value & 0xff
+            ]);
+        }
+        else {
+            return new Uint8Array([
+                MultiByte.prefix,
+                (value >> 24) & 0xff,
+                (value >> 16) & 0xff,
+                (value >> 8) & 0xff,
+                value & 0xff
+            ]);
+        }
+    }
+    static encodeNegativeI32(value) {
+        if (value >= -this.oneByteBound) {
+            return new Uint8Array([(value ^ SingleByteMode.negPrefix) & 0xff]);
+        }
+        else if (value >= -this.twoByteBound) {
+            return new Uint8Array([((value >> 8) ^ TwoByteMode.negPrefix) & 0xff, value & 0xff]);
+        }
+        else if (value >= -this.fourByteBound) {
+            return new Uint8Array([
+                ((value >> 24) ^ FourByteMode.negPrefix) & 0xff,
+                (value >> 16) & 0xff,
+                (value >> 8) & 0xff,
+                value & 0xff
+            ]);
+        }
+        else {
+            return new Uint8Array([
+                MultiByte.prefix,
+                (value >> 24) & 0xff,
+                (value >> 16) & 0xff,
+                (value >> 8) & 0xff,
+                value & 0xff
+            ]);
+        }
+    }
+    static encodeI256(value) {
+        (0, codec_1.assert)(value >= Signed.i256LowerBound && value < Signed.i256UpperBound, `Invalid i256 value: ${value}`);
         if (value >= -0x20000000 && value < 0x20000000) {
             return this.encodeI32(Number(value));
         }
         else {
             const bytes = bigint_codec_1.BigIntCodec.encode(value);
-            const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff;
+            const header = (bytes.length - 4 + MultiByte.prefix) & 0xff;
             return new Uint8Array([header, ...bytes]);
         }
     }
-    decodeI256(input) {
-        const decoded = this.decode(input);
-        return this.toI256(decoded);
-    }
-    toI32(value) {
-        const body = new Uint8Array([value.mode, ...value.rest]);
-        const mode = value.mode & maskRest;
-        if (fixedSize(mode)) {
-            const isPositive = (value.mode & signFlag) == 0;
-            if (isPositive) {
-                return decodePositiveInt(value.mode, body);
-            }
-            else {
-                return decodeNegativeInt(value.mode, body);
-            }
+    static decodeInt(mode, body) {
+        const isPositive = (body[0] & Signed.signFlag) === 0;
+        if (isPositive) {
+            return Signed.decodePositiveInt(mode, body);
         }
         else {
-            if (body.length === 5) {
-                return ((body[1] & 0xff) << 24) | ((body[2] & 0xff) << 16) | ((body[3] & 0xff) << 8) | (body[4] & 0xff);
-            }
-            else {
-                throw new Error(`Expect 4 bytes int, but get ${body.length - 1} bytes int`);
-            }
+            return Signed.decodeNegativeInt(mode, body);
         }
     }
-    fromI32(value) {
-        return this.decode(this.encodeI32(value));
+    static decodePositiveInt(mode, body) {
+        switch (mode.type) {
+            case 'SingleByte':
+                return body[0];
+            case 'TwoByte':
+                (0, codec_1.assert)(body.length === 2, 'Length should be 2');
+                return ((body[0] & maskMode) << 8) | (body[1] & 0xff);
+            case 'FourByte':
+                (0, codec_1.assert)(body.length === 4, 'Length should be 4');
+                return ((body[0] & maskMode) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff);
+        }
     }
-    toI256(value) {
-        const mode = value.mode & maskRest;
-        if (fixedSize(mode)) {
-            return BigInt(this.toI32(value));
+    static decodeNegativeInt(mode, body) {
+        switch (mode.type) {
+            case 'SingleByte':
+                return body[0] | maskModeNeg;
+            case 'TwoByte':
+                (0, codec_1.assert)(body.length === 2, 'Length should be 2');
+                return ((body[0] | maskModeNeg) << 8) | (body[1] & 0xff);
+            case 'FourByte':
+                (0, codec_1.assert)(body.length === 4, 'Length should be 4');
+                return ((body[0] | maskModeNeg) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff);
         }
-        else {
-            (0, codec_1.assert)(value.rest.length <= 32, 'Expect <= 32 bytes for I256');
-            return bigint_codec_1.BigIntCodec.decode(value.rest, true);
+    }
+    static decodeI32(mode, body) {
+        switch (mode.type) {
+            case 'SingleByte':
+            case 'TwoByte':
+            case 'FourByte':
+                return Signed.decodeInt(mode, body);
+            case 'MultiByte':
+                if (body.length === 5) {
+                    return (body[1] << 24) | ((body[2] & 0xff) << 16) | ((body[3] & 0xff) << 8) | (body[4] & 0xff);
+                }
+                else {
+                    throw new Error(`Expect 4 bytes int, but get ${body.length - 1} bytes int`);
+                }
         }
     }
-    fromI256(value) {
-        return this.decode(this.encodeI256(value));
+    static decodeI256(mode, body) {
+        switch (mode.type) {
+            case 'SingleByte':
+            case 'TwoByte':
+            case 'FourByte':
+                return BigInt(Signed.decodeInt(mode, body));
+            case 'MultiByte':
+                const bytes = body.slice(1, body.length);
+                (0, codec_1.assert)(bytes.length <= 32, 'Expect <= 32 bytes for I256');
+                return bigint_codec_1.BigIntCodec.decodeSigned(bytes);
+        }
     }
 }
-exports.CompactSignedIntCodec = CompactSignedIntCodec;
-exports.compactSignedIntCodec = new CompactSignedIntCodec();
-function decodePositiveInt(rawMode, body) {
-    const mode = rawMode & maskRest;
-    switch (mode) {
-        case CompactInt.oneBytePrefix:
-            return rawMode;
-        case CompactInt.twoBytePrefix:
-            (0, codec_1.assert)(body.length === 2, 'Length should be 2');
-            return ((body[0] & maskMode) << 8) | (body[1] & 0xff);
-        case CompactInt.fourBytePrefix:
-            (0, codec_1.assert)(body.length === 4, 'Length should be 4');
-            return ((body[0] & maskMode) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff);
-        default:
-            if (body.length === 5) {
-                return Number(BigInt('0x' + (0, utils_1.binToHex)(body.slice(1))));
-            }
-            else {
-                throw new Error(`decodePositiveInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`);
-            }
+exports.Signed = Signed;
+Signed.signFlag = 0x20; // 0b00100000
+Signed.oneByteBound = BigInt(0x20);
+Signed.twoByteBound = Signed.oneByteBound << BigInt(8);
+Signed.fourByteBound = Signed.oneByteBound << BigInt(8 * 3);
+Signed.i256UpperBound = BigInt(1) << BigInt(255);
+Signed.i256LowerBound = -Signed.i256UpperBound;
+Signed.i32UpperBound = 2 ** 31;
+Signed.i32LowerBound = -Signed.i32UpperBound;
+exports.i256Codec = new (class extends codec_1.Codec {
+    encode(input) {
+        return Signed.encodeI256(input);
     }
-}
-function decodeNegativeInt(rawMode, body) {
-    const mode = rawMode & maskRest;
-    switch (mode) {
-        case CompactInt.oneBytePrefix:
-            return rawMode | maskModeNeg;
-        case CompactInt.twoBytePrefix:
-            (0, codec_1.assert)(body.length === 2, 'Length should be 2');
-            return ((body[0] | maskModeNeg) << 8) | (body[1] & 0xff);
-        case CompactInt.fourBytePrefix:
-            (0, codec_1.assert)(body.length === 4, 'Length should be 4');
-            return ((body[0] | maskModeNeg) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff);
-        default:
-            throw new Error(`decodeNegativeInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`);
+    _decode(input) {
+        const { mode, body } = decodeMode(input);
+        return Signed.decodeI256(mode, body);
     }
-}
-function fixedSize(mode) {
-    return mode === CompactInt.oneBytePrefix || mode === CompactInt.twoBytePrefix || mode === CompactInt.fourBytePrefix;
-}
+})();
+exports.i32Codec = new (class extends codec_1.Codec {
+    encode(input) {
+        return Signed.encodeI32(input);
+    }
+    _decode(input) {
+        const { mode, body } = decodeMode(input);
+        return Signed.decodeI32(mode, body);
+    }
+})();

package/dist/src/codec/contract-codec.d.ts

@@ -1,21 +1,18 @@
-import { Parser } from 'binary-parser';
-import { DecodedArray } from './array-codec';
 import { Codec } from './codec';
-import { DecodedCompactInt } from './compact-int-codec';
 import { Method } from './method-codec';
+import { Reader } from './reader';
 export interface HalfDecodedContract {
-    fieldLength: DecodedCompactInt;
-    methodIndexes: DecodedArray<DecodedCompactInt>;
+    fieldLength: number;
+    methodIndexes: number[];
     methods: Uint8Array;
 }
 export interface Contract {
     fieldLength: number;
     methods: Method[];
 }
-export declare class ContractCodec implements Codec<HalfDecodedContract> {
-    parser: Parser;
+export declare class ContractCodec extends Codec<HalfDecodedContract> {
     encode(input: HalfDecodedContract): Uint8Array;
-    decode(input: Uint8Array): HalfDecodedContract;
+    _decode(input: Reader): HalfDecodedContract;
     decodeContract(input: Uint8Array): Contract;
     encodeContract(contract: Contract): Uint8Array;
 }