@alephium/web3 0.40.0 → 0.41.0

package/src/contract/contract.ts

@@ -34,7 +34,8 @@ import {
   getDefaultPrimitiveValue,
   PrimitiveTypes,
   decodeArrayType,
-  fromApiPrimitiveVal
+  fromApiPrimitiveVal,
+  tryGetCallResult
 } from '../api'
 import { CompileProjectResult } from '../api/api-alephium'
 import {
@@ -87,7 +88,7 @@ const crypto = new WebCrypto()
 export type FieldsSig = node.FieldsSig
 export type MapsSig = node.MapsSig
 export type EventSig = node.EventSig
-export type FunctionSig = node.FunctionSig
+export type FunctionSig = Omit<node.FunctionSig, 'isPublic' | 'usePreapprovedAssets' | 'useAssetsInContract'>
 export type Fields = NamedVals
 export type Arguments = NamedVals
 export type Constant = node.Constant
@@ -280,7 +281,18 @@ export class ProjectArtifact {
     return fsPromises.writeFile(filepath, content)
   }
 
-  needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean {
+  getChangedSources(sourceInfos: SourceInfo[]): SourceInfo[] {
+    const result: SourceInfo[] = []
+    for (const sourceInfo of sourceInfos) {
+      const info = this.infos.get(sourceInfo.name)
+      if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
+        result.push(sourceInfo)
+      }
+    }
+    return result
+  }
+
+  needToReCompile(compilerOptions: node.CompilerOptions, fullNodeVersion: string): boolean {
     ProjectArtifact.checkCompilerOptionsParameter(compilerOptions)
     if (this.fullNodeVersion !== fullNodeVersion) {
       return true
@@ -294,16 +306,6 @@ export class ProjectArtifact {
       return true
     }
 
-    if (sourceInfos.length !== this.infos.size) {
-      return true
-    }
-    for (const sourceInfo of sourceInfos) {
-      const info = this.infos.get(sourceInfo.name)
-      if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
-        return true
-      }
-    }
-
     return false
   }
 
@@ -326,15 +328,22 @@ export class ProjectArtifact {
   }
 }
 
