@alephium/web3 0.37.0 → 0.38.1

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

@@ -0,0 +1,31 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { ArrayCodec, DecodedArray } from './array-codec';
+import { DecodedCompactInt } from './compact-int-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>;
+}
+export interface Method {
+    isPublic: boolean;
+    assetModifier: number;
+    argsLength: number;
+    localsLength: number;
+    returnLength: number;
+    instrs: Instr[];
+}
+export declare class MethodCodec implements Codec<DecodedMethod> {
+    parser: Parser;
+    encode(input: DecodedMethod): Buffer;
+    decode(input: Buffer): DecodedMethod;
+    static toMethod(decodedMethod: DecodedMethod): Method;
+    static fromMethod(method: Method): DecodedMethod;
+}
+export declare const methodCodec: MethodCodec;
+export declare const methodsCodec: ArrayCodec<DecodedMethod>;

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methodsCodec = exports.methodCodec = exports.MethodCodec = 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 buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const array_codec_1 = require("./array-codec");
+const compact_int_codec_1 = require("./compact-int-codec");
+const instr_codec_1 = require("./instr-codec");
+class MethodCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .uint8('isPublic')
+            .uint8('assetModifier')
+            .nest('argsLength', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .nest('localsLength', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .nest('returnLength', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .nest('instrs', {
+            type: instr_codec_1.instrsCodec.parser
+        });
+    }
+    encode(input) {
+        const result = [input.isPublic, input.assetModifier];
+        result.push(...compact_int_codec_1.compactUnsignedIntCodec.encode(input.argsLength));
+        result.push(...compact_int_codec_1.compactUnsignedIntCodec.encode(input.localsLength));
+        result.push(...compact_int_codec_1.compactUnsignedIntCodec.encode(input.returnLength));
+        result.push(...instr_codec_1.instrsCodec.encode(input.instrs.value));
+        return buffer_1.Buffer.from(result);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    static toMethod(decodedMethod) {
+        return {
+            isPublic: decodedMethod.isPublic === 1,
+            assetModifier: decodedMethod.assetModifier,
+            argsLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
+            localsLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
+            returnLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
+            instrs: decodedMethod.instrs.value
+        };
+    }
+    static fromMethod(method) {
+        return {
+            isPublic: method.isPublic ? 1 : 0,
+            assetModifier: method.assetModifier,
+            argsLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.argsLength),
+            localsLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.localsLength),
+            returnLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.returnLength),
+            instrs: instr_codec_1.instrsCodec.fromArray(method.instrs)
+        };
+    }
+}
+exports.MethodCodec = MethodCodec;
+exports.methodCodec = new MethodCodec();
+exports.methodsCodec = new array_codec_1.ArrayCodec(exports.methodCodec);

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

@@ -0,0 +1,15 @@
+import { Buffer } from 'buffer/';
+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>): Buffer;
+    decode(input: Buffer): Option<T>;
+    fromBuffer(input?: Buffer): Option<T>;
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionCodec = 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 buffer_1 = require("buffer/");
+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;
+    }
+    encode(input) {
+        const result = [input.option];
+        if (input.option === 1) {
+            result.push(...this.childCodec.encode(input.value));
+        }
+        return buffer_1.Buffer.from(result);
+    }
+    decode(input) {
+        const result = this.parser.parse(input);
+        return {
+            ...result,
+            value: result.option ? this.childCodec.decode(result.value.value) : undefined
+        };
+    }
+    fromBuffer(input) {
+        return {
+            option: input ? 1 : 0,
+            value: input ? this.childCodec.decode(input) : undefined
+        };
+    }
+}
+exports.OptionCodec = OptionCodec;

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

@@ -0,0 +1,7 @@
+import { ArrayCodec } from './array-codec';
+import { Either, EitherCodec } 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 outputsCodec: ArrayCodec<Either<AssetOutput, ContractOutput>>;

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

@@ -0,0 +1,26 @@
+"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.outputsCodec = exports.outputCodec = void 0;
+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.outputsCodec = new array_codec_1.ArrayCodec(exports.outputCodec);

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

