@alephium/web3 0.3.0-rc.5 → 0.3.0-rc.8

package/src/contract/contract.ts

@@ -86,14 +86,32 @@ class TypedMatcher<T extends SourceKind> {
   }
 }
 
+function removeParentsPrefix(parts: string[]): string {
+  let index = 0
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[`${i}`] === '..') {
+      index += 1
+    } else {
+      break
+    }
+  }
+  return path.join(...parts.slice(index))
+}
+
 class SourceInfo {
   type: SourceKind
   name: string
   contractRelativePath: string
   sourceCode: string
   sourceCodeHash: string
+  isExternal: boolean
 
   getArtifactPath(artifactsRootDir: string): string {
+    if (this.isExternal) {
+      const relativePath = removeParentsPrefix(this.contractRelativePath.split(path.sep))
+      const externalPath = path.join('.external', relativePath)
+      return path.join(artifactsRootDir, externalPath) + '.json'
+    }
     return path.join(artifactsRootDir, this.contractRelativePath) + '.json'
   }
 
@@ -102,23 +120,27 @@ class SourceInfo {
     name: string,
     sourceCode: string,
     sourceCodeHash: string,
-    contractRelativePath: string
+    contractRelativePath: string,
+    isExternal: boolean
   ) {
     this.type = type
     this.name = name
     this.sourceCode = sourceCode
     this.sourceCodeHash = sourceCodeHash
     this.contractRelativePath = contractRelativePath
+    this.isExternal = isExternal
   }
 
   static async from(
     type: SourceKind,
     name: string,
     sourceCode: string,
-    contractRelativePath: string
+    contractRelativePath: string,
+    isExternal: boolean
   ): Promise<SourceInfo> {
     const sourceCodeHash = await crypto.subtle.digest('SHA-256', Buffer.from(sourceCode))
-    return new SourceInfo(type, name, sourceCode, Buffer.from(sourceCodeHash).toString('hex'), contractRelativePath)
+    const sourceCodeHashHex = Buffer.from(sourceCodeHash).toString('hex')
+    return new SourceInfo(type, name, sourceCode, sourceCodeHashHex, contractRelativePath, isExternal)
   }
 }
 
@@ -223,12 +245,13 @@ export class Project {
 
   static currentProject: Project
 
+  static readonly importRegex = new RegExp('^import "[^"./]+/[^"]*[a-z][a-z_0-9]*(.ral)?"', 'mg')
   static readonly abstractContractMatcher = new TypedMatcher<SourceKind>(
     '^Abstract Contract ([A-Z][a-zA-Z0-9]*)',
     SourceKind.AbstractContract
   )
   static readonly contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract)
-  static readonly interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceKind.Interface)
+  static readonly interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*)', SourceKind.Interface)
   static readonly scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script)
   static readonly matchers = [
     Project.abstractContractMatcher,
@@ -445,45 +468,107 @@ export class Project {
     }
   }
 
+  private static getImportSourcePath(projectRootDir: string, importPath: string): string {
+    const parts = importPath.split(path.sep)
+    if (parts.length > 1 && parts[0] === 'std') {
+      const currentDir = path.dirname(__filename)
+      return path.join(...[currentDir, '..', '..', '..', importPath])
+    }
+    let moduleDir = projectRootDir
+    while (true) {
+      const expectedPath = path.join(...[moduleDir, 'node_modules', importPath])
+      if (fs.existsSync(expectedPath)) {
+        return expectedPath
+      }
+      const oldModuleDir = moduleDir
+      moduleDir = path.join(moduleDir, '..')
+      if (oldModuleDir === moduleDir) {
+        throw new Error(`Specified import file does not exist: ${importPath}`)
+      }
+    }
+  }
+
+  private static async handleImports(
+    projectRootDir: string,
+    contractRootDir: string,
+    sourceStr: string,
+    importsCache: string[]
+  ): Promise<[string, SourceInfo[]]> {
+    const localImportsCache: string[] = []
+    const result = sourceStr.replace(Project.importRegex, (match) => {
+      localImportsCache.push(match)
+      return ''
+    })
+    const externalSourceInfos: SourceInfo[] = []
+    for (const myImport of localImportsCache) {
+      const originImportPath = myImport.slice(8, -1)
+      const importPath = originImportPath.endsWith('.ral') ? originImportPath : originImportPath + '.ral'
+      if (!importsCache.includes(importPath)) {
+        importsCache.push(importPath)
+        const sourcePath = Project.getImportSourcePath(projectRootDir, importPath)
+        const sourceInfos = await Project.loadSourceFile(
+          projectRootDir,
+          contractRootDir,
+          sourcePath,
+          importsCache,
+          true
+        )
+        externalSourceInfos.push(...sourceInfos)
+      }
+    }
+    return [result, externalSourceInfos]
+  }
+
   private static async loadSourceFile(
+    projectRootDir: string,
     contractsRootDir: string,
-    dirPath: string,
-    filename: string
+    sourcePath: string,
+    importsCache: string[],
+    isExternal: boolean
   ): Promise<SourceInfo[]> {
-    const contractPath = path.join(dirPath, filename)
-    const contractRelativePath = path.relative(contractsRootDir, contractPath)
-    if (!filename.endsWith('.ral')) {
-      throw new Error(`Invalid filename: ${contractPath}, smart contract file name should end with ".ral"`)
+    const contractRelativePath = path.relative(contractsRootDir, sourcePath)
+    if (!sourcePath.endsWith('.ral')) {
+      throw new Error(`Invalid filename: ${sourcePath}, smart contract file name should end with ".ral"`)
     }
 
-    const sourceBuffer = await fsPromises.readFile(contractPath)
-    const sourceStr = sourceBuffer.toString()
-    const sourceInfos: SourceInfo[] = []
+    const sourceBuffer = await fsPromises.readFile(sourcePath)
+    const [sourceStr, externalSourceInfos] = await Project.handleImports(
+      projectRootDir,
+      contractsRootDir,
+      sourceBuffer.toString(),
+      importsCache
+    )
+    if (sourceStr.match(new RegExp('^import "', 'mg')) !== null) {
+      throw new Error(`Invalid import statements, source: ${sourcePath}`)
+    }
+    const sourceInfos = externalSourceInfos
     for (const matcher of this.matchers) {
       const results = sourceStr.matchAll(matcher.matcher)
       for (const result of results) {
-        const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath)
+        const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath, isExternal)
         sourceInfos.push(sourceInfo)
       }
     }
     return sourceInfos
   }
 
