@alephium/web3 0.8.2-test.3 → 0.9.0-rc.1

package/src/api/node-provider.ts

@@ -20,7 +20,7 @@ import { ApiRequestArguments, ApiRequestHandler, forwardRequests, request, Token
 import { Api as NodeApi } from './api-alephium'
 import { DEFAULT_THROTTLE_FETCH } from './utils'
 import { HexString } from '../contract'
-import { addressFromTokenId } from '../utils'
+import { addressFromTokenId, groupOfAddress } from '../utils'
 
 function initializeNodeApi(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): NodeApi<string> {
   const nodeApi = new NodeApi<string>({
@@ -33,7 +33,21 @@ function initializeNodeApi(baseUrl: string, apiKey?: string, customFetch?: typeo
   return nodeApi
 }
 
-export class NodeProvider {
+interface NodeProviderApis {
+  wallets: NodeApi<string>['wallets']
+  infos: NodeApi<string>['infos']
+  blockflow: NodeApi<string>['blockflow']
+  addresses: NodeApi<string>['addresses']
+  transactions: NodeApi<string>['transactions']
+  mempool: NodeApi<string>['mempool']
+  contracts: NodeApi<string>['contracts']
+  multisig: NodeApi<string>['multisig']
+  utils: NodeApi<string>['utils']
+  miners: NodeApi<string>['miners']
+  events: NodeApi<string>['events']
+}
+
+export class NodeProvider implements NodeProviderApis {
   readonly wallets: NodeApi<string>['wallets']
   readonly infos: NodeApi<string>['infos']
   readonly blockflow: NodeApi<string>['blockflow']
@@ -50,13 +64,9 @@ export class NodeProvider {
   constructor(provider: NodeProvider)
   constructor(handler: ApiRequestHandler)
   constructor(param0: string | NodeProvider | ApiRequestHandler, apiKey?: string, customFetch?: typeof fetch) {
-    let nodeApi: NodeProvider
+    let nodeApi: NodeProviderApis
     if (typeof param0 === 'string') {
-      const api = initializeNodeApi(param0, apiKey, customFetch)
-      nodeApi = {
-        ...api,
-        fetchStdTokenMetaData: async (tokenId: string) => fetchStdTokenMetaData(api.contracts, tokenId)
-      }
+      nodeApi = initializeNodeApi(param0, apiKey, customFetch)
     } else if (typeof param0 === 'function') {
       nodeApi = new NodeProvider('https://1.2.3.4:0')
       forwardRequests(nodeApi, param0 as ApiRequestHandler)
@@ -92,24 +102,30 @@ export class NodeProvider {
 
   // Only use this when the token is following the standard token interface
   fetchStdTokenMetaData = async (tokenId: HexString): Promise<TokenMetaData> => {
-    return fetchStdTokenMetaData(this.contracts, tokenId)
+    const group = 0
+    const address = addressFromTokenId(tokenId)
+    const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }))
+    const result = await this.contracts.postContractsMulticallContract({
+      calls: calls
+    })
+    return {
+      symbol: result.results[0].returns[0].value as any as string,
+      name: result.results[1].returns[0].value as any as string,
+      decimals: Number(result.results[2].returns[0].value as any as string),
+      totalSupply: BigInt(result.results[3].returns[0].value as any as string)
+    }
   }
-}
 
-async function fetchStdTokenMetaData(
-  contractAPI: NodeApi<string>['contracts'],
-  tokenId: HexString
-): Promise<TokenMetaData> {
-  const group = 0
-  const address = addressFromTokenId(tokenId)
-  const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }))
-  const result = await contractAPI.postContractsMulticallContract({
-    calls: calls
-  })
-  return {
-    symbol: result.results[0].returns[0].value as any as string,
-    name: result.results[1].returns[0].value as any as string,
-    decimals: Number(result.results[2].returns[0].value as any as string),
-    totalSupply: BigInt(result.results[3].returns[0].value as any as string)
+  guessStdInterfaceId = async (tokenId: HexString): Promise<HexString | undefined> => {
+    const address = addressFromTokenId(tokenId)
+    const group = groupOfAddress(address)
+    const rawState = await this.contracts.getContractsAddressState(addressFromTokenId(tokenId), { group })
+    const lastImmField = rawState.immFields.slice(-1).pop()?.value
+    const interfaceIdPrefix = '414c5048' // the hex of 'ALPH'
+    if (typeof lastImmField === 'string' && lastImmField.startsWith(interfaceIdPrefix)) {
+      return lastImmField.slice(8)
+    } else {
+      return undefined
+    }
   }
 }

package/src/api/types.ts

@@ -136,7 +136,12 @@ export function toApiVal(v: Val, tpe: string): node.Val {
   }
 }
 
-function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result: Val, nextIndex: number] {
+function _fromApiVal(
+  vals: node.Val[],
+  valIndex: number,
+  tpe: string,
+  systemEvent = false
+): [result: Val, nextIndex: number] {
   if (vals.length === 0) {
     throw new Error('Not enough Vals')
   }
@@ -146,7 +151,7 @@ function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result:
     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) {
+  } else if ((tpe === 'ByteVec' || tpe === 'Address') && (firstVal.type === tpe || systemEvent)) {
     return [firstVal.value as string, valIndex + 1]
   } else {
     const [baseType, dims] = decodeArrayType(tpe)
@@ -162,26 +167,16 @@ function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result:
   }
 }
 
-export function fromApiVals(
-  vals: node.Val[],
-  names: string[],
-  types: string[],
-  optionalNames: string[] = [],
-  optionalTypes: string[] = []
-): NamedVals {
+export function fromApiVals(vals: node.Val[], names: string[], types: string[], systemEvent = false): NamedVals {
   let valIndex = 0
   const result: NamedVals = {}
   types.forEach((currentType, index) => {
     const currentName = names[`${index}`]
-    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
+    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType, systemEvent)
     valIndex = nextIndex
     result[`${currentName}`] = val
   })
-  if (valIndex === vals.length) {
-    return result
-  }
-  const optionalFields = fromApiVals(vals.slice(valIndex), optionalNames, optionalTypes)
-  return { ...result, ...optionalFields }
+  return result
 }
 
 export function fromApiArray(vals: node.Val[], types: string[]): Val[] {

package/src/contract/contract.ts

@@ -68,6 +68,8 @@ export type Fields = NamedVals
 export type Arguments = NamedVals
 export type HexString = string
 
+export const StdIdFieldName = '__stdInterfaceId'
+
 enum SourceKind {
   Contract = 0,
   Script = 1,
@@ -667,6 +669,7 @@ export class Contract extends Artifact {
   readonly codeHash: string
   readonly fieldsSig: FieldsSig
   readonly eventsSig: EventSig[]
+  readonly stdInterfaceId?: HexString
 
   readonly bytecodeDebug: string
   readonly codeHashDebug: string
@@ -680,7 +683,8 @@ export class Contract extends Artifact {
     codeHashDebug: string,
     fieldsSig: FieldsSig,
     eventsSig: EventSig[],
-    functions: FunctionSig[]
+    functions: FunctionSig[],
+    stdInterfaceId?: HexString
   ) {
     super(version, name, functions)
     this.bytecode = bytecode
@@ -688,6 +692,7 @@ export class Contract extends Artifact {
     this.codeHash = codeHash
     this.fieldsSig = fieldsSig
     this.eventsSig = eventsSig
+    this.stdInterfaceId = stdInterfaceId
 
     this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
     this.codeHashDebug = codeHashDebug
@@ -715,7 +720,8 @@ export class Contract extends Artifact {
       codeHashDebug ? codeHashDebug : artifact.codeHash,
       artifact.fieldsSig,
       artifact.eventsSig,
-      artifact.functions
+      artifact.functions,
+      artifact.stdInterfaceId === null ? undefined : artifact.stdInterfaceId
     )
     return contract
   }
@@ -730,7 +736,8 @@ export class Contract extends Artifact {
       result.codeHashDebug,
       result.fields,
       result.events,
-      result.functions
+      result.functions,
+      result.stdInterfaceId
     )
   }
 
@@ -742,7 +749,7 @@ export class Contract extends Artifact {
   }
 
   override toString(): string {
-    const object = {
+    const object: any = {
       version: this.version,
       name: this.name,
       bytecode: this.bytecode,
@@ -751,6 +758,9 @@ export class Contract extends Artifact {
       eventsSig: this.eventsSig,
       functions: this.functions
     }
+    if (this.stdInterfaceId !== undefined) {
+      object.stdInterfaceId = this.stdInterfaceId
+    }
     return JSON.stringify(object, null, 2)
   }
 
@@ -852,16 +862,14 @@ export class Contract extends Artifact {
   }
 
   static ContractCreatedEventIndex = -1
-  static ContractCreatedEvent: SystemEventSig = {
+  static ContractCreatedEvent: EventSig = {
     name: 'ContractCreated',
-    fieldNames: ['address'],
-    fieldTypes: ['Address'],
-    optionalFieldNames: ['parentAddress'],
-    optionalFieldTypes: ['Address']
+    fieldNames: ['address', 'parentAddress', 'stdInterfaceId'],
+    fieldTypes: ['Address', 'Address', 'ByteVec']
   }
 
   static ContractDestroyedEventIndex = -2
-  static ContractDestroyedEvent: SystemEventSig = {
+  static ContractDestroyedEvent: EventSig = {
     name: 'ContractDestroyed',
     fieldNames: ['address'],
     fieldTypes: ['Address']
@@ -872,10 +880,10 @@ export class Contract extends Artifact {
     let name: string
 
     if (event.eventIndex == Contract.ContractCreatedEventIndex) {
-      fields = fromApiSystemEventFields(event.fields, Contract.ContractCreatedEvent)
+      fields = toContractCreatedEventFields(fromApiEventFields(event.fields, Contract.ContractCreatedEvent, true))
       name = Contract.ContractCreatedEvent.name
     } else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
-      fields = fromApiSystemEventFields(event.fields, Contract.ContractDestroyedEvent)
+      fields = fromApiEventFields(event.fields, Contract.ContractDestroyedEvent, true)
       name = Contract.ContractDestroyedEvent.name
     } else {
       const contract = Project.currentProject.contractByCodeHash(codeHash!)
@@ -923,7 +931,8 @@ export class Contract extends Artifact {
     signer: SignerProvider,
     params: DeployContractParams<P>
   ): Promise<SignDeployContractTxParams> {
-    const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {})
+    const initialFields: Fields = params.initialFields ?? {}
+    const bytecode = this.buildByteCodeToDeploy(addStdIdToFields(this, initialFields))
     const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignDeployContractTxParams = {
       signerAddress: selectedAccount.address,
@@ -1106,18 +1115,8 @@ function fromApiFields(immFields: node.Val[], mutFields: node.Val[], fieldsSig:
   return fromApiVals(vals, fieldsSig.names, fieldsSig.types)
 }
 
-function fromApiEventFields(vals: node.Val[], eventSig: node.EventSig): Fields {
-  return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes)
-}
-
-function fromApiSystemEventFields(vals: node.Val[], systemEventSig: SystemEventSig): Fields {
-  return fromApiVals(
-    vals,
-    systemEventSig.fieldNames,
-    systemEventSig.fieldTypes,
-    systemEventSig.optionalFieldNames ?? [],
-    systemEventSig.optionalFieldTypes ?? []
-  )
+function fromApiEventFields(vals: node.Val[], eventSig: node.EventSig, systemEvent = false): Fields {
+  return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes, systemEvent)
 }
 
 export interface Asset {
@@ -1313,7 +1312,10 @@ export abstract class ContractFactory<I, F extends Fields = Fields> {
   abstract at(address: string): I
 
   async deploy(signer: SignerProvider, deployParams: DeployContractParams<F>): Promise<DeployContractResult<I>> {
-    const signerParams = await this.contract.txParamsForDeployment(signer, deployParams)
+    const signerParams = await this.contract.txParamsForDeployment(signer, {
+      ...deployParams,
+      initialFields: addStdIdToFields(this.contract, deployParams.initialFields)
+    })
     const result = await signer.signAndSubmitDeployContractTx(signerParams)
     return {
       ...result,
@@ -1327,7 +1329,7 @@ export abstract class ContractFactory<I, F extends Fields = Fields> {
       alphAmount: asset?.alphAmount ?? ONE_ALPH,
       tokens: asset?.tokens
     }
-    return this.contract.toState(initFields, newAsset, address)
+    return this.contract.toState(addStdIdToFields(this.contract, initFields), newAsset, address)
   }
 }
 
@@ -1374,19 +1376,32 @@ function specialContractAddress(n: number): string {
 export const CreateContractEventAddress = specialContractAddress(-1)
 export const DestroyContractEventAddress = specialContractAddress(-2)
 
-export interface SystemEventSig extends EventSig {
-  optionalFieldNames?: string[]
-  optionalFieldTypes?: string[]
+export type ContractCreatedEventFields = {
+  address: Address
+  parentAddress?: Address
+  stdInterfaceIdGuessed?: HexString
 }
+export type ContractDestroyedEventFields = {
+  address: Address
+}
+export type ContractCreatedEvent = ContractEvent<ContractCreatedEventFields>
+export type ContractDestroyedEvent = ContractEvent<ContractDestroyedEventFields>
 
-export type ContractCreatedEvent = ContractEvent<{ address: Address; parentAddress?: Address }>
-export type ContractDestroyedEvent = ContractEvent<{ address: Address }>
-
-function decodeSystemEvent(event: node.ContractEvent, systemEventSig: SystemEventSig, eventIndex: number): Fields {
+function decodeSystemEvent(event: node.ContractEvent, eventSig: EventSig, eventIndex: number): Fields {
   if (event.eventIndex !== eventIndex) {
     throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`)
   }
-  return fromApiSystemEventFields(event.fields, systemEventSig)
+  return fromApiEventFields(event.fields, eventSig, true)
+}
+
+function toContractCreatedEventFields(fields: Fields): ContractCreatedEventFields {
+  const parentAddress = fields['parentAddress'] as string
+  const stdInterfaceId = fields['stdInterfaceId'] as string
+  return {
+    address: fields['address'] as Address,
+    parentAddress: parentAddress === '' ? undefined : (parentAddress as Address),
+    stdInterfaceIdGuessed: stdInterfaceId === '' ? undefined : (stdInterfaceId as HexString)
+  }
 }
 
 export function decodeContractCreatedEvent(event: node.ContractEvent): Omit<ContractCreatedEvent, 'contractAddress'> {
@@ -1396,10 +1411,7 @@ export function decodeContractCreatedEvent(event: node.ContractEvent): Omit<Cont
     txId: event.txId,
     eventIndex: event.eventIndex,
     name: Contract.ContractCreatedEvent.name,
-    fields: {
-      address: fields['address'] as Address,
-      parentAddress: fields['parentAddress'] === undefined ? undefined : (fields['parentAddress'] as Address)
-    }
+    fields: toContractCreatedEventFields(fields)
   }
 }
 
@@ -1441,16 +1453,27 @@ export function subscribeEventsFromContract<T extends Fields, M extends Contract
   return subscribeToEvents(opt, address, fromCount)
 }
 
+export function addStdIdToFields<F extends Fields>(
+  contract: Contract,
+  fields: F
+): F | (F & { __stdInterfaceId: HexString }) {
+  const stdInterfaceIdPrefix = '414c5048' // the hex of 'ALPH'
+  return contract.stdInterfaceId === undefined
+    ? fields
+    : { ...fields, __stdInterfaceId: stdInterfaceIdPrefix + contract.stdInterfaceId }
+}
+
 export async function testMethod<I, F extends Fields, A extends Arguments, R>(
   contract: ContractFactory<I, F>,
   methodName: string,
   params: Optional<TestContractParams<F, A>, 'testArgs' | 'initialFields'>
 ): Promise<TestContractResult<R>> {
   const txId = params?.txId ?? randomTxId()
+  const initialFields = params.initialFields === undefined ? {} : params.initialFields
   const apiParams = contract.contract.toApiTestContractParams(methodName, {
     ...params,
     txId: txId,
-    initialFields: params.initialFields === undefined ? {} : params.initialFields,
+    initialFields: addStdIdToFields(contract.contract, initialFields),
     testArgs: params.testArgs === undefined ? {} : params.testArgs
   })
   const apiResult = await getCurrentNodeProvider().contracts.postContractsTestContract(apiParams)

package/src/index.ts

@@ -25,6 +25,7 @@ export * from './contract'
 export * from './signer'
 export * from './utils'
 export * from './transaction'
+export * from './token'
 
 export * from './constants'
 export * as web3 from './global'

package/src/token/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 * from './nft'

package/src/token/nft.ts

@@ -0,0 +1,34 @@
+/*
+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/>.
+*/
+
+// JSON Schema for the NFT metadata, which is pointed to by the value
+// returned from the `getTokenUri` method of the NFT contract
+export interface NFTMetadata {
+  name: string
+  description: string
+  image: string
+}
+
+// JSON Schema for the NFT Collection metadata, which is pointed to by
+// the value returned from the `getCollectionUri` method of the NFT Collection
+// Contract
+export interface NFTCollectionMetadata {
+  name: string
+  description: string
+  image: string
+}

package/std/fungible_token_interface.ral

@@ -1,3 +1,4 @@
+@std(id = #0001)
 Interface IFungibleToken {
   pub fn getSymbol() -> ByteVec
 

package/std/nft_collection_interface.ral

@@ -1,8 +1,29 @@
+@std(id = #0002)
 Interface INFTCollection {
-   event Minted(minter: Address, tokenIndex: U256, tokenId: ByteVec)
+   // Collection Uri points to a json file containing metadata for the NFT collection.
+   //
+   // The schema of the json file is:
+   // {
+   //     "title": "NFT Collection Metadata",
+   //     "type": "object",
+   //     "properties": {
+   //         "name": {
+   //             "type": "string",
+   //             "description": "Name of the NFT collection"
+   //         },
+   //         "description": {
+   //             "type": "string",
+   //             "description": "General description of the NFT collection"
+   //         },
+   //         "image": {
+   //             "type": "string",
+   //             "description": "A URI to the image that represents the NFT collection"
+   //         }
+   //     }
+   // }
+   pub fn getCollectionUri() -> ByteVec
 
-   pub fn getName() -> ByteVec
-   pub fn getSymbol() -> ByteVec
    pub fn totalSupply() -> U256
+
    pub fn nftByIndex(index: U256) -> INFT
 }

package/std/nft_interface.ral

@@ -1,3 +1,25 @@
+@std(id = #0003)
 Interface INFT {
+   // Token Uri points to a json file containing metadata for the NFT.
+   //
+   // The schema of the json file is:
+   // {
+   //     "title": "NFT Metadata",
+   //     "type": "object",
+   //     "properties": {
+   //         "name": {
+   //             "type": "string",
+   //             "description": "Name of the NFT"
+   //         },
+   //         "description": {
+   //             "type": "string",
+   //             "description": "General description of the NFT"
+   //         },
+   //         "image": {
+   //             "type": "string",
+   //             "description": "A URI to the image that represents the NFT"
+   //         }
+   //     }
+   // }
    pub fn getTokenUri() -> ByteVec
 }

package/jest-config.json

@@ -1,11 +0,0 @@
-{
-  "testPathIgnorePatterns": [".*/node_modules/"],
-  "transform": {
-    "^.+\\.(t|j)sx?$": "ts-jest"
-  },
-  "testMatch": ["**/*.test.ts"],
-  "moduleFileExtensions": ["ts", "tsx", "js", "jsx", "json", "node"],
-  "collectCoverage": true,
-  "coverageDirectory": "./coverage/",
-  "collectCoverageFrom": ["src/**/*.ts"]
-}