@alephium/web3 0.42.0 → 0.44.0

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { ArrayCodec, DecodedArray } from './array-codec';
 import { DecodedCompactInt } from './compact-int-codec';
@@ -24,8 +23,8 @@ export interface Method {
 }
 export declare class MethodCodec implements Codec<DecodedMethod> {
     parser: Parser;
-    encode(input: DecodedMethod): Buffer;
-    decode(input: Buffer): DecodedMethod;
+    encode(input: DecodedMethod): Uint8Array;
+    decode(input: Uint8Array): DecodedMethod;
     static toMethod(decodedMethod: DecodedMethod): Method;
     static fromMethod(method: Method): DecodedMethod;
 }

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

@@ -18,7 +18,6 @@ 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");
@@ -54,13 +53,13 @@ class MethodCodec {
             .uint8('isPublic')
             .uint8('assetModifier')
             .nest('argsLength', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .nest('localsLength', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .nest('returnLength', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .nest('instrs', {
             type: instr_codec_1.instrsCodec.parser
@@ -68,11 +67,11 @@ class MethodCodec {
     }
     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(...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 buffer_1.Buffer.from(result);
+        return new Uint8Array(result);
     }
     decode(input) {
         return this.parser.parse(input);
@@ -81,9 +80,9 @@ class MethodCodec {
         return {
             isPublic: decodedMethod.isPublic === 1,
             ...decodeAssetModifier(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),
+            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
         };
     }
@@ -91,9 +90,9 @@ class MethodCodec {
         return {
             isPublic: method.isPublic ? 1 : 0,
             assetModifier: encodeAssetModifier(method),
-            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),
+            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)
         };
     }

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { Codec } from './codec';
 export interface Option<T> {
@@ -9,7 +8,7 @@ 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>;
+    encode(input: Option<T>): Uint8Array;
+    decode(input: Uint8Array): Option<T>;
+    fromBytes(input?: Uint8Array): Option<T>;
 }

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

@@ -18,7 +18,6 @@ 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', {
@@ -36,7 +35,7 @@ class OptionCodec {
         if (input.option === 1) {
             result.push(...this.childCodec.encode(input.value));
         }
-        return buffer_1.Buffer.from(result);
+        return new Uint8Array(result);
     }
     decode(input) {
         const result = this.parser.parse(input);
@@ -45,7 +44,7 @@ class OptionCodec {
             value: result.option ? this.childCodec.decode(result.value.value) : undefined
         };
     }
-    fromBuffer(input) {
+    fromBytes(input) {
         return {
             option: input ? 1 : 0,
             value: input ? this.childCodec.decode(input) : undefined

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { Codec } from './codec';
@@ -12,10 +11,10 @@ export interface Script {
 }
 export declare class ScriptCodec implements Codec<DecodedScript> {
     parser: Parser;
-    encode(input: DecodedScript): Buffer;
-    decode(input: Buffer): DecodedScript;
-    decodeScript(input: Buffer): Script;
-    encodeScript(inputTxScript: Script): Buffer;
+    encode(input: DecodedScript): Uint8Array;
+    decode(input: Uint8Array): DecodedScript;
+    decodeScript(input: Uint8Array): Script;
+    encodeScript(inputTxScript: Script): Uint8Array;
 }
 export declare const scriptCodec: ScriptCodec;
 export declare const statefulScriptCodecOpt: OptionCodec<DecodedScript>;

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

@@ -18,7 +18,6 @@ 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 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");
@@ -30,8 +29,7 @@ class ScriptCodec {
         });
     }
     encode(input) {
-        const script = method_codec_1.methodsCodec.encode(input.methods.value);
-        return buffer_1.Buffer.from(script);
+        return method_codec_1.methodsCodec.encode(input.methods.value);
     }
     decode(input) {
         return this.parser.parse(input);
@@ -42,7 +40,7 @@ class ScriptCodec {
         return { methods };
     }
     encodeScript(inputTxScript) {
-        const methodLength = compact_int_codec_1.compactUnsignedIntCodec.fromU32(inputTxScript.methods.length);
+        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 } });
     }

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

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

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

@@ -1,6 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signaturesCodec = exports.signatureCodec = exports.SignatureCodec = 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 array_codec_1 = require("./array-codec");
 class SignatureCodec {

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

@@ -1,9 +1,8 @@
 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;
+    encode(value: number): Uint8Array;
+    decode(bytes: Uint8Array): number;
 }
 export declare const signedIntCodec: SignedIntCodec;

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

@@ -20,7 +20,6 @@ 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', {
@@ -28,7 +27,7 @@ class SignedIntCodec {
         });
     }
     encode(value) {
-        return buffer_1.Buffer.from([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff]);
+        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');

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

@@ -1,16 +1,15 @@
-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;
+    tokenId: Uint8Array;
     amount: DecodedCompactInt;
 }
 export declare class TokenCodec implements Codec<Token> {
     parser: Parser;
-    encode(input: Token): Buffer;
-    decode(input: Buffer): Token;
+    encode(input: Token): Uint8Array;
+    decode(input: Uint8Array): Token;
 }
 export declare const tokenCodec: TokenCodec;
 export declare const tokensCodec: ArrayCodec<Token>;

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

@@ -18,10 +18,10 @@ 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");
+const utils_1 = require("../utils");
 class TokenCodec {
     constructor() {
         this.parser = binary_parser_1.Parser.start()
@@ -34,8 +34,8 @@ class TokenCodec {
     }
     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]);
+        const amount = compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount);
+        return (0, utils_1.concatBytes)([tokenId, amount]);
     }
     decode(input) {
         return this.parser.parse(input);

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { UnsignedTx } from './unsigned-tx-codec';
@@ -17,10 +16,10 @@ export interface Transaction {
 }
 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;
+    encode(decodedTx: Transaction): Uint8Array;
+    decode(input: Uint8Array): Transaction;
+    encodeApiTransaction(input: ApiTransaction): Uint8Array;
+    decodeApiTransaction(input: Uint8Array): ApiTransaction;
     static toApiTransaction(transaction: Transaction): ApiTransaction;
     static fromApiTransaction(tx: ApiTransaction): Transaction;
 }

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

