@alephium/web3 0.36.1 → 0.38.0

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

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlockScriptCodec = exports.UnlockScriptCodec = exports.P2SHCodec = 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 script_codec_1 = require("./script-codec");
+const bytestring_codec_1 = require("./bytestring-codec");
+const lockup_script_codec_1 = require("./lockup-script-codec");
+class P2PKHCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start().buffer('publicKey', { length: 33 });
+    }
+    encode(input) {
+        return input.publicKey;
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+const p2pkhCodec = new P2PKHCodec();
+class P2MPKHCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start().nest('publicKeys', {
+            type: array_codec_1.ArrayCodec.arrayParser(binary_parser_1.Parser.start()
+                .nest('publicKey', { type: p2pkhCodec.parser })
+                .nest('index', { type: compact_int_codec_1.compactUnsignedIntCodec.parser }))
+        });
+    }
+    encode(input) {
+        return buffer_1.Buffer.concat([
+            buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(input.publicKeys.length)),
+            ...input.publicKeys.value.map((v) => {
+                return buffer_1.Buffer.concat([v.publicKey.publicKey, buffer_1.Buffer.from(compact_int_codec_1.compactUnsignedIntCodec.encode(v.index))]);
+            })
+        ]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+const p2mpkhCodec = new P2MPKHCodec();
+class ValCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .int8('type')
+            .choice('val', {
+            tag: 'type',
+            choices: {
+                0x00: new binary_parser_1.Parser().uint8('value'),
+                0x01: compact_int_codec_1.compactSignedIntCodec.parser,
+                0x02: compact_int_codec_1.compactUnsignedIntCodec.parser,
+                0x03: bytestring_codec_1.byteStringCodec.parser,
+                0x04: lockup_script_codec_1.lockupScriptCodec.parser // Address
+            }
+        });
+    }
+    encode(input) {
+        const valType = input.type;
+        if (valType === 0x00) {
+            // Boolean
+            return buffer_1.Buffer.from([valType, input.val]);
+        }
+        else if (valType === 0x01) {
+            // I256
+            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+        }
+        else if (valType === 0x02) {
+            // U256
+            return buffer_1.Buffer.from([valType, ...compact_int_codec_1.compactUnsignedIntCodec.encode(input.val)]);
+        }
+        else if (valType === 0x03) {
+            // ByteVec
+            return buffer_1.Buffer.from([valType, ...bytestring_codec_1.byteStringCodec.encode(input.val)]);
+        }
+        else if (valType === 0x04) {
+            // Address
+            return buffer_1.Buffer.from([valType, ...lockup_script_codec_1.lockupScriptCodec.encode(input.val)]);
+        }
+        else {
+            throw new Error(`ValCodec: unsupported val type: ${valType}`);
+        }
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+const valCodec = new ValCodec();
+const valsCodec = new array_codec_1.ArrayCodec(valCodec);
+class P2SHCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .nest('script', {
+            type: script_codec_1.scriptCodec.parser
+        })
+            .nest('params', {
+            type: valsCodec.parser
+        });
+    }
+    encode(input) {
+        return buffer_1.Buffer.concat([script_codec_1.scriptCodec.encode(input.script), valsCodec.encode(input.params.value)]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+exports.P2SHCodec = P2SHCodec;
+const p2shCodec = new P2SHCodec();
+class UnlockScriptCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .uint8('scriptType')
+            .choice('script', {
+            tag: 'scriptType',
+            choices: {
+                0: p2pkhCodec.parser,
+                1: p2mpkhCodec.parser,
+                2: p2shCodec.parser,
+                3: binary_parser_1.Parser.start() // TODO: SameAsPrevious, FIXME
+            }
+        });
+    }
+    encode(input) {
+        const scriptType = input.scriptType;
+        const inputUnLockScript = input.script;
+        const inputUnLockScriptType = buffer_1.Buffer.from([scriptType]);
+        if (scriptType === 0) {
+            // P2PKH
+            return buffer_1.Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript)]);
+        }
+        else if (scriptType === 1) {
+            // P2MPKH
+            return buffer_1.Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript)]);
+        }
+        else if (scriptType === 2) {
+            // P2SH
+            return buffer_1.Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script)]);
+        }
+        else if (scriptType === 3) {
+            // SameAsPrevious
+            return inputUnLockScriptType;
+        }
+        else {
+            throw new Error(`TODO: encode unlock script: ${scriptType}`);
+        }
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+}
+exports.UnlockScriptCodec = UnlockScriptCodec;
+exports.unlockScriptCodec = new UnlockScriptCodec();

package/dist/src/codec/unsigned-tx-codec.d.ts

