@alephium/web3 0.2.0-rc.1 → 0.2.0-rc.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.2.0-rc.1",
+  "version": "0.2.0-rc.12",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,29 +27,16 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.5.0-rc2",
+    "alephium_version": "1.5.0-rc7",
     "explorer_backend_version": "1.7.1"
   },
   "scripts": {
     "build": "rm -rf dist/* && npx tsc --build . && webpack",
-    "bundle": "webpack",
+    "test": "jest -i --config ./jest-config.json",
     "update-schemas": "npm run update-schema:alephium && npm run update-schema:explorer",
-    "update-schema:alephium": "npx swagger-typescript-api -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/v${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
-    "update-schema:explorer": "npx swagger-typescript-api -t ./configs -o ./src/api -n api-explorer.ts -p https://raw.githubusercontent.com/alephium/explorer-backend/v${npm_package_config_explorer_backend_version}/app/src/main/resources/explorer-backend-openapi.json",
+    "update-schema:alephium": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/v${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
+    "update-schema:explorer": "npx swagger-typescript-api --disable-throw-on-error -t ./configs -o ./src/api -n api-explorer.ts -p https://raw.githubusercontent.com/alephium/explorer-backend/v${npm_package_config_explorer_backend_version}/app/src/main/resources/explorer-backend-openapi.json",
     "check-versions": "node scripts/check-versions.js ${npm_package_config_alephium_version} ${npm_package_config_explorer_backend_version}",
-    "dev": "tsnd --respawn lib/index.ts",
-    "lint": "eslint . --ext ts",
-    "lint:fix": "eslint . --fix --ext ts",
-    "test": "jest -i --config ./configs/jest.config.ts",
-    "test:client": "jest -i --config ./configs/jest-client.config.ts",
-    "test:unit": "jest -i --config ./configs/jest-unit.config.ts",
-    "test:watch": "npm run test -- --watch --coverage=false",
-    "test:watch:unit": "npm run test:unit -- --watch --coverage=false",
-    "test:watch:client": "npm run test:client -- --watch --coverage=false",
-    "prepublishOnly": "npm run build",
-    "prepack": "node scripts/rename-gitignore.js .gitignore gitignore",
-    "postpack": "node scripts/rename-gitignore.js gitignore .gitignore",
-    "prettier": "prettier --write \"**/*.{js,jsx,ts,tsx,json,md}\"",
     "start-devnet": "node scripts/start-devnet.js ${npm_package_config_alephium_version}",
     "restart-devnet": "npm run start-devnet",
     "stop-devnet": "node scripts/stop-devnet.js"
@@ -64,15 +51,12 @@
     "buffer": "^6.0.3",
     "commander": "^9.1.0",
     "cross-fetch": "^3.1.5",
-    "crypto-js": "4.1.1",
-    "elliptic": "6.5.4",
     "eventemitter3": "^4.0.7",
     "find-up": "^2.1.0",
     "fs-extra": "^10.0.1"
   },
   "devDependencies": {
-    "@types/crypto-js": "^4.1.1",
-    "@types/elliptic": "^6.4.13",
+    "@babel/eslint-parser": "^7.18.9",
     "@types/find-up": "^2.1.0",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.5.1",
@@ -81,14 +65,12 @@
     "@types/rewire": "^2.5.28",
     "@typescript-eslint/eslint-plugin": "^4.30.0",
     "@typescript-eslint/parser": "^4.30.0",
-    "babel-eslint": "^10.1.0",
     "clean-webpack-plugin": "4.0.0",
     "crypto-browserify": "^3.12.0",
     "eslint": "^7.32.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-header": "^3.1.1",
     "eslint-plugin-prettier": "^4.0.0",
-    "eslint-plugin-react": "^7.29.4",
     "eslint-plugin-security": "1.4.0",
     "html-webpack-plugin": "5.5.0",
     "jest": "^28.1.0",
@@ -98,7 +80,6 @@
     "mock-socket": "^9.0.8",
     "prettier": "^2.3.2",
     "process": "^0.11.10",
-    "react-app-rewired": "^2.2.1",
     "rewire": "^6.0.0",
     "shelljs": "^0.8.5",
     "stream-browserify": "^3.0.0",
@@ -107,21 +88,12 @@
     "ts-jest": "^28.0.2",
     "ts-node": "^10.7.0",
     "tslib": "^2.3.1",
-    "typescript": "^4.4.2",
+    "typescript": "4.7.4",
     "webpack": "^5.72.0",
     "webpack-cli": "^4.9.2"
   },
   "engines": {
-    "node": ">=14.0.0",
+    "node": ">=16.0.0",
     "npm": ">=7.0.0"
-  },
-  "prettier": {
-    "printWidth": 120,
-    "tabWidth": 2,
-    "useTabs": false,
-    "semi": false,
-    "singleQuote": true,
-    "bracketSameLine": false,
-    "trailingComma": "none"
   }
 }

