@alephium/web3 0.35.1 → 0.36.1

package/dist/src/contract/ralph.js

@@ -18,7 +18,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.falttenFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.encodeBool = void 0;
+exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.flattenFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.encodeBool = void 0;
 const buffer_1 = require("buffer/");
 const api_1 = require("../api");
 const utils_1 = require("../utils");
@@ -240,58 +240,74 @@ function encodeScriptField(tpe, value) {
         case 'U256':
             const u256 = (0, api_1.toApiNumber256)(value);
             return encodeScriptFieldU256(BigInt(u256));
-        case 'ByteVec':
-            const hexStr = (0, api_1.toApiByteVec)(value);
-            return new Uint8Array([Instruction.bytesConst, ...encodeByteVec(hexStr)]);
         case 'Address':
             const address = (0, api_1.toApiAddress)(value);
             return new Uint8Array([Instruction.addressConst, ...encodeAddress(address)]);
+        default: // ByteVec or Contract
+            const hexStr = (0, api_1.toApiByteVec)(value);
+            return new Uint8Array([Instruction.bytesConst, ...encodeByteVec(hexStr)]);
     }
     throw invalidScriptField(tpe, value);
 }
 exports.encodeScriptField = encodeScriptField;
-function flattenArray(name, type, val, acc) {
-    const semiColonIndex = type.lastIndexOf(';');
-    if (semiColonIndex == -1) {
-        throw new Error(`Invalid array type: ${type}`);
-    }
-    const subType = type.slice(1, semiColonIndex);
-    val.forEach((v, index) => {
-        const isArrayType = subType.includes(';');
-        const isArrayValue = Array.isArray(v);
-        if (isArrayType && isArrayValue) {
-            flattenArray(`${name}[${index}]`, subType, v, acc);
-        }
-        else if (!isArrayType && !isArrayValue) {
-            acc.push({ name: `${name}[${index}]`, type: subType, value: v });
-        }
-        else {
-            const value = isArrayValue ? `[` + v.join(', ') + `]` : v.toString();
-            throw new Error(`Invalid field, expected type is ${subType}, but value is ${value}`);
-        }
-    });
-}
-function falttenFields(fields, fieldsSig) {
-    const allFields = [];
-    fieldsSig.names.forEach((name, index) => {
-        const field = fields[`${name}`];
+function flattenFields(fields, names, types, isMutable, structs) {
+    return names.flatMap((name, index) => {
         if (!(name in fields)) {
             throw new Error(`The value of field ${name} is not provided`);
         }
-        const type = fieldsSig.types[`${index}`];
-        if (Array.isArray(field)) {
-            flattenArray(name, type, field, allFields);
+        return flattenField(isMutable[`${index}`], name, types[`${index}`], fields[`${name}`], structs);
+    });
+}
+exports.flattenFields = flattenFields;
+function flattenField(isMutable, name, type, value, structs) {
+    if (Array.isArray(value) && type.startsWith('[')) {
+        const [baseType, size] = (0, api_1.decodeArrayType)(type);
+        if (value.length !== size) {
+            throw Error(`Invalid array length, expected ${size}, got ${value.length}`);
         }
-        else {
-            allFields.push({ name, type, value: field });
+        return value.flatMap((item, index) => {
+            return flattenField(isMutable, `${name}[${index}]`, baseType, item, structs);
+        });
+    }
+    const struct = structs.find((s) => s.name === type);
+    if (struct !== undefined) {
+        if (typeof value !== 'object') {
+            throw Error(`Expected an object, but got ${typeof value}`);
         }
-    });
-    return allFields;
+        return struct.fieldNames.flatMap((fieldName, index) => {
+            if (!(fieldName in value)) {
+                throw new Error(`The value of field ${fieldName} is not provided`);
+            }
+            const isFieldMutable = struct.isMutable[`${index}`];
+            const fieldType = struct.fieldTypes[`${index}`];
+            const fieldValue = value[`${fieldName}`];
+            return flattenField(isMutable && isFieldMutable, `${name}.${fieldName}`, fieldType, fieldValue, structs);
+        });
+    }
+    const primitiveType = checkPrimitiveValue(name, type, value);
+    return [{ name, type: primitiveType, value, isMutable }];
+}
+function checkPrimitiveValue(name, ralphType, value) {
+    const tsType = typeof value;
+    if (ralphType === 'Bool' && tsType === 'boolean') {
+        return ralphType;
+    }
+    if ((ralphType === 'U256' || ralphType === 'I256') &&
+        (tsType === 'string' || tsType === 'number' || tsType === 'bigint')) {
+        return ralphType;
+    }
+    if ((ralphType === 'Address' || ralphType === 'ByteVec') && tsType === 'string') {
+        return ralphType;
+    }
+    if (!ralphType.startsWith('[') && tsType === 'string') {
+        // contract type
+        return 'ByteVec';
+    }
+    throw Error(`Invalid value ${value} for ${name}, expected a value of type ${ralphType}`);
 }
-exports.falttenFields = falttenFields;
 const scriptFieldRegex = /\{([0-9]*)\}/g;
-function buildScriptByteCode(bytecodeTemplate, fields, fieldsSig) {
-    const allFields = falttenFields(fields, fieldsSig);
+function buildScriptByteCode(bytecodeTemplate, fields, fieldsSig, structs) {
+    const allFields = flattenFields(fields, fieldsSig.names, fieldsSig.types, fieldsSig.isMutable, structs);
     return bytecodeTemplate.replace(scriptFieldRegex, (_, fieldIndex) => {
         const field = allFields[`${fieldIndex}`];
         return _encodeField(field.name, () => encodeScriptFieldAsString(field.type, field.value));
@@ -309,27 +325,17 @@ function _encodeField(fieldName, encodeFunc) {
         throw error;
     }
 }
-function encodeFields(fields, fieldsSig, mutable) {
-    const fieldIndexes = fieldsSig.isMutable
-        .map((_, index) => index)
-        .filter((index) => fieldsSig.isMutable[`${index}`] === mutable);
-    const fieldsEncoded = fieldIndexes.flatMap((fieldIndex) => {
-        const fieldName = fieldsSig.names[`${fieldIndex}`];
-        const fieldType = fieldsSig.types[`${fieldIndex}`];
-        if (fieldName in fields) {
-            const fieldValue = fields[`${fieldName}`];
-            return _encodeField(fieldName, () => encodeContractField(fieldType, fieldValue));
-        }
-        else {
-            throw new Error(`The value of field ${fieldName} is not provided`);
-        }
-    });
-    const fieldsLength = buffer_1.Buffer.from(encodeI256(BigInt(fieldsEncoded.length))).toString('hex');
-    return fieldsLength + fieldsEncoded.map((f) => buffer_1.Buffer.from(f).toString('hex')).join('');
+function encodeFields(fields) {
+    const prefix = (0, utils_1.binToHex)(encodeI256(BigInt(fields.length)));
+    const encoded = fields
+        .map((field) => (0, utils_1.binToHex)(_encodeField(field.name, () => encodeContractField(field.type, field.value))))
+        .join('');
+    return prefix + encoded;
 }
-function buildContractByteCode(bytecode, fields, fieldsSig) {
-    const encodedImmFields = encodeFields(fields, fieldsSig, false);
-    const encodedMutFields = encodeFields(fields, fieldsSig, true);
+function buildContractByteCode(bytecode, fields, fieldsSig, structs) {
+    const allFields = flattenFields(fields, fieldsSig.names, fieldsSig.types, fieldsSig.isMutable, structs);
+    const encodedImmFields = encodeFields(allFields.filter((f) => !f.isMutable));
+    const encodedMutFields = encodeFields(allFields.filter((f) => f.isMutable));
     return bytecode + encodedImmFields + encodedMutFields;
 }
 exports.buildContractByteCode = buildContractByteCode;
@@ -347,43 +353,25 @@ function encodeContractFieldI256(value) {
 function encodeContractFieldU256(value) {
     return new Uint8Array([ApiValType.U256, ...encodeU256(value)]);
 }
-function encodeContractFieldArray(tpe, val) {
-    if (!Array.isArray(val)) {
-        throw new Error(`Expected array, got ${val}`);
-    }
-    const semiColonIndex = tpe.lastIndexOf(';');
-    if (semiColonIndex == -1) {
-        throw new Error(`Invalid Array type: ${tpe}`);
-    }
-    const subType = tpe.slice(1, semiColonIndex);
-    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
-    if (val.length != dim) {
-        throw new Error(`Invalid val dimension: ${val}`);
-    }
-    else {
-        return val.flatMap((v) => encodeContractField(subType, v));
-    }
-}
 function encodeContractField(tpe, value) {
     switch (tpe) {
         case 'Bool':
             const byte = (0, api_1.toApiBoolean)(value) ? 1 : 0;
-            return [new Uint8Array([ApiValType.Bool, byte])];
+            return new Uint8Array([ApiValType.Bool, byte]);
         case 'I256':
             const i256 = (0, api_1.toApiNumber256)(value);
-            return [encodeContractFieldI256(BigInt(i256))];
+            return encodeContractFieldI256(BigInt(i256));
         case 'U256':
             const u256 = (0, api_1.toApiNumber256)(value);
-            return [encodeContractFieldU256(BigInt(u256))];
+            return encodeContractFieldU256(BigInt(u256));
         case 'ByteVec':
             const hexStr = (0, api_1.toApiByteVec)(value);
-            return [new Uint8Array([ApiValType.ByteVec, ...encodeByteVec(hexStr)])];
+            return new Uint8Array([ApiValType.ByteVec, ...encodeByteVec(hexStr)]);
         case 'Address':
             const address = (0, api_1.toApiAddress)(value);
-            return [new Uint8Array([ApiValType.Address, ...encodeAddress(address)])];
+            return new Uint8Array([ApiValType.Address, ...encodeAddress(address)]);
         default:
-            // Array type
-            return encodeContractFieldArray(tpe, value);
+            throw Error(`Expected primitive type, got ${tpe}`);
     }
 }
 exports.encodeContractField = encodeContractField;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.35.1",
+  "version": "0.36.1",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "2.9.0",
+    "alephium_version": "2.10.0",
     "explorer_backend_version": "1.17.0"
   },
   "type": "commonjs",

package/src/api/api-alephium.ts

@@ -430,6 +430,7 @@ export interface CompileContractResult {
 export interface CompileProjectResult {
   contracts: CompileContractResult[]
   scripts: CompileScriptResult[]
+  structs?: StructSig[]
 }
 
 export interface CompileScriptResult {
@@ -802,6 +803,13 @@ export interface Source {
   utxos?: OutputRef[]
 }
 
+export interface StructSig {
+  name: string
+  fieldNames: string[]
+  fieldTypes: string[]
+  isMutable: boolean[]
+}
+
 export interface SubmitMultisig {
   unsignedTx: string
   signatures: string[]
@@ -1292,7 +1300,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 2.9.0
+ * @version 2.10.0
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/api/types.ts

@@ -22,9 +22,13 @@ import { assertType, bs58, Eq, isBase58, isHexString } from '../utils'
 import * as node from './api-alephium'
 
 export type Number256 = bigint | string
-export type Val = Number256 | boolean | string | Val[]
+export type Val = Number256 | boolean | string | Val[] | ValObject
+// eslint-disable-next-line
+export interface ValObject extends Record<string, Val> {} // bypassing typescript recursive type limitations
 export type NamedVals = Record<string, Val>
 
+export const PrimitiveTypes = ['U256', 'I256', 'Bool', 'ByteVec', 'Address']
+
 export interface Token {
   id: string
   amount: Number256
@@ -144,121 +148,34 @@ export function toApiVal(v: Val, tpe: string): node.Val {
   }
 }
 
-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')
-  }
-
-  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 || systemEvent)) {
-    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[], systemEvent = false): NamedVals {
-  let valIndex = 0
-  const result: NamedVals = {}
-  types.forEach((currentType, index) => {
-    const currentName = names[`${index}`]
-    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType, systemEvent)
-    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
+export function fromApiPrimitiveVal(value: node.Val, tpe: string, systemEvent = false): Val {
+  if (tpe === 'Bool' && value.type === tpe) {
+    return value.value as boolean
+  } else if ((tpe === 'U256' || tpe === 'I256') && value.type === tpe) {
+    return fromApiNumber256(value.value as string)
+  } else if ((tpe === 'ByteVec' || tpe === 'Address') && (value.type === tpe || systemEvent)) {
+    return value.value as string
   } else {
-    throw new Error(`Invalid node.Val type: ${v}`)
+    throw new Error(`Expected primitive type, got ${tpe}`)
   }
 }
 
-function decodeArrayType(tpe: string): [baseType: string, dims: number[]] {
+export function decodeArrayType(tpe: string): [string, 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]]
+    throw new Error(`Invalid array type: ${tpe}`)
   }
+  const baseType = tpe.slice(1, semiColonIndex)
+  const size = parseInt(tpe.slice(semiColonIndex + 1, -1))
+  return [baseType, size]
 }
 
-export function getDefaultValue(tpe: string): Val {
+export function getDefaultPrimitiveValue(tpe: string): Val {
   if (tpe === 'U256' || tpe === 'I256') return 0n
   if (tpe === 'Bool') return false
   if (tpe === 'ByteVec') return ''
   if (tpe === 'Address') return ZERO_ADDRESS
-
-  // array type
-  const [baseType, dims] = decodeArrayType(tpe)
-  const defaultBaseValue = getDefaultValue(baseType)
-  return dims.reduceRight((acc, length) => Array(length).fill(acc), defaultBaseValue)
-}
-
-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
-  }
-}
-
-export function typeLength(tpe: string): number {
-  if (tpe === 'U256' || tpe === 'I256' || tpe === 'Bool' || tpe === 'ByteVec' || tpe === 'Address') {
-    return 1
-  }
-  const [, dims] = decodeArrayType(tpe)
-  return dims.reduce((a, b) => a * b)
+  throw Error(`Expected primitive type, got ${tpe}`)
 }
 
 export interface ApiRequestArguments {