@alephium/web3 0.2.0-rc.14 → 0.2.0-rc.16

package/dist/src/contract/contract.js

@@ -172,12 +172,16 @@ class Project {
         contracts.forEach((c) => {
             files.set(c.sourceFile.contractPath, {
                 sourceCodeHash: c.sourceFile.sourceCodeHash,
+                bytecodeDebugPatch: c.artifact.bytecodeDebugPatch,
+                codeHashDebug: c.artifact.codeHashDebug,
                 warnings: c.warnings
             });
         });
         scripts.forEach((s) => {
             files.set(s.sourceFile.contractPath, {
                 sourceCodeHash: s.sourceFile.sourceCodeHash,
+                bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
+                codeHashDebug: '',
                 warnings: s.warnings
             });
         });
@@ -185,6 +189,8 @@ class Project {
         sourceFiles.slice(compiledSize).forEach((c) => {
             files.set(c.contractPath, {
                 sourceCodeHash: c.sourceCodeHash,
+                bytecodeDebugPatch: '',
+                codeHashDebug: '',
                 warnings: []
             });
         });
@@ -243,7 +249,7 @@ class Project {
         await this.projectArtifact.saveToFile(this.artifactsRootDir);
     }
     contractByCodeHash(codeHash) {
-        const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash);
+        const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash);
         if (typeof contract === 'undefined') {
             throw new Error(`Unknown code with code hash: ${codeHash}`);
         }
@@ -284,11 +290,11 @@ class Project {
                 const warnings = info.warnings;
                 const artifactDir = file.getArtifactPath(artifactsRootDir);
                 if (file.type === SourceType.Contract) {
-                    const artifact = await Contract.fromArtifactFile(artifactDir);
+                    const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug);
                     contracts.push(new Compiled(file, artifact, warnings));
                 }
                 else if (file.type === SourceType.Script) {
-                    const artifact = await Script.fromArtifactFile(artifactDir);
+                    const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch);
                     scripts.push(new Compiled(file, artifact, warnings));
                 }
             }
