@alephium/web3 1.4.0 → 1.5.0

package/dist/src/codec/int-as-4bytes-codec.d.ts

@@ -0,0 +1,7 @@
+import { Codec } from './codec';
+import { Reader } from './reader';
+export declare class IntAs4BytesCodec extends Codec<number> {
+    encode(value: number): Uint8Array;
+    _decode(input: Reader): number;
+}
+export declare const intAs4BytesCodec: IntAs4BytesCodec;

package/dist/src/codec/{signed-int-codec.js → int-as-4bytes-codec.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signedIntCodec = exports.SignedIntCodec = void 0;
+exports.intAs4BytesCodec = exports.IntAs4BytesCodec = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,21 +18,15 @@ 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");
-class SignedIntCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start().buffer('value', {
-            length: 4
-        });
-    }
+class IntAs4BytesCodec extends codec_1.Codec {
     encode(value) {
         return new Uint8Array([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff]);
     }
-    decode(bytes) {
-        (0, codec_1.assert)(bytes.length === 4, 'Length should be 4');
+    _decode(input) {
+        const bytes = input.consumeBytes(4);
         return ((bytes[0] & 0xff) << 24) | ((bytes[1] & 0xff) << 16) | ((bytes[2] & 0xff) << 8) | (bytes[3] & 0xff);
     }
 }
-exports.SignedIntCodec = SignedIntCodec;
-exports.signedIntCodec = new SignedIntCodec();
+exports.IntAs4BytesCodec = IntAs4BytesCodec;
+exports.intAs4BytesCodec = new IntAs4BytesCodec();

package/dist/src/codec/lockup-script-codec.d.ts

@@ -1,27 +1,24 @@
-import { Parser } from 'binary-parser';
-import { DecodedCompactInt } from './compact-int-codec';
-import { Codec } from './codec';
-import { DecodedArray } from './array-codec';
-export interface PublicKeyHash {
-    publicKeyHash: Uint8Array;
+import { EnumCodec } from './codec';
+export type PublicKeyHash = Uint8Array;
+export type P2PKH = Uint8Array;
+export type P2SH = Uint8Array;
+export type P2C = Uint8Array;
+export declare const p2cCodec: import("./codec").FixedSizeCodec;
+export interface P2MPKH {
+    publicKeyHashes: PublicKeyHash[];
+    m: number;
 }
-export interface MultiSig {
-    publicKeyHashes: DecodedArray<PublicKeyHash>;
-    m: DecodedCompactInt;
-}
-export interface P2SH {
-    scriptHash: Uint8Array;
-}
-export interface P2C {
-    contractId: Uint8Array;
-}
-export interface LockupScript {
-    scriptType: number;
-    script: PublicKeyHash | MultiSig | P2SH | P2C;
-}
-export declare class LockupScriptCodec implements Codec<LockupScript> {
-    parser: Parser;
-    encode(input: LockupScript): Uint8Array;
-    decode(input: Uint8Array): LockupScript;
-}
-export declare const lockupScriptCodec: LockupScriptCodec;
+export type LockupScript = {
+    kind: 'P2PKH';
+    value: P2PKH;
+} | {
+    kind: 'P2MPKH';
+    value: P2MPKH;
+} | {
+    kind: 'P2SH';
+    value: P2SH;
+} | {
+    kind: 'P2C';
+    value: P2C;
+};
+export declare const lockupScriptCodec: EnumCodec<LockupScript>;

package/dist/src/codec/lockup-script-codec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lockupScriptCodec = exports.LockupScriptCodec = void 0;
+exports.lockupScriptCodec = exports.p2cCodec = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,63 +18,17 @@ 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 compact_int_codec_1 = require("./compact-int-codec");
 const codec_1 = require("./codec");
 const array_codec_1 = require("./array-codec");
-class PublicKeyHashCodec {
-    constructor() {
-        this.parser = (0, codec_1.fixedSizeBytes)('publicKeyHash', 32);
-    }
-    encode(input) {
-        return input.publicKeyHash;
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-const publicKeyHashCodec = new PublicKeyHashCodec();
-const publicKeyHashesCodec = new array_codec_1.ArrayCodec(publicKeyHashCodec);
-const multiSigParser = binary_parser_1.Parser.start()
-    .nest('publicKeyHashes', { type: publicKeyHashesCodec.parser })
-    .nest('m', { type: compact_int_codec_1.compactSignedIntCodec.parser });
-class LockupScriptCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .uint8('scriptType')
-            .choice('script', {
-            tag: 'scriptType',
-            choices: {
-                0: publicKeyHashCodec.parser,
-                1: multiSigParser,
-                2: binary_parser_1.Parser.start().buffer('scriptHash', { length: 32 }),
-                3: binary_parser_1.Parser.start().buffer('contractId', { length: 32 })
-            }
-        });
-    }
-    encode(input) {
-        const result = [input.scriptType];
-        if (input.scriptType === 0) {
-            result.push(...input.script.publicKeyHash);
-        }
-        else if (input.scriptType === 1) {
-            result.push(...publicKeyHashesCodec.encode(input.script.publicKeyHashes.value));
-            result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.script.m));
-        }
-        else if (input.scriptType === 2) {
-            result.push(...input.script.scriptHash);
-        }
-        else if (input.scriptType === 3) {
-            result.push(...input.script.contractId);
-        }
-        else {
-            throw new Error(`Unsupported script type: ${input.scriptType}`);
-        }
-        return new Uint8Array(result);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.LockupScriptCodec = LockupScriptCodec;
-exports.lockupScriptCodec = new LockupScriptCodec();
+exports.p2cCodec = codec_1.byte32Codec;
+const p2mpkhCodec = new codec_1.ObjectCodec({
+    publicKeyHashes: new array_codec_1.ArrayCodec(codec_1.byte32Codec),
+    m: compact_int_codec_1.i32Codec
+});
+exports.lockupScriptCodec = new codec_1.EnumCodec('lockup script', {
+    P2PKH: codec_1.byte32Codec,
+    P2MPKH: p2mpkhCodec,
+    P2SH: codec_1.byte32Codec,
+    P2C: codec_1.byte32Codec
+});

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

@@ -1,16 +1,7 @@
-import { Parser } from 'binary-parser';
-import { ArrayCodec, DecodedArray } from './array-codec';
-import { DecodedCompactInt } from './compact-int-codec';
+import { ArrayCodec } from './array-codec';
 import { Codec } from './codec';
 import { Instr } from './instr-codec';
-export interface DecodedMethod {
-    isPublic: number;
-    assetModifier: number;
-    argsLength: DecodedCompactInt;
-    localsLength: DecodedCompactInt;
-    returnLength: DecodedCompactInt;
-    instrs: DecodedArray<Instr>;
-}
+import { Reader } from './reader';
 export interface Method {
     isPublic: boolean;
     usePreapprovedAssets: boolean;
@@ -21,12 +12,9 @@ export interface Method {
     returnLength: number;
     instrs: Instr[];
 }
-export declare class MethodCodec implements Codec<DecodedMethod> {
-    parser: Parser;
-    encode(input: DecodedMethod): Uint8Array;
-    decode(input: Uint8Array): DecodedMethod;
-    static toMethod(decodedMethod: DecodedMethod): Method;
-    static fromMethod(method: Method): DecodedMethod;
+export declare class MethodCodec extends Codec<Method> {
+    encode(method: Method): Uint8Array;
+    _decode(input: Reader): Method;
 }
 export declare const methodCodec: MethodCodec;
-export declare const methodsCodec: ArrayCodec<DecodedMethod>;
+export declare const methodsCodec: ArrayCodec<Method>;

package/dist/src/codec/method-codec.js

@@ -18,10 +18,11 @@ 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 array_codec_1 = require("./array-codec");
 const compact_int_codec_1 = require("./compact-int-codec");
+const codec_1 = require("./codec");
 const instr_codec_1 = require("./instr-codec");
+const utils_1 = require("../utils");
 function decodeAssetModifier(encoded) {
     const usePayToContractOnly = (encoded & 4) !== 0;
     switch (encoded & 3) {
@@ -47,54 +48,25 @@ function encodeAssetModifier(arg) {
                 : 3;
     return encoded | (arg.usePayToContractOnly ? 4 : 0);
 }
-class MethodCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .uint8('isPublic')
-            .uint8('assetModifier')
-            .nest('argsLength', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .nest('localsLength', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .nest('returnLength', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .nest('instrs', {
-            type: instr_codec_1.instrsCodec.parser
-        });
+class MethodCodec extends codec_1.Codec {
+    encode(method) {
+        const bytes = [];
+        bytes.push(codec_1.boolCodec.encode(method.isPublic));
+        bytes.push(new Uint8Array([encodeAssetModifier(method)]));
+        bytes.push(compact_int_codec_1.i32Codec.encode(method.argsLength));
+        bytes.push(compact_int_codec_1.i32Codec.encode(method.localsLength));
+        bytes.push(compact_int_codec_1.i32Codec.encode(method.returnLength));
+        bytes.push(instr_codec_1.instrsCodec.encode(method.instrs));
+        return (0, utils_1.concatBytes)(bytes);
     }
-    encode(input) {
-        const result = [input.isPublic, input.assetModifier];
-        result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.argsLength));
-        result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.localsLength));
-        result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.returnLength));
-        result.push(...instr_codec_1.instrsCodec.encode(input.instrs.value));
-        return new Uint8Array(result);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-    static toMethod(decodedMethod) {
-        return {
-            isPublic: decodedMethod.isPublic === 1,
-            ...decodeAssetModifier(decodedMethod.assetModifier),
-            argsLength: compact_int_codec_1.compactSignedIntCodec.toI32(decodedMethod.argsLength),
-            localsLength: compact_int_codec_1.compactSignedIntCodec.toI32(decodedMethod.localsLength),
-            returnLength: compact_int_codec_1.compactSignedIntCodec.toI32(decodedMethod.returnLength),
-            instrs: decodedMethod.instrs.value
-        };
-    }
-    static fromMethod(method) {
-        return {
-            isPublic: method.isPublic ? 1 : 0,
-            assetModifier: encodeAssetModifier(method),
-            argsLength: compact_int_codec_1.compactSignedIntCodec.fromI32(method.argsLength),
-            localsLength: compact_int_codec_1.compactSignedIntCodec.fromI32(method.localsLength),
-            returnLength: compact_int_codec_1.compactSignedIntCodec.fromI32(method.returnLength),
-            instrs: instr_codec_1.instrsCodec.fromArray(method.instrs)
-        };
+    _decode(input) {
+        const isPublic = codec_1.boolCodec._decode(input);
+        const assetModifier = decodeAssetModifier(codec_1.byteCodec._decode(input));
+        const argsLength = compact_int_codec_1.i32Codec._decode(input);
+        const localsLength = compact_int_codec_1.i32Codec._decode(input);
+        const returnLength = compact_int_codec_1.i32Codec._decode(input);
+        const instrs = instr_codec_1.instrsCodec._decode(input);
+        return { ...assetModifier, isPublic, argsLength, localsLength, returnLength, instrs };
     }
 }
 exports.MethodCodec = MethodCodec;

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

@@ -1,14 +1,9 @@
-import { Parser } from 'binary-parser';
 import { Codec } from './codec';
-export interface Option<T> {
-    option: number;
-    value?: T;
-}
-export declare class OptionCodec<T> implements Codec<Option<T>> {
-    private childCodec;
-    parser: Parser;
-    constructor(childCodec: Codec<T>, parser?: Parser);
-    encode(input: Option<T>): Uint8Array;
-    decode(input: Uint8Array): Option<T>;
-    fromBytes(input?: Uint8Array): Option<T>;
-}
+export type Option<T> = {
+    kind: 'None';
+    value: undefined;
+} | {
+    kind: 'Some';
+    value: T;
+};
+export declare function option<T>(codec: Codec<T>): Codec<Option<T>>;

package/dist/src/codec/option-codec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OptionCodec = void 0;
+exports.option = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,37 +18,19 @@ 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");
-class OptionCodec {
-    constructor(childCodec, parser = new binary_parser_1.Parser().uint8('option').choice('value', {
-        tag: 'option',
-        choices: {
-            0: new binary_parser_1.Parser(),
-            1: childCodec.parser
-        }
-    })) {
-        this.childCodec = childCodec;
-        this.parser = parser;
+const codec_1 = require("./codec");
+const undefinedCodec = new (class extends codec_1.Codec {
+    encode() {
+        return new Uint8Array([]);
     }
-    encode(input) {
-        const result = [input.option];
-        if (input.option === 1) {
-            result.push(...this.childCodec.encode(input.value));
-        }
-        return new Uint8Array(result);
-    }
-    decode(input) {
-        const result = this.parser.parse(input);
-        return {
-            ...result,
-            value: result.option ? this.childCodec.decode(result.value.value) : undefined
-        };
-    }
-    fromBytes(input) {
-        return {
-            option: input ? 1 : 0,
-            value: input ? this.childCodec.decode(input) : undefined
-        };
+    _decode() {
+        return undefined;
     }
+})();
+function option(codec) {
+    return new codec_1.EnumCodec('option', {
+        None: undefinedCodec,
+        Some: codec
+    });
 }
-exports.OptionCodec = OptionCodec;
+exports.option = option;

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

@@ -1,7 +1,7 @@
 import { ArrayCodec } from './array-codec';
-import { Either, EitherCodec } from './either-codec';
+import { Either } from './either-codec';
 import { AssetOutput } from './asset-output-codec';
 import { ContractOutput } from './contract-output-codec';
 export type Output = Either<AssetOutput, ContractOutput>;
-export declare const outputCodec: EitherCodec<AssetOutput, ContractOutput>;
+export declare const outputCodec: import("./codec").Codec<Either<AssetOutput, ContractOutput>>;
 export declare const outputsCodec: ArrayCodec<Either<AssetOutput, ContractOutput>>;

package/dist/src/codec/output-codec.js

@@ -22,5 +22,5 @@ const array_codec_1 = require("./array-codec");
 const either_codec_1 = require("./either-codec");
 const asset_output_codec_1 = require("./asset-output-codec");
 const contract_output_codec_1 = require("./contract-output-codec");
-exports.outputCodec = new either_codec_1.EitherCodec(asset_output_codec_1.assetOutputCodec, contract_output_codec_1.contractOutputCodec);
+exports.outputCodec = (0, either_codec_1.either)('output', asset_output_codec_1.assetOutputCodec, contract_output_codec_1.contractOutputCodec);
 exports.outputsCodec = new array_codec_1.ArrayCodec(exports.outputCodec);

package/dist/src/codec/reader.d.ts

@@ -0,0 +1,8 @@
+export declare class Reader {
+    private index;
+    private bytes;
+    constructor(bytes: Uint8Array);
+    consumeByte(): number;
+    consumeBytes(num: number): Uint8Array;
+    consumeAll(): Uint8Array;
+}

package/dist/src/codec/reader.js

@@ -0,0 +1,48 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reader = void 0;
+class Reader {
+    constructor(bytes) {
+        this.index = 0;
+        this.bytes = bytes;
+    }
+    consumeByte() {
+        if (this.index >= this.bytes.length) {
+            throw new Error(`Index out of range: unable to consume byte at index ${this.index}, data length: ${this.bytes.length}`);
+        }
+        const byte = this.bytes[`${this.index}`];
+        this.index += 1;
+        return byte;
+    }
+    consumeBytes(num) {
+        const from = this.index;
+        const to = this.index + num;
+        if (from > to || to > this.bytes.length) {
+            throw new Error(`Index out of range: unable to consume bytes from index ${from} to ${to}, data length: ${this.bytes.length}`);
+        }
+        const bytes = this.bytes.slice(from, to);
+        this.index = to;
+        return bytes;
+    }
+    consumeAll() {
+        return this.consumeBytes(this.bytes.length - this.index);
+    }
+}
+exports.Reader = Reader;

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

@@ -1,20 +1,12 @@
-import { Parser } from 'binary-parser';
-import { DecodedArray } from './array-codec';
 import { Codec } from './codec';
-import { DecodedMethod, Method } from './method-codec';
-import { OptionCodec } from './option-codec';
-export interface DecodedScript {
-    methods: DecodedArray<DecodedMethod>;
-}
+import { Method } from './method-codec';
+import { Reader } from './reader';
 export interface Script {
     methods: Method[];
 }
-export declare class ScriptCodec implements Codec<DecodedScript> {
-    parser: Parser;
-    encode(input: DecodedScript): Uint8Array;
-    decode(input: Uint8Array): DecodedScript;
-    decodeScript(input: Uint8Array): Script;
-    encodeScript(inputTxScript: Script): Uint8Array;
+export declare class ScriptCodec extends Codec<Script> {
+    encode(input: Script): Uint8Array;
+    _decode(input: Reader): Script;
 }
 export declare const scriptCodec: ScriptCodec;
-export declare const statefulScriptCodecOpt: OptionCodec<DecodedScript>;
+export declare const statefulScriptCodecOpt: Codec<import("./option-codec").Option<Script>>;

package/dist/src/codec/script-codec.js

@@ -18,33 +18,17 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.statefulScriptCodecOpt = exports.scriptCodec = exports.ScriptCodec = void 0;
-const binary_parser_1 = require("binary-parser");
+const codec_1 = require("./codec");
 const method_codec_1 = require("./method-codec");
 const option_codec_1 = require("./option-codec");
-const compact_int_codec_1 = require("./compact-int-codec");
-class ScriptCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start().nest('methods', {
-            type: method_codec_1.methodsCodec.parser
-        });
-    }
+class ScriptCodec extends codec_1.Codec {
     encode(input) {
-        return method_codec_1.methodsCodec.encode(input.methods.value);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-    decodeScript(input) {
-        const decodedTxScript = this.decode(input);
-        const methods = decodedTxScript.methods.value.map((decodedMethod) => method_codec_1.MethodCodec.toMethod(decodedMethod));
-        return { methods };
+        return method_codec_1.methodsCodec.encode(input.methods);
     }
-    encodeScript(inputTxScript) {
-        const methodLength = compact_int_codec_1.compactSignedIntCodec.fromI32(inputTxScript.methods.length);
-        const decodedMethods = inputTxScript.methods.map((method) => method_codec_1.MethodCodec.fromMethod(method));
-        return this.encode({ methods: { value: decodedMethods, length: methodLength } });
+    _decode(input) {
+        return { methods: method_codec_1.methodsCodec._decode(input) };
     }
 }
 exports.ScriptCodec = ScriptCodec;
 exports.scriptCodec = new ScriptCodec();
-exports.statefulScriptCodecOpt = new option_codec_1.OptionCodec(exports.scriptCodec);
+exports.statefulScriptCodecOpt = (0, option_codec_1.option)(exports.scriptCodec);

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

@@ -1,13 +1,5 @@
-import { Parser } from 'binary-parser';
 import { ArrayCodec } from './array-codec';
-import { Codec } from './codec';
-export interface Signature {
-    value: Uint8Array;
-}
-export declare class SignatureCodec implements Codec<Signature> {
-    parser: Parser;
-    encode(input: Signature): Uint8Array;
-    decode(input: Uint8Array): Signature;
-}
-export declare const signatureCodec: SignatureCodec;
-export declare const signaturesCodec: ArrayCodec<Signature>;
+import { FixedSizeCodec } from './codec';
+export type Signature = Uint8Array;
+export declare const signatureCodec: FixedSizeCodec;
+export declare const signaturesCodec: ArrayCodec<Uint8Array>;

package/dist/src/codec/signature-codec.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signaturesCodec = exports.signatureCodec = exports.SignatureCodec = void 0;
+exports.signaturesCodec = exports.signatureCodec = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,19 +18,7 @@ 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 array_codec_1 = require("./array-codec");
-class SignatureCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start().buffer('value', { length: 64 });
-    }
-    encode(input) {
-        return input.value;
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.SignatureCodec = SignatureCodec;
-exports.signatureCodec = new SignatureCodec();
+const codec_1 = require("./codec");
+exports.signatureCodec = new codec_1.FixedSizeCodec(64);
 exports.signaturesCodec = new array_codec_1.ArrayCodec(exports.signatureCodec);

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

@@ -0,0 +1,8 @@
+import { Codec } from './codec';
+import { Reader } from './reader';
+export declare class TimestampCodec extends Codec<bigint> {
+    static max: bigint;
+    encode(input: bigint): Uint8Array;
+    _decode(input: Reader): bigint;
+}
+export declare const timestampCodec: TimestampCodec;

package/dist/src/codec/timestamp-codec.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timestampCodec = exports.TimestampCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+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 utils_1 = require("../utils");
+const codec_1 = require("./codec");
+class TimestampCodec extends codec_1.Codec {
+    encode(input) {
+        (0, codec_1.assert)(input >= 0n && input < TimestampCodec.max, `Invalid timestamp: ${input}`);
+        const byteArray = new Uint8Array(8);
+        for (let index = 0; index < 8; index += 1) {
+            byteArray[`${index}`] = Number((input >> BigInt((7 - index) * 8)) & BigInt(0xff));
+        }
+        return byteArray;
+    }
+    _decode(input) {
+        const bytes = input.consumeBytes(8);
+        return BigInt(`0x${(0, utils_1.binToHex)(bytes)}`);
+    }
+}
+exports.TimestampCodec = TimestampCodec;
+TimestampCodec.max = 1n << 64n;
+exports.timestampCodec = new TimestampCodec();

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

@@ -1,15 +1,8 @@
-import { Parser } from 'binary-parser';
-import { DecodedCompactInt } from './compact-int-codec';
-import { Codec } from './codec';
+import { ObjectCodec } from './codec';
 import { ArrayCodec } from './array-codec';
 export interface Token {
     tokenId: Uint8Array;
-    amount: DecodedCompactInt;
+    amount: bigint;
 }
-export declare class TokenCodec implements Codec<Token> {
-    parser: Parser;
-    encode(input: Token): Uint8Array;
-    decode(input: Uint8Array): Token;
-}
-export declare const tokenCodec: TokenCodec;
+export declare const tokenCodec: ObjectCodec<Token>;
 export declare const tokensCodec: ArrayCodec<Token>;