@alephium/web3 0.43.0 → 0.45.0

package/dist/src/codec/array-codec.js

@@ -50,7 +50,7 @@ class ArrayCodec {
     }
     fromArray(inputs) {
         return {
-            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(inputs.length),
+            length: compact_int_codec_1.compactSignedIntCodec.fromI32(inputs.length),
             value: inputs
         };
     }

package/dist/src/codec/asset-output-codec.js

@@ -32,7 +32,7 @@ class AssetOutputCodec {
     constructor() {
         this.parser = binary_parser_1.Parser.start()
             .nest('amount', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .nest('lockupScript', {
             type: lockup_script_codec_1.lockupScriptCodec.parser
@@ -111,12 +111,12 @@ class AssetOutputCodec {
             };
         });
         const tokens = {
-            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(tokensValue.length),
+            length: compact_int_codec_1.compactSignedIntCodec.fromI32(tokensValue.length),
             value: tokensValue
         };
         const additionalDataValue = (0, utils_1.hexToBinUnsafe)(fixedOutput.message);
         const additionalData = {
-            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(additionalDataValue.length),
+            length: compact_int_codec_1.compactSignedIntCodec.fromI32(additionalDataValue.length),
             value: additionalDataValue
         };
         return {

package/dist/src/codec/bytestring-codec.js

@@ -25,22 +25,22 @@ class ByteStringCodec {
     constructor() {
         this.parser = new binary_parser_1.Parser()
             .nest('length', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .buffer('value', {
             length: function (ctx) {
-                return compact_int_codec_1.compactUnsignedIntCodec.toU32(this['length']);
+                return compact_int_codec_1.compactSignedIntCodec.toI32(this['length']);
             }
         });
     }
     encode(input) {
-        return (0, utils_1.concatBytes)([compact_int_codec_1.compactUnsignedIntCodec.encode(input.length), input.value]);
+        return (0, utils_1.concatBytes)([compact_int_codec_1.compactSignedIntCodec.encode(input.length), input.value]);
     }
     decode(input) {
         return this.parser.parse(input);
     }
     encodeBytes(input) {
-        return (0, utils_1.concatBytes)([compact_int_codec_1.compactUnsignedIntCodec.encodeU32(input.length), input]);
+        return (0, utils_1.concatBytes)([compact_int_codec_1.compactSignedIntCodec.encodeI32(input.length), input]);
     }
     decodeBytes(input) {
         return this.decode(input).value;

package/dist/src/codec/compact-int-codec.d.ts

@@ -21,11 +21,8 @@ export declare class CompactUnsignedIntCodec implements Codec<DecodedCompactInt>
     encode(input: DecodedCompactInt): Uint8Array;
     encodeU32(value: number): Uint8Array;
     encodeU256(value: bigint): Uint8Array;
-    decodeU32(input: Uint8Array): number;
     decodeU256(input: Uint8Array): bigint;
     decode(input: Uint8Array): DecodedCompactInt;
-    toU32(value: DecodedCompactInt): number;
-    fromU32(value: number): DecodedCompactInt;
     toU256(value: DecodedCompactInt): bigint;
     fromU256(value: bigint): DecodedCompactInt;
 }

package/dist/src/codec/compact-int-codec.js

@@ -102,10 +102,6 @@ class CompactUnsignedIntCodec {
             return new Uint8Array([header, ...bytes]);
         }
     }
-    decodeU32(input) {
-        const decoded = this.decode(input);
-        return this.toU32(decoded);
-    }
     decodeU256(input) {
         const decoded = this.decode(input);
         return this.toU256(decoded);
@@ -113,17 +109,11 @@ class CompactUnsignedIntCodec {
     decode(input) {
         return this.parser.parse(input);
     }
-    toU32(value) {
-        const body = new Uint8Array([value.mode, ...value.rest]);
-        return decodePositiveInt(value.mode, body);
-    }
-    fromU32(value) {
-        return this.decode(this.encodeU32(value));
-    }
     toU256(value) {
         const mode = value.mode & maskRest;
         if (fixedSize(mode)) {
-            return BigInt(this.toU32(value));
+            const body = new Uint8Array([value.mode, ...value.rest]);
+            return BigInt(decodePositiveInt(value.mode, body));
         }
         else {
             (0, codec_1.assert)(value.rest.length <= 32, 'Expect <= 32 bytes for U256');

package/dist/src/codec/contract-codec.js

@@ -47,8 +47,8 @@ class ContractCodec {
     }
     decodeContract(input) {
         const halfDecoded = this.decode(input);
-        const fieldLength = compact_int_codec_1.compactUnsignedIntCodec.toU32(halfDecoded.fieldLength);
-        const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compact_int_codec_1.compactUnsignedIntCodec.toU32(v));
+        const fieldLength = compact_int_codec_1.compactSignedIntCodec.toI32(halfDecoded.fieldLength);
+        const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compact_int_codec_1.compactSignedIntCodec.toI32(v));
         const methods = [];
         for (let i = 0, start = 0; i < methodIndexes.length; i++) {
             const end = methodIndexes[i];

package/dist/src/codec/contract-output-codec.js

@@ -70,7 +70,7 @@ class ContractOutputCodec {
             };
         });
         const tokens = {
-            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(tokensValue.length),
+            length: compact_int_codec_1.compactSignedIntCodec.fromI32(tokensValue.length),
             value: tokensValue
         };
         return { amount, lockupScript, tokens };

package/dist/src/codec/method-codec.js

@@ -53,13 +53,13 @@ class MethodCodec {
             .uint8('isPublic')
             .uint8('assetModifier')
             .nest('argsLength', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .nest('localsLength', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .nest('returnLength', {
-            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+            type: compact_int_codec_1.compactSignedIntCodec.parser
         })
             .nest('instrs', {
             type: instr_codec_1.instrsCodec.parser
@@ -67,9 +67,9 @@ class MethodCodec {
     }
     encode(input) {
         const result = [input.isPublic, input.assetModifier];
-        result.push(...compact_int_codec_1.compactUnsignedIntCodec.encode(input.argsLength));
-        result.push(...compact_int_codec_1.compactUnsignedIntCodec.encode(input.localsLength));
-        result.push(...compact_int_codec_1.compactUnsignedIntCodec.encode(input.returnLength));
+        result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.argsLength));
+        result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.localsLength));
+        result.push(...compact_int_codec_1.compactSignedIntCodec.encode(input.returnLength));
         result.push(...instr_codec_1.instrsCodec.encode(input.instrs.value));
         return new Uint8Array(result);
     }
@@ -80,9 +80,9 @@ class MethodCodec {
         return {
             isPublic: decodedMethod.isPublic === 1,
             ...decodeAssetModifier(decodedMethod.assetModifier),
-            argsLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
-            localsLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
-            returnLength: compact_int_codec_1.compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
+            argsLength: compact_int_codec_1.compactSignedIntCodec.toI32(decodedMethod.argsLength),
+            localsLength: compact_int_codec_1.compactSignedIntCodec.toI32(decodedMethod.localsLength),
+            returnLength: compact_int_codec_1.compactSignedIntCodec.toI32(decodedMethod.returnLength),
             instrs: decodedMethod.instrs.value
         };
     }
@@ -90,9 +90,9 @@ class MethodCodec {
         return {
             isPublic: method.isPublic ? 1 : 0,
             assetModifier: encodeAssetModifier(method),
-            argsLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.argsLength),
-            localsLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.localsLength),
-            returnLength: compact_int_codec_1.compactUnsignedIntCodec.fromU32(method.returnLength),
+            argsLength: compact_int_codec_1.compactSignedIntCodec.fromI32(method.argsLength),
+            localsLength: compact_int_codec_1.compactSignedIntCodec.fromI32(method.localsLength),
+            returnLength: compact_int_codec_1.compactSignedIntCodec.fromI32(method.returnLength),
             instrs: instr_codec_1.instrsCodec.fromArray(method.instrs)
         };
     }

package/dist/src/codec/script-codec.js

@@ -40,7 +40,7 @@ class ScriptCodec {
         return { methods };
     }
     encodeScript(inputTxScript) {
-        const methodLength = compact_int_codec_1.compactUnsignedIntCodec.fromU32(inputTxScript.methods.length);
+        const methodLength = compact_int_codec_1.compactSignedIntCodec.fromI32(inputTxScript.methods.length);
         const decodedMethods = inputTxScript.methods.map((method) => method_codec_1.MethodCodec.fromMethod(method));
         return this.encode({ methods: { value: decodedMethods, length: methodLength } });
     }

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

@@ -1,5 +1,5 @@
 import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
-import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
+import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address, SignExecuteScriptTxResult } from '../signer';
 import { Optional, HexString } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
 import { Method } from '../codec';
@@ -220,6 +220,14 @@ export interface CallContractResult<R> {
     events: ContractEvent[];
     debugMessages: DebugMessage[];
 }
+export interface SignExecuteContractMethodParams<T extends Arguments = Arguments> {
+    args: T;
+    signer: SignerProvider;
+    attoAlphAmount?: Number256;
+    tokens?: Token[];
+    gasAmount?: number;
+    gasPrice?: Number256;
+}
 export declare const CreateContractEventAddresses: string[];
 export declare const DestroyContractEventAddresses: string[];
 export type ContractCreatedEventFields = {
@@ -267,6 +275,7 @@ export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>
 export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
 export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
 export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
+export declare function signExecuteMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<SignExecuteContractMethodParams<A>, 'args'>): Promise<SignExecuteScriptTxResult>;
 export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
 export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export declare const getContractIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;

package/dist/src/contract/contract.js

@@ -40,7 +40,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.getMapItem = exports.RalphMap = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddresses = exports.CreateContractEventAddresses = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.fromApiEventFields = exports.fromApiArray = exports.getDefaultValue = exports.fromApiFields = exports.Script = exports.Contract = exports.Artifact = exports.Struct = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
+exports.getTokenIdFromUnsignedTx = exports.getContractIdFromUnsignedTx = exports.getContractEventsCurrentCount = exports.multicallMethods = exports.signExecuteMethod = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.getMapItem = exports.RalphMap = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddresses = exports.CreateContractEventAddresses = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.fromApiEventFields = exports.fromApiArray = exports.getDefaultValue = exports.fromApiFields = exports.Script = exports.Contract = exports.Artifact = exports.Struct = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
 const fs_1 = require("fs");
 const api_1 = require("../api");
 const ralph = __importStar(require("./ralph"));
@@ -1042,6 +1042,182 @@ async function callMethod(contract, instance, methodName, params, getContractByC
     return callResult;
 }
 exports.callMethod = callMethod;
+async function signExecuteMethod(contract, instance, methodName, params) {
+    const methodIndex = contract.contract.getMethodIndex(methodName);
+    const functionSig = contract.contract.functions[methodIndex];
+    const usePreapprovedAssets = contract.contract.decodedMethods[methodIndex].usePreapprovedAssets;
+    const bytecodeTemplate = getBytecodeTemplate(methodIndex, usePreapprovedAssets, functionSig, contract.contract.structs, params.attoAlphAmount, params.tokens);
+    const fieldsSig = toFieldsSig(contract.contract.name, functionSig);
+    const bytecode = ralph.buildScriptByteCode(bytecodeTemplate, { __contract__: instance.contractId, ...params.args }, fieldsSig, contract.contract.structs);
+    const signer = params.signer;
+    const selectedAccount = await signer.getSelectedAccount();
+    const signerParams = {
+        signerAddress: selectedAccount.address,
+        signerKeyType: selectedAccount.keyType,
+        bytecode: bytecode,
+        attoAlphAmount: params.attoAlphAmount,
+        tokens: params.tokens,
+        gasAmount: params.gasAmount,
+        gasPrice: params.gasPrice
+    };
+    return await signer.signAndSubmitExecuteScriptTx(signerParams);
+}
+exports.signExecuteMethod = signExecuteMethod;
+function getBytecodeTemplate(methodIndex, usePreapprovedAssets, functionSig, structs, attoAlphAmount, tokens) {
+    // For the default TxScript main function
+    const numberOfMethods = '01';
+    const isPublic = '01';
+    const modifier = usePreapprovedAssets ? '03' : '00';
+    const argsLength = '00';
+    const returnsLength = '00';
+    const [templateVarStoreLocalInstrs, templateVarsLength] = getTemplateVarStoreLocalInstrs(functionSig, structs);
+    const approveAlphInstrs = getApproveAlphInstrs(usePreapprovedAssets ? attoAlphAmount : undefined);
+    const approveTokensInstrs = getApproveTokensInstrs(usePreapprovedAssets ? tokens : undefined);
+    const callerInstrs = getCallAddressInstrs(approveAlphInstrs.length / 2 + approveTokensInstrs.length / 3);
+    // First template var is the contract
+    const functionArgsNum = encodeU256Const(BigInt(templateVarsLength - 1));
+    const localsLength = encodeI32(templateVarStoreLocalInstrs.length / 2);
+    const templateVarLoadLocalInstrs = getTemplateVarLoadLocalInstrs(functionSig, structs);
+    const functionReturnTypesLength = functionSig.returnTypes.reduce((acc, returnType) => acc + ralph.typeLength(returnType, structs), 0);
+    const functionReturnPopInstrs = encodeInstr(codec_1.Pop).repeat(functionReturnTypesLength);
+    const functionReturnNum = encodeU256Const(BigInt(functionReturnTypesLength));
+    const contractTemplateVar = '{0}'; // always the 1st argument
+    const externalCallInstr = encodeInstr((0, codec_1.CallExternal)(methodIndex));
+    const numberOfInstrs = encodeI32(callerInstrs.length +
+        approveAlphInstrs.length +
+        approveTokensInstrs.length +
+        templateVarStoreLocalInstrs.length +
+        templateVarLoadLocalInstrs.length +
+        functionReturnTypesLength +
+        4 // functionArgsNum, functionReturnNum, contractTemplate, externalCallInstr
+    );
+    return (numberOfMethods +
+        isPublic +
+        modifier +
+        argsLength +
+        localsLength +
+        returnsLength +
+        numberOfInstrs +
+        callerInstrs.join('') +
+        approveAlphInstrs.join('') +
+        approveTokensInstrs.join('') +
+        templateVarStoreLocalInstrs.join('') +
+        templateVarLoadLocalInstrs.join('') +
+        functionArgsNum +
+        functionReturnNum +
+        contractTemplateVar +
+        externalCallInstr +
+        functionReturnPopInstrs);
+}
+function getApproveAlphInstrs(attoAlphAmount) {
+    const approveAlphInstrs = [];
+    if (attoAlphAmount) {
+        const approvedAttoAlphAmount = encodeU256Const(BigInt(attoAlphAmount));
+        approveAlphInstrs.push(approvedAttoAlphAmount);
+        approveAlphInstrs.push(encodeInstr(codec_1.ApproveAlph));
+    }
+    return approveAlphInstrs;
+}
+function getApproveTokensInstrs(tokens) {
+    const approveTokensInstrs = [];
+    if (tokens) {
+        tokens.forEach((token) => {
+            const tokenIdBin = (0, utils_1.hexToBinUnsafe)(token.id);
+            approveTokensInstrs.push(encodeInstr((0, codec_1.ByteConst)({
+                length: codec_1.compactSignedIntCodec.fromI32(tokenIdBin.length),
+                value: tokenIdBin
+            })));
+            approveTokensInstrs.push(encodeU256Const(BigInt(token.amount)));
+            approveTokensInstrs.push(encodeInstr(codec_1.ApproveToken));
+        });
+    }
+    return approveTokensInstrs;
+}
+function getCallAddressInstrs(approveAssetsNum) {
+    const callerInstrs = [];
+    if (approveAssetsNum > 0) {
+        callerInstrs.push(encodeInstr(codec_1.CallerAddress));
+        const dup = encodeInstr(codec_1.Dup);
+        if (approveAssetsNum > 1) {
+            callerInstrs.push(...new Array(approveAssetsNum - 1).fill(dup));
+        }
+    }
+    return callerInstrs;
+}
+function getTemplateVarStoreLocalInstrs(functionSig, structs) {
+    let templateVarIndex = 1; // Start from 1 since first one is always the contract id
+    let localsLength = 0;
+    const templateVarStoreInstrs = [];
+    functionSig.paramTypes.forEach((paramType) => {
+        const fieldsLength = ralph.typeLength(paramType, structs);
+        if (fieldsLength > 1) {
+            for (let i = 0; i < fieldsLength; i++) {
+                templateVarStoreInstrs.push(`{${templateVarIndex + i}}`);
+            }
+            for (let i = 0; i < fieldsLength; i++) {
+                templateVarStoreInstrs.push(encodeStoreLocalInstr(localsLength + (fieldsLength - i - 1)));
+            }
+            localsLength = localsLength + fieldsLength;
+        }
+        templateVarIndex = templateVarIndex + fieldsLength;
+    });
+    return [templateVarStoreInstrs, templateVarIndex];
+}
+function getTemplateVarLoadLocalInstrs(functionSig, structs) {
+    let templateVarIndex = 1;
+    let loadIndex = 0;
+    const templateVarLoadInstrs = [];
+    functionSig.paramTypes.forEach((paramType) => {
+        const fieldsLength = ralph.typeLength(paramType, structs);
+        if (fieldsLength === 1) {
+            templateVarLoadInstrs.push(`{${templateVarIndex}}`);
+        }
+        if (fieldsLength > 1) {
+            for (let i = 0; i < fieldsLength; i++) {
+                templateVarLoadInstrs.push(encodeLoadLocalInstr(loadIndex + i));
+            }
+            loadIndex = loadIndex + fieldsLength;
+        }
+        templateVarIndex = templateVarIndex + fieldsLength;
+    });
+    return templateVarLoadInstrs;
+}
+function encodeStoreLocalInstr(index) {
+    if (index < 0 || index > 0xff) {
+        throw new Error(`StoreLocal index ${index} must be between 0 and 255 inclusive`);
+    }
+    return encodeInstr((0, codec_1.StoreLocal)(index));
+}
+function encodeLoadLocalInstr(index) {
+    if (index < 0 || index > 0xff) {
+        throw new Error(`LoadLocal index ${index} must be between 0 and 255 inclusive`);
+    }
+    return encodeInstr((0, codec_1.LoadLocal)(index));
+}
+function encodeI32(value) {
+    return (0, utils_1.binToHex)(codec_1.compactSignedIntCodec.encodeI32(value));
+}
+function encodeU256Const(value) {
+    if (value < 0) {
+        throw new Error(`value ${value} must be non-negative`);
+    }
+    if (value < 6) {
+        return (BigInt(0x0c) + value).toString(16).padStart(2, '0');
+    }
+    else {
+        return encodeInstr((0, codec_1.U256Const)(codec_1.compactUnsignedIntCodec.fromU256(BigInt(value))));
+    }
+}
+function encodeInstr(instr) {
+    return (0, utils_1.binToHex)(codec_1.instrCodec.encode(instr));
+}
+function toFieldsSig(contractName, functionSig) {
+    return {
+        names: ['__contract__'].concat(functionSig.paramNames),
+        types: [contractName].concat(functionSig.paramTypes),
+        isMutable: [false].concat(functionSig.paramIsMutable)
+    };
+}
 async function multicallMethods(contract, instance, calls, getContractByCodeHash) {
     const callEntries = Object.entries(calls);
     const callsParams = callEntries.map((entry) => {

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

@@ -60,6 +60,7 @@ export declare function tryDecodeMapDebugLog(message: string): {
 } | undefined;
 export declare function decodePrimitive(value: Uint8Array, type: string): Val;
 export declare function primitiveToByteVec(value: Val, type: string): Uint8Array;
+export declare function typeLength(typ: string, structs: Struct[]): number;
 export declare function flattenFields(fields: Fields, names: string[], types: string[], isMutable: boolean[], structs: Struct[]): {
     name: string;
     type: 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.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;
+exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.encodeContractFields = exports.buildScriptByteCode = exports.flattenFields = exports.typeLength = 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 api_1 = require("../api");
 const utils_1 = require("../utils");
 const codec_1 = require("../codec");
@@ -402,6 +402,21 @@ function primitiveToByteVec(value, type) {
     }
 }
 exports.primitiveToByteVec = primitiveToByteVec;
+function typeLength(typ, structs) {
+    if (api_1.PrimitiveTypes.includes(typ)) {
+        return 1;
+    }
+    if (typ.startsWith('[')) {
+        const [baseType, size] = (0, api_1.decodeArrayType)(typ);
+        return size * typeLength(baseType, structs);
+    }
+    const struct = structs.find((s) => s.name === typ);
+    if (struct !== undefined) {
+        return struct.fieldTypes.reduce((acc, fieldType) => acc + typeLength(fieldType, structs), 0);
+    }
+    return 1;
+}
+exports.typeLength = typeLength;
 function flattenFields(fields, names, types, isMutable, structs) {
     return names.flatMap((name, index) => {
         if (!(name in fields)) {

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@alephium/web3",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
   "browser": "dist/alephium-web3.min.js",
   "types": "dist/src/index.d.ts",
   "exports": {
-    "node": "./dist/src/index.js",
-    "default": "./dist/alephium-web3.min.js"
+    "node": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "default": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/alephium-web3.min.js"
+    }
   },
   "typesVersions": {
     "*": {

package/src/codec/array-codec.ts

@@ -16,7 +16,7 @@ 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 { Parser } from 'binary-parser'
-import { compactSignedIntCodec, compactUnsignedIntCodec, DecodedCompactInt } from './compact-int-codec'
+import { compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
 import { Codec } from './codec'
 
 export interface DecodedArray<T> {
@@ -55,7 +55,7 @@ export class ArrayCodec<T> implements Codec<T[]> {
 
   fromArray(inputs: T[]): DecodedArray<T> {
     return {
-      length: compactUnsignedIntCodec.fromU32(inputs.length),
+      length: compactSignedIntCodec.fromI32(inputs.length),
       value: inputs
     }
   }

package/src/codec/asset-output-codec.ts

@@ -17,7 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
 import { signedIntCodec } from './signed-int-codec'
 import { longCodec } from './long-codec'
 import { ByteString, byteStringCodec } from './bytestring-codec'
@@ -40,7 +40,7 @@ export interface AssetOutput {
 export class AssetOutputCodec implements Codec<AssetOutput> {
   parser = Parser.start()
     .nest('amount', {
-      type: compactUnsignedIntCodec.parser
+      type: compactSignedIntCodec.parser
     })
     .nest('lockupScript', {
       type: lockupScriptCodec.parser
@@ -124,12 +124,12 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
       }
     })
     const tokens: DecodedArray<Token> = {
-      length: compactUnsignedIntCodec.fromU32(tokensValue.length),
+      length: compactSignedIntCodec.fromI32(tokensValue.length),
       value: tokensValue
     }
     const additionalDataValue = hexToBinUnsafe(fixedOutput.message)
     const additionalData: ByteString = {
-      length: compactUnsignedIntCodec.fromU32(additionalDataValue.length),
+      length: compactSignedIntCodec.fromI32(additionalDataValue.length),
       value: additionalDataValue
     }
 

package/src/codec/bytestring-codec.ts

@@ -16,7 +16,7 @@ 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 { Parser } from 'binary-parser'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { concatBytes } from '../utils'
 
@@ -28,16 +28,16 @@ export interface ByteString {
 export class ByteStringCodec implements Codec<ByteString> {
   parser = new Parser()
     .nest('length', {
-      type: compactUnsignedIntCodec.parser
+      type: compactSignedIntCodec.parser
     })
     .buffer('value', {
       length: function (ctx) {
-        return compactUnsignedIntCodec.toU32(this['length']! as any as DecodedCompactInt)
+        return compactSignedIntCodec.toI32(this['length']! as any as DecodedCompactInt)
       }
     })
 
   encode(input: ByteString): Uint8Array {
-    return concatBytes([compactUnsignedIntCodec.encode(input.length), input.value])
+    return concatBytes([compactSignedIntCodec.encode(input.length), input.value])
   }
 
   decode(input: Uint8Array): ByteString {
@@ -45,7 +45,7 @@ export class ByteStringCodec implements Codec<ByteString> {
   }
 
   encodeBytes(input: Uint8Array): Uint8Array {
-    return concatBytes([compactUnsignedIntCodec.encodeU32(input.length), input])
+    return concatBytes([compactSignedIntCodec.encodeI32(input.length), input])
   }
 
   decodeBytes(input: Uint8Array): Uint8Array {

package/src/codec/compact-int-codec.ts

@@ -110,11 +110,6 @@ export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
     }
   }
 
-  decodeU32(input: Uint8Array): number {
-    const decoded = this.decode(input)
-    return this.toU32(decoded)
-  }
-
   decodeU256(input: Uint8Array): bigint {
     const decoded = this.decode(input)
     return this.toU256(decoded)
@@ -124,19 +119,11 @@ export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
     return this.parser.parse(input)
   }
 
-  toU32(value: DecodedCompactInt): number {
-    const body = new Uint8Array([value.mode, ...value.rest])
-    return decodePositiveInt(value.mode, body)
-  }
-
-  fromU32(value: number): DecodedCompactInt {
-    return this.decode(this.encodeU32(value))
-  }
-
   toU256(value: DecodedCompactInt): bigint {
     const mode = value.mode & maskRest
     if (fixedSize(mode)) {
-      return BigInt(this.toU32(value))
+      const body = new Uint8Array([value.mode, ...value.rest])
+      return BigInt(decodePositiveInt(value.mode, body))
     } else {
       assert(value.rest.length <= 32, 'Expect <= 32 bytes for U256')
       return BigIntCodec.decode(value.rest, false)

package/src/codec/contract-codec.ts

@@ -60,8 +60,8 @@ export class ContractCodec implements Codec<HalfDecodedContract> {
 
   decodeContract(input: Uint8Array): Contract {
     const halfDecoded = this.decode(input)
-    const fieldLength = compactUnsignedIntCodec.toU32(halfDecoded.fieldLength)
-    const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compactUnsignedIntCodec.toU32(v))
+    const fieldLength = compactSignedIntCodec.toI32(halfDecoded.fieldLength)
+    const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compactSignedIntCodec.toI32(v))
     const methods: Method[] = []
     for (let i = 0, start = 0; i < methodIndexes.length; i++) {
       const end = methodIndexes[i]

package/src/codec/contract-output-codec.ts

@@ -17,7 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 import { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
 import { P2C } from './lockup-script-codec'
 import { Codec } from './codec'
 import { Token, tokensCodec } from './token-codec'
@@ -82,7 +82,7 @@ export class ContractOutputCodec implements Codec<ContractOutput> {
       }
     })
     const tokens: DecodedArray<Token> = {
-      length: compactUnsignedIntCodec.fromU32(tokensValue.length),
+      length: compactSignedIntCodec.fromI32(tokensValue.length),
       value: tokensValue
     }