@alephium/web3 0.36.1 → 0.38.0

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

@@ -0,0 +1,23 @@
+export * from './array-codec';
+export * as assetOutput from './asset-output-codec';
+export * from './bigint-codec';
+export * from './bytestring-codec';
+export * from './codec';
+export * from './compact-int-codec';
+export * as contractOutput from './contract-output-codec';
+export * from './contract-output-ref-codec';
+export * from './either-codec';
+export * from './input-codec';
+export * from './instr-codec';
+export * as lockupScript from './lockup-script-codec';
+export * as unlockScript from './unlock-script-codec';
+export * from './long-codec';
+export * from './method-codec';
+export * from './option-codec';
+export * as script from './script-codec';
+export * from './signature-codec';
+export * from './signed-int-codec';
+export * as token from './token-codec';
+export * from './transaction-codec';
+export * from './unsigned-tx-codec';
+export * as contract from './contract-codec';

package/dist/src/codec/index.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contract = exports.token = exports.script = exports.unlockScript = exports.lockupScript = exports.contractOutput = exports.assetOutput = void 0;
+__exportStar(require("./array-codec"), exports);
+exports.assetOutput = __importStar(require("./asset-output-codec"));
+__exportStar(require("./bigint-codec"), exports);
+__exportStar(require("./bytestring-codec"), exports);
+__exportStar(require("./codec"), exports);
+__exportStar(require("./compact-int-codec"), exports);
+exports.contractOutput = __importStar(require("./contract-output-codec"));
+__exportStar(require("./contract-output-ref-codec"), exports);
+__exportStar(require("./either-codec"), exports);
+__exportStar(require("./input-codec"), exports);
+__exportStar(require("./instr-codec"), exports);
+exports.lockupScript = __importStar(require("./lockup-script-codec"));
+exports.unlockScript = __importStar(require("./unlock-script-codec"));
+__exportStar(require("./long-codec"), exports);
+__exportStar(require("./method-codec"), exports);
+__exportStar(require("./option-codec"), exports);
+exports.script = __importStar(require("./script-codec"));
+__exportStar(require("./signature-codec"), exports);
+__exportStar(require("./signed-int-codec"), exports);
+exports.token = __importStar(require("./token-codec"));
+__exportStar(require("./transaction-codec"), exports);
+__exportStar(require("./unsigned-tx-codec"), exports);
+exports.contract = __importStar(require("./contract-codec"));

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

@@ -0,0 +1,22 @@
+import { Buffer } from 'buffer/';
+import { Parser } from 'binary-parser';
+import { AssetInput } from '../api/api-alephium';
+import { UnlockScript } from './unlock-script-codec';
+import { Codec } from './codec';
+import { ArrayCodec } from './array-codec';
+export interface Input {
+    outputRef: {
+        hint: number;
+        key: Buffer;
+    };
+    unlockScript: UnlockScript;
+}
+export declare class InputCodec implements Codec<Input> {
+    parser: Parser;
+    encode(input: Input): Buffer;
+    decode(input: Buffer): Input;
+    static toAssetInputs(inputs: Input[]): AssetInput[];
+    static fromAssetInputs(inputs: AssetInput[]): Input[];
+}
+export declare const inputCodec: InputCodec;
+export declare const inputsCodec: ArrayCodec<Input>;

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputsCodec = exports.inputCodec = exports.InputCodec = 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 unlock_script_codec_1 = require("./unlock-script-codec");
+const signed_int_codec_1 = require("./signed-int-codec");
+const array_codec_1 = require("./array-codec");
+class InputCodec {
+    constructor() {
+        this.parser = binary_parser_1.Parser.start()
+            .nest('outputRef', {
+            type: binary_parser_1.Parser.start().int32('hint').buffer('key', { length: 32 })
+        })
+            .nest('unlockScript', {
+            type: unlock_script_codec_1.unlockScriptCodec.parser
+        });
+    }
+    encode(input) {
+        return buffer_1.Buffer.concat([
+            buffer_1.Buffer.from([...signed_int_codec_1.signedIntCodec.encode(input.outputRef.hint), ...input.outputRef.key]),
+            unlock_script_codec_1.unlockScriptCodec.encode(input.unlockScript)
+        ]);
+    }
+    decode(input) {
+        return this.parser.parse(input);
+    }
+    static toAssetInputs(inputs) {
+        return inputs.map((input) => {
+            const hint = input.outputRef.hint;
+            const key = (0, utils_1.binToHex)(input.outputRef.key);
+            const unlockScript = unlock_script_codec_1.unlockScriptCodec.encode(input.unlockScript);
+            return {
+                outputRef: { hint, key },
+                unlockScript: unlockScript.toString('hex')
+            };
+        });
+    }
+    static fromAssetInputs(inputs) {
+        return inputs.map((input) => {
+            const hint = input.outputRef.hint;
+            const key = buffer_1.Buffer.from(input.outputRef.key, 'hex');
+            const unlockScript = unlock_script_codec_1.unlockScriptCodec.decode(buffer_1.Buffer.from(input.unlockScript, 'hex'));
+            return {
+                outputRef: { hint, key },
+                unlockScript
+            };
+        });
+    }
+}
+exports.InputCodec = InputCodec;
+exports.inputCodec = new InputCodec();
+exports.inputsCodec = new array_codec_1.ArrayCodec(exports.inputCodec);

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