-function removeOldArtifacts(dir: string) {
+function removeOldArtifacts(dir: string, sourceFiles: SourceInfo[]) {
   const files = fs.readdirSync(dir)
   files.forEach((file) => {
     const filePath = path.join(dir, file)
     const stat = fs.statSync(filePath)
     if (stat.isDirectory()) {
-      removeOldArtifacts(filePath)
+      removeOldArtifacts(filePath, sourceFiles)
     } else if (filePath.endsWith('.ral.json') || filePath.endsWith('.ral')) {
-      fs.unlinkSync(filePath)
+      const filename = path.basename(filePath)
+      const artifactName = filename.slice(0, filename.indexOf('.'))
+      const sourceFile = sourceFiles.find(
+        (s) => s.name === artifactName && (s.type === SourceKind.Contract || s.type === SourceKind.Script)
+      )
+      if (sourceFile === undefined) {
+        fs.unlinkSync(filePath)
+      }
     }
   })
 
@@ -521,7 +530,11 @@ export class Project {
     return fsPromises.writeFile(filePath, JSON.stringify(structs, null, 2))
   }
 
-  private async saveArtifactsToFile(projectRootDir: string): Promise<void> {
+  private async saveArtifactsToFile(
+    projectRootDir: string,
+    skipSaveArtifacts: boolean,
+    changedSources: SourceInfo[]
+  ): Promise<void> {
     const artifactsRootDir = this.artifactsRootDir
     const saveToFile = async function (compiled: Compiled<Artifact>): Promise<void> {
       const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir)
@@ -531,9 +544,32 @@ export class Project {
       }
       return fsPromises.writeFile(artifactPath, compiled.artifact.toString())
     }
-    this.contracts.forEach((contract) => saveToFile(contract))
-    this.scripts.forEach((script) => saveToFile(script))
-    this.saveStructsToFile()
+    for (const [_, contract] of this.contracts) {
+      if (!skipSaveArtifacts || changedSources.find((s) => s.name === contract.sourceInfo.name) !== undefined) {
+        await saveToFile(contract)
+      }
+    }
+    for (const [_, script] of this.scripts) {
+      await saveToFile(script)
+    }
+    await this.saveStructsToFile()
+    await this.saveProjectArtifact(projectRootDir, skipSaveArtifacts, changedSources)
+  }
+
+  private async saveProjectArtifact(projectRootDir: string, skipSaveArtifacts: boolean, changedSources: SourceInfo[]) {
+    if (skipSaveArtifacts) {
+      // we should not update the `codeHashDebug` if the `skipSaveArtifacts` is enabled
+      const prevProjectArtifact = await ProjectArtifact.from(projectRootDir)
+      if (prevProjectArtifact !== undefined) {
+        for (const [name, info] of this.projectArtifact.infos) {
+          if (changedSources.find((s) => s.name === name) === undefined) {
+            const prevInfo = prevProjectArtifact.infos.get(name)
+            info.bytecodeDebugPatch = prevInfo?.bytecodeDebugPatch ?? info.bytecodeDebugPatch
+            info.codeHashDebug = prevInfo?.codeHashDebug ?? info.codeHashDebug
+          }
+        }
+      }
+    }
     await this.projectArtifact.saveToFile(projectRootDir)
   }
 
@@ -587,7 +623,9 @@ export class Project {
     contractsRootDir: string,
     artifactsRootDir: string,
     errorOnWarnings: boolean,
-    compilerOptions: node.CompilerOptions
+    compilerOptions: node.CompilerOptions,
+    changedSources: SourceInfo[],
+    skipSaveArtifacts = false
   ): Promise<Project> {
     const removeDuplicates = sourceInfos.reduce((acc: SourceInfo[], sourceInfo: SourceInfo) => {
       if (acc.find((info) => info.sourceCodeHash === sourceInfo.sourceCodeHash) === undefined) {
@@ -639,20 +677,23 @@ export class Project {
       errorOnWarnings,
       projectArtifact
     )
-    await project.saveArtifactsToFile(projectRootDir)
+    await project.saveArtifactsToFile(projectRootDir, skipSaveArtifacts, changedSources)
     return project
   }
 
   private static async loadArtifacts(
     provider: NodeProvider,
     sourceInfos: SourceInfo[],
-    projectArtifact: ProjectArtifact,
     projectRootDir: string,
     contractsRootDir: string,
     artifactsRootDir: string,
     errorOnWarnings: boolean,
     compilerOptions: node.CompilerOptions
   ): Promise<Project> {
+    const projectArtifact = await ProjectArtifact.from(projectRootDir)
+    if (projectArtifact === undefined) {
+      throw Error('Failed to load project artifact')
+    }
     try {
       const contracts = new Map<string, Compiled<Contract>>()
       const scripts = new Map<string, Compiled<Script>>()
@@ -698,7 +739,8 @@ export class Project {
         contractsRootDir,
         artifactsRootDir,
         errorOnWarnings,
-        compilerOptions
+        compilerOptions,
+        sourceInfos
       )
     }
   }
@@ -821,19 +863,22 @@ export class Project {
     projectRootDir = '.',
     contractsRootDir = Project.DEFAULT_CONTRACTS_DIR,
     artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR,
-    defaultFullNodeVersion: string | undefined = undefined
+    defaultFullNodeVersion: string | undefined = undefined,
+    skipSaveArtifacts = false
   ): Promise<void> {
     const provider = getCurrentNodeProvider()
     const fullNodeVersion = defaultFullNodeVersion ?? (await provider.infos.getInfosVersion()).version
     const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir)
     const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
     const projectArtifact = await ProjectArtifact.from(projectRootDir)
+    const changedSources = projectArtifact?.getChangedSources(sourceFiles) ?? sourceFiles
     if (
       projectArtifact === undefined ||
-      projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles, fullNodeVersion)
+      projectArtifact.needToReCompile(nodeCompilerOptions, fullNodeVersion) ||
+      changedSources.length > 0
     ) {
       if (fs.existsSync(artifactsRootDir)) {
-        removeOldArtifacts(artifactsRootDir)
+        removeOldArtifacts(artifactsRootDir, sourceFiles)
       }
       console.log(`Compiling contracts in folder "${contractsRootDir}"`)
       Project.currentProject = await Project.compile(
@@ -844,21 +889,21 @@ export class Project {
         contractsRootDir,
         artifactsRootDir,
         errorOnWarnings,
-        nodeCompilerOptions
-      )
-    } else {
-      console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`)
-      Project.currentProject = await Project.loadArtifacts(
-        provider,
-        sourceFiles,
-        projectArtifact,
-        projectRootDir,
-        contractsRootDir,
-        artifactsRootDir,
-        errorOnWarnings,
-        nodeCompilerOptions
+        nodeCompilerOptions,
+        changedSources,
+        skipSaveArtifacts
       )
     }
+    // we need to reload those contracts that did not regenerate bytecode
+    Project.currentProject = await Project.loadArtifacts(
+      provider,
+      sourceFiles,
+      projectRootDir,
+      contractsRootDir,
+      artifactsRootDir,
+      errorOnWarnings,
+      nodeCompilerOptions
+    )
   }
 }
 
@@ -875,18 +920,6 @@ export abstract class Artifact {
 
   abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string
 
-  publicFunctions(): string[] {
-    return this.functions.filter((func) => func.isPublic).map((func) => func.name)
-  }
-
-  usingPreapprovedAssetsFunctions(): string[] {
-    return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name)
-  }
-
-  usingAssetsInContractFunctions(): string[] {
-    return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name)
-  }
-
   async isDevnet(signer: SignerProvider): Promise<boolean> {
     if (!signer.nodeProvider) {
       return false
@@ -896,6 +929,16 @@ export abstract class Artifact {
   }
 }
 
+function fromFunctionSig(sig: node.FunctionSig): FunctionSig {
+  return {
+    name: sig.name,
+    paramNames: sig.paramNames,
+    paramTypes: sig.paramTypes,
+    paramIsMutable: sig.paramIsMutable,
+    returnTypes: sig.returnTypes
+  }
+}
+
 export class Contract extends Artifact {
   readonly bytecode: string
   readonly bytecodeDebugPatch: string
@@ -910,6 +953,7 @@ export class Contract extends Artifact {
 
   readonly bytecodeDebug: string
   readonly codeHashDebug: string
+  readonly decodedMethods: Method[]
 
   constructor(
     version: string,
@@ -941,6 +985,20 @@ export class Contract extends Artifact {
 
     this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
     this.codeHashDebug = codeHashDebug
+
+    this.decodedMethods = contract.contractCodec.decodeContract(Buffer.from(bytecode, 'hex')).methods
+  }
+
+  publicFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].isPublic)
+  }
+
+  usingPreapprovedAssetsFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].usePreapprovedAssets)
+  }
+
+  usingAssetsInContractFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].useContractAssets)
   }
 
   // TODO: safely parse json
@@ -987,7 +1045,7 @@ export class Contract extends Artifact {
       result.codeHashDebug,
       result.fields,
       result.events,
-      result.functions,
+      result.functions.map(fromFunctionSig),
       result.constants,
       result.enums,
       structs,
@@ -1348,7 +1406,7 @@ export class Script extends Artifact {
       result.bytecodeTemplate,
       result.bytecodeDebugPatch,
       result.fields,
-      result.functions,
+      result.functions.map(fromFunctionSig),
       structs
     )
   }
@@ -1831,14 +1889,14 @@ export function subscribeEventsFromContract<T extends Fields, M extends Contract
   decodeFunc: (event: node.ContractEvent) => M,
   fromCount?: number
 ): EventSubscription {
-  const messageCallback = (event: node.ContractEvent): Promise<void> => {
+  const messageCallback = (event: node.ContractEvent) => {
     if (event.eventIndex !== eventIndex) {
       return Promise.resolve()
     }
     return options.messageCallback(decodeFunc(event))
   }
 
-  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
+  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>) => {
     return options.errorCallback(err, subscription as unknown as Subscription<M>)
   }
   const opt: EventSubscribeOptions<node.ContractEvent> = {
@@ -1877,7 +1935,9 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
   const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs)
   const loadImmFieldByIndex: Method = {
     isPublic: true,
-    assetModifier: 0,
+    usePreapprovedAssets: false,
+    useContractAssets: false,
+    usePayToContractOnly: false,
     argsLength: 1,
     localsLength: 1,
     returnLength: 1,
@@ -1905,7 +1965,9 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
   }
   const destroy: Method = {
     isPublic: true,
-    assetModifier: 2,
+    usePreapprovedAssets: false,
+    useContractAssets: true,
+    usePayToContractOnly: false,
     argsLength: 1,
     localsLength: 1,
     returnLength: 0,
@@ -2008,24 +2070,36 @@ export async function testMethod<
 }
 
 export class RalphMap<K extends Val, V extends Val> {
+  private readonly groupIndex: number
   constructor(
     private readonly parentContract: Contract,
-    private readonly parentInstance: ContractInstance,
+    private readonly parentContractId: HexString,
     private readonly mapName: string
-  ) {}
+  ) {
+    this.groupIndex = groupOfAddress(addressFromContractId(parentContractId))
+  }
 
   async get(key: K): Promise<V | undefined> {
-    return getMapItem(this.parentContract, this.parentInstance, this.mapName, key)
+    return getMapItem(this.parentContract, this.parentContractId, this.groupIndex, this.mapName, key)
   }
 
   async contains(key: K): Promise<boolean> {
     return this.get(key).then((v) => v !== undefined)
   }
+
+  toJSON() {
+    return {
+      parentContractId: this.parentContractId,
+      mapName: this.mapName,
+      groupIndex: this.groupIndex
+    }
+  }
 }
 
 export async function getMapItem<R extends Val>(
   parentContract: Contract,
-  parentInstance: ContractInstance,
+  parentContractId: HexString,
+  groupIndex: number,
   mapName: string,
   key: Val
 ): Promise<R | undefined> {
@@ -2035,13 +2109,7 @@ export async function getMapItem<R extends Val>(
     throw new Error(`Map ${mapName} does not exist in contract ${parentContract.name}`)
   }
   const [keyType, valueType] = ralph.parseMapType(mapType)
-  const mapItemContractId = calcWrapperContractId(
-    parentInstance.contractId,
-    index!,
-    key,
-    keyType,
-    parentInstance.groupIndex
-  )
+  const mapItemContractId = calcWrapperContractId(parentContractId, index!, key, keyType, groupIndex)
   const mapItemAddress = addressFromContractId(mapItemContractId)
   try {
     const state = await getCurrentNodeProvider().contracts.getContractsAddressState(mapItemAddress)
@@ -2271,13 +2339,13 @@ export function subscribeContractEvents(
   options: EventSubscribeOptions<ContractEvent<any>>,
   fromCount?: number
 ): EventSubscription {
-  const messageCallback = (event: node.ContractEvent): Promise<void> => {
+  const messageCallback = (event: node.ContractEvent) => {
     return options.messageCallback({
       ...decodeEvent(contract, instance, event, event.eventIndex),
       contractAddress: instance.address
     })
   }
-  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
+  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>) => {
     return options.errorCallback(err, subscription as unknown as Subscription<ContractEvent<any>>)
   }
   const opt: EventSubscribeOptions<node.ContractEvent> = {
@@ -2369,10 +2437,3 @@ export const getContractIdFromUnsignedTx = async (
 
 // This function only works in the simple case where a single non-subcontract is created in the tx
 export const getTokenIdFromUnsignedTx = getContractIdFromUnsignedTx
-
-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/contract/events.ts

@@ -16,33 +16,24 @@ 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 { web3 } from '..'
+import * as web3 from '../global'
 import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
 export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
-  onEventCountChanged?: (eventCount: number) => Promise<void>
+  onEventCountChanged?: (eventCount: number) => Promise<void> | void
 }
 
 export class EventSubscription extends Subscription<node.ContractEvent> {
   readonly contractAddress: string
   private fromCount: number
-  private onEventCountChanged?: (eventCount: number) => Promise<void>
+  private onEventCountChanged?: (eventCount: number) => Promise<void> | void
 
   constructor(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
     super(options)
     this.contractAddress = contractAddress
     this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
     this.onEventCountChanged = options.onEventCountChanged
-
-    this.startPolling()
-  }
-
-  override startPolling(): void {
-    this.eventEmitter.on('tick', async () => {
-      await this.polling()
-    })
-    this.eventEmitter.emit('tick')
   }
 
   currentEventCount(): number {
@@ -54,12 +45,7 @@ export class EventSubscription extends Subscription<node.ContractEvent> {
       const events = await web3.getCurrentNodeProvider().events.getEventsContractContractaddress(this.contractAddress, {
         start: this.fromCount
       })
-      if (this.cancelled) {
-        return
-      }
-
       if (this.fromCount === events.nextStart) {
-        this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval)
         return
       }
 
@@ -83,5 +69,7 @@ export function subscribeToEvents(
   contractAddress: string,
   fromCount?: number
 ): EventSubscription {
-  return new EventSubscription(options, contractAddress, fromCount)
+  const subscription = new EventSubscription(options, contractAddress, fromCount)
+  subscription.subscribe()
+  return subscription
 }

package/src/index.ts

@@ -32,3 +32,4 @@ export * as web3 from './global'
 export * as codec from './codec'
 export * as utils from './utils'
 export * from './debug'
+export * from './block'

package/src/signer/tx-builder.ts

@@ -16,7 +16,7 @@ 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 { utils } from '..'
+import { binToHex, contractIdFromAddress } from '../utils'
 import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiTokens } from '../api'
 import { addressFromPublicKey } from '../utils'
 import { toApiDestinations } from './signer'
@@ -90,7 +90,7 @@ export abstract class TransactionBuilder {
       ...rest
     }
     const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
-    const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress))
+    const contractId = binToHex(contractIdFromAddress(response.contractAddress))
     return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 

package/src/transaction/status.ts

@@ -16,7 +16,7 @@ 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 { web3 } from '..'
+import * as web3 from '../global'
 import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
@@ -40,8 +40,6 @@ export class TxStatusSubscription extends Subscription<TxStatus> {
     this.fromGroup = fromGroup
     this.toGroup = toGroup
     this.confirmations = confirmations ?? 1
-
-    this.startPolling()
   }
 
   override async polling(): Promise<void> {
@@ -69,5 +67,7 @@ export function subscribeToTxStatus(
   toGroup?: number,
   confirmations?: number
 ): TxStatusSubscription {
-  return new TxStatusSubscription(options, txId, fromGroup, toGroup, confirmations)
+  const subscription = new TxStatusSubscription(options, txId, fromGroup, toGroup, confirmations)
+  subscription.subscribe()
+  return subscription
 }

package/src/utils/address.ts

@@ -24,6 +24,9 @@ import bs58 from './bs58'
 import djb2 from './djb2'
 import { binToHex, hexToBinUnsafe } from './utils'
 import { KeyType } from '../signer'
+import { MultiSig, lockupScriptCodec } from '../codec/lockup-script-codec'
+import { Buffer } from 'buffer/'
+import { compactSignedIntCodec } from '../codec'
 
 const ec = new EC('secp256k1')
 
@@ -49,8 +52,18 @@ function decodeAndValidateAddress(address: string): Uint8Array {
   if (decoded.length === 0) throw new Error('Address is empty')
   const addressType = decoded[0]
   if (addressType === AddressType.P2MPKH) {
-    // [1, n, ...hashes, m]
-    if ((decoded.length - 3) % 32 === 0) return decoded
+    let multisig: MultiSig
+    try {
+      multisig = lockupScriptCodec.decode(Buffer.from(decoded)).script as MultiSig
+    } catch (_) {
+      throw new Error(`Invalid multisig address: ${address}`)
+    }
+    const n = multisig.publicKeyHashes.value.length
+    const m = compactSignedIntCodec.toI32(multisig.m)
+    if (n < m) {
+      throw new Error(`Invalid multisig address, n: ${n}, m: ${m}`)
+    }
+    return decoded
   } else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {
     // [type, ...hash]
     if (decoded.length === 33) return decoded

package/src/utils/exchange.ts

@@ -16,9 +16,20 @@ 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 { AddressType, addressFromPublicKey, addressFromScript, binToHex, bs58, hexToBinUnsafe } from '..'
+import {
+  AddressType,
+  addressFromPublicKey,
+  addressFromScript,
+  binToHex,
+  bs58,
+  hexToBinUnsafe,
+  isHexString
+} from '../utils'
 import { Transaction } from '../api/api-alephium'
 import { Address } from '../signer'
+import { P2SH, unlockScriptCodec } from '../codec/unlock-script-codec'
+import { Buffer } from 'buffer/'
+import { scriptCodec } from '../codec/script-codec'
 
 export function validateExchangeAddress(address: string) {
   let decoded: Uint8Array
@@ -80,24 +91,35 @@ enum UnlockScriptType {
 }
 
 export function getAddressFromUnlockScript(unlockScript: string): Address {
+  if (!isHexString(unlockScript)) {
+    throw new Error(`Invalid unlock script ${unlockScript}, expected a hex string`)
+  }
   const decoded = 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) {
+    if (unlockScriptBody.length !== 33) {
+      throw new Error(`Invalid p2pkh unlock script: ${unlockScript}`)
+    }
     return addressFromPublicKey(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 addressFromScript(script)
-  } else {
-    throw new Error('Invalid unlock script type')
   }
+
+  if (unlockScriptType === UnlockScriptType.P2SH) {
+    let p2sh: P2SH
+    try {
+      p2sh = unlockScriptCodec.decode(Buffer.from(decoded)).script as P2SH
+    } catch (_) {
+      throw new Error(`Invalid p2sh unlock script: ${unlockScript}`)
+    }
+    return addressFromScript(scriptCodec.encode(p2sh.script))
+  }
+  throw new Error('Invalid unlock script type')
 }
 
 function checkALPHOutput(tx: Transaction): boolean {

package/src/utils/number.ts

@@ -21,7 +21,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 // 2. https://github.com/ethers-io/ethers.js/blob/724881f34d428406488a1c9f9dbebe54b6edecda/src.ts/utils/fixednumber.ts
 
 import BigNumber from 'bignumber.js'
-import { Number256 } from '..'
+import { Number256 } from '../api/types'
 
 export const isNumeric = (numToCheck: any): boolean => !isNaN(parseFloat(numToCheck)) && isFinite(numToCheck)
 

package/src/utils/sign.ts

@@ -17,7 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ec as EC } from 'elliptic'
-import { binToHex, encodeSignature, hexToBinUnsafe, signatureDecode } from '..'
+import { binToHex, encodeSignature, hexToBinUnsafe, signatureDecode } from '../utils'
 import { KeyType } from '../signer'
 import * as necc from '@noble/secp256k1'
 import { createHash, createHmac } from 'crypto'