All system contract compatibility and better tests

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wharfkit/contract",
     "description": "ContractKit for Wharf",
-    "version": "0.4.0",
+    "version": "0.4.1",
     "homepage": "https://github.com/wharfkit/contract",
     "license": "BSD-3-Clause",
     "main": "lib/contract.js",

src/codegen.ts

@@ -19,11 +19,21 @@ export async function codegen(contractName, abi) {
             '@wharfkit/contract'
         )
 
-        const sessionImports = ['ABI', 'Action', 'Blob', 'Struct', ...getCoreImports(abi)]
+        const allAntelopeImports = [
+            'ABI',
+            'Action',
+            'Blob',
+            'Struct',
+            'Name',
+            ...getCoreImports(abi),
+        ]
+        const antelopeImports = allAntelopeImports.filter(
+            (item, index) => allAntelopeImports.indexOf(item) === index
+        )
 
-        sessionImports.sort()
+        antelopeImports.sort()
 
-        const importCoreStatement = generateImportStatement(sessionImports, '@wharfkit/session')
+        const importCoreStatement = generateImportStatement(antelopeImports, '@wharfkit/antelope')
 
         const {classDeclaration} = await generateContractClass(contractName, abi)
 

src/codegen/contract.ts

@@ -1,4 +1,4 @@
-import {ABI} from '@wharfkit/session'
+import {ABI} from '@wharfkit/antelope'
 import * as ts from 'typescript'
 
 import {generateClassDeclaration} from './helpers'
@@ -43,13 +43,17 @@ export async function generateContractClass(contractName: string, abi: ABI.Def)
 
     classMembers.push(constructorMember)
 
-    const actionMethod = generateActionMethod(abi)
+    if (abi.actions.length) {
+        const actionMethod = generateActionMethod(abi)
 
-    classMembers.push(actionMethod)
+        classMembers.push(actionMethod)
+    }
 
