@alephium/web3 0.42.0 → 0.44.0

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,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 { ArrayCodec, DecodedArray } from './array-codec'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { instrsCodec, Instr } from './instr-codec'
 
@@ -83,28 +82,28 @@ export class MethodCodec implements Codec<DecodedMethod> {
     .uint8('isPublic')
     .uint8('assetModifier')
     .nest('argsLength', {
-      type: compactUnsignedIntCodec.parser
+      type: compactSignedIntCodec.parser
     })
     .nest('localsLength', {
-      type: compactUnsignedIntCodec.parser
+      type: compactSignedIntCodec.parser
     })
     .nest('returnLength', {
-      type: compactUnsignedIntCodec.parser
+      type: compactSignedIntCodec.parser
     })
     .nest('instrs', {
       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(...compactSignedIntCodec.encode(input.argsLength))
+    result.push(...compactSignedIntCodec.encode(input.localsLength))
+    result.push(...compactSignedIntCodec.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)
   }
 
@@ -112,9 +111,9 @@ export class MethodCodec implements Codec<DecodedMethod> {
     return {
       isPublic: decodedMethod.isPublic === 1,
       ...decodeAssetModifier(decodedMethod.assetModifier),
-      argsLength: compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
-      localsLength: compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
-      returnLength: compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
+      argsLength: compactSignedIntCodec.toI32(decodedMethod.argsLength),
+      localsLength: compactSignedIntCodec.toI32(decodedMethod.localsLength),
+      returnLength: compactSignedIntCodec.toI32(decodedMethod.returnLength),
       instrs: decodedMethod.instrs.value
     }
   }
@@ -123,9 +122,9 @@ export class MethodCodec implements Codec<DecodedMethod> {
     return {
       isPublic: method.isPublic ? 1 : 0,
       assetModifier: encodeAssetModifier(method),
-      argsLength: compactUnsignedIntCodec.fromU32(method.argsLength),
-      localsLength: compactUnsignedIntCodec.fromU32(method.localsLength),
-      returnLength: compactUnsignedIntCodec.fromU32(method.returnLength),
+      argsLength: compactSignedIntCodec.fromI32(method.argsLength),
+      localsLength: compactSignedIntCodec.fromI32(method.localsLength),
+      returnLength: compactSignedIntCodec.fromI32(method.returnLength),
       instrs: instrsCodec.fromArray(method.instrs)
     }
   }

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,13 +16,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/>.
 */
 
-import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
 import { Codec } from './codec'
 import { DecodedMethod, methodsCodec, Method, MethodCodec } from './method-codec'
 import { OptionCodec } from './option-codec'
-import { compactUnsignedIntCodec } from './compact-int-codec'
+import { compactSignedIntCodec } from './compact-int-codec'
 
 export interface DecodedScript {
   methods: DecodedArray<DecodedMethod>
@@ -37,23 +36,22 @@ 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 {
-    const methodLength = compactUnsignedIntCodec.fromU32(inputTxScript.methods.length)
+  encodeScript(inputTxScript: Script): Uint8Array {
+    const methodLength = compactSignedIntCodec.fromI32(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)
   }
 }

package/src/codec/unsigned-tx-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 { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium'
-import { binToHex, hexToBinUnsafe } from '../utils'
+import { binToHex, concatBytes, hexToBinUnsafe } from '../utils'
 import { DecodedScript, scriptCodec, statefulScriptCodecOpt } from './script-codec'
 import { Option } from './option-codec'
 import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
@@ -58,9 +57,9 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
       type: assetOutputsCodec.parser
     })
 
-  encode(decodedUnsignedTx: UnsignedTx): Buffer {
-    return Buffer.concat([
-      Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
+  encode(decodedUnsignedTx: UnsignedTx): Uint8Array {
+    return concatBytes([
+      new Uint8Array([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
       statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
       compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
       compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
@@ -69,16 +68,16 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
     ])
   }
 
-  decode(input: Buffer): UnsignedTx {
+  decode(input: Uint8Array): UnsignedTx {
     return this.parser.parse(input)
   }
 
-  encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer {
+  encodeApiUnsignedTx(input: ApiUnsignedTx): Uint8Array {
     const decoded = UnsignedTxCodec.fromApiUnsignedTx(input)
     return this.encode(decoded)
   }
 
-  decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx {
+  decodeApiUnsignedTx(input: Uint8Array): ApiUnsignedTx {
     const decoded = this.parser.parse(input)
     return UnsignedTxCodec.toApiUnsignedTx(decoded)
   }
@@ -98,7 +97,7 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
     const fixedOutputs = AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value)
     let scriptOpt: string | undefined = undefined
     if (unsigned.statefulScript.option === 1) {
-      scriptOpt = scriptCodec.encode(unsigned.statefulScript.value!).toString('hex')
+      scriptOpt = binToHex(scriptCodec.encode(unsigned.statefulScript.value!))
     }
 
     return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs }
@@ -113,8 +112,8 @@ export class UnsignedTxCodec implements Codec<UnsignedTx> {
     const inputs = inputsCodec.fromArray(inputsValue)
     const fixedOutputsValue = AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs)
     const fixedOutputs = assetOutputsCodec.fromArray(fixedOutputsValue)
-    const statefulScript = statefulScriptCodecOpt.fromBuffer(
-      unsignedTx.scriptOpt ? Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined
+    const statefulScript = statefulScriptCodecOpt.fromBytes(
+      unsignedTx.scriptOpt ? hexToBinUnsafe(unsignedTx.scriptOpt) : undefined
     )
 
     return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript }