@alephium/web3 0.37.0 → 0.38.0

package/dist/src/api/api-alephium.d.ts

@@ -375,6 +375,7 @@ export interface CompileContractResult {
     enums: Enum[];
     events: EventSig[];
     warnings: string[];
+    maps?: MapsSig;
     stdInterfaceId?: string;
 }
 export interface CompileProjectResult {
@@ -579,6 +580,10 @@ export interface InterCliquePeerInfo {
 export interface InternalServerError {
     detail: string;
 }
+export interface MapsSig {
+    names: string[];
+    types: string[];
+}
 export interface MemPooled {
     type: string;
 }

package/dist/src/api/types.d.ts

@@ -1,6 +1,6 @@
 import * as node from './api-alephium';
 export type Number256 = bigint | string;
-export type Val = Number256 | boolean | string | Val[] | ValObject;
+export type Val = Number256 | boolean | string | Val[] | ValObject | Map<Val, Val>;
 export interface ValObject extends Record<string, Val> {
 }
 export type NamedVals = Record<string, Val>;

package/dist/src/codec/array-codec.d.ts

@@ -0,0 +1,17 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { DecodedCompactInt } from './compact-int-codec';
+import { Codec } from './codec';
+export interface DecodedArray<T> {
+    length: DecodedCompactInt;
+    value: T[];
+}
+export declare class ArrayCodec<T> implements Codec<T[]> {
+    private childCodec;
+    parser: Parser;
+    constructor(childCodec: Codec<T>, parser?: Parser);
+    encode(input: T[]): Buffer;
+    decode(input: Buffer): T[];
+    static arrayParser(parser: Parser): Parser;
+    fromArray(inputs: T[]): DecodedArray<T>;
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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/>.
+*/
+const buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const compact_int_codec_1 = require("./compact-int-codec");
+class ArrayCodec {
+    constructor(childCodec, parser = ArrayCodec.arrayParser(childCodec.parser)) {
+        this.childCodec = childCodec;
+        this.parser = parser;
+    }
+    encode(input) {
+        const result = [...compact_int_codec_1.compactSignedIntCodec.encodeI256(BigInt(input.length))];
+        for (const element of input) {
+            result.push(...this.childCodec.encode(element));
+        }
+        return buffer_1.Buffer.from(result);
+    }
+    decode(input) {
+        const result = this.parser.parse(input);
+        return result.value.map((v) => this.childCodec.decode(v.value));
+    }
+    static arrayParser(parser) {
+        return new binary_parser_1.Parser()
+            .nest('length', {
+            type: compact_int_codec_1.compactSignedIntCodec.parser
+        })
+            .array('value', {
+            length: function (ctx) {
+                return compact_int_codec_1.compactSignedIntCodec.toI32(this['length']);
+            },
+            type: parser
+        });
+    }
+    fromArray(inputs) {
+        return {
+            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(inputs.length),
+            value: inputs
+        };
+    }
+}
+exports.ArrayCodec = ArrayCodec;

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

@@ -0,0 +1,27 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { ArrayCodec, DecodedArray } from './array-codec';
+import { DecodedCompactInt } from './compact-int-codec';
+import { ByteString } from './bytestring-codec';
+import { LockupScript } from './lockup-script-codec';
+import { FixedAssetOutput } from '../api/api-alephium';
+import { Codec } from './codec';
+import { Token } from './token-codec';
+export interface AssetOutput {
+    amount: DecodedCompactInt;
+    lockupScript: LockupScript;
+    lockTime: Buffer;
+    tokens: DecodedArray<Token>;
+    additionalData: ByteString;
+}
+export declare class AssetOutputCodec implements Codec<AssetOutput> {
+    parser: Parser;
+    encode(input: AssetOutput): Buffer;
+    decode(input: Buffer): AssetOutput;
+    static toFixedAssetOutputs(txIdBytes: Uint8Array, outputs: AssetOutput[]): FixedAssetOutput[];
+    static toFixedAssetOutput(txIdBytes: Uint8Array, output: AssetOutput, index: number): FixedAssetOutput;
+    static fromFixedAssetOutputs(fixedOutputs: FixedAssetOutput[]): AssetOutput[];
+    static fromFixedAssetOutput(fixedOutput: FixedAssetOutput): AssetOutput;
+}
+export declare const assetOutputCodec: AssetOutputCodec;
+export declare const assetOutputsCodec: ArrayCodec<AssetOutput>;

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetOutputsCodec = exports.assetOutputCodec = exports.AssetOutputCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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/>.
+*/
+const buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const array_codec_1 = require("./array-codec");
+const compact_int_codec_1 = require("./compact-int-codec");
+const signed_int_codec_1 = require("./signed-int-codec");
+const long_codec_1 = require("./long-codec");
+const bytestring_codec_1 = require("./bytestring-codec");
+const lockup_script_codec_1 = require("./lockup-script-codec");
+const hash_1 = require("./hash");
+const utils_1 = require("../utils");
+const token_codec_1 = require("./token-codec");
+class AssetOutputCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .nest('amount', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .nest('lockupScript', {
+            type: lockup_script_codec_1.lockupScriptCodec.parser
+        })
+            .buffer('lockTime', {
+            length: 8
+        })
+            .nest('tokens', {
+            type: token_codec_1.tokensCodec.parser
+        })
+            .nest('additionalData', {
+            type: bytestring_codec_1.byteStringCodec.parser
+        });
+    }
+    encode(input) {
+        const amount = buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.amount));
+        const lockupScript = lockup_script_codec_1.lockupScriptCodec.encode(input.lockupScript);
+        const lockTime = buffer_1.Buffer.from(input.lockTime);
+        const tokens = buffer_1.Buffer.from(token_codec_1.tokensCodec.encode(input.tokens.value));
+        const additionalData = buffer_1.Buffer.from(bytestring_codec_1.byteStringCodec.encode(input.additionalData));
+        return buffer_1.Buffer.concat([amount, lockupScript, lockTime, tokens, additionalData]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    static toFixedAssetOutputs(txIdBytes, outputs) {
+        return outputs.map((output, index) => AssetOutputCodec.toFixedAssetOutput(txIdBytes, output, index));
+    }
+    static toFixedAssetOutput(txIdBytes, output, index) {
+        const attoAlphAmount = compact_int_codec_1.compactUnsignedIntCodec.toU256(output.amount).toString();
+        const lockTime = Number(long_codec_1.longCodec.decode(output.lockTime));
+        const tokens = output.tokens.value.map((token) => {
+            return {
+                id: token.tokenId.toString('hex'),
+                amount: compact_int_codec_1.compactUnsignedIntCodec.toU256(token.amount).toString()
+            };
+        });
+        const message = output.additionalData.value.toString('hex');
+        const scriptType = output.lockupScript.scriptType;
+        const key = (0, utils_1.binToHex)((0, hash_1.blakeHash)(buffer_1.Buffer.concat([txIdBytes, signed_int_codec_1.signedIntCodec.encode(index)])));
+        const outputLockupScript = output.lockupScript.script;
+        const address = utils_1.bs58.encode(lockup_script_codec_1.lockupScriptCodec.encode(output.lockupScript));
+        let hint = undefined;
+        if (scriptType === 0) {
+            // P2PKH
+            hint = (0, hash_1.createHint)(outputLockupScript.publicKeyHash);
+        }
+        else if (scriptType === 1) {
+            // P2MPKH
+            hint = (0, hash_1.createHint)(outputLockupScript.publicKeyHashes.value[0].publicKeyHash);
+        }
+        else if (scriptType === 2) {
+            // P2SH
+            hint = (0, hash_1.createHint)(outputLockupScript.scriptHash);
+        }
+        else if (scriptType === 3) {
+            throw new Error(`P2C script type not allowed for asset output`);
+        }
+        else {
+            throw new Error(`Unexpected output script type: ${scriptType}`);
+        }
+        return { hint, key, attoAlphAmount, lockTime, tokens, address, message };
+    }
+    static fromFixedAssetOutputs(fixedOutputs) {
+        return fixedOutputs.map((output) => {
+            return AssetOutputCodec.fromFixedAssetOutput(output);
+        });
+    }
+    static fromFixedAssetOutput(fixedOutput) {
+        const amount = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(fixedOutput.attoAlphAmount));
+        const lockTime = long_codec_1.longCodec.encode(BigInt(fixedOutput.lockTime));
+        const lockupScript = lockup_script_codec_1.lockupScriptCodec.decode(buffer_1.Buffer.from(utils_1.bs58.decode(fixedOutput.address)));
+        const tokensValue = fixedOutput.tokens.map((token) => {
+            return {
+                tokenId: buffer_1.Buffer.from(token.id, 'hex'),
+                amount: compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(token.amount))
+            };
+        });
+        const tokens = {
+            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(tokensValue.length),
+            value: tokensValue
+        };
+        const additionalDataValue = buffer_1.Buffer.from(fixedOutput.message, 'hex');
+        const additionalData = {
+            length: compact_int_codec_1.compactUnsignedIntCodec.fromU32(additionalDataValue.length),
+            value: additionalDataValue
+        };
+        return {
+            amount,
+            lockupScript,
+            lockTime,
+            tokens,
+            additionalData
+        };
+    }
+}
+exports.AssetOutputCodec = AssetOutputCodec;
+exports.assetOutputCodec = new AssetOutputCodec();
+exports.assetOutputsCodec = new array_codec_1.ArrayCodec(exports.assetOutputCodec);