@@ -0,0 +1,230 @@
+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 { Codec } from './codec';
+export interface InstrValue {
+}
+export interface InstrValueWithIndex extends InstrValue {
+    index: number;
+}
+export interface InstrValueWithCompactInt extends InstrValue {
+    value: DecodedCompactInt;
+}
+export interface ByteStringConst extends InstrValue {
+    value: ByteString;
+}
+export interface AddressConst extends InstrValue {
+    value: LockupScript;
+}
+export interface Debug extends InstrValue {
+    stringParts: DecodedArray<ByteString>;
+}
+export interface CreateMapEntryValue extends InstrValue {
+    immFields: number;
+    mutFields: number;
+}
+export interface Instr {
+    code: number;
+    value: InstrValue;
+}
+export declare const CallLocal: (index: number) => Instr;
+export declare const CallExternal: (index: number) => Instr;
+export declare const Return: Instr;
+export declare const ConstTrue: Instr;
+export declare const ConstFalse: Instr;
+export declare const I256Const0: Instr;
+export declare const I256Const1: Instr;
+export declare const I256Const2: Instr;
+export declare const I256Const3: Instr;
+export declare const I256Const4: Instr;
+export declare const I256Const5: Instr;
+export declare const I256ConstN1: Instr;
+export declare const U256Const0: Instr;
+export declare const U256Const1: Instr;
+export declare const U256Const2: Instr;
+export declare const U256Const3: Instr;
+export declare const U256Const4: Instr;
+export declare const U256Const5: Instr;
+export declare const I256Const: (value: DecodedCompactInt) => Instr;
+export declare const U256Const: (value: DecodedCompactInt) => Instr;
+export declare const ByteConst: (value: ByteString) => Instr;
+export declare const AddressConst: (value: LockupScript) => Instr;
+export declare const LoadLocal: (index: number) => Instr;
+export declare const StoreLocal: (index: number) => Instr;
+export declare const Pop: Instr;
+export declare const BoolNot: Instr;
+export declare const BoolAnd: Instr;
+export declare const BoolOr: Instr;
+export declare const BoolEq: Instr;
+export declare const BoolNeq: Instr;
+export declare const BoolToByteVec: Instr;
+export declare const I256Add: Instr;
+export declare const I256Sub: Instr;
+export declare const I256Mul: Instr;
+export declare const I256Div: Instr;
+export declare const I256Mod: Instr;
+export declare const I256Eq: Instr;
+export declare const I256Neq: Instr;
+export declare const I256Lt: Instr;
+export declare const I256Le: Instr;
+export declare const I256Gt: Instr;
+export declare const I256Ge: Instr;
+export declare const U256Add: Instr;
+export declare const U256Sub: Instr;
+export declare const U256Mul: Instr;
+export declare const U256Div: Instr;
+export declare const U256Mod: Instr;
+export declare const U256Eq: Instr;
+export declare const U256Neq: Instr;
+export declare const U256Lt: Instr;
+export declare const U256Le: Instr;
+export declare const U256Gt: Instr;
+export declare const U256Ge: Instr;
+export declare const U256ModAdd: Instr;
+export declare const U256ModSub: Instr;
+export declare const U256ModMul: Instr;
+export declare const U256BitAnd: Instr;
+export declare const U256BitOr: Instr;
+export declare const U256Xor: Instr;
+export declare const U256SHL: Instr;
+export declare const U256SHR: Instr;
+export declare const I256ToU256: Instr;
+export declare const I256ToByteVec: Instr;
+export declare const U256ToI256: Instr;
+export declare const U256ToByteVec: Instr;
+export declare const ByteVecEq: Instr;
+export declare const ByteVecNeq: Instr;
+export declare const ByteVecSize: Instr;
+export declare const ByteVecConcat: Instr;
+export declare const AddressEq: Instr;
+export declare const AddressNeq: Instr;
+export declare const AddressToByteVec: Instr;
+export declare const IsAssetAddress: Instr;
+export declare const IsContractAddress: Instr;
+export declare const Jump: (value: DecodedCompactInt) => Instr;
+export declare const IfTrue: (value: DecodedCompactInt) => Instr;
+export declare const IfFalse: (value: DecodedCompactInt) => Instr;
+export declare const Assert: Instr;
+export declare const Blake2b: Instr;
+export declare const Keccak256: Instr;
+export declare const Sha256: Instr;
+export declare const Sha3: Instr;
+export declare const VerifyTxSignature: Instr;
+export declare const VerifySecP256K1: Instr;
+export declare const VerifyED25519: Instr;
+export declare const NetworkId: Instr;
+export declare const BlockTimeStamp: Instr;
+export declare const BlockTarget: Instr;
+export declare const TxId: Instr;
+export declare const TxInputAddressAt: Instr;
+export declare const TxInputsSize: Instr;
+export declare const VerifyAbsoluteLocktime: Instr;
+export declare const VerifyRelativeLocktime: Instr;
+export declare const Log1: Instr;
+export declare const Log2: Instr;
+export declare const Log3: Instr;
+export declare const Log4: Instr;
+export declare const Log5: Instr;
+export declare const ByteVecSlice: Instr;
+export declare const ByteVecToAddress: Instr;
+export declare const Encode: Instr;
+export declare const Zeros: Instr;
+export declare const U256To1Byte: Instr;
+export declare const U256To2Byte: Instr;
+export declare const U256To4Byte: Instr;
+export declare const U256To8Byte: Instr;
+export declare const U256To16Byte: Instr;
+export declare const U256To32Byte: Instr;
+export declare const U256From1Byte: Instr;
+export declare const U256From2Byte: Instr;
+export declare const U256From4Byte: Instr;
+export declare const U256From8Byte: Instr;
+export declare const U256From16Byte: Instr;
+export declare const U256From32Byte: Instr;
+export declare const EthEcRecover: Instr;
+export declare const Log6: Instr;
+export declare const Log7: Instr;
+export declare const Log8: Instr;
+export declare const Log9: Instr;
+export declare const ContractIdToAddress: Instr;
+export declare const LoadLocalByIndex: Instr;
+export declare const StoreLocalByIndex: Instr;
+export declare const Dup: Instr;
+export declare const AssertWithErrorCode: Instr;
+export declare const Swap: Instr;
+export declare const BlockHash: Instr;
+export declare const DEBUG: (stringParts: DecodedArray<ByteString>) => Instr;
+export declare const TxGasPrice: Instr;
+export declare const TxGasAmount: Instr;
+export declare const TxGasFee: Instr;
+export declare const I256Exp: Instr;
+export declare const U256Exp: Instr;
+export declare const U256ModExp: Instr;
+export declare const VerifyBIP340Schnorr: Instr;
+export declare const GetSegragatedSignature: Instr;
+export declare const MulModN: Instr;
+export declare const AddModN: Instr;
+export declare const U256ToString: Instr;
+export declare const I256ToString: Instr;
+export declare const BoolToString: Instr;
+export declare const LoadMutField: (index: number) => Instr;
+export declare const StoreMutField: (index: number) => Instr;
+export declare const ApproveAlph: Instr;
+export declare const ApproveToken: Instr;
+export declare const AlphRemaining: Instr;
+export declare const TokenRemaining: Instr;
+export declare const IsPaying: Instr;
+export declare const TransferAlph: Instr;
+export declare const TransferAlphFromSelf: Instr;
+export declare const TransferAlphToSelf: Instr;
+export declare const TransferToken: Instr;
+export declare const TransferTokenFromSelf: Instr;
+export declare const TransferTokenToSelf: Instr;
+export declare const CreateContract: Instr;
+export declare const CreateContractWithToken: Instr;
+export declare const CopyCreateContract: Instr;
+export declare const DestroySelf: Instr;
+export declare const SelfContractId: Instr;
+export declare const SelfAddress: Instr;
+export declare const CallerContractId: Instr;
+export declare const CallerAddress: Instr;
+export declare const IsCallerFromTxScript: Instr;
+export declare const CallerInitialStateHash: Instr;
+export declare const CallerCodeHash: Instr;
+export declare const ContractInitialStateHash: Instr;
+export declare const ContractInitialCodeHash: Instr;
+export declare const MigrateSimple: Instr;
+export declare const MigrateWithFields: Instr;
+export declare const CopyCreateContractWithToken: Instr;
+export declare const BurnToken: Instr;
+export declare const LockApprovedAssets: Instr;
+export declare const CreateSubContract: Instr;
+export declare const CreateSubContractWithToken: Instr;
+export declare const CopyCreateSubContract: Instr;
+export declare const CopyCreateSubContractWithToken: Instr;
+export declare const LoadMutFieldByIndex: Instr;
+export declare const StoreMutFieldByIndex: Instr;
+export declare const ContractExists: Instr;
+export declare const CreateContractAndTransferToken: Instr;
+export declare const CopyCreateContractAndTransferToken: Instr;
+export declare const CreateSubContractAndTransferToken: Instr;
+export declare const CopyCreateSubContractAndTransferToken: Instr;
+export declare const NullContractAddress: Instr;
+export declare const SubContractId: Instr;
+export declare const SubContractIdOf: Instr;
+export declare const AlphTokenId: Instr;
+export declare const LoadImmField: (index: number) => Instr;
+export declare const LoadImmFieldByIndex: Instr;
+export declare const PayGasFee: Instr;
+export declare const MinimalContractDeposit: Instr;
+export declare const CreateMapEntry: (immFields: number, mutFields: number) => Instr;
+export declare class InstrCodec implements Codec<Instr> {
+    parser: Parser;
+    encode(instr: Instr): Buffer;
+    decode(input: Buffer): Instr;
+}
+export declare const instrCodec: InstrCodec;
+export declare const instrsCodec: ArrayCodec<Instr>;