@alephium/web3 1.4.0 → 1.5.0

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

@@ -17,30 +17,12 @@ 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.tokensCodec = exports.tokenCodec = exports.TokenCodec = void 0;
-const binary_parser_1 = require("binary-parser");
+exports.tokensCodec = exports.tokenCodec = void 0;
 const compact_int_codec_1 = require("./compact-int-codec");
+const codec_1 = require("./codec");
 const array_codec_1 = require("./array-codec");
-const utils_1 = require("../utils");
-class TokenCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .buffer('tokenId', {
-            length: 32
-        })
-            .nest('amount', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
-        });
-    }
-    encode(input) {
-        const tokenId = input.tokenId;
-        const amount = compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount);
-        return (0, utils_1.concatBytes)([tokenId, amount]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.TokenCodec = TokenCodec;
-exports.tokenCodec = new TokenCodec();
+exports.tokenCodec = new codec_1.ObjectCodec({
+    tokenId: codec_1.byte32Codec,
+    amount: compact_int_codec_1.u256Codec
+});
 exports.tokensCodec = new array_codec_1.ArrayCodec(exports.tokenCodec);

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

@@ -1,23 +1,18 @@
-import { Parser } from 'binary-parser';
-import { DecodedArray } from './array-codec';
 import { UnsignedTx } from './unsigned-tx-codec';
 import { Signature } from './signature-codec';
 import { ContractOutputRef } from './contract-output-ref-codec';
 import { Transaction as ApiTransaction } from '../api/api-alephium';
-import { Codec } from './codec';
+import { ObjectCodec } from './codec';
 import { Output } from './output-codec';
 export interface Transaction {
     unsigned: UnsignedTx;
     scriptExecutionOk: number;
-    contractInputs: DecodedArray<ContractOutputRef>;
-    generatedOutputs: DecodedArray<Output>;
-    inputSignatures: DecodedArray<Signature>;
-    scriptSignatures: DecodedArray<Signature>;
+    contractInputs: ContractOutputRef[];
+    generatedOutputs: Output[];
+    inputSignatures: Signature[];
+    scriptSignatures: Signature[];
 }
-export declare class TransactionCodec implements Codec<Transaction> {
-    parser: Parser;
-    encode(decodedTx: Transaction): Uint8Array;
-    decode(input: Uint8Array): Transaction;
+export declare class TransactionCodec extends ObjectCodec<Transaction> {
     encodeApiTransaction(input: ApiTransaction): Uint8Array;
     decodeApiTransaction(input: Uint8Array): ApiTransaction;
     static toApiTransaction(transaction: Transaction): ApiTransaction;

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

@@ -18,67 +18,35 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transactionCodec = exports.TransactionCodec = void 0;
-const binary_parser_1 = require("binary-parser");
 const unsigned_tx_codec_1 = require("./unsigned-tx-codec");
 const signature_codec_1 = require("./signature-codec");
 const contract_output_ref_codec_1 = require("./contract-output-ref-codec");
 const asset_output_codec_1 = require("./asset-output-codec");
 const contract_output_codec_1 = require("./contract-output-codec");
 const utils_1 = require("../utils");
+const codec_1 = require("./codec");
 const output_codec_1 = require("./output-codec");
-class TransactionCodec {
-    constructor() {
-        this.parser = new binary_parser_1.Parser()
-            .nest('unsigned', {
-            type: unsigned_tx_codec_1.unsignedTxCodec.parser
-        })
-            .uint8('scriptExecutionOk')
-            .nest('contractInputs', {
-            type: contract_output_ref_codec_1.contractOutputRefsCodec.parser
-        })
-            .nest('generatedOutputs', {
-            type: output_codec_1.outputsCodec.parser
-        })
-            .nest('inputSignatures', {
-            type: signature_codec_1.signaturesCodec.parser
-        })
-            .nest('scriptSignatures', {
-            type: signature_codec_1.signaturesCodec.parser
-        });
-    }
-    encode(decodedTx) {
-        return (0, utils_1.concatBytes)([
-            unsigned_tx_codec_1.unsignedTxCodec.encode(decodedTx.unsigned),
-            new Uint8Array([decodedTx.scriptExecutionOk]),
-            contract_output_ref_codec_1.contractOutputRefsCodec.encode(decodedTx.contractInputs.value),
-            output_codec_1.outputsCodec.encode(decodedTx.generatedOutputs.value),
-            signature_codec_1.signaturesCodec.encode(decodedTx.inputSignatures.value),
-            signature_codec_1.signaturesCodec.encode(decodedTx.scriptSignatures.value)
-        ]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
+class TransactionCodec extends codec_1.ObjectCodec {
     encodeApiTransaction(input) {
         const decodedTx = TransactionCodec.fromApiTransaction(input);
         return this.encode(decodedTx);
     }
     decodeApiTransaction(input) {
-        const decodedTx = this.parser.parse(input);
+        const decodedTx = this.decode(input);
         return TransactionCodec.toApiTransaction(decodedTx);
     }
     static toApiTransaction(transaction) {
         const txId = unsigned_tx_codec_1.UnsignedTxCodec.txId(transaction.unsigned);
         const unsigned = unsigned_tx_codec_1.UnsignedTxCodec.toApiUnsignedTx(transaction.unsigned);
         const scriptExecutionOk = !!transaction.scriptExecutionOk;
-        const contractInputs = transaction.contractInputs.value.map((contractInput) => {
+        const contractInputs = transaction.contractInputs.map((contractInput) => {
             const hint = contractInput.hint;
             const key = (0, utils_1.binToHex)(contractInput.key);
             return { hint, key };
         });
         const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
-        const generatedOutputs = transaction.generatedOutputs.value.map((output, index) => {
-            if (output.either === 0) {
+        const generatedOutputs = transaction.generatedOutputs.map((output, index) => {
+            if (output.kind === 'Left') {
                 const fixedAssetOutput = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutput(txIdBytes, output.value, index);
                 return { ...fixedAssetOutput, type: 'AssetOutput' };
             }
@@ -86,8 +54,8 @@ class TransactionCodec {
                 return contract_output_codec_1.ContractOutputCodec.convertToApiContractOutput(txIdBytes, output.value, index);
             }
         });
-        const inputSignatures = transaction.inputSignatures.value.map((signature) => (0, utils_1.binToHex)(signature.value));
-        const scriptSignatures = transaction.scriptSignatures.value.map((signature) => (0, utils_1.binToHex)(signature.value));
+        const inputSignatures = transaction.inputSignatures.map((signature) => (0, utils_1.binToHex)(signature));
+        const scriptSignatures = transaction.scriptSignatures.map((signature) => (0, utils_1.binToHex)(signature));
         return { unsigned, scriptExecutionOk, contractInputs, generatedOutputs, inputSignatures, scriptSignatures };
     }
     static fromApiTransaction(tx) {
@@ -98,30 +66,37 @@ class TransactionCodec {
         });
         const generatedOutputs = tx.generatedOutputs.map((output) => {
             if (output.type === 'AssetOutput') {
-                return output_codec_1.outputCodec.fromLeft(asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutput(output));
+                return { kind: 'Left', value: asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutput(output) };
             }
             else if (output.type === 'ContractOutput') {
-                return output_codec_1.outputCodec.fromRight(contract_output_codec_1.ContractOutputCodec.convertToOutput(output));
+                return { kind: 'Right', value: contract_output_codec_1.ContractOutputCodec.convertToOutput(output) };
             }
             else {
                 throw new Error('Invalid output type');
             }
         });
         const inputSignatures = tx.inputSignatures.map((signature) => {
-            return { value: (0, utils_1.hexToBinUnsafe)(signature) };
+            return (0, utils_1.hexToBinUnsafe)(signature);
         });
         const scriptSignatures = tx.scriptSignatures.map((signature) => {
-            return { value: (0, utils_1.hexToBinUnsafe)(signature) };
+            return (0, utils_1.hexToBinUnsafe)(signature);
         });
         return {
             unsigned,
             scriptExecutionOk,
-            contractInputs: contract_output_ref_codec_1.contractOutputRefsCodec.fromArray(contractInputs),
-            generatedOutputs: output_codec_1.outputsCodec.fromArray(generatedOutputs),
-            inputSignatures: signature_codec_1.signaturesCodec.fromArray(inputSignatures),
-            scriptSignatures: signature_codec_1.signaturesCodec.fromArray(scriptSignatures)
+            contractInputs: contractInputs,
+            generatedOutputs: generatedOutputs,
+            inputSignatures: inputSignatures,
+            scriptSignatures: scriptSignatures
         };
     }
 }
 exports.TransactionCodec = TransactionCodec;
-exports.transactionCodec = new TransactionCodec();
+exports.transactionCodec = new TransactionCodec({
+    unsigned: unsigned_tx_codec_1.unsignedTxCodec,
+    scriptExecutionOk: codec_1.byteCodec,
+    contractInputs: contract_output_ref_codec_1.contractOutputRefsCodec,
+    generatedOutputs: output_codec_1.outputsCodec,
+    inputSignatures: signature_codec_1.signaturesCodec,
+    scriptSignatures: signature_codec_1.signaturesCodec
+});

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

@@ -1,39 +1,28 @@
-import { Parser } from 'binary-parser';
-import { DecodedArray } from './array-codec';
-import { DecodedCompactInt } from './compact-int-codec';
-import { Codec } from './codec';
-import { DecodedScript } from './script-codec';
-import { ByteString } from './bytestring-codec';
-import { LockupScript } from './lockup-script-codec';
-export interface P2PKH {
-    publicKey: Uint8Array;
-}
-export interface P2MPKH {
-    publicKeys: DecodedArray<{
-        publicKey: P2PKH;
-        index: DecodedCompactInt;
-    }>;
-}
-export interface Val {
-    type: number;
-    val: number | DecodedCompactInt | ByteString | LockupScript;
+import { EnumCodec } from './codec';
+import { Script } from './script-codec';
+import { Val } from './val';
+export type P2PKH = Uint8Array;
+export interface KeyWithIndex {
+    publicKey: P2PKH;
+    index: number;
 }
+export type P2MPKH = KeyWithIndex[];
 export interface P2SH {
-    script: DecodedScript;
-    params: DecodedArray<Val>;
-}
-export declare class P2SHCodec implements Codec<P2SH> {
-    parser: Parser;
-    encode(input: P2SH): Uint8Array;
-    decode(input: Uint8Array): P2SH;
-}
-export interface UnlockScript {
-    scriptType: number;
-    script: P2PKH | P2MPKH | P2SH;
-}
-export declare class UnlockScriptCodec implements Codec<UnlockScript> {
-    parser: Parser;
-    encode(input: UnlockScript): Uint8Array;
-    decode(input: Uint8Array): UnlockScript;
+    script: Script;
+    params: Val[];
 }
-export declare const unlockScriptCodec: UnlockScriptCodec;
+export type SameAsPrevious = 'SameAsPrevious';
+export type UnlockScript = {
+    kind: 'P2PKH';
+    value: P2PKH;
+} | {
+    kind: 'P2MPKH';
+    value: P2MPKH;
+} | {
+    kind: 'P2SH';
+    value: P2SH;
+} | {
+    kind: 'SameAsPrevious';
+    value: SameAsPrevious;
+};
+export declare const unlockScriptCodec: EnumCodec<UnlockScript>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unlockScriptCodec = exports.UnlockScriptCodec = exports.P2SHCodec = void 0;
+exports.unlockScriptCodec = void 0;
 /*
 Copyright 2018 - 2022 The Alephium Authors
 This file is part of the alephium project.
@@ -18,153 +18,32 @@ 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 script_codec_1 = require("./script-codec");
-const bytestring_codec_1 = require("./bytestring-codec");
-const lockup_script_codec_1 = require("./lockup-script-codec");
-const utils_1 = require("../utils");
-class P2PKHCodec {
-    constructor() {
-        this.parser = (0, codec_1.fixedSizeBytes)('publicKey', 33);
-    }
-    encode(input) {
-        return input.publicKey;
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-const p2pkhCodec = new P2PKHCodec();
-class P2MPKHCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start().nest('publicKeys', {
-            type: array_codec_1.ArrayCodec.arrayParser(binary_parser_1.Parser.start()
-                .nest('publicKey', { type: p2pkhCodec.parser })
-                .nest('index', { type: compact_int_codec_1.compactUnsignedIntCodec.parser }))
-        });
-    }
-    encode(input) {
-        return (0, utils_1.concatBytes)([
-            compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length),
-            ...input.publicKeys.value.map((v) => {
-                return (0, utils_1.concatBytes)([v.publicKey.publicKey, compact_int_codec_1.compactUnsignedIntCodec.encode(v.index)]);
-            })
-        ]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-const p2mpkhCodec = new P2MPKHCodec();
-class ValCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .int8('type')
-            .choice('val', {
-            tag: 'type',
-            choices: {
-                0x00: new binary_parser_1.Parser().uint8('value'),
-                0x01: compact_int_codec_1.compactSignedIntCodec.parser,
-                0x02: compact_int_codec_1.compactUnsignedIntCodec.parser,
-                0x03: bytestring_codec_1.byteStringCodec.parser,
-                0x04: lockup_script_codec_1.lockupScriptCodec.parser // Address
-            }
-        });
-    }
-    encode(input) {
-        const valType = input.type;
-        if (valType === 0x00) {
-            // Boolean
-            return new Uint8Array([valType, input.val]);
-        }
-        else if (valType === 0x01) {
-            // I256
-            return new Uint8Array([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
-        }
-        else if (valType === 0x02) {
-            // U256
-            return new Uint8Array([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
-        }
-        else if (valType === 0x03) {
-            // ByteVec
-            return new Uint8Array([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
-        }
-        else if (valType === 0x04) {
-            // Address
-            return new Uint8Array([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
-        }
-        else {
-            throw new Error(`ValCodec: unsupported val type: ${valType}`);
-        }
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-const valCodec = new ValCodec();
-const valsCodec = new array_codec_1.ArrayCodec(valCodec);
-class P2SHCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .nest('script', {
-            type: script_codec_1.scriptCodec.parser
-        })
-            .nest('params', {
-            type: valsCodec.parser
-        });
-    }
-    encode(input) {
-        return (0, utils_1.concatBytes)([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.P2SHCodec = P2SHCodec;
-const p2shCodec = new P2SHCodec();
-class UnlockScriptCodec {
-    constructor() {
-        this.parser = binary_parser_1.Parser.start()
-            .uint8('scriptType')
-            .choice('script', {
-            tag: 'scriptType',
-            choices: {
-                0: p2pkhCodec.parser,
-                1: p2mpkhCodec.parser,
-                2: p2shCodec.parser,
-                3: binary_parser_1.Parser.start() // TODO: SameAsPrevious, FIXME
-            }
-        });
-    }
-    encode(input) {
-        const scriptType = input.scriptType;
-        const inputUnLockScript = input.script;
-        if (scriptType === 0) {
-            // P2PKH
-            return new Uint8Array([scriptType, ...p2pkhCodec.encode(inputUnLockScript)]);
-        }
-        else if (scriptType === 1) {
-            // P2MPKH
-            return new Uint8Array([scriptType, ...p2mpkhCodec.encode(inputUnLockScript)]);
-        }
-        else if (scriptType === 2) {
-            // P2SH
-            return new Uint8Array([scriptType, ...p2shCodec.encode(inputUnLockScript)]);
-        }
-        else if (scriptType === 3) {
-            // SameAsPrevious
-            return new Uint8Array([scriptType]);
-        }
-        else {
-            throw new Error(`TODO: encode unlock script: ${scriptType}`);
-        }
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
-}
-exports.UnlockScriptCodec = UnlockScriptCodec;
-exports.unlockScriptCodec = new UnlockScriptCodec();
+const val_1 = require("./val");
+const p2pkhCodec = new codec_1.FixedSizeCodec(33);
+const keyWithIndexCodec = new codec_1.ObjectCodec({
+    publicKey: p2pkhCodec,
+    index: compact_int_codec_1.i32Codec
+});
+const p2mpkhCodec = new array_codec_1.ArrayCodec(keyWithIndexCodec);
+const p2shCodec = new codec_1.ObjectCodec({
+    script: script_codec_1.scriptCodec,
+    params: val_1.valsCodec
+});
+const sameAsPreviousCodec = new (class extends codec_1.Codec {
+    encode() {
+        return new Uint8Array([]);
+    }
+    _decode() {
+        return 'SameAsPrevious';
+    }
+})();
+exports.unlockScriptCodec = new codec_1.EnumCodec('unlock script', {
+    P2PKH: p2pkhCodec,
+    P2MPKH: p2mpkhCodec,
+    P2SH: p2shCodec,
+    SameAsPrevious: sameAsPreviousCodec
+});

package/dist/src/codec/unsigned-tx-codec.d.ts

@@ -1,25 +1,19 @@
-import { Parser } from 'binary-parser';
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium';
-import { DecodedScript } from './script-codec';
+import { Script } from './script-codec';
 import { Option } from './option-codec';
-import { DecodedCompactInt } from './compact-int-codec';
 import { Input } from './input-codec';
 import { AssetOutput } from './asset-output-codec';
-import { DecodedArray } from './array-codec';
-import { Codec } from './codec';
+import { ObjectCodec } from './codec';
 export interface UnsignedTx {
     version: number;
     networkId: number;
-    statefulScript: Option<DecodedScript>;
-    gasAmount: DecodedCompactInt;
-    gasPrice: DecodedCompactInt;
-    inputs: DecodedArray<Input>;
-    fixedOutputs: DecodedArray<AssetOutput>;
+    statefulScript: Option<Script>;
+    gasAmount: number;
+    gasPrice: bigint;
+    inputs: Input[];
+    fixedOutputs: AssetOutput[];
 }
-export declare class UnsignedTxCodec implements Codec<UnsignedTx> {
-    parser: Parser;
-    encode(decodedUnsignedTx: UnsignedTx): Uint8Array;
-    decode(input: Uint8Array): UnsignedTx;
+export declare class UnsignedTxCodec extends ObjectCodec<UnsignedTx> {
     encodeApiUnsignedTx(input: ApiUnsignedTx): Uint8Array;
     decodeApiUnsignedTx(input: Uint8Array): ApiUnsignedTx;
     static txId(unsignedTx: UnsignedTx): string;

package/dist/src/codec/unsigned-tx-codec.js

@@ -1,70 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unsignedTxCodec = exports.UnsignedTxCodec = 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 script_codec_1 = require("./script-codec");
 const compact_int_codec_1 = require("./compact-int-codec");
 const input_codec_1 = require("./input-codec");
 const asset_output_codec_1 = require("./asset-output-codec");
 const hash_1 = require("./hash");
-class UnsignedTxCodec {
-    constructor() {
-        this.parser = new binary_parser_1.Parser()
-            .uint8('version')
-            .uint8('networkId')
-            .nest('statefulScript', {
-            type: script_codec_1.statefulScriptCodecOpt.parser
-        })
-            .nest('gasAmount', {
-            type: compact_int_codec_1.compactSignedIntCodec.parser
-        })
-            .nest('gasPrice', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
-        })
-            .nest('inputs', {
-            type: input_codec_1.inputsCodec.parser
-        })
-            .nest('fixedOutputs', {
-            type: asset_output_codec_1.assetOutputsCodec.parser
-        });
-    }
-    encode(decodedUnsignedTx) {
-        return (0, utils_1.concatBytes)([
-            new Uint8Array([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
-            script_codec_1.statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
-            compact_int_codec_1.compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
-            compact_int_codec_1.compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
-            input_codec_1.inputsCodec.encode(decodedUnsignedTx.inputs.value),
-            asset_output_codec_1.assetOutputsCodec.encode(decodedUnsignedTx.fixedOutputs.value)
-        ]);
-    }
-    decode(input) {
-        return this.parser.parse(input);
-    }
+const codec_1 = require("./codec");
+class UnsignedTxCodec extends codec_1.ObjectCodec {
     encodeApiUnsignedTx(input) {
         const decoded = UnsignedTxCodec.fromApiUnsignedTx(input);
         return this.encode(decoded);
     }
     decodeApiUnsignedTx(input) {
-        const decoded = this.parser.parse(input);
+        const decoded = this.decode(input);
         return UnsignedTxCodec.toApiUnsignedTx(decoded);
     }
     static txId(unsignedTx) {
@@ -75,12 +25,12 @@ class UnsignedTxCodec {
         const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
         const version = unsigned.version;
         const networkId = unsigned.networkId;
-        const gasAmount = compact_int_codec_1.compactSignedIntCodec.toI32(unsigned.gasAmount);
-        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.toU256(unsigned.gasPrice).toString();
-        const inputs = input_codec_1.InputCodec.toAssetInputs(unsigned.inputs.value);
-        const fixedOutputs = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value);
+        const gasAmount = unsigned.gasAmount;
+        const gasPrice = unsigned.gasPrice.toString();
+        const inputs = input_codec_1.InputCodec.toAssetInputs(unsigned.inputs);
+        const fixedOutputs = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs);
         let scriptOpt = undefined;
-        if (unsigned.statefulScript.option === 1) {
+        if (unsigned.statefulScript.kind === 'Some') {
             scriptOpt = (0, utils_1.binToHex)(script_codec_1.scriptCodec.encode(unsigned.statefulScript.value));
         }
         return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs };
@@ -88,15 +38,23 @@ class UnsignedTxCodec {
     static fromApiUnsignedTx(unsignedTx) {
         const version = unsignedTx.version;
         const networkId = unsignedTx.networkId;
-        const gasAmount = compact_int_codec_1.compactSignedIntCodec.fromI32(unsignedTx.gasAmount);
-        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(unsignedTx.gasPrice));
-        const inputsValue = input_codec_1.InputCodec.fromAssetInputs(unsignedTx.inputs);
-        const inputs = input_codec_1.inputsCodec.fromArray(inputsValue);
-        const fixedOutputsValue = asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs);
-        const fixedOutputs = asset_output_codec_1.assetOutputsCodec.fromArray(fixedOutputsValue);
-        const statefulScript = script_codec_1.statefulScriptCodecOpt.fromBytes(unsignedTx.scriptOpt ? (0, utils_1.hexToBinUnsafe)(unsignedTx.scriptOpt) : undefined);
+        const gasAmount = unsignedTx.gasAmount;
+        const gasPrice = BigInt(unsignedTx.gasPrice);
+        const inputs = input_codec_1.InputCodec.fromAssetInputs(unsignedTx.inputs);
+        const fixedOutputs = asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs);
+        const statefulScript = unsignedTx.scriptOpt !== undefined
+            ? { kind: 'Some', value: script_codec_1.scriptCodec.decode((0, utils_1.hexToBinUnsafe)(unsignedTx.scriptOpt)) }
+            : { kind: 'None', value: undefined };
         return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript };
     }
 }
 exports.UnsignedTxCodec = UnsignedTxCodec;
-exports.unsignedTxCodec = new UnsignedTxCodec();
+exports.unsignedTxCodec = new UnsignedTxCodec({
+    version: codec_1.byteCodec,
+    networkId: codec_1.byteCodec,
+    statefulScript: script_codec_1.statefulScriptCodecOpt,
+    gasAmount: compact_int_codec_1.i32Codec,
+    gasPrice: compact_int_codec_1.u256Codec,
+    inputs: input_codec_1.inputsCodec,
+    fixedOutputs: asset_output_codec_1.assetOutputsCodec
+});

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

@@ -0,0 +1,27 @@
+import { ByteString } from './bytestring-codec';
+import { EnumCodec } from './codec';
+import { LockupScript } from './lockup-script-codec';
+import { ArrayCodec } from './array-codec';
+export type ValBool = {
+    kind: 'Bool';
+    value: boolean;
+};
+export type ValI256 = {
+    kind: 'I256';
+    value: bigint;
+};
+export type ValU256 = {
+    kind: 'U256';
+    value: bigint;
+};
+export type ValByteVec = {
+    kind: 'ByteVec';
+    value: ByteString;
+};
+export type ValAddress = {
+    kind: 'Address';
+    value: LockupScript;
+};
+export type Val = ValBool | ValI256 | ValU256 | ValByteVec | ValAddress;
+export declare const valCodec: EnumCodec<Val>;
+export declare const valsCodec: ArrayCodec<Val>;