package/scripts/create-project.ts

@@ -73,7 +73,7 @@ function prepareShared(packageRoot: string, projectRoot: string) {
   console.log('...')
 
   fsExtra.copySync(path.join(packageRoot, 'templates/shared'), projectRoot)
-  copy('', ['.editorconfig', '.eslintignore', '.gitattributes', 'LICENSE'])
+  copy('', ['.editorconfig', '.eslintignore', '.gitattributes'])
   copy('dev', ['user.conf'])
   copy('scripts', ['start-devnet.js', 'stop-devnet.js'])
   if (fsExtra.existsSync(path.join(packageRoot, 'gitignore'))) {
@@ -87,7 +87,8 @@ function prepareShared(packageRoot: string, projectRoot: string) {
 
 function prepareBase(packageRoot: string, projectRoot: string) {
   prepareShared(packageRoot, projectRoot)
-  copy('contracts', ['greeter.ral', 'greeter_interface.ral', 'greeter_main.ral'])
+  copy('contracts', ['greeter_main.ral'])
+  copy('contracts/greeter', ['greeter.ral', 'greeter_interface.ral'])
   fsExtra.copySync(path.join(packageRoot, 'templates/base'), projectRoot)
 }
 

package/src/api/api-alephium.ts

@@ -422,6 +422,7 @@ export interface ChangeActiveAddress {
 }
 
 export interface CompileContractResult {
+  name: string
   bytecode: string
 
   /** @format 32-byte-hash */
@@ -429,12 +430,29 @@ export interface CompileContractResult {
   fields: FieldsSig
   functions: FunctionSig[]
   events: EventSig[]
+  warnings: string[]
+}
+
+export interface CompileProjectResult {
+  contracts: CompileContractResult[]
+  scripts: CompileScriptResult[]
 }
 
 export interface CompileScriptResult {
+  name: string
   bytecodeTemplate: string
   fields: FieldsSig
   functions: FunctionSig[]
+  warnings: string[]
+}
+
+export interface CompilerOptions {
+  ignoreUnusedConstantsWarnings?: boolean
+  ignoreUnusedVariablesWarnings?: boolean
+  ignoreUnusedFieldsWarnings?: boolean
+  ignoreUnusedPrivateFunctionsWarnings?: boolean
+  ignoreReadonlyCheckWarnings?: boolean
+  ignoreExternalCallCheckWarnings?: boolean
 }
 
 export interface Confirmed {
@@ -457,6 +475,7 @@ export interface Confirmed {
 
 export interface Contract {
   code: string
+  compilerOptions?: CompilerOptions
 }
 
 export interface ContractEvent {
@@ -561,7 +580,6 @@ export type DiscoveryAction = Reachable | Unreachable
 
 export interface EventSig {
   name: string
-  signature: string
   fieldNames: string[]
   fieldTypes: string[]
 }
@@ -571,9 +589,9 @@ export interface FetchResponse {
 }
 
 export interface FieldsSig {
-  signature: string
   names: string[]
   types: string[]
+  isMutable: boolean[]
 }
 
 export interface FixedAssetOutput {
@@ -599,9 +617,12 @@ export interface FixedAssetOutput {
 
 export interface FunctionSig {
   name: string
-  signature: string
-  argNames: string[]
-  argTypes: string[]
+  usePreapprovedAssets: boolean
+  useAssetsInContract: boolean
+  isPublic: boolean
+  paramNames: string[]
+  paramTypes: string[]
+  paramIsMutable: boolean[]
   returnTypes: string[]
 }
 
@@ -703,6 +724,11 @@ export interface Penalty {
   type: string
 }
 
+export interface Project {
+  code: string
+  compilerOptions?: CompilerOptions
+}
+
 export interface Reachable {
   peers: string[]
   type: string
@@ -729,6 +755,7 @@ export interface RevealMnemonicResult {
 
 export interface Script {
   code: string
+  compilerOptions?: CompilerOptions
 }
 
 export interface SelfClique {
@@ -1058,16 +1085,7 @@ export interface WalletUnlock {
 }
 
 import 'cross-fetch/polyfill'
-
-function convertHttpResponse<T>(
-  response: HttpResponse<T, { detail: string }> | HttpResponse<T, { detail: string }>
-): T {
-  if (response.error) {
-    throw new Error(response.error.detail)
-  } else {
-    return response.data
-  }
-}
+import { convertHttpResponse } from './utils'
 
 export type QueryParamsType = Record<string | number, any>
 export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>
@@ -1271,7 +1289,6 @@ export class HttpClient<SecurityDataType = unknown> {
         this.abortControllers.delete(cancelToken)
       }
 
-      if (!response.ok) throw data
       return data
     })
   }
@@ -2160,6 +2177,27 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * No description
+     *
+     * @tags Contracts
+     * @name PostContractsCompileProject
+     * @summary Compile a project
+     * @request POST:/contracts/compile-project
+     */
+    postContractsCompileProject: (data: Project, params: RequestParams = {}) =>
+      this.request<
+        CompileProjectResult,
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/contracts/compile-project`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * No description
      *

package/src/api/api-explorer.ts

@@ -278,16 +278,7 @@ export interface UnconfirmedTransaction {
 }
 
 import 'cross-fetch/polyfill'
-
-function convertHttpResponse<T>(
-  response: HttpResponse<T, { detail: string }> | HttpResponse<T, { detail: string }>
-): T {
-  if (response.error) {
-    throw new Error(response.error.detail)
-  } else {
-    return response.data
-  }
-}
+import { convertHttpResponse } from './utils'
 
 export type QueryParamsType = Record<string | number, any>
 export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>
@@ -491,7 +482,6 @@ export class HttpClient<SecurityDataType = unknown> {
         this.abortControllers.delete(cancelToken)
       }
 
-      if (!response.ok) throw data
       return data
     })
   }

package/src/api/index.ts

@@ -19,9 +19,19 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import { Api as NodeApi } from './api-alephium'
 import { Api as ExplorerApi } from './api-explorer'
 
-export class NodeProvider extends NodeApi<null> {
-  constructor(baseUrl: string) {
-    super({ baseUrl: baseUrl })
+export class NodeProvider extends NodeApi<string> {
+  constructor(baseUrl: string, apiKey?: string) {
+    // eslint-disable-next-line security/detect-possible-timing-attacks
+    if (apiKey === undefined) {
+      super({ baseUrl: baseUrl })
+    } else {
+      super({
+        baseUrl: baseUrl,
+        baseApiParams: { secure: true },
+        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+      })
+      this.setSecurityData(apiKey)
+    }
   }
 }
 
@@ -33,3 +43,4 @@ export class ExplorerProvider extends ExplorerApi<null> {
 
 export * as node from './api-alephium'
 export * as explorer from './api-explorer'
+export * from './types'

package/src/api/types.ts

@@ -0,0 +1,233 @@
+/*
+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 { assertType, bs58, Eq } from '../utils'
+import * as node from './api-alephium'
+
+export type Number256 = number | bigint | string
+export type Val = Number256 | boolean | string | Val[]
+export type NamedVals = Record<string, Val>
+
+export interface Token {
+  id: string
+  amount: Number256
+}
+assertType<Eq<keyof Token, keyof node.Token>>
+
+export function toApiToken(token: Token): node.Token {
+  return { id: token.id, amount: toApiNumber256(token.amount) }
+}
+
+export function toApiTokens(tokens?: Token[]): node.Token[] | undefined {
+  return tokens?.map(toApiToken)
+}
+
+export function fromApiToken(token: node.Token): Token {
+  return { id: token.id, amount: fromApiNumber256(token.amount) }
+}
+
+export function fromApiTokens(tokens?: node.Token[]): Token[] | undefined {
+  return tokens?.map(fromApiToken)
+}
+
+export function toApiBoolean(v: Val): boolean {
+  if (typeof v === 'boolean') {
+    return v
+  } else {
+    throw new Error(`Invalid boolean value: ${v}`)
+  }
+}
+
+// TODO: check integer bounds
+export function toApiNumber256(v: Val): string {
+  if ((typeof v === 'number' && Number.isInteger(v)) || typeof v === 'bigint') {
+    return v.toString()
+  } else if (typeof v === 'string') {
+    return v
+  } else {
+    throw new Error(`Invalid 256 bit number: ${v}`)
+  }
+}
+
+export function toApiNumber256Optional(v?: Val): string | undefined {
+  return v === undefined ? undefined : toApiNumber256(v)
+}
+
+export function fromApiNumber256(n: string): Number256 {
+  if (Number.isSafeInteger(Number.parseInt(n))) {
+    return Number(n)
+  } else {
+    return BigInt(n)
+  }
+}
+
+// TODO: check hex string
+export function toApiByteVec(v: Val): string {
+  if (typeof v === 'string') {
+    // try to convert from address to contract id
+    try {
+      const address = bs58.decode(v)
+      if (address.length == 33 && address[0] == 3) {
+        return Buffer.from(address.slice(1)).toString('hex')
+      }
+    } catch (_) {
+      return v as string
+    }
+    return v as string
+  } else {
+    throw new Error(`Invalid string: ${v}`)
+  }
+}
+
+export function toApiAddress(v: Val): string {
+  if (typeof v === 'string') {
+    try {
+      bs58.decode(v)
+      return v as string
+    } catch (error) {
+      throw new Error(`Invalid base58 string: ${v}`)
+    }
+  } else {
+    throw new Error(`Invalid string: ${v}`)
+  }
+}
+
+export function toApiArray(tpe: string, v: Val): node.Val {
+  if (!Array.isArray(v)) {
+    throw new Error(`Expected array, got ${v}`)
+  }
+
+  const semiColonIndex = tpe.lastIndexOf(';')
+  if (semiColonIndex == -1) {
+    throw new Error(`Invalid Val type: ${tpe}`)
+  }
+
+  const subType = tpe.slice(1, semiColonIndex)
+  const dim = parseInt(tpe.slice(semiColonIndex + 1, -1))
+  if ((v as Val[]).length != dim) {
+    throw new Error(`Invalid val dimension: ${v}`)
+  } else {
+    return { value: (v as Val[]).map((v) => toApiVal(v, subType)), type: 'Array' }
+  }
+}
+
+export function toApiVal(v: Val, tpe: string): node.Val {
+  if (tpe === 'Bool') {
+    return { value: toApiBoolean(v), type: tpe }
+  } else if (tpe === 'U256' || tpe === 'I256') {
+    return { value: toApiNumber256(v), type: tpe }
+  } else if (tpe === 'ByteVec') {
+    return { value: toApiByteVec(v), type: tpe }
+  } else if (tpe === 'Address') {
+    return { value: toApiAddress(v), type: tpe }
+  } else {
+    return toApiArray(tpe, v)
+  }
+}
+
+function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result: Val, nextIndex: number] {
+  if (vals.length === 0) {
+    throw new Error('Not enough Vals')
+  }
+
+  const firstVal = vals[`${valIndex}`]
+  if (tpe === 'Bool' && firstVal.type === tpe) {
+    return [firstVal.value as boolean, valIndex + 1]
+  } else if ((tpe === 'U256' || tpe === 'I256') && firstVal.type === tpe) {
+    return [fromApiNumber256(firstVal.value as string), valIndex + 1]
+  } else if ((tpe === 'ByteVec' || tpe === 'Address') && firstVal.type === tpe) {
+    return [firstVal.value as string, valIndex + 1]
+  } else {
+    const [baseType, dims] = decodeArrayType(tpe)
+    const arraySize = dims.reduce((a, b) => a * b)
+    const nextIndex = valIndex + arraySize
+    const valsToUse = vals.slice(valIndex, nextIndex)
+    if (valsToUse.length == arraySize && valsToUse.every((val) => val.type === baseType)) {
+      const localVals = valsToUse.map((val) => fromApiVal(val, baseType))
+      return [foldVals(localVals, dims), nextIndex]
+    } else {
+      throw new Error(`Invalid array Val type: ${valsToUse}, ${tpe}`)
+    }
+  }
+}
+
+export function fromApiVals(vals: node.Val[], names: string[], types: string[]): NamedVals {
+  let valIndex = 0
+  const result: NamedVals = {}
+  types.forEach((currentType, index) => {
+    const currentName = names[`${index}`]
+    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
+    valIndex = nextIndex
+    result[`${currentName}`] = val
+  })
+  return result
+}
+
+export function fromApiArray(vals: node.Val[], types: string[]): Val[] {
+  let valIndex = 0
+  const result: Val[] = []
+  for (const currentType of types) {
+    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
+    result.push(val)
+    valIndex = nextIndex
+  }
+  return result
+}
+
+export function fromApiVal(v: node.Val, tpe: string): Val {
+  if (v.type === 'Bool' && v.type === tpe) {
+    return v.value as boolean
+  } else if ((v.type === 'U256' || v.type === 'I256') && v.type === tpe) {
+    return fromApiNumber256(v.value as string)
+  } else if ((v.type === 'ByteVec' || v.type === 'Address') && v.type === tpe) {
+    return v.value as string
+  } else {
+    throw new Error(`Invalid node.Val type: ${v}`)
+  }
+}
+
+function decodeArrayType(tpe: string): [baseType: string, dims: number[]] {
+  const semiColonIndex = tpe.lastIndexOf(';')
+  if (semiColonIndex === -1) {
+    throw new Error(`Invalid Val type: ${tpe}`)
+  }
+
+  const subType = tpe.slice(1, semiColonIndex)
+  const dim = parseInt(tpe.slice(semiColonIndex + 1, -1))
+  if (subType[0] == '[') {
+    const [baseType, subDim] = decodeArrayType(subType)
+    return [baseType, (subDim.unshift(dim), subDim)]
+  } else {
+    return [subType, [dim]]
+  }
+}
+
+function foldVals(vals: Val[], dims: number[]): Val {
+  if (dims.length == 1) {
+    return vals
+  } else {
+    const result: Val[] = []
+    const chunkSize = vals.length / dims[0]
+    const chunkDims = dims.slice(1)
+    for (let i = 0; i < vals.length; i += chunkSize) {
+      const chunk = vals.slice(i, i + chunkSize)
+      result.push(foldVals(chunk, chunkDims))
+    }
+    return result
+  }
+}

package/src/{utils/password-crypto.test.ts → api/utils.ts}

@@ -16,12 +16,10 @@ 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 { decrypt } from './password-crypto'
-
-describe('password-crypto', () => {
-  it('should raise an error if payload version is not 1', () => {
-    const password = 'passw0rd'
-    const payloadRaw = '{"version":2}'
-    expect(() => decrypt(password, payloadRaw)).toThrow('Invalid version: got 2, expected: 1')
-  })
-})
+export function convertHttpResponse<T>(response: { data: T; error?: { detail: string } }): T {
+  if (response.error) {
+    throw new Error(`[Node API Error] - ${response.error.detail}`)
+  } else {
+    return response.data
+  }
+}