@@ -18,7 +18,6 @@ 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");
@@ -48,13 +47,13 @@ class TransactionCodec {
         });
     }
     encode(decodedTx) {
-        return buffer_1.Buffer.concat([
+        return (0, utils_1.concatBytes)([
             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)])
+            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) {
@@ -74,7 +73,7 @@ class TransactionCodec {
         const scriptExecutionOk = !!transaction.scriptExecutionOk;
         const contractInputs = transaction.contractInputs.value.map((contractInput) => {
             const hint = contractInput.hint;
-            const key = contractInput.key.toString('hex');
+            const key = (0, utils_1.binToHex)(contractInput.key);
             return { hint, key };
         });
         const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
@@ -87,15 +86,15 @@ class TransactionCodec {
                 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'));
+        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));
         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') };
+            return { hint: contractInput.hint, key: (0, utils_1.hexToBinUnsafe)(contractInput.key) };
         });
         const generatedOutputs = tx.generatedOutputs.map((output) => {
             if (output.type === 'AssetOutput') {
@@ -109,10 +108,10 @@ class TransactionCodec {
             }
         });
         const inputSignatures = tx.inputSignatures.map((signature) => {
-            return { value: buffer_1.Buffer.from(signature, 'hex') };
+            return { value: (0, utils_1.hexToBinUnsafe)(signature) };
         });
         const scriptSignatures = tx.scriptSignatures.map((signature) => {
-            return { value: buffer_1.Buffer.from(signature, 'hex') };
+            return { value: (0, utils_1.hexToBinUnsafe)(signature) };
         });
         return {
             unsigned,

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { DecodedArray } from './array-codec';
 import { DecodedCompactInt } from './compact-int-codec';
@@ -7,7 +6,7 @@ import { DecodedScript } from './script-codec';
 import { ByteString } from './bytestring-codec';
 import { LockupScript } from './lockup-script-codec';
 export interface P2PKH {
-    publicKey: Buffer;
+    publicKey: Uint8Array;
 }
 export interface P2MPKH {
     publicKeys: DecodedArray<{
@@ -25,8 +24,8 @@ export interface P2SH {
 }
 export declare class P2SHCodec implements Codec<P2SH> {
     parser: Parser;
-    encode(input: P2SH): Buffer;
-    decode(input: Buffer): P2SH;
+    encode(input: P2SH): Uint8Array;
+    decode(input: Uint8Array): P2SH;
 }
 export interface UnlockScript {
     scriptType: number;
@@ -34,7 +33,7 @@ export interface UnlockScript {
 }
 export declare class UnlockScriptCodec implements Codec<UnlockScript> {
     parser: Parser;
-    encode(input: UnlockScript): Buffer;
-    decode(input: Buffer): UnlockScript;
+    encode(input: UnlockScript): Uint8Array;
+    decode(input: Uint8Array): UnlockScript;
 }
 export declare const unlockScriptCodec: UnlockScriptCodec;

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

@@ -18,13 +18,13 @@ 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 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 = binary_parser_1.Parser.start().buffer('publicKey', { length: 33 });
@@ -46,10 +46,10 @@ class P2MPKHCodec {
         });
     }
     encode(input) {
-        return buffer_1.Buffer.concat([
-            buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length)),
+        return (0, utils_1.concatBytes)([
+            compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length),
             ...input.publicKeys.value.map((v) => {
-                return buffer_1.Buffer.concat([v.publicKey.publicKey, buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(v.index))]);
+                return (0, utils_1.concatBytes)([v.publicKey.publicKey, compact_int_codec_1.compactUnsignedIntCodec.encode(v.index)]);
             })
         ]);
     }
@@ -77,23 +77,23 @@ class ValCodec {
         const valType = input.type;
         if (valType === 0x00) {
             // Boolean
-            return buffer_1.Buffer.from([valType, input.val]);
+            return new Uint8Array([valType, input.val]);
         }
         else if (valType === 0x01) {
             // I256
-            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
         }
         else if (valType === 0x02) {
             // U256
-            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
         }
         else if (valType === 0x03) {
             // ByteVec
-            return buffer_1.Buffer.from([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
         }
         else if (valType === 0x04) {
             // Address
-            return buffer_1.Buffer.from([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
+            return new Uint8Array([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
         }
         else {
             throw new Error(`ValCodec: unsupported val type: ${valType}`);
@@ -116,7 +116,7 @@ class P2SHCodec {
         });
     }
     encode(input) {
-        return buffer_1.Buffer.concat([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
+        return (0, utils_1.concatBytes)([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
     }
     decode(input) {
         return this.parser.parse(input);
@@ -141,22 +141,21 @@ class UnlockScriptCodec {
     encode(input) {
         const scriptType = input.scriptType;
         const inputUnLockScript = input.script;
-        const inputUnLockScriptType = buffer_1.Buffer.from([scriptType]);
         if (scriptType === 0) {
             // P2PKH
-            return buffer_1.Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript)]);
+            return new Uint8Array([scriptType, ...p2pkhCodec.encode(inputUnLockScript)]);
         }
         else if (scriptType === 1) {
             // P2MPKH
-            return buffer_1.Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript)]);
+            return new Uint8Array([scriptType, ...p2mpkhCodec.encode(inputUnLockScript)]);
         }
         else if (scriptType === 2) {
             // P2SH
-            return buffer_1.Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script)]);
+            return new Uint8Array([scriptType, ...p2shCodec.encode(inputUnLockScript)]);
         }
         else if (scriptType === 3) {
             // SameAsPrevious
-            return inputUnLockScriptType;
+            return new Uint8Array([scriptType]);
         }
         else {
             throw new Error(`TODO: encode unlock script: ${scriptType}`);

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

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer/';
 import { Parser } from 'binary-parser';
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium';
 import { DecodedScript } from './script-codec';
@@ -19,10 +18,10 @@ export interface UnsignedTx {
 }
 export declare class UnsignedTxCodec implements Codec<UnsignedTx> {
     parser: Parser;
-    encode(decodedUnsignedTx: UnsignedTx): Buffer;
-    decode(input: Buffer): UnsignedTx;
-    encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer;
-    decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx;
+    encode(decodedUnsignedTx: UnsignedTx): Uint8Array;
+    decode(input: Uint8Array): UnsignedTx;
+    encodeApiUnsignedTx(input: ApiUnsignedTx): Uint8Array;
+    decodeApiUnsignedTx(input: Uint8Array): ApiUnsignedTx;
     static txId(unsignedTx: UnsignedTx): string;
     static toApiUnsignedTx(unsigned: UnsignedTx): ApiUnsignedTx;
     static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx;

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

@@ -18,7 +18,6 @@ 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 utils_1 = require("../utils");
 const script_codec_1 = require("./script-codec");
@@ -48,8 +47,8 @@ class UnsignedTxCodec {
         });
     }
     encode(decodedUnsignedTx) {
-        return buffer_1.Buffer.concat([
-            buffer_1.Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
+        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),
@@ -82,7 +81,7 @@ class UnsignedTxCodec {
         const fixedOutputs = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value);
         let scriptOpt = undefined;
         if (unsigned.statefulScript.option === 1) {
-            scriptOpt = script_codec_1.scriptCodec.encode(unsigned.statefulScript.value).toString('hex');
+            scriptOpt = (0, utils_1.binToHex)(script_codec_1.scriptCodec.encode(unsigned.statefulScript.value));
         }
         return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs };
     }
@@ -95,7 +94,7 @@ class UnsignedTxCodec {
         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.fromBuffer(unsignedTx.scriptOpt ? buffer_1.Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined);
+        const statefulScript = script_codec_1.statefulScriptCodecOpt.fromBytes(unsignedTx.scriptOpt ? (0, utils_1.hexToBinUnsafe)(unsignedTx.scriptOpt) : undefined);
         return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript };
     }
 }

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

@@ -1,5 +1,5 @@
 import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
-import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
+import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address, SignExecuteScriptTxResult } from '../signer';
 import { Optional, HexString } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
 import { Method } from '../codec';
@@ -220,6 +220,14 @@ export interface CallContractResult<R> {
     events: ContractEvent[];
     debugMessages: DebugMessage[];
 }
+export interface SignExecuteContractMethodParams<T extends Arguments = Arguments> {
+    args: T;
+    signer: SignerProvider;
+    attoAlphAmount?: Number256;
+    tokens?: Token[];
+    gasAmount?: number;
+    gasPrice?: Number256;
+}
 export declare const CreateContractEventAddresses: string[];
 export declare const DestroyContractEventAddresses: string[];
 export type ContractCreatedEventFields = {
@@ -267,6 +275,7 @@ export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>
 export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
 export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
 export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
+export declare function signExecuteMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<SignExecuteContractMethodParams<A>, 'args'>): Promise<SignExecuteScriptTxResult>;
 export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
 export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export declare const getContractIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;