@alephium/web3 0.39.0 → 0.39.2

package/dist/src/api/node-provider.d.ts

@@ -1,6 +1,6 @@
 import { ApiRequestArguments, ApiRequestHandler, FungibleTokenMetaData, NFTMetaData, NFTCollectionMetaData } from './types';
 import { Api as NodeApi } from './api-alephium';
-import { HexString } from '../contract';
+import { HexString } from '../utils';
 interface NodeProviderApis {
     wallets: NodeApi<string>['wallets'];
     infos: NodeApi<string>['infos'];

package/dist/src/contract/contract.d.ts

@@ -1,6 +1,6 @@
 import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
 import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
-import { Optional } from '../utils';
+import { Optional, HexString } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
 export type FieldsSig = node.FieldsSig;
 export type MapsSig = node.MapsSig;
@@ -8,7 +8,6 @@ export type EventSig = node.EventSig;
 export type FunctionSig = node.FunctionSig;
 export type Fields = NamedVals;
 export type Arguments = NamedVals;
-export type HexString = string;
 export type Constant = node.Constant;
 export type Enum = node.Enum;
 export declare const StdIdFieldName = "__stdInterfaceId";

package/dist/src/contract/ralph.d.ts

@@ -1,4 +1,5 @@
 import { Val } from '../api';
+import { HexString } from '../utils';
 import { Fields, FieldsSig, Struct } from './contract';
 export declare function encodeBool(bool: boolean): Uint8Array;
 export declare function decodeBool(bytes: Uint8Array): boolean;
@@ -18,6 +19,30 @@ export declare function encodeVmI256(i256: bigint): Uint8Array;
 export declare function encodeVmU256(u256: bigint): Uint8Array;
 export declare function encodeVmByteVec(bytes: string): Uint8Array;
 export declare function encodeVmAddress(address: string): Uint8Array;
+export declare function boolVal(value: boolean): {
+    type: 'Bool';
+    value: Val;
+};
+export declare function i256Val(value: bigint | number): {
+    type: 'I256';
+    value: Val;
+};
+export declare function u256Val(value: bigint | number): {
+    type: 'U256';
+    value: Val;
+};
+export declare function byteVecVal(value: HexString): {
+    type: 'ByteVec';
+    value: Val;
+};
+export declare function addressVal(value: string): {
+    type: 'Address';
+    value: Val;
+};
+export declare function encodePrimitiveValues(values: {
+    type: string;
+    value: Val;
+}[]): Uint8Array;
 export declare function encodeScriptFieldAsString(tpe: string, value: Val): string;
 export declare function encodeScriptField(tpe: string, value: Val): Uint8Array;
 export declare function splitFields(fieldsSig: FieldsSig): [FieldsSig, FieldsSig];
@@ -42,6 +67,10 @@ export declare function flattenFields(fields: Fields, names: string[], types: st
     isMutable: boolean;
 }[];
 export declare function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: FieldsSig, structs: Struct[]): string;
+export declare function encodeContractFields(fields: Fields, fieldsSig: FieldsSig, structs: Struct[]): {
+    encodedImmFields: Uint8Array;
+    encodedMutFields: Uint8Array;
+};
 export declare function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: FieldsSig, structs: Struct[]): string;
 export declare function encodeContractField(tpe: string, value: Val): Uint8Array;
 export declare function buildDebugBytecode(bytecode: string, bytecodePatch: string): string;

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.flattenFields = exports.primitiveToByteVec = exports.decodePrimitive = exports.tryDecodeMapDebugLog = exports.calcFieldSize = exports.encodeMapPrefix = exports.parseMapType = exports.splitFields = 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.decodeBool = exports.encodeBool = void 0;
+exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.encodeContractFields = exports.buildScriptByteCode = exports.flattenFields = exports.primitiveToByteVec = exports.decodePrimitive = exports.tryDecodeMapDebugLog = exports.calcFieldSize = exports.encodeMapPrefix = exports.parseMapType = exports.splitFields = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodePrimitiveValues = exports.addressVal = exports.byteVecVal = exports.u256Val = exports.i256Val = exports.boolVal = exports.encodeVmAddress = exports.encodeVmByteVec = exports.encodeVmU256 = exports.encodeVmI256 = exports.encodeVmBool = exports.VmValType = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.decodeBool = exports.encodeBool = void 0;
 const buffer_1 = require("buffer/");
 const api_1 = require("../api");
 const utils_1 = require("../utils");
