@cmts-dev/carmentis-sdk-core 1.1.4 → 1.2.0

package/dist/carmentis-sdk-core.d.ts

@@ -149,6 +149,11 @@ export declare class AbciQueryEncoder {
                     type: import("../common").SectionType.SIGNATURE;
                     signature: Uint8Array<ArrayBufferLike>;
                     schemeId: number;
+                } | {
+                    type: import("../common").SectionType.AUXILIARY_SIGNATURE;
+                    tag: string;
+                    signature: Uint8Array<ArrayBufferLike>;
+                    schemeId: number;
                 } | {
                     type: import("../common").SectionType.ALLOWED_ADDITIONAL_WRITER;
                     allowedWriterAccountId: Uint8Array<ArrayBufferLike>;
@@ -898,6 +903,25 @@ export declare const AbciResponseSchema: val.VariantSchema<"responseType", [val.
         }>]>;
         readonly microblockBody: val.ObjectSchema<{
             readonly sections: val.ArraySchema<val.VariantSchema<"type", [val.ObjectSchema<{
+                readonly type: val.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+                readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly signature: val.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly schemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, val.ObjectSchema<{
                 readonly type: val.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
                 readonly signature: val.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
@@ -4405,6 +4429,29 @@ export declare class Assertion {
     static assert(isVerified: boolean, messageOnUnverified?: string): void;
 }
 
+export declare type AuxiliarySignatureSection = val.InferOutput<typeof AuxiliarySignatureSectionSchema>;
+
+export declare const AuxiliarySignatureSectionSchema: val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.AUXILIARY_SIGNATURE, undefined>;
+    readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly signature: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly schemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>;
+
 export declare type AwaitMicroblockAnchoringAbciRequest = val.InferOutput<typeof AwaitMicroblockAnchoringAbciRequestSchema>;
 
 export declare const AwaitMicroblockAnchoringAbciRequestSchema: val.ObjectSchema<{
@@ -4947,6 +4994,11 @@ export declare class BlockchainUtils {
             type: import("../common").SectionType.SIGNATURE;
             signature: Uint8Array<ArrayBufferLike>;
             schemeId: number;
+        } | {
+            type: import("../common").SectionType.AUXILIARY_SIGNATURE;
+            tag: string;
+            signature: Uint8Array<ArrayBufferLike>;
+            schemeId: number;
         } | {
             type: import("../common").SectionType.ALLOWED_ADDITIONAL_WRITER;
             allowedWriterAccountId: Uint8Array<ArrayBufferLike>;
@@ -5798,6 +5850,13 @@ export declare class CMTSToken implements Currency {
      * @return {CMTSToken} A new CMTSToken object representing the result of the subtraction.
      */
     sub(other: CMTSToken): CMTSToken;
+    /**
+     * Multiplies the value of the current CMTSToken by a provided constant and returns a new CMTSToken with the resulting value.
+     *
+     * @param {number} constant - The multiplication constant.
+     * @return {CMTSToken} A new CMTSToken object representing the result of the multiplication.
+     */
+    mul(constant: number): CMTSToken;
     /**
      * Converts the object to a string representation combining the amount and its unit label.
      * The returned string typically includes the numerical value and its corresponding unit.
@@ -8102,7 +8161,7 @@ export declare class Microblock {
      */
     getGas(): number;
     /**
-     * Get the fees in tokens
+     * Get the fees as a CMTSToken
      */
     getFees(): CMTSToken;
     /**
@@ -8156,6 +8215,10 @@ export declare class Microblock {
      * @return {Section<T>[]} An array of sections with the specified type.
      */
     getAllSections(): Section[];
+    setGasAndSeal(provider: Provider, privateKey: PrivateSignatureKey, sealingParams?: {
+        feesPayerAccount?: Uint8Array;
+        includeGas?: boolean;
+    }): Promise<void>;
     /**
      * Seals the microblock by signing it with the provided private key. Optionally, the fees payer account
      * can be set before sealing the microblock.
@@ -8368,6 +8431,25 @@ export declare const MicroblockBodyItemSchema: val.ObjectSchema<{
     }>]>;
     readonly microblockBody: val.ObjectSchema<{
         readonly sections: val.ArraySchema<val.VariantSchema<"type", [val.ObjectSchema<{
+            readonly type: val.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+            readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly signature: val.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly schemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>;
+        }, undefined>, val.ObjectSchema<{
             readonly type: val.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
             readonly signature: val.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
@@ -8932,6 +9014,25 @@ export declare const MicroblockBodysAbciResponseSchema: val.ObjectSchema<{
         }>]>;
         readonly microblockBody: val.ObjectSchema<{
             readonly sections: val.ArraySchema<val.VariantSchema<"type", [val.ObjectSchema<{
+                readonly type: val.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+                readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                    size: number;
+                    readonly typeId: 2;
+                }>]>;
+                readonly signature: val.InstanceSchema<{
+                    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                    readonly prototype: Uint8Array<ArrayBufferLike>;
+                    readonly BYTES_PER_ELEMENT: number;
+                    of(...items: number[]): Uint8Array<ArrayBuffer>;
+                    from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                    from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                    from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                }, undefined>;
+                readonly schemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+                    readonly typeId: number;
+                }>]>;
+            }, undefined>, val.ObjectSchema<{
                 readonly type: val.LiteralSchema<import("../../blockchain/section/SectionType").SectionType.SIGNATURE, undefined>;
                 readonly signature: val.InstanceSchema<{
                     new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
@@ -9480,6 +9581,25 @@ export declare const MicroblockBodysAbciResponseSchema: val.ObjectSchema<{
 
 export declare const MicroblockBodySchema: val.ObjectSchema<{
     readonly sections: val.ArraySchema<val.VariantSchema<"type", [val.ObjectSchema<{
+        readonly type: val.LiteralSchema<import("../section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+        readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+            size: number;
+            readonly typeId: 2;
+        }>]>;
+        readonly signature: val.InstanceSchema<{
+            new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+            readonly prototype: Uint8Array<ArrayBufferLike>;
+            readonly BYTES_PER_ELEMENT: number;
+            of(...items: number[]): Uint8Array<ArrayBuffer>;
+            from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+            from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+            from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        }, undefined>;
+        readonly schemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+            readonly typeId: number;
+        }>]>;
+    }, undefined>, val.ObjectSchema<{
         readonly type: val.LiteralSchema<import("../section/SectionType").SectionType.SIGNATURE, undefined>;
         readonly signature: val.InstanceSchema<{
             new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
@@ -10324,6 +10444,25 @@ export declare const MicroblockStructSchema: val.ObjectSchema<{
     }, undefined>;
     readonly body: val.ObjectSchema<{
         readonly sections: val.ArraySchema<val.VariantSchema<"type", [val.ObjectSchema<{
+            readonly type: val.LiteralSchema<import("../section/SectionType").SectionType.AUXILIARY_SIGNATURE, undefined>;
+            readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+                size: number;
+                readonly typeId: 2;
+            }>]>;
+            readonly signature: val.InstanceSchema<{
+                new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+                readonly prototype: Uint8Array<ArrayBufferLike>;
+                readonly BYTES_PER_ELEMENT: number;
+                of(...items: number[]): Uint8Array<ArrayBuffer>;
+                from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+                from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+                from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+                from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+            }, undefined>;
+            readonly schemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+                readonly typeId: number;
+            }>]>;
+        }, undefined>, val.ObjectSchema<{
             readonly type: val.LiteralSchema<import("../section/SectionType").SectionType.SIGNATURE, undefined>;
             readonly signature: val.InstanceSchema<{
                 new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
@@ -13027,6 +13166,11 @@ export declare class Provider extends AbstractProvider {
             type: import("../common").SectionType.SIGNATURE;
             signature: Uint8Array<ArrayBufferLike>;
             schemeId: number;
+        } | {
+            type: import("../common").SectionType.AUXILIARY_SIGNATURE;
+            tag: string;
+            signature: Uint8Array<ArrayBufferLike>;
+            schemeId: number;
         } | {
             type: import("../common").SectionType.ALLOWED_ADDITIONAL_WRITER;
             allowedWriterAccountId: Uint8Array<ArrayBufferLike>;
@@ -13969,6 +14113,25 @@ export declare namespace SECTIONS {
 }
 
 export declare const SectionSchema: val.VariantSchema<"type", [val.ObjectSchema<{
+    readonly type: val.LiteralSchema<SectionType.AUXILIARY_SIGNATURE, undefined>;
+    readonly tag: val.SchemaWithPipe<readonly [val.StringSchema<undefined>, val.CustomSchema<string, `Expected size is ${number} bytes`>, val.MetadataAction<string, {
+        size: number;
+        readonly typeId: 2;
+    }>]>;
+    readonly signature: val.InstanceSchema<{
+        new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
+        readonly prototype: Uint8Array<ArrayBufferLike>;
+        readonly BYTES_PER_ELEMENT: number;
+        of(...items: number[]): Uint8Array<ArrayBuffer>;
+        from(arrayLike: ArrayLike<number>): Uint8Array<ArrayBuffer>;
+        from<T>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+        from(elements: Iterable<number>): Uint8Array<ArrayBuffer>;
+        from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
+    }, undefined>;
+    readonly schemeId: val.SchemaWithPipe<readonly [val.NumberSchema<undefined>, val.IntegerAction<number, undefined>, val.MinValueAction<number, 0, undefined>, val.MaxValueAction<number, number, undefined>, val.MetadataAction<number, {
+        readonly typeId: number;
+    }>]>;
+}, undefined>, val.ObjectSchema<{
     readonly type: val.LiteralSchema<SectionType.SIGNATURE, undefined>;
     readonly signature: val.InstanceSchema<{
         new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array<ArrayBufferLike>;
@@ -14513,6 +14676,7 @@ export declare const SectionSchema: val.VariantSchema<"type", [val.ObjectSchema<
 }, undefined>], undefined>;
 
 export declare enum SectionType {
+    AUXILIARY_SIGNATURE = 126,
     SIGNATURE = 127,
     ALLOWED_ADDITIONAL_WRITER = 128,
     CUSTOM = 129,
@@ -14849,6 +15013,11 @@ export declare class StructureChecker {
         type: SectionType.SIGNATURE;
         signature: Uint8Array<ArrayBufferLike>;
         schemeId: number;
+    } | {
+        type: SectionType.AUXILIARY_SIGNATURE;
+        tag: string;
+        signature: Uint8Array<ArrayBufferLike>;
+        schemeId: number;
     } | {
         type: SectionType.ALLOWED_ADDITIONAL_WRITER;
         allowedWriterAccountId: Uint8Array<ArrayBufferLike>;