@alephium/web3 0.40.0 → 0.41.0

package/dist/src/utils/exchange.js

@@ -18,11 +18,14 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAddressFromUnlockScript = exports.getSenderAddress = exports.getALPHDepositInfo = exports.isALPHTransferTx = exports.validateExchangeAddress = void 0;
-const __1 = require("..");
+const utils_1 = require("../utils");
+const unlock_script_codec_1 = require("../codec/unlock-script-codec");
+const buffer_1 = require("buffer/");
+const script_codec_1 = require("../codec/script-codec");
 function validateExchangeAddress(address) {
     let decoded;
     try {
-        decoded = __1.bs58.decode(address);
+        decoded = utils_1.bs58.decode(address);
     }
     catch (_) {
         throw new Error('Invalid base58 string');
@@ -30,7 +33,7 @@ function validateExchangeAddress(address) {
     if (decoded.length === 0)
         throw new Error('Address is empty');
     const addressType = decoded[0];
-    if (addressType !== __1.AddressType.P2PKH && addressType !== __1.AddressType.P2SH) {
+    if (addressType !== utils_1.AddressType.P2PKH && addressType !== utils_1.AddressType.P2SH) {
         throw new Error('Invalid address type');
     }
     if (decoded.length !== 33) {
@@ -83,27 +86,34 @@ var UnlockScriptType;
     UnlockScriptType[UnlockScriptType["P2SH"] = 2] = "P2SH";
 })(UnlockScriptType || (UnlockScriptType = {}));
 function getAddressFromUnlockScript(unlockScript) {
-    const decoded = (0, __1.hexToBinUnsafe)(unlockScript);
+    if (!(0, utils_1.isHexString)(unlockScript)) {
+        throw new Error(`Invalid unlock script ${unlockScript}, expected a hex string`);
+    }
+    const decoded = (0, utils_1.hexToBinUnsafe)(unlockScript);
     if (decoded.length === 0)
         throw new Error('UnlockScript is empty');
     const unlockScriptType = decoded[0];
     const unlockScriptBody = decoded.slice(1);
     if (unlockScriptType === UnlockScriptType.P2PKH) {
-        return (0, __1.addressFromPublicKey)((0, __1.binToHex)(unlockScriptBody));
+        if (unlockScriptBody.length !== 33) {
+            throw new Error(`Invalid p2pkh unlock script: ${unlockScript}`);
+        }
+        return (0, utils_1.addressFromPublicKey)((0, utils_1.binToHex)(unlockScriptBody));
     }
-    else if (unlockScriptType === UnlockScriptType.P2MPKH) {
+    if (unlockScriptType === UnlockScriptType.P2MPKH) {
         throw new Error('Naive multi-sig address is not supported for exchanges as it will be replaced by P2SH');
     }
-    else if (unlockScriptType === UnlockScriptType.P2SH) {
-        // FIXEME: for now we assume that the params is empty, so we need to
-        // remove the last byte from the `unlockScriptBody`, we can decode
-        // the unlock script once the codec PR is merged
-        const script = unlockScriptBody.slice(0, -1);
-        return (0, __1.addressFromScript)(script);
-    }
-    else {
-        throw new Error('Invalid unlock script type');
+    if (unlockScriptType === UnlockScriptType.P2SH) {
+        let p2sh;
+        try {
+            p2sh = unlock_script_codec_1.unlockScriptCodec.decode(buffer_1.Buffer.from(decoded)).script;
+        }
+        catch (_) {
+            throw new Error(`Invalid p2sh unlock script: ${unlockScript}`);
+        }
+        return (0, utils_1.addressFromScript)(script_codec_1.scriptCodec.encode(p2sh.script));
     }
+    throw new Error('Invalid unlock script type');
 }
 exports.getAddressFromUnlockScript = getAddressFromUnlockScript;
 function checkALPHOutput(tx) {

package/dist/src/utils/number.d.ts

@@ -1,4 +1,4 @@
-import { Number256 } from '..';
+import { Number256 } from '../api/types';
 export declare const isNumeric: (numToCheck: any) => boolean;
 export interface IPrettifyNumberConfig {
     minDecimalPlaces: number;

package/dist/src/utils/sign.js

@@ -42,7 +42,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifySignature = exports.sign = void 0;
 const elliptic_1 = require("elliptic");
-const __1 = require("..");
+const utils_1 = require("../utils");
 const necc = __importStar(require("@noble/secp256k1"));
 const crypto_1 = require("crypto");
 const ec = new elliptic_1.ec('secp256k1');
@@ -63,11 +63,11 @@ function sign(hash, privateKey, _keyType) {
     if (keyType === 'default') {
         const key = ec.keyFromPrivate(privateKey);
         const signature = key.sign(hash);
-        return (0, __1.encodeSignature)(signature);
+        return (0, utils_1.encodeSignature)(signature);
     }
     else {
-        const signature = necc.schnorr.signSync((0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(privateKey));
-        return (0, __1.binToHex)(signature);
+        const signature = necc.schnorr.signSync((0, utils_1.hexToBinUnsafe)(hash), (0, utils_1.hexToBinUnsafe)(privateKey));
+        return (0, utils_1.binToHex)(signature);
     }
 }
 exports.sign = sign;
@@ -76,10 +76,10 @@ function verifySignature(hash, publicKey, signature, _keyType) {
     try {
         if (keyType === 'default') {
             const key = ec.keyFromPublic(publicKey, 'hex');
-            return key.verify(hash, (0, __1.signatureDecode)(ec, signature));
+            return key.verify(hash, (0, utils_1.signatureDecode)(ec, signature));
         }
         else {
-            return necc.schnorr.verifySync((0, __1.hexToBinUnsafe)(signature), (0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(publicKey));
+            return necc.schnorr.verifySync((0, utils_1.hexToBinUnsafe)(signature), (0, utils_1.hexToBinUnsafe)(hash), (0, utils_1.hexToBinUnsafe)(publicKey));
         }
     }
     catch (error) {

package/dist/src/utils/subscription.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'eventemitter3';
-type MessageCallback<Message> = (message: Message) => Promise<void>;
-type ErrorCallback<Message> = (error: any, subscription: Subscription<Message>) => Promise<void>;
+type MessageCallback<Message> = (message: Message) => Promise<void> | void;
+type ErrorCallback<Message> = (error: any, subscription: Subscription<Message>) => Promise<void> | void;
 export interface SubscribeOptions<Message> {
     pollingInterval: number;
     messageCallback: MessageCallback<Message>;
@@ -14,9 +14,9 @@ export declare abstract class Subscription<Message> {
     protected eventEmitter: EventEmitter;
     protected cancelled: boolean;
     constructor(options: SubscribeOptions<Message>);
-    startPolling(): void;
+    subscribe(): void;
     unsubscribe(): void;
     isCancelled(): boolean;
-    abstract polling(): Promise<void>;
+    protected abstract polling(): Promise<void>;
 }
 export {};

package/dist/src/utils/subscription.js

@@ -31,7 +31,7 @@ class Subscription {
         this.cancelled = false;
         this.eventEmitter = new eventemitter3_1.default();
     }
-    startPolling() {
+    subscribe() {
         this.eventEmitter.on('tick', async () => {
             await this.polling();
             if (!this.cancelled) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@alephium/web3",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
   "browser": "dist/alephium-web3.min.js",
   "types": "dist/src/index.d.ts",
   "exports": {
-    ".": "./dist/src/index.js",
-    "./test": "./dist/src/test/index.js"
+    "node": "./dist/src/index.js",
+    "default": "./dist/alephium-web3.min.js"
   },
   "typesVersions": {
     "*": {

package/src/api/node-provider.ts

@@ -28,7 +28,6 @@ import {
   requestWithLog
 } from './types'
 import { Api as NodeApi, CallContractFailed, CallContractSucceeded } from './api-alephium'
-import { tryGetCallResult } from '../contract'
 import {
   HexString,
   addressFromContractId,
@@ -38,6 +37,7 @@ import {
   isHexString,
   toNonNegativeBigInt
 } from '../utils'
+import * as node from '../api/api-alephium'
 
 function initializeNodeApi(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): NodeApi<string> {
   const nodeApi = new NodeApi<string>({
@@ -253,3 +253,10 @@ export class NodeProvider implements NodeProviderApis {
     }
   }
 }
+
+export function tryGetCallResult(result: node.CallContractResult): node.CallContractSucceeded {
+  if (result.type === 'CallContractFailed') {
+    throw new Error(`Failed to call contract, error: ${(result as node.CallContractFailed).error}`)
+  }
+  return result as node.CallContractSucceeded
+}

package/src/api/utils.ts

@@ -17,7 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import 'cross-fetch/polyfill'
-import { node } from '..'
+import * as node from '../api/api-alephium'
 
 export function convertHttpResponse<T>(response: { status: number; data: T; error?: { detail: string } }): T {
   if (response.error) {

package/src/block/block.ts

@@ -0,0 +1,139 @@
+/*
+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/>.
+*/
+
+import { Subscription, SubscribeOptions } from '../utils/subscription'
+import * as node from '../api/api-alephium'
+import { NodeProvider } from '../api'
+import * as web3 from '../global'
+
+export type ReorgCallback = (orphanBlocks: node.BlockEntry[], newBlocks: node.BlockEntry[]) => Promise<void> | void
+
+export interface BlockSubscribeOptions extends SubscribeOptions<node.BlockEntry> {
+  reorgCallback?: ReorgCallback
+}
+
+export abstract class BlockSubscriptionBase extends Subscription<node.BlockEntry> {
+  abstract readonly reorgCallback?: ReorgCallback
+  abstract readonly fromGroup: number
+  abstract readonly toGroup: number
+
+  abstract getHashesAtHeight(height: number): Promise<string[]>
+  abstract getBlockByHash(hash: string): Promise<node.BlockEntry>
+
+  protected getParentHash(block: node.BlockEntry): string {
+    const index = Math.floor(block.deps.length / 2) + this.toGroup
+    return block.deps[index]
+  }
+
+  protected async handleReorg(blockHash: string, blockHeight: number) {
+    console.info(`reorg occur, hash: ${blockHash}, height: ${blockHeight}`)
+    if (this.reorgCallback === undefined) return
+
+    const orphans: string[] = []
+    const newHashes: string[] = []
+    let fromHash = blockHash
+    let fromHeight = blockHeight
+    while (true) {
+      const hashes = await this.getHashesAtHeight(fromHeight)
+      const canonicalHash = hashes[0]
+      if (canonicalHash !== fromHash) {
+        orphans.push(fromHash)
+        newHashes.push(canonicalHash)
+        const block = await this.getBlockByHash(fromHash)
+        fromHash = this.getParentHash(block)
+        fromHeight -= 1
+      } else {
+        break
+      }
+    }
+
+    const orphanBlocks: node.BlockEntry[] = []
+    for (const hash of orphans.reverse()) {
+      const block = await this.getBlockByHash(hash)
+      orphanBlocks.push(block)
+    }
+
+    const newBlocks: node.BlockEntry[] = []
+    for (const hash of newHashes.reverse()) {
+      const block = await this.getBlockByHash(hash)
+      newBlocks.push(block)
+    }
+    console.info(`orphan hashes: ${orphanBlocks.map((b) => b.hash)}, new hashes: ${newBlocks.map((b) => b.hash)}`)
+    await this.reorgCallback(orphanBlocks, newBlocks)
+  }
+}
+
+export class BlockSubscription extends BlockSubscriptionBase {
+  readonly nodeProvider: NodeProvider
+  readonly fromGroup: number
+  readonly toGroup: number
+  readonly reorgCallback?: ReorgCallback
+  private currentBlockHeight: number
+  private parentBlockHash: string | undefined
+
+  constructor(
+    options: BlockSubscribeOptions,
+    fromGroup: number,
+    toGroup: number,
+    fromBlockHeight: number,
+    nodeProvider: NodeProvider | undefined = undefined
+  ) {
+    super(options)
+    this.nodeProvider = nodeProvider ?? web3.getCurrentNodeProvider()
+    this.fromGroup = fromGroup
+    this.toGroup = toGroup
+    this.reorgCallback = options.reorgCallback
+    this.currentBlockHeight = fromBlockHeight
+    this.parentBlockHash = undefined
+  }
+
+  override async getHashesAtHeight(height: number): Promise<string[]> {
+    const result = await this.nodeProvider.blockflow.getBlockflowHashes({
+      fromGroup: this.fromGroup,
+      toGroup: this.toGroup,
+      height
+    })
+    return result.headers
+  }
+
+  override async getBlockByHash(hash: string): Promise<node.BlockEntry> {
+    return await this.nodeProvider.blockflow.getBlockflowBlocksBlockHash(hash)
+  }
+
+  override async polling(): Promise<void> {
+    try {
+      const chainInfo = await this.nodeProvider.blockflow.getBlockflowChainInfo({
+        fromGroup: this.fromGroup,
+        toGroup: this.toGroup
+      })
+
+      while (this.currentBlockHeight <= chainInfo.currentHeight) {
+        const hashes = await this.getHashesAtHeight(this.currentBlockHeight)
+        const block = await this.getBlockByHash(hashes[0])
+        if (this.parentBlockHash !== undefined && this.getParentHash(block) !== this.parentBlockHash) {
+          await this.handleReorg(this.parentBlockHash, this.currentBlockHeight - 1)
+        }
+        await this.messageCallback(block)
+        this.currentBlockHeight += 1
+        this.parentBlockHash = hashes[0]
+      }
+    } catch (err) {
+      await this.errorCallback(err, this)
+    }
+  }
+}

package/src/block/index.ts

@@ -0,0 +1,19 @@
+/*
+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/>.
+*/
+
+export { ReorgCallback, BlockSubscribeOptions, BlockSubscription } from './block'

package/src/codec/contract-output-codec.ts

@@ -24,7 +24,7 @@ import { Codec } from './codec'
 import { Token, tokensCodec } from './token-codec'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
-import { binToHex, bs58 } from '..'
+import { binToHex, bs58 } from '../utils'
 import { signedIntCodec } from './signed-int-codec'
 import { lockupScriptCodec } from './lockup-script-codec'
 

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

@@ -17,7 +17,7 @@ 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 { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { ArrayCodec, DecodedArray } from './array-codec'
 
@@ -41,7 +41,7 @@ const publicKeyHashCodec = new PublicKeyHashCodec()
 const publicKeyHashesCodec = new ArrayCodec(publicKeyHashCodec)
 const multiSigParser = Parser.start()
   .nest('publicKeyHashes', { type: publicKeyHashesCodec.parser })
-  .nest('m', { type: compactUnsignedIntCodec.parser })
+  .nest('m', { type: compactSignedIntCodec.parser })
 export interface MultiSig {
   publicKeyHashes: DecodedArray<PublicKeyHash>
   m: DecodedCompactInt
@@ -79,7 +79,7 @@ export class LockupScriptCodec implements Codec<LockupScript> {
       result.push(...(input.script as PublicKeyHash).publicKeyHash)
     } else if (input.scriptType === 1) {
       result.push(...publicKeyHashesCodec.encode((input.script as MultiSig).publicKeyHashes.value))
-      result.push(...compactUnsignedIntCodec.encode((input.script as MultiSig).m))
+      result.push(...compactSignedIntCodec.encode((input.script as MultiSig).m))
     } else if (input.scriptType === 2) {
       result.push(...(input.script as P2SH).scriptHash)
     } else if (input.scriptType === 3) {

package/src/codec/method-codec.ts

@@ -33,13 +33,51 @@ export interface DecodedMethod {
 
 export interface Method {
   isPublic: boolean
-  assetModifier: number
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
   argsLength: number
   localsLength: number
   returnLength: number
   instrs: Instr[]
 }
 
+function decodeAssetModifier(encoded: number): {
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
+} {
+  const usePayToContractOnly = (encoded & 4) !== 0
+  switch (encoded & 3) {
+    case 0:
+      return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: false }
+    case 1:
+      return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: true }
+    case 2:
+      return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: true }
+    case 3:
+      return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: false }
+    default:
+      throw new Error(`Invalid asset modifier: ${encoded}`)
+  }
+}
+
+function encodeAssetModifier(arg: {
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
+}): number {
+  const encoded =
+    !arg.usePreapprovedAssets && !arg.useContractAssets
+      ? 0
+      : arg.usePreapprovedAssets && arg.useContractAssets
+      ? 1
+      : !arg.usePreapprovedAssets && arg.useContractAssets
+      ? 2
+      : 3
+  return encoded | (arg.usePayToContractOnly ? 4 : 0)
+}
+
 export class MethodCodec implements Codec<DecodedMethod> {
   parser = Parser.start()
     .uint8('isPublic')
@@ -73,7 +111,7 @@ export class MethodCodec implements Codec<DecodedMethod> {
   static toMethod(decodedMethod: DecodedMethod): Method {
     return {
       isPublic: decodedMethod.isPublic === 1,
-      assetModifier: decodedMethod.assetModifier,
+      ...decodeAssetModifier(decodedMethod.assetModifier),
       argsLength: compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
       localsLength: compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
       returnLength: compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
@@ -84,7 +122,7 @@ export class MethodCodec implements Codec<DecodedMethod> {
   static fromMethod(method: Method): DecodedMethod {
     return {
       isPublic: method.isPublic ? 1 : 0,
-      assetModifier: method.assetModifier,
+      assetModifier: encodeAssetModifier(method),
       argsLength: compactUnsignedIntCodec.fromU32(method.argsLength),
       localsLength: compactUnsignedIntCodec.fromU32(method.localsLength),
       returnLength: compactUnsignedIntCodec.fromU32(method.returnLength),

package/src/codec/script-codec.ts

@@ -15,30 +15,48 @@ 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 { DecodedArray } from './array-codec'
 import { Codec } from './codec'
-import { DecodedMethod, methodsCodec } from './method-codec'
+import { DecodedMethod, methodsCodec, Method, MethodCodec } from './method-codec'
 import { OptionCodec } from './option-codec'
+import { compactUnsignedIntCodec } from './compact-int-codec'
 
-export interface Script {
+export interface DecodedScript {
   methods: DecodedArray<DecodedMethod>
 }
 
-export class ScriptCodec implements Codec<Script> {
+export interface Script {
+  methods: Method[]
+}
+
+export class ScriptCodec implements Codec<DecodedScript> {
   parser = Parser.start().nest('methods', {
     type: methodsCodec.parser
   })
 
-  encode(input: Script): Buffer {
+  encode(input: DecodedScript): Buffer {
     const script = methodsCodec.encode(input.methods.value)
     return Buffer.from(script)
   }
 
-  decode(input: Buffer): Script {
+  decode(input: Buffer): DecodedScript {
     return this.parser.parse(input)
   }
+
+  decodeScript(input: Buffer): 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)
+    const decodedMethods = inputTxScript.methods.map((method) => MethodCodec.fromMethod(method))
+    return this.encode({ methods: { value: decodedMethods, length: methodLength } })
+  }
 }
 
 export const scriptCodec = new ScriptCodec()

package/src/codec/transaction-codec.ts

@@ -27,7 +27,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 '..'
+import { hexToBinUnsafe } from '../utils'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { Codec } from './codec'
 import { Output, outputCodec, outputsCodec } from './output-codec'

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

@@ -20,7 +20,7 @@ import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
 import { Codec } from './codec'
-import { Script, scriptCodec } from './script-codec'
+import { DecodedScript, Script, scriptCodec } from './script-codec'
 import { ByteString, byteStringCodec } from './bytestring-codec'
 import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
 
@@ -122,7 +122,7 @@ const valCodec = new ValCodec()
 const valsCodec = new ArrayCodec(valCodec)
 
 export interface P2SH {
-  script: Script
+  script: DecodedScript
   params: DecodedArray<Val>
 }
 

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

@@ -19,7 +19,7 @@ import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium'
 import { binToHex, hexToBinUnsafe } from '../utils'
-import { Script, scriptCodec, statefulScriptCodecOpt } from './script-codec'
+import { DecodedScript, scriptCodec, statefulScriptCodecOpt } from './script-codec'
 import { Option } from './option-codec'
 import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
 import { Input, InputCodec, inputsCodec } from './input-codec'
@@ -31,7 +31,7 @@ import { Codec } from './codec'
 export interface UnsignedTx {
   version: number
   networkId: number
-  statefulScript: Option<Script>
+  statefulScript: Option<DecodedScript>
   gasAmount: DecodedCompactInt
   gasPrice: DecodedCompactInt
   inputs: DecodedArray<Input>