-    const tableMethod = generateTableMethod(abi)
+    if (abi.tables.length) {
+        const tableMethod = generateTableMethod(abi)
 
-    classMembers.push(tableMethod)
+        classMembers.push(tableMethod)
+    }
 
     // Construct class declaration
     const classDeclaration = generateClassDeclaration('Contract', classMembers, {
@@ -189,6 +193,16 @@ function generateTableMethod(abi: ABI.Def): ts.MethodDeclaration {
         undefined
     )
 
+    const scopeParameter = ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        undefined,
+        'scope',
+        ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+        ts.factory.createTypeReferenceNode('NameType'),
+        undefined
+    )
+
     // 4. Generate the function body.
     const methodBody = ts.factory.createBlock(
         [
@@ -201,6 +215,7 @@ function generateTableMethod(abi: ABI.Def): ts.MethodDeclaration {
                     undefined,
                     [
                         ts.factory.createIdentifier('name'),
+                        ts.factory.createIdentifier('scope'),
                         ts.factory.createIdentifier('TableMap[name]'),
                     ]
                 )
@@ -216,7 +231,7 @@ function generateTableMethod(abi: ABI.Def): ts.MethodDeclaration {
         'table',
         undefined,
         [typeParameter],
-        [nameParameter],
+        [nameParameter, scopeParameter],
         undefined,
         methodBody
     )

src/codegen/helpers.ts

@@ -1,34 +1,19 @@
+import * as Antelope from '@wharfkit/antelope'
 import {ABI} from '@wharfkit/antelope'
 import * as ts from 'typescript'
 
 import {capitalize} from '../utils'
 
-export const EOSIO_CORE_CLASSES = [
-    'Asset',
-    'Checksum256',
-    'Float64',
-    'Name',
-    'TimePoint',
-    'TimePointSec',
-    'UInt128',
-    'UInt16',
-    'UInt32',
-    'UInt64',
-    'UInt8',
-]
-
-export const EOSIO_CORE_TYPES = [
-    'AssetType',
-    'Checksum256Type',
-    'Float64Type',
-    'NameType',
-    'TimePointType',
-    'UInt128Type',
-    'UInt16Type',
-    'UInt32Type',
-    'UInt64Type',
-    'UInt8Type',
-]
+const ANTELOPE_CLASSES: string[] = []
+Object.keys(Antelope).map((key) => {
+    if (Antelope[key].abiName) {
+        ANTELOPE_CLASSES.push(key)
+    }
+})
+
+export const ANTELOPE_CLASS_MAPPINGS = {
+    block_timestamp_type: 'BlockTimestamp',
+}
 
 export function getCoreImports(abi: ABI.Def) {
     const coreImports: string[] = []
@@ -127,11 +112,18 @@ export function generateInterface(
 }
 
 export function findCoreClass(type: string): string | undefined {
-    for (const coreType of EOSIO_CORE_CLASSES) {
-        if (type.split('_').join('') === coreType.toLowerCase()) {
-            return coreType
-        }
+    if (ANTELOPE_CLASS_MAPPINGS[type]) {
+        return ANTELOPE_CLASS_MAPPINGS[type]
     }
+
+    const parsedType = parseType(type).split('_').join('')
+
+    return (
+        ANTELOPE_CLASSES.find((antelopeClass) => parsedType === antelopeClass.toLowerCase()) ||
+        ANTELOPE_CLASSES.find(
+            (antelopeClass) => parsedType.replace(/[0-9]/g, '') === antelopeClass.toLowerCase()
+        )
+    )
 }
 
 export function findCoreType(type: string): string | undefined {
@@ -145,26 +137,22 @@ export function findCoreType(type: string): string | undefined {
 export function findInternalType(type: string, typeNamespace: string | null, abi: ABI.Def): string {
     let {type: typeString} = extractDecorator(type)
 
+    typeString = parseType(typeString)
+
     const relevantAbitype = findAbiType(typeString, abi)
 
     if (relevantAbitype) {
         typeString = relevantAbitype
     }
 
-    const variantType = findVariantType(typeString, typeNamespace, abi)
-
-    if (variantType) {
-        typeString = variantType
-    }
-
     return formatInternalType(typeString, typeNamespace, abi)
 }
 
 function formatInternalType(typeString: string, namespace: string | null, abi: ABI.Def): string {
     const structNames = abi.structs.map((struct) => struct.name.toLowerCase())
 
     if (structNames.includes(typeString.toLowerCase())) {
-        return `${namespace ? `${namespace}.` : ''}${generateStructClassName(typeString)}`
+        return `${namespace ? `${namespace}` : ''}${generateStructClassName(typeString)}`
     } else {
         return findCoreClass(typeString) || capitalize(typeString)
     }
@@ -177,6 +165,12 @@ export function generateStructClassName(name) {
         .join('')
 }
 
+function findAliasType(typeString: string, abi: ABI.Def): string | undefined {
+    const alias = abi.types.find((type) => type.new_type_name === typeString)
+
+    return alias?.type
+}
+
 function findVariantType(
     typeString: string,
     namespace: string | null,
@@ -190,16 +184,24 @@ function findVariantType(
         return
     }
 
-    return abiVariant.types
-        .map((variant) => formatInternalType(variant, namespace, abi))
-        .join(' | ')
+    return abiVariant.types.join(' | ')
 }
 
-export function findAbiType(
-    typeString: string,
-    abi: ABI.Def,
-    typeNamespace = ''
-): string | undefined {
+export function findAbiType(type: string, abi: ABI.Def, typeNamespace = ''): string | undefined {
+    let typeString = type
+
+    const aliasType = findAliasType(typeString, abi)
+
+    if (aliasType) {
+        typeString = aliasType
+    }
+
+    const variantType = findVariantType(typeString, typeNamespace, abi)
+
+    if (variantType) {
+        typeString = variantType
+    }
+
     const abiType = abi.structs.find((abiType) => abiType.name === typeString)?.name
 
     if (abiType) {
@@ -211,6 +213,8 @@ export function findExternalType(type: string, abi: ABI.Def, typeNamespace?: str
     let {type: typeString} = extractDecorator(type)
     const {decorator} = extractDecorator(type)
 
+    typeString = parseType(typeString)
+
     const relevantAbitype = findAbiType(typeString, abi, typeNamespace)
 
     if (relevantAbitype) {
@@ -232,3 +236,7 @@ export function extractDecorator(type: string): {type: string; decorator?: strin
 
     return {type}
 }
+
+function parseType(type: string): string {
+    return type.replace('$', '')
+}

src/codegen/interfaces.ts

@@ -1,4 +1,4 @@
-import {ABI} from '@wharfkit/session'
+import {ABI} from '@wharfkit/antelope'
 import ts from 'typescript'
 import {capitalize} from '../utils'
 import {findExternalType} from './helpers'
@@ -29,16 +29,17 @@ export function generateActionNamesInterface(abi: ABI.Def): ts.InterfaceDeclarat
 
 export function generateActionInterface(actionStruct, abi): ts.InterfaceDeclaration {
     const members = actionStruct.fields.map((field) => {
+        const typeReferenceNode = ts.factory.createTypeReferenceNode(
+            findParamTypeString(field.type, 'Types.', abi)
+        )
+
         return ts.factory.createPropertySignature(
             undefined,
             field.name.toLowerCase(),
             field.type.includes('?')
                 ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
                 : undefined,
-            ts.factory.createTypeReferenceNode(
-                findExternalType(field.type, abi, 'Types.'),
-                undefined
-            )
+            typeReferenceNode
         )
     })
 
@@ -68,3 +69,21 @@ export function generateActionsNamespace(abi: ABI.Def): ts.ModuleDeclaration {
         ts.NodeFlags.Namespace
     )
 }
+
+function findParamTypeString(typeString: string, namespace: string | null, abi: ABI.Def): string {
+    const fieldType = findExternalType(typeString, abi, namespace ? namespace : undefined)
+
+    if (fieldType === 'Symbol') {
+        return 'Asset.SymbolType'
+    }
+
+    if (fieldType === 'Bool') {
+        return 'boolean'
+    }
+
+    if (['String', 'Boolean', 'Number'].includes(fieldType)) {
+        return fieldType.toLowerCase()
+    }
+
+    return fieldType
+}

src/codegen/maps.ts

@@ -1,12 +1,12 @@
-import {ABI} from '@wharfkit/session'
+import {ABI} from '@wharfkit/antelope'
 import * as ts from 'typescript'
 import {findAbiType} from './helpers'
 
 export function generateTableMap(abi: ABI.Def): ts.VariableStatement {
     // Map over tables to create the object properties
     const tableProperties = abi.tables.map((table) =>
         ts.factory.createPropertyAssignment(
-            String(table.name),
+            JSON.stringify(table.name),
             ts.factory.createIdentifier(findAbiType(table.type, abi, 'Types.') || table.type)
         )
     )

src/codegen/structs.ts

@@ -157,20 +157,9 @@ export function generateField(
 
 function orderStructs(structs) {
     const orderedStructs: StructData[] = []
-    const structNames = structs.map((struct) => struct.structName)
 
     for (const struct of structs) {
-        for (const field of struct.fields) {
-            const {type: fieldType} = extractDecorator(field.type)
-
-            if (structNames.includes(fieldType.toLowerCase())) {
-                const dependencyStruct = structs.find(
-                    (struct) => struct.structName === fieldType.toLowerCase()
-                )
-                orderedStructs.push(dependencyStruct)
-            }
-        }
-
+        orderedStructs.push(...findDependencies(struct, structs))
         orderedStructs.push(struct)
     }
 
@@ -179,6 +168,28 @@ function orderStructs(structs) {
     })
 }
 
+function findDependencies(struct: StructData, allStructs: StructData[]): StructData[] {
+    const dependencies: StructData[] = []
+
+    const structNames = allStructs.map((struct) => struct.structName)
+
+    for (const field of struct.fields) {
+        const {type: fieldType} = extractDecorator(field.type)
+
+        if (structNames.includes(fieldType.toLowerCase())) {
+            const dependencyStruct = allStructs.find(
+                (struct) => struct.structName === fieldType.toLowerCase()
+            )
+            if (dependencyStruct) {
+                dependencies.push(...findDependencies(dependencyStruct, allStructs))
+                dependencies.push(dependencyStruct)
+            }
+        }
+    }
+
+    return dependencies
+}
+
 function findFieldStructType(
     typeString: string,
     namespace: string | null,
@@ -200,10 +211,14 @@ function findFieldStructTypeString(
 ): string {
     const fieldType = findInternalType(typeString, namespace, abi)
 
-    if (['String', 'Boolean', 'Number'].includes(fieldType)) {
+    if (['String', 'Number'].includes(fieldType)) {
         return fieldType.toLowerCase()
     }
 
+    if (fieldType === 'Bool') {
+        return 'boolean'
+    }
+
     if (fieldType === 'Symbol') {
         return 'Asset.Symbol'
     }

src/contract.ts

@@ -73,7 +73,7 @@ export class Contract {
         return this.tableNames.includes(String(name))
     }
 
-    public table<RowType = any>(name: NameType, rowType?): Table<RowType> {
+    public table<RowType = any>(name: NameType, scope?: NameType, rowType?): Table<RowType> {
         if (!this.hasTable(name)) {
             throw new Error(`Contract (${this.account}) does not have a table named (${name})`)
         }