@alephium/web3 0.41.0 → 0.43.0

package/src/codec/input-codec.ts

@@ -15,10 +15,9 @@ 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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { AssetInput } from '../api/api-alephium'
-import { binToHex } from '../utils'
+import { binToHex, concatBytes, hexToBinUnsafe } from '../utils'
 import { UnlockScript, unlockScriptCodec } from './unlock-script-codec'
 import { Codec } from './codec'
 import { signedIntCodec } from './signed-int-codec'
@@ -27,7 +26,7 @@ import { ArrayCodec } from './array-codec'
 export interface Input {
   outputRef: {
     hint: number
-    key: Buffer
+    key: Uint8Array
   }
   unlockScript: UnlockScript
 }
@@ -41,14 +40,15 @@ export class InputCodec implements Codec<Input> {
       type: unlockScriptCodec.parser
     })
 
-  encode(input: Input): Buffer {
-    return Buffer.concat([
-      Buffer.from([...signedIntCodec.encode(input.outputRef.hint), ...input.outputRef.key]),
+  encode(input: Input): Uint8Array {
+    return concatBytes([
+      signedIntCodec.encode(input.outputRef.hint),
+      input.outputRef.key,
       unlockScriptCodec.encode(input.unlockScript)
     ])
   }
 
-  decode(input: Buffer): Input {
+  decode(input: Uint8Array): Input {
     return this.parser.parse(input)
   }
 
@@ -59,7 +59,7 @@ export class InputCodec implements Codec<Input> {
       const unlockScript = unlockScriptCodec.encode(input.unlockScript)
       return {
         outputRef: { hint, key },
-        unlockScript: unlockScript.toString('hex')
+        unlockScript: binToHex(unlockScript)
       }
     })
   }
@@ -67,8 +67,8 @@ export class InputCodec implements Codec<Input> {
   static fromAssetInputs(inputs: AssetInput[]): Input[] {
     return inputs.map((input) => {
       const hint = input.outputRef.hint
-      const key = Buffer.from(input.outputRef.key, 'hex')
-      const unlockScript = unlockScriptCodec.decode(Buffer.from(input.unlockScript, 'hex'))
+      const key = hexToBinUnsafe(input.outputRef.key)
+      const unlockScript = unlockScriptCodec.decode(hexToBinUnsafe(input.unlockScript))
       return {
         outputRef: { hint, key },
         unlockScript

package/src/codec/instr-codec.ts

@@ -15,7 +15,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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
@@ -458,7 +457,7 @@ export class InstrCodec implements Codec<Instr> {
       }
     })
 
-  encode(instr: Instr): Buffer {
+  encode(instr: Instr): Uint8Array {
     const instrValue = instr.value
     const result = [instr.code]
     const instrsWithIndex = [0x00, 0x01, 0x16, 0x17, 0xa0, 0xa1, 0xce]
@@ -480,10 +479,10 @@ export class InstrCodec implements Codec<Instr> {
       result.push(...signedIntCodec.encode((instrValue as InstrValueWithIndex).index))
     }
 
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): Instr {
+  decode(input: Uint8Array): Instr {
     return this.parser.parse(input)
   }
 }

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

@@ -15,24 +15,23 @@ 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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { ArrayCodec, DecodedArray } from './array-codec'
 
 export interface PublicKeyHash {
-  publicKeyHash: Buffer
+  publicKeyHash: Uint8Array
 }
 
 class PublicKeyHashCodec implements Codec<PublicKeyHash> {
   parser = Parser.start().buffer('publicKeyHash', { length: 32 })
 
-  encode(input: PublicKeyHash): Buffer {
+  encode(input: PublicKeyHash): Uint8Array {
     return input.publicKeyHash
   }
 
-  decode(input: Buffer): PublicKeyHash {
+  decode(input: Uint8Array): PublicKeyHash {
     return this.parser.parse(input)
   }
 }
@@ -48,11 +47,11 @@ export interface MultiSig {
 }
 
 export interface P2SH {
-  scriptHash: Buffer
+  scriptHash: Uint8Array
 }
 
 export interface P2C {
-  contractId: Buffer
+  contractId: Uint8Array
 }
 
 export interface LockupScript {
@@ -73,7 +72,7 @@ export class LockupScriptCodec implements Codec<LockupScript> {
       }
     })
 
-  encode(input: LockupScript): Buffer {
+  encode(input: LockupScript): Uint8Array {
     const result: number[] = [input.scriptType]
     if (input.scriptType === 0) {
       result.push(...(input.script as PublicKeyHash).publicKeyHash)
@@ -88,10 +87,10 @@ export class LockupScriptCodec implements Codec<LockupScript> {
       throw new Error(`Unsupported script type: ${input.scriptType}`)
     }
 
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): LockupScript {
+  decode(input: Uint8Array): LockupScript {
     return this.parser.parse(input)
   }
 }

package/src/codec/long-codec.ts

@@ -15,7 +15,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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { Codec, assert } from './codec'
 
@@ -24,7 +23,7 @@ export class LongCodec implements Codec<bigint> {
     length: 8
   })
 
-  encode(input: bigint): Buffer {
+  encode(input: bigint): Uint8Array {
     const byteArray = new Uint8Array(8)
 
     assert(byteArray.length <= 8, 'Length should be less than or equal to 8')
@@ -34,10 +33,10 @@ export class LongCodec implements Codec<bigint> {
       input >>= BigInt(8)
     }
 
-    return Buffer.from(byteArray)
+    return byteArray
   }
 
-  decode(bytes: Buffer): bigint {
+  decode(bytes: Uint8Array): bigint {
     assert(bytes.length == 8, 'Length should be 8')
     let int64 = BigInt(0)
     let pow = BigInt(1)

package/src/codec/method-codec.ts

@@ -15,7 +15,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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
@@ -95,16 +94,16 @@ export class MethodCodec implements Codec<DecodedMethod> {
       type: instrsCodec.parser
     })
 
-  encode(input: DecodedMethod): Buffer {
+  encode(input: DecodedMethod): Uint8Array {
     const result = [input.isPublic, input.assetModifier]
     result.push(...compactUnsignedIntCodec.encode(input.argsLength))
     result.push(...compactUnsignedIntCodec.encode(input.localsLength))
     result.push(...compactUnsignedIntCodec.encode(input.returnLength))
     result.push(...instrsCodec.encode(input.instrs.value))
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): DecodedMethod {
+  decode(input: Uint8Array): DecodedMethod {
     return this.parser.parse(input)
   }
 

package/src/codec/option-codec.ts

@@ -15,7 +15,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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { Codec } from './codec'
 
@@ -35,15 +34,15 @@ export class OptionCodec<T> implements Codec<Option<T>> {
     })
   ) {}
 
-  encode(input: Option<T>): Buffer {
+  encode(input: Option<T>): Uint8Array {
     const result = [input.option]
     if (input.option === 1) {
       result.push(...this.childCodec.encode(input.value!))
     }
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): Option<T> {
+  decode(input: Uint8Array): Option<T> {
     const result = this.parser.parse(input)
     return {
       ...result,
@@ -51,7 +50,7 @@ export class OptionCodec<T> implements Codec<Option<T>> {
     }
   }
 
-  fromBuffer(input?: Buffer): Option<T> {
+  fromBytes(input?: Uint8Array): Option<T> {
     return {
       option: input ? 1 : 0,
       value: input ? this.childCodec.decode(input) : undefined

package/src/codec/script-codec.ts

@@ -16,7 +16,6 @@ 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/>.
 */
 
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
 import { Codec } from './codec'
@@ -37,22 +36,21 @@ export class ScriptCodec implements Codec<DecodedScript> {
     type: methodsCodec.parser
   })
 
-  encode(input: DecodedScript): Buffer {
-    const script = methodsCodec.encode(input.methods.value)
-    return Buffer.from(script)
+  encode(input: DecodedScript): Uint8Array {
+    return methodsCodec.encode(input.methods.value)
   }
 
-  decode(input: Buffer): DecodedScript {
+  decode(input: Uint8Array): DecodedScript {
     return this.parser.parse(input)
   }
 
-  decodeScript(input: Buffer): Script {
+  decodeScript(input: Uint8Array): Script {
     const decodedTxScript = this.decode(input)
     const methods = decodedTxScript.methods.value.map((decodedMethod) => MethodCodec.toMethod(decodedMethod))
     return { methods }
   }
 
-  encodeScript(inputTxScript: Script): Buffer {
+  encodeScript(inputTxScript: Script): Uint8Array {
     const methodLength = compactUnsignedIntCodec.fromU32(inputTxScript.methods.length)
     const decodedMethods = inputTxScript.methods.map((method) => MethodCodec.fromMethod(method))
     return this.encode({ methods: { value: decodedMethods, length: methodLength } })

package/src/codec/signature-codec.ts

@@ -15,23 +15,22 @@ 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/>.
 */
-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 class SignatureCodec implements Codec<Signature> {
   parser = Parser.start().buffer('value', { length: 64 })
 
-  encode(input: Signature): Buffer {
+  encode(input: Signature): Uint8Array {
     return input.value
   }
 
-  decode(input: Buffer): Signature {
+  decode(input: Uint8Array): Signature {
     return this.parser.parse(input)
   }
 }

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

@@ -18,17 +18,16 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import { Parser } from 'binary-parser'
 import { Codec, assert } from './codec'
 
-import { Buffer } from 'buffer/'
 export class SignedIntCodec implements Codec<number> {
   parser = Parser.start().buffer('value', {
     length: 4
   })
 
-  encode(value: number): Buffer {
-    return Buffer.from([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff])
+  encode(value: number): Uint8Array {
+    return new Uint8Array([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff])
   }
 
-  decode(bytes: Buffer): number {
+  decode(bytes: Uint8Array): number {
     assert(bytes.length === 4, 'Length should be 4')
     return ((bytes[0] & 0xff) << 24) | ((bytes[1] & 0xff) << 16) | ((bytes[2] & 0xff) << 8) | (bytes[3] & 0xff)
   }

package/src/codec/token-codec.ts

@@ -16,14 +16,14 @@ 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/>.
 */
 
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { ArrayCodec } from './array-codec'
+import { concatBytes } from '../utils'
 
 export interface Token {
-  tokenId: Buffer
+  tokenId: Uint8Array
   amount: DecodedCompactInt
 }
 
@@ -36,13 +36,13 @@ export class TokenCodec implements Codec<Token> {
       type: compactUnsignedIntCodec.parser
     })
 
-  encode(input: Token): Buffer {
+  encode(input: Token): Uint8Array {
     const tokenId = input.tokenId
-    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
-    return Buffer.concat([tokenId, amount])
+    const amount = compactUnsignedIntCodec.encode(input.amount)
+    return concatBytes([tokenId, amount])
   }
 
-  decode(input: Buffer): Token {
+  decode(input: Uint8Array): Token {
     return this.parser.parse(input)
   }
 }

package/src/codec/transaction-codec.ts

@@ -16,7 +16,6 @@ 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/>.
 */
 
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
 
@@ -27,7 +26,7 @@ import { Either } from './either-codec'
 import { AssetOutput, AssetOutputCodec } from './asset-output-codec'
 import { ContractOutput, ContractOutputCodec } from './contract-output-codec'
 import { FixedAssetOutput, Transaction as ApiTransaction } from '../api/api-alephium'
-import { hexToBinUnsafe } from '../utils'
+import { binToHex, hexToBinUnsafe, concatBytes } from '../utils'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { Codec } from './codec'
 import { Output, outputCodec, outputsCodec } from './output-codec'
@@ -60,27 +59,27 @@ export class TransactionCodec implements Codec<Transaction> {
       type: signaturesCodec.parser
     })
 
-  encode(decodedTx: Transaction): Buffer {
-    return Buffer.concat([
+  encode(decodedTx: Transaction): Uint8Array {
+    return concatBytes([
       unsignedTxCodec.encode(decodedTx.unsigned),
-      Buffer.from([decodedTx.scriptExecutionOk]),
-      Buffer.from([...contractOutputRefsCodec.encode(decodedTx.contractInputs.value)]),
-      Buffer.from([...outputsCodec.encode(decodedTx.generatedOutputs.value)]),
-      Buffer.from([...signaturesCodec.encode(decodedTx.inputSignatures.value)]),
-      Buffer.from([...signaturesCodec.encode(decodedTx.scriptSignatures.value)])
+      new Uint8Array([decodedTx.scriptExecutionOk]),
+      contractOutputRefsCodec.encode(decodedTx.contractInputs.value),
+      outputsCodec.encode(decodedTx.generatedOutputs.value),
+      signaturesCodec.encode(decodedTx.inputSignatures.value),
+      signaturesCodec.encode(decodedTx.scriptSignatures.value)
     ])
   }
 
-  decode(input: Buffer): Transaction {
+  decode(input: Uint8Array): Transaction {
     return this.parser.parse(input)
   }
 
-  encodeApiTransaction(input: ApiTransaction): Buffer {
+  encodeApiTransaction(input: ApiTransaction): Uint8Array {
     const decodedTx = TransactionCodec.fromApiTransaction(input)
     return this.encode(decodedTx)
   }
 
-  decodeApiTransaction(input: Buffer): ApiTransaction {
+  decodeApiTransaction(input: Uint8Array): ApiTransaction {
     const decodedTx = this.parser.parse(input)
     return TransactionCodec.toApiTransaction(decodedTx)
   }
@@ -91,7 +90,7 @@ export class TransactionCodec implements Codec<Transaction> {
     const scriptExecutionOk = !!transaction.scriptExecutionOk
     const contractInputs = transaction.contractInputs.value.map((contractInput) => {
       const hint = contractInput.hint
-      const key = contractInput.key.toString('hex')
+      const key = binToHex(contractInput.key)
       return { hint, key }
     })
     const txIdBytes = hexToBinUnsafe(txId)
@@ -104,8 +103,8 @@ export class TransactionCodec implements Codec<Transaction> {
       }
     })
 
-    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) => binToHex(signature.value))
+    const scriptSignatures = transaction.scriptSignatures.value.map((signature) => binToHex(signature.value))
 
     return { unsigned, scriptExecutionOk, contractInputs, generatedOutputs, inputSignatures, scriptSignatures }
   }
@@ -114,7 +113,7 @@ export class TransactionCodec implements Codec<Transaction> {
     const unsigned = UnsignedTxCodec.fromApiUnsignedTx(tx.unsigned)
     const scriptExecutionOk = tx.scriptExecutionOk ? 1 : 0
     const contractInputs: ContractOutputRef[] = tx.contractInputs.map((contractInput) => {
-      return { hint: contractInput.hint, key: Buffer.from(contractInput.key, 'hex') }
+      return { hint: contractInput.hint, key: hexToBinUnsafe(contractInput.key) }
     })
     const generatedOutputs: Either<AssetOutput, ContractOutput>[] = tx.generatedOutputs.map((output) => {
       if (output.type === 'AssetOutput') {
@@ -127,10 +126,10 @@ export class TransactionCodec implements Codec<Transaction> {
     })
 
     const inputSignatures: Signature[] = tx.inputSignatures.map((signature) => {
-      return { value: Buffer.from(signature, 'hex') }
+      return { value: hexToBinUnsafe(signature) }
     })
     const scriptSignatures: Signature[] = tx.scriptSignatures.map((signature) => {
-      return { value: Buffer.from(signature, 'hex') }
+      return { value: hexToBinUnsafe(signature) }
     })
 
     return {

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

@@ -15,27 +15,27 @@ 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/>.
 */
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
 import { Codec } from './codec'
-import { DecodedScript, Script, scriptCodec } from './script-codec'
+import { DecodedScript, scriptCodec } from './script-codec'
 import { ByteString, byteStringCodec } from './bytestring-codec'
 import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
+import { concatBytes } from '../utils'
 
 export interface P2PKH {
-  publicKey: Buffer
+  publicKey: Uint8Array
 }
 
 class P2PKHCodec implements Codec<P2PKH> {
   parser = Parser.start().buffer('publicKey', { length: 33 })
 
-  encode(input: P2PKH): Buffer {
+  encode(input: P2PKH): Uint8Array {
     return input.publicKey
   }
 
-  decode(input: Buffer): P2PKH {
+  decode(input: Uint8Array): P2PKH {
     return this.parser.parse(input)
   }
 }
@@ -57,16 +57,16 @@ class P2MPKHCodec implements Codec<P2MPKH> {
     )
   })
 
-  encode(input: P2MPKH): Buffer {
-    return Buffer.concat([
-      Buffer.from(compactUnsignedIntCodec.encode(input.publicKeys.length)),
+  encode(input: P2MPKH): Uint8Array {
+    return concatBytes([
+      compactUnsignedIntCodec.encode(input.publicKeys.length),
       ...input.publicKeys.value.map((v) => {
-        return Buffer.concat([v.publicKey.publicKey, Buffer.from(compactUnsignedIntCodec.encode(v.index))])
+        return concatBytes([v.publicKey.publicKey, compactUnsignedIntCodec.encode(v.index)])
       })
     ])
   }
 
-  decode(input: Buffer): any {
+  decode(input: Uint8Array): any {
     return this.parser.parse(input)
   }
 }
@@ -90,30 +90,30 @@ class ValCodec implements Codec<Val> {
       }
     })
 
-  encode(input: Val): Buffer {
+  encode(input: Val): Uint8Array {
     const valType = input.type
 
     if (valType === 0x00) {
       // Boolean
-      return Buffer.from([valType, input.val as number])
+      return new Uint8Array([valType, input.val as number])
     } else if (valType === 0x01) {
       // I256
-      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
+      return new Uint8Array([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
     } else if (valType === 0x02) {
       // U256
-      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
+      return new Uint8Array([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
     } else if (valType === 0x03) {
       // ByteVec
-      return Buffer.from([valType, ...byteStringCodec.encode(input.val as ByteString)])
+      return new Uint8Array([valType, ...byteStringCodec.encode(input.val as ByteString)])
     } else if (valType === 0x04) {
       // Address
-      return Buffer.from([valType, ...lockupScriptCodec.encode(input.val as LockupScript)])
+      return new Uint8Array([valType, ...lockupScriptCodec.encode(input.val as LockupScript)])
     } else {
       throw new Error(`ValCodec: unsupported val type: ${valType}`)
     }
   }
 
-  decode(input: Buffer): Val {
+  decode(input: Uint8Array): Val {
     return this.parser.parse(input)
   }
 }
@@ -135,11 +135,11 @@ export class P2SHCodec implements Codec<P2SH> {
       type: valsCodec.parser
     })
 
-  encode(input: P2SH): Buffer {
-    return Buffer.concat([scriptCodec.encode(input.script), valsCodec.encode(input.params.value)])
+  encode(input: P2SH): Uint8Array {
+    return concatBytes([scriptCodec.encode(input.script), valsCodec.encode(input.params.value)])
   }
 
-  decode(input: Buffer): P2SH {
+  decode(input: Uint8Array): P2SH {
     return this.parser.parse(input)
   }
 }
@@ -164,29 +164,28 @@ export class UnlockScriptCodec implements Codec<UnlockScript> {
       }
     })
 
-  encode(input: UnlockScript): Buffer {
+  encode(input: UnlockScript): Uint8Array {
     const scriptType = input.scriptType
     const inputUnLockScript = input.script
-    const inputUnLockScriptType = Buffer.from([scriptType])
 
     if (scriptType === 0) {
       // P2PKH
-      return Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript as P2PKH)])
+      return new Uint8Array([scriptType, ...p2pkhCodec.encode(inputUnLockScript as P2PKH)])
     } else if (scriptType === 1) {
       // P2MPKH
-      return Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript as P2MPKH)])
+      return new Uint8Array([scriptType, ...p2mpkhCodec.encode(inputUnLockScript as P2MPKH)])
     } else if (scriptType === 2) {
       // P2SH
-      return Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script as P2SH)])
+      return new Uint8Array([scriptType, ...p2shCodec.encode(inputUnLockScript as P2SH)])
     } else if (scriptType === 3) {
       // SameAsPrevious
-      return inputUnLockScriptType
+      return new Uint8Array([scriptType])
     } else {
       throw new Error(`TODO: encode unlock script: ${scriptType}`)
     }
   }
 
-  decode(input: Buffer): UnlockScript {
+  decode(input: Uint8Array): UnlockScript {
     return this.parser.parse(input)
   }
 }