@@ -0,0 +1,16 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { DecodedArray } from './array-codec';
+import { Codec } from './codec';
+import { DecodedMethod } from './method-codec';
+import { OptionCodec } from './option-codec';
+export interface Script {
+    methods: DecodedArray<DecodedMethod>;
+}
+export declare class ScriptCodec implements Codec<Script> {
+    parser: Parser;
+    encode(input: Script): Buffer;
+    decode(input: Buffer): Script;
+}
+export declare const scriptCodec: ScriptCodec;
+export declare const statefulScriptCodecOpt: OptionCodec<Script>;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statefulScriptCodecOpt = exports.scriptCodec = exports.ScriptCodec = 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 buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const method_codec_1 = require("./method-codec");
+const option_codec_1 = require("./option-codec");
+class ScriptCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start().nest('methods', {
+            type: method_codec_1.methodsCodec.parser
+        });
+    }
+    encode(input) {
+        const script = method_codec_1.methodsCodec.encode(input.methods.value);
+        return buffer_1.Buffer.from(script);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+exports.ScriptCodec = ScriptCodec;
+exports.scriptCodec = new ScriptCodec();
+exports.statefulScriptCodecOpt = new option_codec_1.OptionCodec(exports.scriptCodec);

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

@@ -0,0 +1,14 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { ArrayCodec } from './array-codec';
+import { Codec } from './codec';
+export interface Signature {
+    value: Buffer;
+}
+export declare class SignatureCodec implements Codec<Signature> {
+    parser: Parser;
+    encode(input: Signature): Buffer;
+    decode(input: Buffer): Signature;
+}
+export declare const signatureCodec: SignatureCodec;
+export declare const signaturesCodec: ArrayCodec<Signature>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signaturesCodec = exports.signatureCodec = exports.SignatureCodec = void 0;
+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();
+exports.signaturesCodec = new array_codec_1.ArrayCodec(exports.signatureCodec);

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

@@ -0,0 +1,9 @@
+import { Parser } from 'binary-parser';
+import { Codec } from './codec';
+import { Buffer } from 'buffer/';
+export declare class SignedIntCodec implements Codec<number> {
+    parser: Parser;
+    encode(value: number): Buffer;
+    decode(bytes: Buffer): number;
+}
+export declare const signedIntCodec: SignedIntCodec;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signedIntCodec = exports.SignedIntCodec = 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 codec_1 = require("./codec");
+const buffer_1 = require("buffer/");
+class SignedIntCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start().buffer('value', {
+            length: 4
+        });
+    }
+    encode(value) {
+        return buffer_1.Buffer.from([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff]);
+    }
+    decode(bytes) {
+        (0, codec_1.assert)(bytes.length === 4, 'Length should be 4');
+        return ((bytes[0] & 0xff) << 24) | ((bytes[1] & 0xff) << 16) | ((bytes[2] & 0xff) << 8) | (bytes[3] & 0xff);
+    }
+}
+exports.SignedIntCodec = SignedIntCodec;
+exports.signedIntCodec = new SignedIntCodec();

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

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

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