@@ -385,15 +391,18 @@ class Artifact {
 }
 exports.Artifact = Artifact;
 class Contract extends Artifact {
-    constructor(name, bytecode, codeHash, fieldsSig, eventsSig, functions) {
+    constructor(name, bytecode, bytecodeDebugPatch, codeHash, codeHashDebug, fieldsSig, eventsSig, functions) {
         super(name, functions);
         this.bytecode = bytecode;
+        this.bytecodeDebugPatch = bytecodeDebugPatch;
         this.codeHash = codeHash;
         this.fieldsSig = fieldsSig;
         this.eventsSig = eventsSig;
+        this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
+        this.codeHashDebug = codeHashDebug;
     }
     // TODO: safely parse json
-    static fromJson(artifact) {
+    static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '') {
         if (artifact.name == null ||
             artifact.bytecode == null ||
             artifact.codeHash == null ||
@@ -402,17 +411,17 @@ class Contract extends Artifact {
             artifact.functions == null) {
             throw Error('The artifact JSON for contract is incomplete');
         }
-        const contract = new Contract(artifact.name, artifact.bytecode, artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
+        const contract = new Contract(artifact.name, artifact.bytecode, bytecodeDebugPatch, artifact.codeHash, codeHashDebug ? codeHashDebug : artifact.codeHash, artifact.fieldsSig, artifact.eventsSig, artifact.functions);
         return contract;
     }
     static fromCompileResult(result) {
-        return new Contract(result.name, result.bytecode, result.codeHash, result.fields, result.events, result.functions);
+        return new Contract(result.name, result.bytecode, result.bytecodeDebugPatch, result.codeHash, result.codeHashDebug, result.fields, result.events, result.functions);
     }
     // support both 'code.ral' and 'code.ral.json'
-    static async fromArtifactFile(path) {
+    static async fromArtifactFile(path, bytecodeDebugPatch, codeHashDebug) {
         const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
-        return Contract.fromJson(artifact);
+        return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug);
     }
     async fetchState(address, group) {
         const state = await Project.currentProject.nodeProvider.contracts.getContractsAddressState(address, {
@@ -450,11 +459,20 @@ class Contract extends Artifact {
         bytes[0] = 3;
         return utils_1.bs58.encode(bytes);
     }
-    async _test(funcName, params, expectPublic, accessType) {
+    _printDebugMessages(funcName, messages) {
+        if (messages.length != 0) {
+            console.log(`Testing ${this.name}.${funcName}:`);
+            messages.forEach((m) => console.log(`Debug - ${m.contractAddress} - ${m.message}`));
+        }
+    }
+    async _test(funcName, params, expectPublic, accessType, printDebugMessages) {
         const apiParams = this.toTestContract(funcName, params);
         const apiResult = await Project.currentProject.nodeProvider.contracts.postContractsTestContract(apiParams);
         const methodIndex = typeof params.testMethodIndex !== 'undefined' ? params.testMethodIndex : this.getMethodIndex(funcName);
         const isPublic = this.functions[`${methodIndex}`].isPublic;
+        if (printDebugMessages) {
+            this._printDebugMessages(funcName, apiResult.debugMessages);
+        }
         if (isPublic === expectPublic) {
             const result = await this.fromTestContractResult(methodIndex, apiResult);
             return result;
@@ -463,11 +481,11 @@ class Contract extends Artifact {
             throw new Error(`The test method ${funcName} is not ${accessType}`);
         }
     }
-    async testPublicMethod(funcName, params) {
-        return this._test(funcName, params, true, 'public');
+    async testPublicMethod(funcName, params, printDebugMessages = true) {
+        return this._test(funcName, params, true, 'public', printDebugMessages);
     }
-    async testPrivateMethod(funcName, params) {
-        return this._test(funcName, params, false, 'private');
+    async testPrivateMethod(funcName, params, printDebugMessages = true) {
+        return this._test(funcName, params, false, 'private', printDebugMessages);
     }
     toApiFields(fields) {
         if (typeof fields === 'undefined') {
@@ -499,7 +517,7 @@ class Contract extends Artifact {
         return {
             group: params.group,
             address: params.address,
-            bytecode: this.bytecode,
+            bytecode: this.bytecodeDebug,
             initialFields: this.toApiFields(params.initialFields),
             initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
             methodIndex: this.getMethodIndex(funcName),
@@ -547,6 +565,7 @@ class Contract extends Artifact {
         return {
             address: result.address,
             contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.address)),
+            contractAddress: result.address,
             returns: (0, api_1.fromApiArray)(result.returns, this.functions[`${methodIndex}`].returnTypes),
             gasUsed: result.gasUsed,
             contracts: await Promise.all(result.contracts.map((contract) => this.fromApiContractState(contract))),
@@ -560,7 +579,8 @@ class Contract extends Artifact {
                 else {
                     throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
                 }
-            }))
+            })),
+            debugMessages: result.debugMessages
         };
     }
     async paramsForDeployment(params) {
@@ -600,28 +620,29 @@ Contract.ContractDestroyedEvent = {
     fieldTypes: ['Address']
 };
 class Script extends Artifact {
-    constructor(name, bytecodeTemplate, fieldsSig, functions) {
+    constructor(name, bytecodeTemplate, bytecodeDebugPatch, fieldsSig, functions) {
         super(name, functions);
         this.bytecodeTemplate = bytecodeTemplate;
+        this.bytecodeDebugPatch = bytecodeDebugPatch;
         this.fieldsSig = fieldsSig;
     }
     static fromCompileResult(result) {
-        return new Script(result.name, result.bytecodeTemplate, result.fields, result.functions);
+        return new Script(result.name, result.bytecodeTemplate, result.bytecodeDebugPatch, result.fields, result.functions);
     }
     // TODO: safely parse json
-    static fromJson(artifact) {
+    static fromJson(artifact, bytecodeDebugPatch = '') {
         if (artifact.name == null ||
             artifact.bytecodeTemplate == null ||
             artifact.fieldsSig == null ||
             artifact.functions == null) {
             throw Error('The artifact JSON for script is incomplete');
         }
-        return new Script(artifact.name, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
+        return new Script(artifact.name, artifact.bytecodeTemplate, bytecodeDebugPatch, artifact.fieldsSig, artifact.functions);
     }
-    static async fromArtifactFile(path) {
+    static async fromArtifactFile(path, bytecodeDebugPatch) {
         const content = await fs_2.promises.readFile(path);
         const artifact = JSON.parse(content.toString());
-        return this.fromJson(artifact);
+        return this.fromJson(artifact, bytecodeDebugPatch);
     }
     toString() {
         const object = {

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

@@ -10,3 +10,4 @@ export declare function encodeScriptField(tpe: string, value: Val): Uint8Array;
 export declare function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: FieldsSig): string;
 export declare function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: FieldsSig): 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.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.encodeBool = void 0;
+exports.buildDebugBytecode = exports.encodeContractField = exports.buildContractByteCode = exports.buildScriptByteCode = exports.encodeScriptField = exports.encodeScriptFieldAsString = exports.encodeAddress = exports.encodeByteVec = exports.encodeU256 = exports.encodeI256 = exports.encodeBool = void 0;
 const buffer_1 = require("buffer/");
 const utils_1 = require("../utils");
 const bigIntZero = BigInt(0);
@@ -343,6 +343,32 @@ exports.encodeContractField = encodeContractField;
 function invalidVal(tpe, value) {
     return Error(`Invalid API value ${value} for type ${tpe}`);
 }
+function buildDebugBytecode(bytecode, bytecodePatch) {
+    if (bytecodePatch === '') {
+        return bytecode;
+    }
+    const pattern = /[=+-][0-9a-f]*/g;
+    let result = '';
+    let index = 0;
+    for (const parts of bytecodePatch.matchAll(pattern)) {
+        const part = parts[0];
+        const diffType = part[0];
+        if (diffType === '=') {
+            const length = parseInt(part.substring(1));
+            result = result + bytecode.slice(index, index + length);
+            index = index + length;
+        }
+        else if (diffType === '+') {
+            result = result + part.substring(1);
+        }
+        else {
+            const length = parseInt(part.substring(1));
+            index = index + length;
+        }
+    }
+    return result;
+}
+exports.buildDebugBytecode = buildDebugBytecode;
 // export function buildContractByteCode(
 //   compiled: node.TemplateContractByteCode,
 //   templateVariables: TemplateVariables

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.2.0-rc.14",
+  "version": "0.2.0-rc.16",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,8 +27,8 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.5.0-rc8",
-    "explorer_backend_version": "1.7.1"
+    "alephium_version": "1.5.0-rc9",
+    "explorer_backend_version": "1.9.0-rc0"
   },
   "scripts": {
     "build": "rm -rf dist/* && npx tsc --build . && webpack",

package/src/api/api-alephium.ts

@@ -437,9 +437,13 @@ export interface ChangeActiveAddress {
 export interface CompileContractResult {
   name: string
   bytecode: string
+  bytecodeDebugPatch: string
 
   /** @format 32-byte-hash */
   codeHash: string
+
+  /** @format 32-byte-hash */
+  codeHashDebug: string
   fields: FieldsSig
   functions: FunctionSig[]
   events: EventSig[]
@@ -454,6 +458,7 @@ export interface CompileProjectResult {
 export interface CompileScriptResult {
   name: string
   bytecodeTemplate: string
+  bytecodeDebugPatch: string
   fields: FieldsSig
   functions: FunctionSig[]
   warnings: string[]
@@ -574,6 +579,12 @@ export interface ContractState {
   asset: AssetState
 }
 
+export interface DebugMessage {
+  /** @format address */
+  contractAddress: string
+  message: string
+}
+
 export interface DecodeUnsignedTx {
   unsignedTx: string
 }
@@ -895,6 +906,7 @@ export interface TestContractResult {
   txInputs: string[]
   txOutputs: Output[]
   events: ContractEventByTxId[]
+  debugMessages: DebugMessage[]
 }
 
 export interface TestInputAsset {

package/src/api/api-explorer.ts

@@ -28,6 +28,29 @@ export interface AddressInfo {
   txNumber: number
 }
 
+export interface AssetOutput {
+  /** @format int32 */
+  hint: number
+
+  /** @format 32-byte-hash */
+  key: string
+
+  /** @format uint256 */
+  attoAlphAmount: string
+  address: string
+  tokens?: Token[]
+
+  /** @format int64 */
+  lockTime?: number
+
+  /** @format hex-string */
+  message?: string
+
+  /** @format 32-byte-hash */
+  spent?: string
+  type: string
+}
+
 export interface BadRequest {
   detail: string
 }
@@ -76,6 +99,23 @@ export interface ConfirmedTransaction {
   type: string
 }
 
+export interface ContractOutput {
+  /** @format int32 */
+  hint: number
+
+  /** @format 32-byte-hash */
+  key: string
+
+  /** @format uint256 */
+  attoAlphAmount: string
+  address: string
+  tokens?: Token[]
+
+  /** @format 32-byte-hash */
+  spent?: string
+  type: string
+}
+
 export interface ExplorerInfo {
   releaseVersion: string
   commit: string
@@ -90,14 +130,14 @@ export interface Hashrate {
 
 export interface Input {
   outputRef: OutputRef
-  unlockScript?: string
 
-  /** @format 32-byte-hash */
-  txHashRef: string
-  address: string
+  /** @format hex-string */
+  unlockScript?: string
+  address?: string
 
   /** @format uint256 */
-  amount: string
+  attoAlphAmount?: string
+  tokens?: Token[]
 }
 
 export interface InternalServerError {
@@ -110,28 +150,17 @@ export interface ListBlocks {
   blocks?: BlockEntryLite[]
 }
 
+export interface LogbackValue {
+  name: string
+  level: string
+}
+
 export interface NotFound {
   detail: string
   resource: string
 }
 
-export interface Output {
-  /** @format int32 */
-  hint: number
-
-  /** @format 32-byte-hash */
-  key: string
-
-  /** @format uint256 */
-  amount: string
-  address: string
-
-  /** @format int64 */
-  lockTime?: number
-
-  /** @format 32-byte-hash */
-  spent?: string
-}
+export type Output = AssetOutput | ContractOutput
 
 export interface OutputRef {
   /** @format int32 */
@@ -198,6 +227,14 @@ export interface TimedCount {
   totalCountAllChains: number
 }
 
+export interface Token {
+  /** @format 32-byte-hash */
+  id: string
+
+  /** @format uint256 */
+  amount: string
+}
+
 export interface TokenSupply {
   /** @format int64 */
   timestamp: number
@@ -239,20 +276,6 @@ export interface Transaction {
 
 export type TransactionLike = ConfirmedTransaction | UnconfirmedTransaction
 
-export interface UInput {
-  outputRef: OutputRef
-  unlockScript?: string
-}
-
-export interface UOutput {
-  /** @format uint256 */
-  amount: string
-  address: string
-
-  /** @format int64 */
-  lockTime?: number
-}
-
 export interface Unauthorized {
   detail: string
 }
@@ -266,14 +289,17 @@ export interface UnconfirmedTransaction {
 
   /** @format int32 */
   chainTo: number
-  inputs?: UInput[]
-  outputs?: UOutput[]
+  inputs?: Input[]
+  outputs?: AssetOutput[]
 
   /** @format int32 */
   gasAmount: number
 
   /** @format uint256 */
   gasPrice: string
+
+  /** @format int64 */
+  lastSeen: number
   type: string
 }
 
@@ -560,6 +586,25 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
+  transactionByOutputRefKey = {
+    /**
+     * @description Get a transaction from a output reference key
+     *
+     * @tags Transactions
+     * @name GetTransactionByOutputRefKeyOutputRefKey
+     * @request GET:/transaction-by-output-ref-key/{output-ref-key}
+     */
+    getTransactionByOutputRefKeyOutputRefKey: (outputRefKey: string, params: RequestParams = {}) =>
+      this.request<
+        ConfirmedTransaction,
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/transaction-by-output-ref-key/${outputRefKey}`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
   addresses = {
     /**
      * @description Get address information
@@ -611,6 +656,24 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description List unconfirmed transactions of a given address
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressUnconfirmedTransactions
+     * @request GET:/addresses/{address}/unconfirmed-transactions
+     */
+    getAddressesAddressUnconfirmedTransactions: (address: string, params: RequestParams = {}) =>
+      this.request<
+        UnconfirmedTransaction[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/addresses/${address}/unconfirmed-transactions`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Get address balance
      *
@@ -624,6 +687,75 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         method: 'GET',
         format: 'json',
         ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description List address tokens
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressTokens
+     * @request GET:/addresses/{address}/tokens
+     */
+    getAddressesAddressTokens: (address: string, params: RequestParams = {}) =>
+      this.request<string[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/tokens`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description List address tokens
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressTokensTokenIdTransactions
+     * @request GET:/addresses/{address}/tokens/{token-id}/transactions
+     */
+    getAddressesAddressTokensTokenIdTransactions: (
+      address: string,
+      tokenId: string,
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/tokens/${tokenId}/transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description Get address balance of given token
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressTokensTokenIdBalance
+     * @request GET:/addresses/{address}/tokens/{token-id}/balance
+     */
+    getAddressesAddressTokensTokenIdBalance: (address: string, tokenId: string, params: RequestParams = {}) =>
+      this.request<AddressBalance, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/tokens/${tokenId}/balance`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
+  addressesActive = {
+    /**
+     * @description Are the addresses active (at least 1 transaction)
+     *
+     * @tags Addresses
+     * @name PostAddressesActive
+     * @request POST:/addresses-active
+     */
+    postAddressesActive: (data?: string[], params: RequestParams = {}) =>
+      this.request<boolean[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses-active`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
       }).then(convertHttpResponse)
   }
   infos = {
@@ -760,6 +892,66 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         }
       ).then(convertHttpResponse)
   }
+  unconfirmedTransactions = {
+    /**
+     * @description list unconfirmed transactions
+     *
+     * @tags Unconfirmed Transactions
+     * @name GetUnconfirmedTransactions
+     * @request GET:/unconfirmed-transactions
+     */
+    getUnconfirmedTransactions: (
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<
+        UnconfirmedTransaction[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/unconfirmed-transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
+  tokens = {
+    /**
+     * @description List tokens
+     *
+     * @tags Tokens
+     * @name GetTokens
+     * @request GET:/tokens
+     */
+    getTokens: (query?: { page?: number; limit?: number; reverse?: boolean }, params: RequestParams = {}) =>
+      this.request<string[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * @description List token transactions
+     *
+     * @tags Tokens
+     * @name GetTokensTokenIdTransactions
+     * @request GET:/tokens/{token-id}/transactions
+     */
+    getTokensTokenIdTransactions: (
+      tokenId: string,
+      query?: { page?: number; limit?: number; reverse?: boolean },
+      params: RequestParams = {}
+    ) =>
+      this.request<Transaction[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/${tokenId}/transactions`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse)
+  }
   charts = {
     /**
      * @description `interval-type` query param: hourly, daily
@@ -855,17 +1047,18 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse),
 
     /**
-     * @description Update logging file, only logback.xml is accepted
+     * @description Update logback values
      *
      * @tags Utils
      * @name PutUtilsUpdateLogConfig
      * @request PUT:/utils/update-log-config
      */
-    putUtilsUpdateLogConfig: (data: string, params: RequestParams = {}) =>
+    putUtilsUpdateLogConfig: (data?: LogbackValue[], params: RequestParams = {}) =>
       this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/utils/update-log-config`,
         method: 'PUT',
         body: data,
+        type: ContentType.Json,
         ...params
       }).then(convertHttpResponse)
   }