@@ -0,0 +1,30 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium';
+import { Script } from './script-codec';
+import { Option } from './option-codec';
+import { DecodedCompactInt } from './compact-int-codec';
+import { Input } from './input-codec';
+import { AssetOutput } from './asset-output-codec';
+import { DecodedArray } from './array-codec';
+import { Codec } from './codec';
+export interface UnsignedTx {
+    version: number;
+    networkId: number;
+    statefulScript: Option<Script>;
+    gasAmount: DecodedCompactInt;
+    gasPrice: DecodedCompactInt;
+    inputs: DecodedArray<Input>;
+    fixedOutputs: DecodedArray<AssetOutput>;
+}
+export declare class UnsignedTxCodec implements Codec<UnsignedTx> {
+    parser: Parser;
+    encode(decodedUnsignedTx: UnsignedTx): Buffer;
+    decode(input: Buffer): UnsignedTx;
+    encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer;
+    decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx;
+    static txId(unsignedTx: UnsignedTx): string;
+    static toApiUnsignedTx(unsigned: UnsignedTx): ApiUnsignedTx;
+    static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx;
+}
+export declare const unsignedTxCodec: UnsignedTxCodec;

package/dist/src/codec/unsigned-tx-codec.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsignedTxCodec = exports.UnsignedTxCodec = 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 utils_1 = require("../utils");
+const script_codec_1 = require("./script-codec");
+const compact_int_codec_1 = require("./compact-int-codec");
+const input_codec_1 = require("./input-codec");
+const asset_output_codec_1 = require("./asset-output-codec");
+const hash_1 = require("./hash");
+class UnsignedTxCodec {
+    constructor() {
+        this.parser = new binary_parser_1.Parser()
+            .uint8('version')
+            .uint8('networkId')
+            .nest('statefulScript', {
+            type: script_codec_1.statefulScriptCodecOpt.parser
+        })
+            .nest('gasAmount', {
+            type: compact_int_codec_1.compactSignedIntCodec.parser
+        })
+            .nest('gasPrice', {
+            type: compact_int_codec_1.compactUnsignedIntCodec.parser
+        })
+            .nest('inputs', {
+            type: input_codec_1.inputsCodec.parser
+        })
+            .nest('fixedOutputs', {
+            type: asset_output_codec_1.assetOutputsCodec.parser
+        });
+    }
+    encode(decodedUnsignedTx) {
+        return buffer_1.Buffer.concat([
+            buffer_1.Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
+            script_codec_1.statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
+            compact_int_codec_1.compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
+            compact_int_codec_1.compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
+            input_codec_1.inputsCodec.encode(decodedUnsignedTx.inputs.value),
+            asset_output_codec_1.assetOutputsCodec.encode(decodedUnsignedTx.fixedOutputs.value)
+        ]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    encodeApiUnsignedTx(input) {
+        const decoded = UnsignedTxCodec.fromApiUnsignedTx(input);
+        return this.encode(decoded);
+    }
+    decodeApiUnsignedTx(input) {
+        const decoded = this.parser.parse(input);
+        return UnsignedTxCodec.toApiUnsignedTx(decoded);
+    }
+    static txId(unsignedTx) {
+        return (0, utils_1.binToHex)((0, hash_1.blakeHash)(exports.unsignedTxCodec.encode(unsignedTx)));
+    }
+    static toApiUnsignedTx(unsigned) {
+        const txId = UnsignedTxCodec.txId(unsigned);
+        const txIdBytes = (0, utils_1.hexToBinUnsafe)(txId);
+        const version = unsigned.version;
+        const networkId = unsigned.networkId;
+        const gasAmount = compact_int_codec_1.compactSignedIntCodec.toI32(unsigned.gasAmount);
+        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.toU256(unsigned.gasPrice).toString();
+        const inputs = input_codec_1.InputCodec.toAssetInputs(unsigned.inputs.value);
+        const fixedOutputs = asset_output_codec_1.AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value);
+        let scriptOpt = undefined;
+        if (unsigned.statefulScript.option === 1) {
+            scriptOpt = script_codec_1.scriptCodec.encode(unsigned.statefulScript.value).toString('hex');
+        }
+        return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs };
+    }
+    static fromApiUnsignedTx(unsignedTx) {
+        const version = unsignedTx.version;
+        const networkId = unsignedTx.networkId;
+        const gasAmount = compact_int_codec_1.compactSignedIntCodec.fromI32(unsignedTx.gasAmount);
+        const gasPrice = compact_int_codec_1.compactUnsignedIntCodec.fromU256(BigInt(unsignedTx.gasPrice));
+        const inputsValue = input_codec_1.InputCodec.fromAssetInputs(unsignedTx.inputs);
+        const inputs = input_codec_1.inputsCodec.fromArray(inputsValue);
+        const fixedOutputsValue = asset_output_codec_1.AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs);
+        const fixedOutputs = asset_output_codec_1.assetOutputsCodec.fromArray(fixedOutputsValue);
+        const statefulScript = script_codec_1.statefulScriptCodecOpt.fromBuffer(unsignedTx.scriptOpt ? buffer_1.Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined);
+        return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript };
+    }
+}
+exports.UnsignedTxCodec = UnsignedTxCodec;
+exports.unsignedTxCodec = new UnsignedTxCodec();

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

