@alephium/web3 1.4.0 → 1.5.1

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

@@ -18,49 +18,38 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.contractCodec = exports.ContractCodec = void 0;
-const binary_parser_1 = require("binary-parser");
 const array_codec_1 = require("./array-codec");
+const codec_1 = require("./codec");
 const compact_int_codec_1 = require("./compact-int-codec");
 const method_codec_1 = require("./method-codec");
 const utils_1 = require("../utils");
-const compactSignedIntsCodec = new array_codec_1.ArrayCodec(compact_int_codec_1.compactSignedIntCodec);
-class ContractCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .nest('fieldLength', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .nest('methodIndexes', {
-            type: compactSignedIntsCodec.parser
-        })
-            .buffer('methods', { readUntil: 'eof' });
-    }
+const i32sCodec = new array_codec_1.ArrayCodec(compact_int_codec_1.i32Codec);
+class ContractCodec extends codec_1.Codec {
     encode(input) {
-        return (0, utils_1.concatBytes)([
-            compact_int_codec_1.compactSignedIntCodec.encode(input.fieldLength),
-            compactSignedIntsCodec.encode(input.methodIndexes.value),
-            input.methods
-        ]);
+        return (0, utils_1.concatBytes)([compact_int_codec_1.i32Codec.encode(input.fieldLength), i32sCodec.encode(input.methodIndexes), input.methods]);
     }
-    decode(input) {
-        return this.parser.parse(input);
+    _decode(input) {
+        const fieldLength = compact_int_codec_1.i32Codec._decode(input);
+        const methodIndexes = i32sCodec._decode(input);
+        const methods = input.consumeAll();
+        return { fieldLength, methodIndexes, methods };
     }
     decodeContract(input) {
         const halfDecoded = this.decode(input);
-        const fieldLength = compact_int_codec_1.compactSignedIntCodec.toI32(halfDecoded.fieldLength);
-        const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compact_int_codec_1.compactSignedIntCodec.toI32(v));
+        const fieldLength = halfDecoded.fieldLength;
+        const methodIndexes = halfDecoded.methodIndexes;
         const methods = [];
         for (let i = 0, start = 0; i < methodIndexes.length; i++) {
             const end = methodIndexes[i];
-            const method = method_codec_1.MethodCodec.toMethod(method_codec_1.methodCodec.decode(halfDecoded.methods.slice(start, end)));
+            const method = method_codec_1.methodCodec.decode(halfDecoded.methods.slice(start, end));
             methods.push(method);
             start = end;
         }
         return { fieldLength, methods };
     }
     encodeContract(contract) {
-        const fieldLength = compact_int_codec_1.compactSignedIntCodec.fromI32(contract.fieldLength);
-        const methods = contract.methods.map((m) => method_codec_1.methodCodec.encode(method_codec_1.MethodCodec.fromMethod(m)));
+        const fieldLength = contract.fieldLength;
+        const methods = contract.methods.map((m) => method_codec_1.methodCodec.encode(m));
         let count = 0;
         const methodIndexes = Array.from(Array(methods.length).keys()).map((index) => {
             count += methods[`${index}`].length;
@@ -68,10 +57,7 @@ class ContractCodec {
         });
         const halfDecoded = {
             fieldLength,
-            methodIndexes: {
-                length: compact_int_codec_1.compactSignedIntCodec.fromI32(methodIndexes.length),
-                value: methodIndexes.map((value) => compact_int_codec_1.compactSignedIntCodec.fromI32(value))
-            },
+            methodIndexes: methodIndexes,
             methods: (0, utils_1.concatBytes)(methods)
         };
         return this.encode(halfDecoded);

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

@@ -1,19 +1,13 @@
-import { Parser } from 'binary-parser';
-import { DecodedArray } from './array-codec';
-import { DecodedCompactInt } from './compact-int-codec';
 import { P2C } from './lockup-script-codec';
-import { Codec } from './codec';
+import { ObjectCodec } from './codec';
 import { Token } from './token-codec';
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium';
 export interface ContractOutput {
-    amount: DecodedCompactInt;
+    amount: bigint;
     lockupScript: P2C;
-    tokens: DecodedArray<Token>;
+    tokens: Token[];
 }
-export declare class ContractOutputCodec implements Codec<ContractOutput> {
-    parser: Parser;
-    encode(input: ContractOutput): Uint8Array;
-    decode(input: Uint8Array): ContractOutput;
+export declare class ContractOutputCodec extends ObjectCodec<ContractOutput> {
     static convertToApiContractOutput(txIdBytes: Uint8Array, output: ContractOutput, index: number): ApiContractOutput;
     static convertToOutput(apiContractOutput: ApiContractOutput): ContractOutput;
 }

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

@@ -18,63 +18,43 @@ 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 lockup_script_codec_1 = require("./lockup-script-codec");
+const codec_1 = require("./codec");
 const token_codec_1 = require("./token-codec");
 const hash_1 = require("./hash");
 const utils_1 = require("../utils");
-const signed_int_codec_1 = require("./signed-int-codec");
-const lockup_script_codec_1 = require("./lockup-script-codec");
-class ContractOutputCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .nest('amount', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
-        })
-            .nest('lockupScript', {
-            type: binary_parser_1.Parser.start().buffer('contractId', { length: 32 })
-        })
-            .nest('tokens', {
-            type: token_codec_1.tokensCodec.parser
-        });
-    }
-    encode(input) {
-        const amount = compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount);
-        const lockupScript = input.lockupScript.contractId;
-        const tokens = token_codec_1.tokensCodec.encode(input.tokens.value);
-        return (0, utils_1.concatBytes)([amount, lockupScript, tokens]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
+const int_as_4bytes_codec_1 = require("./int-as-4bytes-codec");
+const lockup_script_codec_2 = require("./lockup-script-codec");
+class ContractOutputCodec extends codec_1.ObjectCodec {
     static convertToApiContractOutput(txIdBytes, output, index) {
-        const hint = (0, hash_1.createHint)(output.lockupScript.contractId);
-        const key = (0, utils_1.binToHex)((0, hash_1.blakeHash)((0, utils_1.concatBytes)([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
-        const attoAlphAmount = compact_int_codec_1.compactUnsignedIntCodec.toU256(output.amount).toString();
-        const address = utils_1.bs58.encode(new Uint8Array([0x03, ...output.lockupScript.contractId]));
-        const tokens = output.tokens.value.map((token) => {
+        const hint = (0, hash_1.createHint)(output.lockupScript);
+        const key = (0, utils_1.binToHex)((0, hash_1.blakeHash)((0, utils_1.concatBytes)([txIdBytes, int_as_4bytes_codec_1.intAs4BytesCodec.encode(index)])));
+        const attoAlphAmount = output.amount.toString();
+        const address = utils_1.bs58.encode(new Uint8Array([0x03, ...output.lockupScript]));
+        const tokens = output.tokens.map((token) => {
             return {
                 id: (0, utils_1.binToHex)(token.tokenId),
-                amount: compact_int_codec_1.compactUnsignedIntCodec.toU256(token.amount).toString()
+                amount: token.amount.toString()
             };
         });
         return { hint, key, attoAlphAmount, address, tokens, type: 'ContractOutput' };
     }
     static convertToOutput(apiContractOutput) {
-        const amount = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(apiContractOutput.attoAlphAmount));
-        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(utils_1.bs58.decode(apiContractOutput.address)).script;
-        const tokensValue = apiContractOutput.tokens.map((token) => {
+        const amount = BigInt(apiContractOutput.attoAlphAmount);
+        const lockupScript = lockup_script_codec_2.lockupScriptCodec.decode(utils_1.bs58.decode(apiContractOutput.address)).value;
+        const tokens = apiContractOutput.tokens.map((token) => {
             return {
                 tokenId: (0, utils_1.hexToBinUnsafe)(token.id),
-                amount: compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(token.amount))
+                amount: BigInt(token.amount)
             };
         });
-        const tokens = {
-            length: compact_int_codec_1.compactSignedIntCodec.fromI32(tokensValue.length),
-            value: tokensValue
-        };
         return { amount, lockupScript, tokens };
     }
 }
 exports.ContractOutputCodec = ContractOutputCodec;
-exports.contractOutputCodec = new ContractOutputCodec();
+exports.contractOutputCodec = new ContractOutputCodec({
+    amount: compact_int_codec_1.u256Codec,
+    lockupScript: lockup_script_codec_1.p2cCodec,
+    tokens: token_codec_1.tokensCodec
+});

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

@@ -1,14 +1,8 @@
-import { Parser } from 'binary-parser';
 import { ArrayCodec } from './array-codec';
-import { Codec } from './codec';
+import { ObjectCodec } from './codec';
 export interface ContractOutputRef {
     hint: number;
     key: Uint8Array;
 }
-export declare class ContractOutputRefCodec implements Codec<ContractOutputRef> {
-    parser: Parser;
-    encode(input: ContractOutputRef): Uint8Array;
-    decode(input: Uint8Array): ContractOutputRef;
-}
-export declare const contractOutputRefCodec: ContractOutputRefCodec;
+export declare const contractOutputRefCodec: ObjectCodec<ContractOutputRef>;
 export declare const contractOutputRefsCodec: ArrayCodec<ContractOutputRef>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.contractOutputRefsCodec = exports.contractOutputRefCodec = exports.ContractOutputRefCodec = void 0;
+exports.contractOutputRefsCodec = exports.contractOutputRefCodec = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,21 +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 signed_int_codec_1 = require("./signed-int-codec");
-const utils_1 = require("../utils");
-class ContractOutputRefCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start().int32('hint').buffer('key', { length: 32 });
-    }
-    encode(input) {
-        return (0, utils_1.concatBytes)([signed_int_codec_1.signedIntCodec.encode(input.hint), input.key]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.ContractOutputRefCodec = ContractOutputRefCodec;
-exports.contractOutputRefCodec = new ContractOutputRefCodec();
+const codec_1 = require("./codec");
+const int_as_4bytes_codec_1 = require("./int-as-4bytes-codec");
+exports.contractOutputRefCodec = new codec_1.ObjectCodec({
+    hint: int_as_4bytes_codec_1.intAs4BytesCodec,
+    key: codec_1.byte32Codec
+});
 exports.contractOutputRefsCodec = new array_codec_1.ArrayCodec(exports.contractOutputRefCodec);

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

@@ -1,16 +1,9 @@
-import { Parser } from 'binary-parser';
 import { Codec } from './codec';
-export interface Either<L, R> {
-    either: number;
-    value: L | R;
-}
-export declare class EitherCodec<L, R> implements Codec<Either<L, R>> {
-    private leftCodec;
-    private rightCodec;
-    parser: Parser;
-    constructor(leftCodec: Codec<L>, rightCodec: Codec<R>, parser?: Parser);
-    encode(input: Either<L, R>): Uint8Array;
-    decode(input: Uint8Array): Either<L, R>;
-    fromLeft(left: L): Either<L, R>;
-    fromRight(right: R): Either<L, R>;
-}
+export type Either<L, R> = {
+    kind: 'Left';
+    value: L;
+} | {
+    kind: 'Right';
+    value: R;
+};
+export declare function either<L, R>(name: string, l: Codec<L>, r: Codec<R>): Codec<Either<L, R>>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EitherCodec = void 0;
+exports.either = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,49 +18,8 @@ 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 EitherCodec {
-    constructor(leftCodec, rightCodec, parser = binary_parser_1.Parser.start()
-        .uint8('either')
-        .choice('value', {
-        tag: 'either',
-        choices: {
-            0: leftCodec.parser,
-            1: rightCodec.parser
-        }
-    })) {
-        this.leftCodec = leftCodec;
-        this.rightCodec = rightCodec;
-        this.parser = parser;
-    }
-    encode(input) {
-        const result = [input.either];
-        if (input.either === 0) {
-            result.push(...this.leftCodec.encode(input.value));
-        }
-        else {
-            result.push(...this.rightCodec.encode(input.value));
-        }
-        return new Uint8Array(result);
-    }
-    decode(input) {
-        const result = this.parser.parse(input);
-        return {
-            ...result,
-            value: result.either === 0 ? this.leftCodec.decode(result.value.value) : this.rightCodec.decode(result.value.value)
-        };
-    }
-    fromLeft(left) {
-        return {
-            either: 0,
-            value: left
-        };
-    }
-    fromRight(right) {
-        return {
-            either: 1,
-            value: right
-        };
-    }
+const codec_1 = require("./codec");
+function either(name, l, r) {
+    return new codec_1.EnumCodec(name, { Left: l, Right: r });
 }
-exports.EitherCodec = EitherCodec;
+exports.either = either;

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

@@ -2,7 +2,7 @@ export * from './array-codec';
 export * as assetOutput from './asset-output-codec';
 export * from './bigint-codec';
 export * from './bytestring-codec';
-export * from './codec';
+export { Codec, boolCodec } from './codec';
 export * from './compact-int-codec';
 export * as contractOutput from './contract-output-codec';
 export * from './contract-output-ref-codec';
@@ -11,12 +11,13 @@ export * from './input-codec';
 export * from './instr-codec';
 export * as lockupScript from './lockup-script-codec';
 export * as unlockScript from './unlock-script-codec';
-export * from './long-codec';
+export * as val from './val';
+export * from './timestamp-codec';
 export * from './method-codec';
 export * from './option-codec';
 export * as script from './script-codec';
 export * from './signature-codec';
-export * from './signed-int-codec';
+export * from './int-as-4bytes-codec';
 export * as token from './token-codec';
 export * from './transaction-codec';
 export * from './unsigned-tx-codec';

package/dist/src/codec/index.js

@@ -43,12 +43,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.contract = exports.token = exports.script = exports.unlockScript = exports.lockupScript = exports.contractOutput = exports.assetOutput = void 0;
+exports.contract = exports.token = exports.script = exports.val = exports.unlockScript = exports.lockupScript = exports.contractOutput = exports.boolCodec = exports.Codec = exports.assetOutput = void 0;
 __exportStar(require("./array-codec"), exports);
 exports.assetOutput = __importStar(require("./asset-output-codec"));
 __exportStar(require("./bigint-codec"), exports);
 __exportStar(require("./bytestring-codec"), exports);
-__exportStar(require("./codec"), exports);
+var codec_1 = require("./codec");
+Object.defineProperty(exports, "Codec", { enumerable: true, get: function () { return codec_1.Codec; } });
+Object.defineProperty(exports, "boolCodec", { enumerable: true, get: function () { return codec_1.boolCodec; } });
 __exportStar(require("./compact-int-codec"), exports);
 exports.contractOutput = __importStar(require("./contract-output-codec"));
 __exportStar(require("./contract-output-ref-codec"), exports);
@@ -57,12 +59,13 @@ __exportStar(require("./input-codec"), exports);
 __exportStar(require("./instr-codec"), exports);
 exports.lockupScript = __importStar(require("./lockup-script-codec"));
 exports.unlockScript = __importStar(require("./unlock-script-codec"));
-__exportStar(require("./long-codec"), exports);
+exports.val = __importStar(require("./val"));
+__exportStar(require("./timestamp-codec"), exports);
 __exportStar(require("./method-codec"), exports);
 __exportStar(require("./option-codec"), exports);
 exports.script = __importStar(require("./script-codec"));
 __exportStar(require("./signature-codec"), exports);
-__exportStar(require("./signed-int-codec"), exports);
+__exportStar(require("./int-as-4bytes-codec"), exports);
 exports.token = __importStar(require("./token-codec"));
 __exportStar(require("./transaction-codec"), exports);
 __exportStar(require("./unsigned-tx-codec"), exports);

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

@@ -1,19 +1,13 @@
-import { Parser } from 'binary-parser';
 import { AssetInput } from '../api/api-alephium';
 import { UnlockScript } from './unlock-script-codec';
-import { Codec } from './codec';
+import { ObjectCodec } from './codec';
 import { ArrayCodec } from './array-codec';
 export interface Input {
-    outputRef: {
-        hint: number;
-        key: Uint8Array;
-    };
+    hint: number;
+    key: Uint8Array;
     unlockScript: UnlockScript;
 }
-export declare class InputCodec implements Codec<Input> {
-    parser: Parser;
-    encode(input: Input): Uint8Array;
-    decode(input: Uint8Array): Input;
+export declare class InputCodec extends ObjectCodec<Input> {
     static toAssetInputs(inputs: Input[]): AssetInput[];
     static fromAssetInputs(inputs: AssetInput[]): Input[];
 }

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

@@ -1,52 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inputsCodec = exports.inputCodec = exports.InputCodec = 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 binary_parser_1 = require("binary-parser");
 const utils_1 = require("../utils");
 const unlock_script_codec_1 = require("./unlock-script-codec");
-const signed_int_codec_1 = require("./signed-int-codec");
+const codec_1 = require("./codec");
 const array_codec_1 = require("./array-codec");
-class InputCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .nest('outputRef', {
-            type: binary_parser_1.Parser.start().int32('hint').buffer('key', { length: 32 })
-        })
-            .nest('unlockScript', {
-            type: unlock_script_codec_1.unlockScriptCodec.parser
-        });
-    }
-    encode(input) {
-        return (0, utils_1.concatBytes)([
-            signed_int_codec_1.signedIntCodec.encode(input.outputRef.hint),
-            input.outputRef.key,
-            unlock_script_codec_1.unlockScriptCodec.encode(input.unlockScript)
-        ]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
+const int_as_4bytes_codec_1 = require("./int-as-4bytes-codec");
+class InputCodec extends codec_1.ObjectCodec {
     static toAssetInputs(inputs) {
         return inputs.map((input) => {
-            const hint = input.outputRef.hint;
-            const key = (0, utils_1.binToHex)(input.outputRef.key);
+            const hint = input.hint;
+            const key = (0, utils_1.binToHex)(input.key);
             const unlockScript = unlock_script_codec_1.unlockScriptCodec.encode(input.unlockScript);
             return {
                 outputRef: { hint, key },
@@ -59,13 +23,14 @@ class InputCodec {
             const hint = input.outputRef.hint;
             const key = (0, utils_1.hexToBinUnsafe)(input.outputRef.key);
             const unlockScript = unlock_script_codec_1.unlockScriptCodec.decode((0, utils_1.hexToBinUnsafe)(input.unlockScript));
-            return {
-                outputRef: { hint, key },
-                unlockScript
-            };
+            return { hint, key, unlockScript };
         });
     }
 }
 exports.InputCodec = InputCodec;
-exports.inputCodec = new InputCodec();
+exports.inputCodec = new InputCodec({
+    hint: int_as_4bytes_codec_1.intAs4BytesCodec,
+    key: codec_1.byte32Codec,
+    unlockScript: unlock_script_codec_1.unlockScriptCodec
+});
 exports.inputsCodec = new array_codec_1.ArrayCodec(exports.inputCodec);