@@ -181,25 +181,49 @@ var VmValType;
     VmValType[VmValType["Address"] = 4] = "Address";
 })(VmValType = exports.VmValType || (exports.VmValType = {}));
 function encodeVmBool(bool) {
-    return buffer_1.Buffer.concat([encodeU256(BigInt(VmValType.Bool)), encodeBool(bool)]);
+    return new Uint8Array([VmValType.Bool, ...encodeBool(bool)]);
 }
 exports.encodeVmBool = encodeVmBool;
 function encodeVmI256(i256) {
-    return buffer_1.Buffer.concat([encodeU256(BigInt(VmValType.I256)), encodeI256(i256)]);
+    return new Uint8Array([VmValType.I256, ...encodeI256(i256)]);
 }
 exports.encodeVmI256 = encodeVmI256;
 function encodeVmU256(u256) {
-    return buffer_1.Buffer.concat([encodeU256(BigInt(VmValType.U256)), encodeU256(u256)]);
+    return new Uint8Array([VmValType.U256, ...encodeU256(u256)]);
 }
 exports.encodeVmU256 = encodeVmU256;
 function encodeVmByteVec(bytes) {
-    return buffer_1.Buffer.concat([encodeU256(BigInt(VmValType.ByteVec)), encodeByteVec(bytes)]);
+    return new Uint8Array([VmValType.ByteVec, ...encodeByteVec(bytes)]);
 }
 exports.encodeVmByteVec = encodeVmByteVec;
 function encodeVmAddress(address) {
-    return buffer_1.Buffer.concat([encodeU256(BigInt(VmValType.Address)), encodeAddress(address)]);
+    return new Uint8Array([VmValType.Address, ...encodeAddress(address)]);
 }
 exports.encodeVmAddress = encodeVmAddress;
+function boolVal(value) {
+    return { type: 'Bool', value };
+}
+exports.boolVal = boolVal;
+function i256Val(value) {
+    return { type: 'I256', value: BigInt(value) };
+}
+exports.i256Val = i256Val;
+function u256Val(value) {
+    return { type: 'U256', value: BigInt(value) };
+}
+exports.u256Val = u256Val;
+function byteVecVal(value) {
+    return { type: 'ByteVec', value };
+}
+exports.byteVecVal = byteVecVal;
+function addressVal(value) {
+    return { type: 'Address', value };
+}
+exports.addressVal = addressVal;
+function encodePrimitiveValues(values) {
+    return encodeFields(values.map(({ type, value }) => ({ name: `${value}`, type, value })));
+}
+exports.encodePrimitiveValues = encodePrimitiveValues;
 function invalidScriptField(tpe, value) {
     return Error(`Invalid script field ${value} for type ${tpe}`);
 }
@@ -455,50 +479,40 @@ function _encodeField(fieldName, encodeFunc) {
     }
 }
 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;
+    const prefix = encodeI256(BigInt(fields.length));
+    return fields.reduce((acc, field) => {
+        const encoded = _encodeField(field.name, () => encodeContractField(field.type, field.value));
+        const bytes = new Uint8Array(acc.byteLength + encoded.byteLength);
+        bytes.set(acc, 0);
+        bytes.set(encoded, acc.byteLength);
+        return bytes;
+    }, prefix);
+}
+function encodeContractFields(fields, fieldsSig, structs) {
+    const allFields = flattenFields(fields, fieldsSig.names, fieldsSig.types, fieldsSig.isMutable, structs);
+    return {
+        encodedImmFields: encodeFields(allFields.filter((f) => !f.isMutable)),
+        encodedMutFields: encodeFields(allFields.filter((f) => f.isMutable))
+    };
 }
+exports.encodeContractFields = encodeContractFields;
 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;
+    const { encodedImmFields, encodedMutFields } = encodeContractFields(fields, fieldsSig, structs);
+    return bytecode + (0, utils_1.binToHex)(encodedImmFields) + (0, utils_1.binToHex)(encodedMutFields);
 }
 exports.buildContractByteCode = buildContractByteCode;