@@ -0,0 +1,46 @@
+"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.tokensCodec = exports.tokenCodec = exports.TokenCodec = void 0;
+const buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const compact_int_codec_1 = require("./compact-int-codec");
+const array_codec_1 = require("./array-codec");
+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 = buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount));
+        return buffer_1.Buffer.concat([tokenId, amount]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+exports.TokenCodec = TokenCodec;
+exports.tokenCodec = new TokenCodec();
+exports.tokensCodec = new array_codec_1.ArrayCodec(exports.tokenCodec);

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

@@ -0,0 +1,27 @@
+import { Buffer } from 'buffer/';
+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 { Output } from './output-codec';
+export interface Transaction {
+    unsigned: UnsignedTx;
+    scriptExecutionOk: number;
+    contractInputs: DecodedArray<ContractOutputRef>;
+    generatedOutputs: DecodedArray<Output>;
+    inputSignatures: DecodedArray<Signature>;
+    scriptSignatures: DecodedArray<Signature>;
+}
+export declare class TransactionCodec implements Codec<Transaction> {
+    parser: Parser;
+    encode(decodedTx: Transaction): Buffer;
+    decode(input: Buffer): Transaction;
+    encodeApiTransaction(input: ApiTransaction): Buffer;
+    decodeApiTransaction(input: Buffer): ApiTransaction;
+    static toApiTransaction(transaction: Transaction): ApiTransaction;
+    static fromApiTransaction(tx: ApiTransaction): Transaction;
+}
+export declare const transactionCodec: TransactionCodec;

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

@@ -0,0 +1,128 @@
+"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.transactionCodec = exports.TransactionCodec = void 0;
+const buffer_1 = require("buffer/");
+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 __1 = require("..");
+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 buffer_1.Buffer.concat([
+            unsigned_tx_codec_1.unsignedTxCodec.encode(decodedTx.unsigned),
+            buffer_1.Buffer.from([decodedTx.scriptExecutionOk]),
+            buffer_1.Buffer.from([...contract_output_ref_codec_1.contractOutputRefsCodec.encode(decodedTx.contractInputs.value)]),
+            buffer_1.Buffer.from([...output_codec_1.outputsCodec.encode(decodedTx.generatedOutputs.value)]),
+            buffer_1.Buffer.from([...signature_codec_1.signaturesCodec.encode(decodedTx.inputSignatures.value)]),
+            buffer_1.Buffer.from([...signature_codec_1.signaturesCodec.encode(decodedTx.scriptSignatures.value)])
+        ]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    encodeApiTransaction(input) {
+        const decodedTx = TransactionCodec.fromApiTransaction(input);
+        return this.encode(decodedTx);
+    }
+    decodeApiTransaction(input) {
+        const decodedTx = this.parser.parse(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 hint = contractInput.hint;
+            const key = contractInput.key.toString('hex');
+            return { hint, key };
+        });
+        const txIdBytes = (0, __1.hexToBinUnsafe)(txId);
+        const generatedOutputs = transaction.generatedOutputs.value.map((output, index) => {
+            if (output.either === 0) {
+                const fixedAssetOutput = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutput(txIdBytes, output.value, index);
+                return { ...fixedAssetOutput, type: 'AssetOutput' };
+            }
+            else {
+                return contract_output_codec_1.ContractOutputCodec.convertToApiContractOutput(txIdBytes, output.value, index);
+            }
+        });
+        const inputSignatures = transaction.inputSignatures.value.map((signature) => signature.value.toString('hex'));
+        const scriptSignatures = transaction.scriptSignatures.value.map((signature) => signature.value.toString('hex'));
+        return { unsigned, scriptExecutionOk, contractInputs, generatedOutputs, inputSignatures, scriptSignatures };
+    }
+    static fromApiTransaction(tx) {
+        const unsigned = unsigned_tx_codec_1.UnsignedTxCodec.fromApiUnsignedTx(tx.unsigned);
+        const scriptExecutionOk = tx.scriptExecutionOk ? 1 : 0;
+        const contractInputs = tx.contractInputs.map((contractInput) => {
+            return { hint: contractInput.hint, key: buffer_1.Buffer.from(contractInput.key, 'hex') };
+        });
+        const generatedOutputs = tx.generatedOutputs.map((output) => {
+            if (output.type === 'AssetOutput') {
+                return output_codec_1.outputCodec.fromLeft(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));
+            }
+            else {
+                throw new Error('Invalid output type');
+            }
+        });
+        const inputSignatures = tx.inputSignatures.map((signature) => {
+            return { value: buffer_1.Buffer.from(signature, 'hex') };
+        });
+        const scriptSignatures = tx.scriptSignatures.map((signature) => {
+            return { value: buffer_1.Buffer.from(signature, 'hex') };
+        });
+        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)
+        };
+    }
+}
+exports.TransactionCodec = TransactionCodec;
+exports.transactionCodec = new TransactionCodec();

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

@@ -0,0 +1,40 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { DecodedArray } from './array-codec';
+import { DecodedCompactInt } from './compact-int-codec';
+import { Codec } from './codec';
+import { Script } from './script-codec';
+import { ByteString } from './bytestring-codec';
+import { LockupScript } from './lockup-script-codec';
+export interface P2PKH {
+    publicKey: Buffer;
+}
+export interface P2MPKH {
+    publicKeys: DecodedArray<{
+        publicKey: P2PKH;
+        index: DecodedCompactInt;
+    }>;
+}
+export interface Val {
+    type: number;
+    val: number | DecodedCompactInt | ByteString | LockupScript;
+}
+export interface P2SH {
+    script: Script;
+    params: DecodedArray<Val>;
+}
+export declare class P2SHCodec implements Codec<P2SH> {
+    parser: Parser;
+    encode(input: P2SH): Buffer;
+    decode(input: Buffer): P2SH;
+}
+export interface UnlockScript {
+    scriptType: number;
+    script: P2PKH | P2MPKH | P2SH;
+}
+export declare class UnlockScriptCodec implements Codec<UnlockScript> {
+    parser: Parser;
+    encode(input: UnlockScript): Buffer;
+    decode(input: Buffer): UnlockScript;
+}
+export declare const unlockScriptCodec: UnlockScriptCodec;