package/dist/src/codec/bigint-codec.d.ts

@@ -0,0 +1,5 @@
+import { Buffer } from 'buffer/';
+export declare class BigIntCodec {
+    static encode(value: bigint): Buffer;
+    static decode(encoded: Buffer, signed: boolean): bigint;
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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/>.
+*/
+const buffer_1 = require("buffer/");
+class BigIntCodec {
+    static encode(value) {
+        // Special case for zero.
+        if (value === 0n) {
+            return buffer_1.Buffer.from([0]);
+        }
+        const isNegative = value < 0n;
+        let absValue = isNegative ? -value : value;
+        const bytes = [];
+        // Extract bytes from absolute value.
+        while (absValue > 0n) {
+            bytes.push(Number(absValue & 0xffn));
+            absValue >>= 8n;
+        }
+        // If the bigint is positive and the most significant byte has its high bit set,
+        // prefix the byte array with a zero byte to signify positive value.
+        if (!isNegative && (bytes[bytes.length - 1] & 0x80) !== 0) {
+            bytes.push(0);
+        }
+        // If the bigint is negative, compute the two's complement of the byte array.
+        if (isNegative) {
+            let carry = true;
+            for (let i = 0; i < bytes.length; i++) {
+                bytes[i] = ~bytes[i] & 0xff; // Invert the bits of the byte.
+                if (carry) {
+                    if (bytes[i] === 0xff) {
+                        bytes[i] = 0;
+                    }
+                    else {
+                        bytes[i] += 1;
+                        carry = false;
+                    }
+                }
+            }
+            // If there's still a carry, and the most significant byte is not 0xFF (to store the negative sign bit),
+            // or if no bytes were set (which means the value was -1), append a 0xFF byte to hold the carry.
+            if (carry || bytes.length === 0 || (bytes[bytes.length - 1] & 0x80) === 0) {
+                bytes.push(0xff);
+            }
+        }
+        // The byte array needs to be reversed since we've constructed it in little-endian order.
+        return buffer_1.Buffer.from(new Uint8Array(bytes.reverse()));
+    }
+    static decode(encoded, signed) {
+        // Special case for zero.
+        if (encoded.length === 1 && encoded[0] === 0) {
+            return 0n;
+        }
+        // Determine if the number is negative by checking the most significant byte (MSB)
+        const isNegative = signed ? encoded[0] === 0xff : signed;
+        // Convert the byte array to a bigint
+        let value = 0n;
+        for (const byte of encoded) {
+            value = (value << 8n) | BigInt(byte);
+        }
+        // If the number is negative, convert from two's complement
+        if (isNegative) {
+            // Create a mask for the value's bit length
+            const mask = (1n << (8n * BigInt(encoded.length))) - 1n;
+            value = -(~value & mask) - 1n;
+        }
+        return value;
+    }
+}
+exports.BigIntCodec = BigIntCodec;

package/dist/src/codec/bytestring-codec.d.ts

@@ -0,0 +1,16 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { DecodedCompactInt } from './compact-int-codec';
+import { Codec } from './codec';
+export interface ByteString {
+    length: DecodedCompactInt;
+    value: Buffer;
+}
+export declare class ByteStringCodec implements Codec<ByteString> {
+    parser: Parser;
+    encode(input: ByteString): Buffer;
+    decode(input: Buffer): ByteString;
+    encodeBuffer(input: Buffer): Buffer;
+    decodeBuffer(input: Buffer): Buffer;
+}
+export declare const byteStringCodec: ByteStringCodec;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.byteStringCodec = exports.ByteStringCodec = void 0;
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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/>.
+*/
+const buffer_1 = require("buffer/");
+const binary_parser_1 = require("binary-parser");
+const compact_int_codec_1 = require("./compact-int-codec");
+class ByteStringCodec {
+    constructor() {
+        this.parser = new binary_parser_1.Parser()
+            .nest('length', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .buffer('value', {
+            length: function (ctx) {
+                return compact_int_codec_1.compactUnsignedIntCodec.toU32(this['length']);
+            }
+        });
+    }
+    encode(input) {
+        return buffer_1.Buffer.from([...compact_int_codec_1.compactUnsignedIntCodec.encode(input.length), ...input.value]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    encodeBuffer(input) {
+        return buffer_1.Buffer.from([...compact_int_codec_1.compactUnsignedIntCodec.encodeU32(input.length), ...input]);
+    }
+    decodeBuffer(input) {
+        return this.decode(input).value;
+    }
+}
+exports.ByteStringCodec = ByteStringCodec;
+exports.byteStringCodec = new ByteStringCodec();

package/dist/src/codec/codec.d.ts

@@ -0,0 +1,8 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+export interface Codec<T> {
+    parser: Parser;
+    encode(input: T): Buffer;
+    decode(input: Buffer): T;
+}
+export declare function assert(value: boolean, message: string): void;

package/dist/src/codec/codec.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(value, message) {
+    if (!value) {
+        throw new Error(message);
+    }
+}
+exports.assert = assert;

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

@@ -0,0 +1,51 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { Codec } from './codec';
+export declare class CompactInt {
+    static readonly oneBytePrefix = 0;
+    static readonly oneByteNegPrefix = 192;
+    static readonly twoBytePrefix = 64;
+    static readonly twoByteNegPrefix = 128;
+    static readonly fourBytePrefix = 128;
+    static readonly fourByteNegPrefix = 64;
+    static readonly multiBytePrefix = 192;
+}
+export interface DecodedCompactInt {
+    mode: number;
+    rest: Uint8Array;
+}
+export declare class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
+    private oneByteBound;
+    private twoByteBound;
+    private fourByteBound;
+    parser: Parser;
+    encode(input: DecodedCompactInt): Buffer;
+    encodeU32(value: number): Buffer;
+    encodeU256(value: bigint): Buffer;
+    decodeU32(input: Buffer): number;
+    decodeU256(input: Buffer): bigint;
+    decode(input: Buffer): DecodedCompactInt;
+    toU32(value: DecodedCompactInt): number;
+    fromU32(value: number): DecodedCompactInt;
+    toU256(value: DecodedCompactInt): bigint;
+    fromU256(value: bigint): DecodedCompactInt;
+}
+export declare const compactUnsignedIntCodec: CompactUnsignedIntCodec;
+export declare class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
+    private signFlag;
+    private oneByteBound;
+    private twoByteBound;
+    private fourByteBound;
+    parser: Parser;
+    encode(input: DecodedCompactInt): Buffer;
+    decode(input: Buffer): DecodedCompactInt;
+    decodeI32(input: Buffer): number;
+    encodeI32(value: number): Buffer;
+    encodeI256(value: bigint): Buffer;
+    decodeI256(input: Buffer): bigint;
+    toI32(value: DecodedCompactInt): number;
+    fromI32(value: number): DecodedCompactInt;
+    toI256(value: DecodedCompactInt): bigint;
+    fromI256(value: bigint): DecodedCompactInt;
+}
+export declare const compactSignedIntCodec: CompactSignedIntCodec;