-var ApiValType;
-(function (ApiValType) {
-    ApiValType[ApiValType["Bool"] = 0] = "Bool";
-    ApiValType[ApiValType["I256"] = 1] = "I256";
-    ApiValType[ApiValType["U256"] = 2] = "U256";
-    ApiValType[ApiValType["ByteVec"] = 3] = "ByteVec";
-    ApiValType[ApiValType["Address"] = 4] = "Address";
-})(ApiValType || (ApiValType = {}));
-function encodeContractFieldI256(value) {
-    return new Uint8Array([ApiValType.I256, ...encodeI256(value)]);
-}
-function encodeContractFieldU256(value) {
-    return new Uint8Array([ApiValType.U256, ...encodeU256(value)]);
-}
 function encodeContractField(tpe, value) {
     switch (tpe) {
         case 'Bool':
-            const byte = (0, api_1.toApiBoolean)(value) ? 1 : 0;
-            return new Uint8Array([ApiValType.Bool, byte]);
+            return encodeVmBool((0, api_1.toApiBoolean)(value));
         case 'I256':
-            const i256 = (0, api_1.toApiNumber256)(value);
-            return encodeContractFieldI256(BigInt(i256));
+            return encodeVmI256(BigInt((0, api_1.toApiNumber256)(value)));
         case 'U256':
-            const u256 = (0, api_1.toApiNumber256)(value);
-            return encodeContractFieldU256(BigInt(u256));
+            return encodeVmU256(BigInt((0, api_1.toApiNumber256)(value)));
         case 'ByteVec':
-            const hexStr = (0, api_1.toApiByteVec)(value);
-            return new Uint8Array([ApiValType.ByteVec, ...encodeByteVec(hexStr)]);
+            return encodeVmByteVec((0, api_1.toApiByteVec)(value));
         case 'Address':
-            const address = (0, api_1.toApiAddress)(value);
-            return new Uint8Array([ApiValType.Address, ...encodeAddress(address)]);
+            return encodeVmAddress((0, api_1.toApiAddress)(value));
         default:
             throw Error(`Expected primitive type, got ${tpe}`);
     }

package/dist/src/utils/utils.d.ts

@@ -1,8 +1,8 @@
 import { ec as EC, SignatureInput } from 'elliptic';
 import BN from 'bn.js';
-import { HexString } from '../contract';
 export declare const networkIds: readonly ["mainnet", "testnet", "devnet"];
 export type NetworkId = (typeof networkIds)[number];
+export type HexString = string;
 export declare function encodeSignature(signature: EC.Signature | {
     r: BN;
     s: BN;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.39.0",
+  "version": "0.39.2",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",

package/src/api/node-provider.ts

@@ -28,8 +28,9 @@ import {
   requestWithLog
 } from './types'
 import { Api as NodeApi, CallContractFailed, CallContractSucceeded } from './api-alephium'
-import { HexString, tryGetCallResult } from '../contract'
+import { tryGetCallResult } from '../contract'
 import {
+  HexString,
   addressFromContractId,
   addressFromTokenId,
   groupOfAddress,

package/src/contract/contract.ts

@@ -58,7 +58,8 @@ import {
   hexToBinUnsafe,
   isDevnet,
   addressFromContractId,
-  subContractId
+  subContractId,
+  HexString
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
@@ -89,7 +90,6 @@ export type EventSig = node.EventSig
 export type FunctionSig = node.FunctionSig
 export type Fields = NamedVals
 export type Arguments = NamedVals
-export type HexString = string
 export type Constant = node.Constant
 export type Enum = node.Enum
 

package/src/contract/ralph.ts

@@ -18,10 +18,9 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { Buffer } from 'buffer/'
 import { Val, decodeArrayType, toApiAddress, toApiBoolean, toApiByteVec, toApiNumber256 } from '../api'
-import { binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
+import { HexString, binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
 import { Fields, FieldsSig, Struct } from './contract'
 import { compactSignedIntCodec, compactUnsignedIntCodec } from '../codec'
-import { lockupScriptCodec } from '../codec/lockup-script-codec'
 
 const bigIntZero = BigInt(0)
 
@@ -175,23 +174,47 @@ export enum VmValType {
 }
 
 export function encodeVmBool(bool: boolean): Uint8Array {
-  return Buffer.concat([encodeU256(BigInt(VmValType.Bool)), encodeBool(bool)])
+  return new Uint8Array([VmValType.Bool, ...encodeBool(bool)])
 }
 
 export function encodeVmI256(i256: bigint): Uint8Array {
-  return Buffer.concat([encodeU256(BigInt(VmValType.I256)), encodeI256(i256)])
+  return new Uint8Array([VmValType.I256, ...encodeI256(i256)])
 }
 
 export function encodeVmU256(u256: bigint): Uint8Array {
-  return Buffer.concat([encodeU256(BigInt(VmValType.U256)), encodeU256(u256)])
+  return new Uint8Array([VmValType.U256, ...encodeU256(u256)])
 }
 
 export function encodeVmByteVec(bytes: string): Uint8Array {
-  return Buffer.concat([encodeU256(BigInt(VmValType.ByteVec)), encodeByteVec(bytes)])
+  return new Uint8Array([VmValType.ByteVec, ...encodeByteVec(bytes)])
 }
 
 export function encodeVmAddress(address: string): Uint8Array {
-  return Buffer.concat([encodeU256(BigInt(VmValType.Address)), encodeAddress(address)])
+  return new Uint8Array([VmValType.Address, ...encodeAddress(address)])
+}
+
+export function boolVal(value: boolean): { type: 'Bool'; value: Val } {
+  return { type: 'Bool', value }
+}
+
+export function i256Val(value: bigint | number): { type: 'I256'; value: Val } {
+  return { type: 'I256', value: BigInt(value) }
+}
+
+export function u256Val(value: bigint | number): { type: 'U256'; value: Val } {
+  return { type: 'U256', value: BigInt(value) }
+}
+
+export function byteVecVal(value: HexString): { type: 'ByteVec'; value: Val } {
+  return { type: 'ByteVec', value }
+}
+
+export function addressVal(value: string): { type: 'Address'; value: Val } {
+  return { type: 'Address', value }
+}
+
+export function encodePrimitiveValues(values: { type: string; value: Val }[]): Uint8Array {
+  return encodeFields(values.map(({ type, value }) => ({ name: `${value}`, type, value })))
 }
 
 function invalidScriptField(tpe: string, value: Val): Error {
@@ -486,59 +509,51 @@ function _encodeField<T>(fieldName: string, encodeFunc: () => T): T {
   }
 }
 
-function encodeFields(fields: { name: string; type: string; value: Val }[]): string {
-  const prefix = binToHex(encodeI256(BigInt(fields.length)))
-  const encoded = fields
-    .map((field) => binToHex(_encodeField(field.name, () => encodeContractField(field.type, field.value))))
-    .join('')
-  return prefix + encoded
+function encodeFields(fields: { name: string; type: string; value: Val }[]): Uint8Array {
+  const prefix = encodeI256(BigInt(fields.length))
+  return fields.reduce((acc, field) => {
+    const encoded = _encodeField(field.name, () => encodeContractField(field.type, field.value))
+    const bytes = new Uint8Array(acc.byteLength + encoded.byteLength)
+    bytes.set(acc, 0)
+    bytes.set(encoded, acc.byteLength)
+    return bytes
+  }, prefix)
 }
 
-export function buildContractByteCode(
-  bytecode: string,
+export function encodeContractFields(
   fields: Fields,
   fieldsSig: FieldsSig,
   structs: Struct[]
-): string {
+): { encodedImmFields: Uint8Array; encodedMutFields: Uint8Array } {
   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
-}
-
-enum ApiValType {
-  Bool = 0,
-  I256 = 1,
-  U256 = 2,
-  ByteVec = 3,
-  Address = 4
-}
-
-function encodeContractFieldI256(value: bigint): Uint8Array {
-  return new Uint8Array([ApiValType.I256, ...encodeI256(value)])
+  return {
+    encodedImmFields: encodeFields(allFields.filter((f) => !f.isMutable)),
+    encodedMutFields: encodeFields(allFields.filter((f) => f.isMutable))
+  }
 }
 
-function encodeContractFieldU256(value: bigint): Uint8Array {
-  return new Uint8Array([ApiValType.U256, ...encodeU256(value)])
+export function buildContractByteCode(
+  bytecode: string,
+  fields: Fields,
+  fieldsSig: FieldsSig,
+  structs: Struct[]
+): string {
+  const { encodedImmFields, encodedMutFields } = encodeContractFields(fields, fieldsSig, structs)
+  return bytecode + binToHex(encodedImmFields) + binToHex(encodedMutFields)
 }
 
 export function encodeContractField(tpe: string, value: Val): Uint8Array {
   switch (tpe) {
     case 'Bool':
-      const byte = toApiBoolean(value) ? 1 : 0
-      return new Uint8Array([ApiValType.Bool, byte])
+      return encodeVmBool(toApiBoolean(value))
     case 'I256':
-      const i256 = toApiNumber256(value)
-      return encodeContractFieldI256(BigInt(i256))
+      return encodeVmI256(BigInt(toApiNumber256(value)))
     case 'U256':
-      const u256 = toApiNumber256(value)
-      return encodeContractFieldU256(BigInt(u256))
+      return encodeVmU256(BigInt(toApiNumber256(value)))
     case 'ByteVec':
-      const hexStr = toApiByteVec(value)
-      return new Uint8Array([ApiValType.ByteVec, ...encodeByteVec(hexStr)])
+      return encodeVmByteVec(toApiByteVec(value))
     case 'Address':
-      const address = toApiAddress(value)
-      return new Uint8Array([ApiValType.Address, ...encodeAddress(address)])
+      return encodeVmAddress(toApiAddress(value))
     default:
       throw Error(`Expected primitive type, got ${tpe}`)
   }

package/src/utils/utils.ts

@@ -18,15 +18,13 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { ec as EC, SignatureInput } from 'elliptic'
 import BN from 'bn.js'
-import bs58 from './bs58'
 import { Buffer } from 'buffer/'
 
 import { TOTAL_NUMBER_OF_GROUPS, TOTAL_NUMBER_OF_CHAINS } from '../constants'
-import { KeyType } from '../signer'
-import { HexString } from '../contract'
 
 export const networkIds = ['mainnet', 'testnet', 'devnet'] as const
 export type NetworkId = (typeof networkIds)[number]
+export type HexString = string
 
 const ec = new EC('secp256k1')