@@ -3,6 +3,7 @@ import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScri
 import { Optional } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
 export type FieldsSig = node.FieldsSig;
+export type MapsSig = node.MapsSig;
 export type EventSig = node.EventSig;
 export type FunctionSig = node.FunctionSig;
 export type Fields = NamedVals;
@@ -130,10 +131,11 @@ export declare class Contract extends Artifact {
     readonly constants: Constant[];
     readonly enums: Enum[];
     readonly structs: Struct[];
+    readonly mapsSig?: MapsSig;
     readonly stdInterfaceId?: HexString;
     readonly bytecodeDebug: string;
     readonly codeHashDebug: string;
-    constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], stdInterfaceId?: HexString);
+    constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], mapsSig?: MapsSig, stdInterfaceId?: HexString);
     static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string, structs?: Struct[]): Contract;
     static fromCompileResult(result: node.CompileContractResult, structs?: Struct[]): Contract;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string, structs?: Struct[]): Promise<Contract>;
@@ -196,7 +198,8 @@ export interface ContractState<T extends Fields = Fields> {
     fieldsSig: FieldsSig;
     asset: Asset;
 }
-export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments> {
+export type TestContractParamsWithoutMaps<F extends Fields = Fields, A extends Arguments = Arguments> = Omit<TestContractParams<F, A>, 'initialMaps'>;
+export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>> {
     group?: number;
     address?: string;
     callerAddress?: string;
@@ -204,6 +207,7 @@ export interface TestContractParams<F extends Fields = Fields, A extends Argumen
     blockTimeStamp?: number;
     txId?: string;
     initialFields: F;
+    initialMaps?: M;
     initialAsset?: Asset;
     testArgs: A;
     existingContracts?: ContractState[];
@@ -218,11 +222,13 @@ export interface ContractEvent<T extends Fields = Fields> {
     fields: T;
 }
 export type DebugMessage = node.DebugMessage;
-export interface TestContractResult<R> {
+export type TestContractResultWithoutMaps<R> = Omit<TestContractResult<R>, 'maps'>;
+export interface TestContractResult<R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>> {
     contractId: string;
     contractAddress: string;
     returns: R;
     gasUsed: number;
+    maps?: M;
     contracts: ContractState[];
     txOutputs: Output[];
     events: ContractEvent[];
@@ -297,8 +303,8 @@ export interface CallContractResult<R> {
     events: ContractEvent[];
     debugMessages: DebugMessage[];
 }
-export declare const CreateContractEventAddress: string;
-export declare const DestroyContractEventAddress: string;
+export declare const CreateContractEventAddresses: string[];
+export declare const DestroyContractEventAddresses: string[];
 export type ContractCreatedEventFields = {
     address: Address;
     parentAddress?: Address;
@@ -315,7 +321,7 @@ export declare function subscribeEventsFromContract<T extends Fields, M extends
 export declare function addStdIdToFields<F extends Fields>(contract: Contract, fields: F): F | (F & {
     __stdInterfaceId: HexString;
 });
-export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R>>;
+export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>>(factory: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R, M>>;
 export declare abstract class ContractInstance {
     readonly address: Address;
     readonly contractId: string;
@@ -323,8 +329,8 @@ export declare abstract class ContractInstance {
     constructor(address: Address);
 }
 export declare function fetchContractState<F extends Fields, I extends ContractInstance>(contract: ContractFactory<I, F>, instance: ContractInstance): Promise<ContractState<F>>;
-export declare function subscribeContractCreatedEvent(options: EventSubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
-export declare function subscribeContractDestroyedEvent(options: EventSubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractCreatedEvent(options: EventSubscribeOptions<ContractCreatedEvent>, fromGroup: number, fromCount?: number): EventSubscription;
+export declare function subscribeContractDestroyedEvent(options: EventSubscribeOptions<ContractDestroyedEvent>, fromGroup: number, fromCount?: number): EventSubscription;
 export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, event: node.ContractEvent, targetEventIndex: number): M;
 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;