-  private static async loadSourceFiles(contractsRootDir: string): Promise<SourceInfo[]> {
-    const loadDir = async function (dirPath: string, results: SourceInfo[]): Promise<void> {
+  private static async loadSourceFiles(projectRootDir: string, contractsRootDir: string): Promise<SourceInfo[]> {
+    const importsCache: string[] = []
+    const sourceInfos: SourceInfo[] = []
+    const loadDir = async function (dirPath: string): Promise<void> {
       const dirents = await fsPromises.readdir(dirPath, { withFileTypes: true })
       for (const dirent of dirents) {
         if (dirent.isFile()) {
-          const sourceInfos = await Project.loadSourceFile(contractsRootDir, dirPath, dirent.name)
-          results.push(...sourceInfos)
+          const sourcePath = path.join(dirPath, dirent.name)
+          const infos = await Project.loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, false)
+          sourceInfos.push(...infos)
         } else {
           const newPath = path.join(dirPath, dirent.name)
-          await loadDir(newPath, results)
+          await loadDir(newPath)
         }
       }
     }
-    const sourceInfos: SourceInfo[] = []
-    await loadDir(contractsRootDir, sourceInfos)
+    await loadDir(contractsRootDir)
     const contractAndScriptSize = sourceInfos.filter(
       (f) => f.type === SourceKind.Contract || f.type === SourceKind.Script
     ).length
@@ -498,11 +583,12 @@ export class Project {
 
   static async build(
     compilerOptionsPartial: Partial<CompilerOptions> = {},
+    projectRootDir = '.',
     contractsRootDir = Project.DEFAULT_CONTRACTS_DIR,
     artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR
   ): Promise<void> {
     const provider = getCurrentNodeProvider()
-    const sourceFiles = await Project.loadSourceFiles(contractsRootDir)
+    const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir)
     const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
     const projectArtifact = await ProjectArtifact.from(artifactsRootDir)
     if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {

package/src/signer/index.ts

@@ -18,3 +18,4 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 export * from './signer'
 export * from './types'
+export * from './tx-builder'

package/src/signer/signer.ts

@@ -17,15 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ec as EC } from 'elliptic'
-import {
-  ExplorerProvider,
-  fromApiNumber256,
-  fromApiTokens,
-  NodeProvider,
-  toApiNumber256,
-  toApiNumber256Optional,
-  toApiTokens
-} from '../api'
+import { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, toApiTokens } from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
 import blake from 'blakejs'
@@ -46,8 +38,14 @@ import {
   SignUnsignedTxParams,
   SignUnsignedTxResult,
   SubmissionResult,
-  SubmitTransactionParams
+  SubmitTransactionParams,
+  ExtSignTransferTxParams,
+  ExtSignDeployContractTxParams,
+  ExtSignExecuteScriptTxParams,
+  ExtSignUnsignedTxParams,
+  ExtSignMessageParams
 } from './types'
+import { TransactionBuilder } from './tx-builder'
 
 const ec = new EC('secp256k1')
 
@@ -71,12 +69,19 @@ export interface SignerProvider {
 // Abstraction for interactive signer (e.g. WalletConnect instance, Extension wallet object)
 export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase>
   extends SignerProvider {
-  enable(opt?: EnableOptions): Promise<void>
+  enable(opt?: EnableOptions): Promise<Address>
   disconnect(): Promise<void>
+
+  // Methods inherited from SignerProvider, but require networkId in the params
+  signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>
+  signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>
+  signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>
 }
 
-export abstract class SignerProviderSimple implements SignerProvider {
-  abstract get nodeProvider(): NodeProvider | undefined
+export abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
   abstract get explorerProvider(): ExplorerProvider | undefined
 
   abstract getSelectedAccount(): Promise<Account>
@@ -86,16 +91,9 @@ export abstract class SignerProviderSimple implements SignerProvider {
     return account.address
   }
 
-  private getNodeProvider(): NodeProvider {
-    if (this.nodeProvider === undefined) {
-      throw Error('The signer does not contain a node provider')
-    }
-    return this.nodeProvider
-  }
-
   async submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult> {
     const data: node.SubmitTransaction = { unsignedTx: params.unsignedTx, signature: params.signature }
-    return this.getNodeProvider().transactions.postTransactionsSubmit(data)
+    return this.nodeProvider.transactions.postTransactionsSubmit(data)
   }
 
   async signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
@@ -132,67 +130,43 @@ export abstract class SignerProviderSimple implements SignerProvider {
   async signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult> {
     const response = await this.buildTransferTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
-    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
+    return { signature, ...response }
   }
 
-  async buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult> {
-    const data: node.BuildTransaction = {
-      ...(await this.usePublicKey(params)),
-      destinations: toApiDestinations(params.destinations),
-      gasPrice: toApiNumber256Optional(params.gasPrice)
-    }
-    return this.getNodeProvider().transactions.postTransactionsBuild(data)
+  override async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    return super.buildTransferTx(params, await this.getPublicKey(params.signerAddress))
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
-    const response = await this.buildContractCreationTx(params)
+    const response = await this.buildDeployContractTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
-    const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress))
-    return { ...response, contractId, signature, gasPrice: fromApiNumber256(response.gasPrice) }
+    return { signature, ...response }
   }
 
-  async buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult> {
-    const data: node.BuildDeployContractTx = {
-      ...(await this.usePublicKey(params)),
-      initialAttoAlphAmount: toApiNumber256Optional(params.initialAttoAlphAmount),
-      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
-      issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
-      gasPrice: toApiNumber256Optional(params.gasPrice)
-    }
-    return this.getNodeProvider().contracts.postContractsUnsignedTxDeployContract(data)
+  override async buildDeployContractTx(
+    params: SignDeployContractTxParams
+  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+    return super.buildDeployContractTx(params, await this.getPublicKey(params.signerAddress))
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
-    const response = await this.buildScriptTx(params)
+    const response = await this.buildExecuteScriptTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
-    return { ...response, signature, gasPrice: fromApiNumber256(response.gasPrice) }
+    return { signature, ...response }
   }
 
-  async buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult> {
-    const data: node.BuildExecuteScriptTx = {
-      ...(await this.usePublicKey(params)),
-      attoAlphAmount: toApiNumber256Optional(params.attoAlphAmount),
-      tokens: toApiTokens(params.tokens),
-      gasPrice: toApiNumber256Optional(params.gasPrice)
-    }
-    return this.getNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data)
+  override async buildExecuteScriptTx(
+    params: SignExecuteScriptTxParams
+  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    return super.buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress))
   }
 
   // in general, wallet should show the decoded information to user for confirmation
   // please overwrite this function for real wallet
   async signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
-    const data = { unsignedTx: params.unsignedTx }
-    const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data)
-    const signature = await this.signRaw(params.signerAddress, decoded.unsignedTx.txId)
-    return {
-      fromGroup: decoded.fromGroup,
-      toGroup: decoded.toGroup,
-      unsignedTx: params.unsignedTx,
-      txId: decoded.unsignedTx.txId,
-      signature,
-      gasAmount: decoded.unsignedTx.gasAmount,
-      gasPrice: fromApiNumber256(decoded.unsignedTx.gasPrice)
-    }
+    const response = await this.buildUnsignedTx(params)
+    const signature = await this.signRaw(params.signerAddress, response.txId)
+    return { signature, ...response }
   }
 
   async signMessage(params: SignMessageParams): Promise<SignMessageResult> {

package/src/signer/tx-builder.ts

@@ -0,0 +1,121 @@
+/*
+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 { utils } from '..'
+import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiTokens } from '../api'
+import { addressFromPublicKey } from '../utils'
+import { toApiDestinations } from './signer'
+import {
+  SignDeployContractTxParams,
+  SignDeployContractTxResult,
+  SignerAddress,
+  SignExecuteScriptTxParams,
+  SignExecuteScriptTxResult,
+  SignTransferTxParams,
+  SignTransferTxResult,
+  SignUnsignedTxParams,
+  SignUnsignedTxResult
+} from './types'
+
+export abstract class TransactionBuilder {
+  abstract get nodeProvider(): NodeProvider
+
+  static create(baseUrl: string, apiKey?: string) {
+    const nodeProvider = new NodeProvider(baseUrl, apiKey)
+    return new (class extends TransactionBuilder {
+      get nodeProvider(): NodeProvider {
+        return nodeProvider
+      }
+    })()
+  }
+
+  private static validatePublicKey(params: SignerAddress, publicKey: string) {
+    const address = addressFromPublicKey(publicKey)
+    if (address !== params.signerAddress) {
+      throw new Error('Unmatched public key')
+    }
+  }
+
+  async buildTransferTx(
+    params: SignTransferTxParams,
+    publicKey: string
+  ): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    TransactionBuilder.validatePublicKey(params, publicKey)
+
+    const { destinations, gasPrice, ...rest } = params
+    const data: node.BuildTransaction = {
+      fromPublicKey: publicKey,
+      destinations: toApiDestinations(destinations),
+      gasPrice: toApiNumber256Optional(gasPrice),
+      ...rest
+    }
+    const response = await this.nodeProvider.transactions.postTransactionsBuild(data)
+    return { ...response, gasPrice: fromApiNumber256(response.gasPrice) }
+  }
+
+  async buildDeployContractTx(
+    params: SignDeployContractTxParams,
+    publicKey: string
+  ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
+    TransactionBuilder.validatePublicKey(params, publicKey)
+
+    const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params
+    const data: node.BuildDeployContractTx = {
+      fromPublicKey: publicKey,
+      initialAttoAlphAmount: toApiNumber256Optional(initialAttoAlphAmount),
+      initialTokenAmounts: toApiTokens(initialTokenAmounts),
+      issueTokenAmount: toApiNumber256Optional(issueTokenAmount),
+      gasPrice: toApiNumber256Optional(gasPrice),
+      ...rest
+    }
+    const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
+    const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress))
+    return { ...response, contractId, gasPrice: fromApiNumber256(response.gasPrice) }
+  }
+
+  async buildExecuteScriptTx(
+    params: SignExecuteScriptTxParams,
+    publicKey: string
+  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    TransactionBuilder.validatePublicKey(params, publicKey)
+
+    const { attoAlphAmount, tokens, gasPrice, ...rest } = params
+    const data: node.BuildExecuteScriptTx = {
+      fromPublicKey: publicKey,
+      attoAlphAmount: toApiNumber256Optional(attoAlphAmount),
+      tokens: toApiTokens(tokens),
+      gasPrice: toApiNumber256Optional(gasPrice),
+      ...rest
+    }
+    const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data)
+    return { ...response, gasPrice: fromApiNumber256(response.gasPrice) }
+  }
+
+  async buildUnsignedTx(params: SignUnsignedTxParams): Promise<Omit<SignUnsignedTxResult, 'signature'>> {
+    const data = { unsignedTx: params.unsignedTx }
+    const decoded = await this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data)
+    return {
+      fromGroup: decoded.fromGroup,
+      toGroup: decoded.toGroup,
+      unsignedTx: params.unsignedTx,
+      txId: decoded.unsignedTx.txId,
+      gasAmount: decoded.unsignedTx.gasAmount,
+      gasPrice: fromApiNumber256(decoded.unsignedTx.gasPrice)
+    }
+  }
+}

package/src/signer/types.ts

@@ -143,6 +143,13 @@ export interface SubmissionResult {
 export interface EnableOptionsBase {
   // chainGroup - specify whether to use addresses from a specific group
   chainGroup?: number
+  networkId: string
   onDisconnected: () => Promise<void>
-  onNetworkChanged: (network: { networkName: string; networkId: number }) => Promise<void>
 }
+
+// Transaction Params for InteractiveSignerProvider
+export type ExtSignTransferTxParams = SignTransferTxParams & { networkId: string }
+export type ExtSignDeployContractTxParams = SignDeployContractTxParams & { networkId: string }
+export type ExtSignExecuteScriptTxParams = SignExecuteScriptTxParams & { networkId: string }
+export type ExtSignUnsignedTxParams = SignUnsignedTxParams & { networkId: string }
+export type ExtSignMessageParams = SignMessageParams & { networkId: string }

package/std/token_interface.ral

@@ -0,0 +1,9 @@
+Interface IToken {
+  pub fn getSymbol() -> ByteVec
+
+  pub fn getName() -> ByteVec
+
+  pub fn getDecimals() -> U256
+
+  pub fn getTotalSupply() -> U256
+}