@meshsdk/core-cst 1.8.14 → 1.9.0-beta-39

package/dist/index.d.cts

@@ -1,16 +1,15 @@
-import * as _cardano_sdk_core from '@cardano-sdk/core';
 import { Cardano, Serialization } from '@cardano-sdk/core';
-export { _cardano_sdk_core as CardanoSDK };
+import * as core from '@cardano-sdk/core';
+export { core as CardanoSDK };
 export { Cardano, Serialization } from '@cardano-sdk/core';
-import * as _cardano_sdk_util from '@cardano-sdk/util';
-import { OpaqueString } from '@cardano-sdk/util';
-export { _cardano_sdk_util as CardanoSDKUtil };
+import { OpaqueString, HexBlob as HexBlob$1 } from '@cardano-sdk/util';
+import * as util from '@cardano-sdk/util';
+export { util as CardanoSDKUtil };
 import * as Crypto from '@cardano-sdk/crypto';
 export { Crypto };
-import * as cjsBip32ed25519 from '@stricahq/bip32ed25519';
-import { DataSignature, Data, NativeScript as NativeScript$1, PlutusScript, IMeshTxSerializer, DeserializedAddress, BuilderData, IDeserializer, IResolver, MeshTxBuilderBody, Protocol, UTxO, Asset, LanguageVersion } from '@meshsdk/common';
+import { DataSignature, BuilderData, PlutusDataType, NativeScript as NativeScript$1, PlutusScript, IMeshTxSerializer, Protocol, DeserializedAddress, IDeserializer, IResolver, MeshTxBuilderBody, Asset, Output, UTxO, LanguageVersion, Data, PubKeyAddress, ScriptAddress } from '@meshsdk/common';
 import { Buffer as Buffer$1 } from 'buffer';
-import * as cjsCbors from '@stricahq/cbors';
+import { CborMap, CborBytes } from '@harmoniclabs/cbor';
 
 declare const Slot: (value: number) => Cardano.Slot;
 type Slot = Cardano.Slot;
@@ -19,16 +18,20 @@ type Value = Serialization.Value;
 type TokenMap = Cardano.TokenMap;
 declare const Transaction: typeof Serialization.Transaction;
 type Transaction = Serialization.Transaction;
-declare const TransactionId: {
-    (value: string): Cardano.TransactionId;
-    fromHexBlob(value: _cardano_sdk_util.HexBlob): Cardano.TransactionId;
-    fromTxBodyCbor(bodyCbor: _cardano_sdk_core.TxBodyCBOR): Cardano.TransactionId;
-};
+declare const TransactionId: (value: string) => Cardano.TransactionId;
 type TransactionId = Cardano.TransactionId;
 declare const TransactionBody: typeof Serialization.TransactionBody;
 type TransactionBody = Serialization.TransactionBody;
 declare const TransactionWitnessSet: typeof Serialization.TransactionWitnessSet;
 type TransactionWitnessSet = Serialization.TransactionWitnessSet;
+declare const AuxilliaryData: typeof Serialization.AuxiliaryData;
+type AuxiliaryData = Serialization.AuxiliaryData;
+declare const TransactionMetadatum: typeof Serialization.TransactionMetadatum;
+type TransactionMetadatum = Serialization.TransactionMetadatum;
+declare const MetadatumMap: typeof Serialization.MetadatumMap;
+type MetadatumMap = Serialization.MetadatumMap;
+declare const MetadatumList: typeof Serialization.MetadatumList;
+type MetadatumList = Serialization.MetadatumList;
 declare const TransactionUnspentOutput: typeof Serialization.TransactionUnspentOutput;
 type TransactionUnspentOutput = Serialization.TransactionUnspentOutput;
 declare const TransactionInput: typeof Serialization.TransactionInput;
@@ -65,7 +68,6 @@ declare const AssetId: {
     getPolicyId(id: Cardano.AssetId): Cardano.PolicyId;
     getAssetName(id: Cardano.AssetId): Cardano.AssetName;
     fromParts(policyId: Cardano.PolicyId, assetName: Cardano.AssetName): Cardano.AssetId;
-    getAssetNameAsText(id: Cardano.AssetId): string;
 };
 type AssetId = Cardano.AssetId;
 declare const ScriptHash: {
@@ -108,10 +110,7 @@ declare const Hash28ByteBase16: {
     fromEd25519KeyHashHex(value: Crypto.Ed25519KeyHashHex): Crypto.Hash28ByteBase16;
 };
 type Hash28ByteBase16 = Crypto.Hash28ByteBase16;
-declare const Hash32ByteBase16: {
-    (value: string): Crypto.Hash32ByteBase16;
-    fromHexBlob<T>(value: _cardano_sdk_util.HexBlob): T;
-};
+declare const Hash32ByteBase16: (value: string) => Crypto.Hash32ByteBase16;
 type Hash32ByteBase16 = Crypto.Hash32ByteBase16;
 declare const CredentialType: typeof Cardano.CredentialType;
 type CredentialType = Cardano.CredentialType;
@@ -142,6 +141,10 @@ declare const Bip32PrivateKey: typeof Crypto.Bip32PrivateKey;
 type Bip32PrivateKey = Crypto.Bip32PrivateKey;
 declare const Bip32PrivateKeyHex: (key: string) => Crypto.Bip32PrivateKeyHex;
 type Bip32PrivateKeyHex = Crypto.Bip32PrivateKeyHex;
+declare const Bip32PublicKey: typeof Crypto.Bip32PublicKey;
+type Bip32PublicKey = Crypto.Bip32PublicKey;
+declare const Bip32PublicKeyHex: (key: string) => Crypto.Bip32PublicKeyHex;
+type Bip32PublicKeyHex = Crypto.Bip32PublicKeyHex;
 declare const PlutusLanguageVersion: typeof Cardano.PlutusLanguageVersion;
 type PlutusLanguageVersion = Cardano.PlutusLanguageVersion;
 declare const NativeScript: typeof Serialization.NativeScript;
@@ -152,6 +155,14 @@ declare const PlutusV2Script: typeof Serialization.PlutusV2Script;
 type PlutusV2Script = Serialization.PlutusV2Script;
 declare const PlutusV3Script: typeof Serialization.PlutusV3Script;
 type PlutusV3Script = Serialization.PlutusV3Script;
+declare const PlutusDataKind: typeof Serialization.PlutusDataKind;
+type PlutusDataKind = Serialization.PlutusDataKind;
+declare const PointerAddress: typeof Cardano.PointerAddress;
+type PointerAddress = Cardano.PointerAddress;
+declare const CertIndex: (value: number) => Cardano.CertIndex;
+type CertIndex = Cardano.CertIndex;
+declare const TxIndex: (value: number) => Cardano.TxIndex;
+type TxIndex = Cardano.TxIndex;
 declare const Costmdls: typeof Serialization.Costmdls;
 type Costmdls = Serialization.Costmdls;
 declare const CostModel: typeof Serialization.CostModel;
@@ -162,17 +173,14 @@ declare const ConstrPlutusData: typeof Serialization.ConstrPlutusData;
 type ConstrPlutusData = Serialization.ConstrPlutusData;
 declare const RewardAccount: {
     (value: string): Cardano.RewardAccount;
-    toHash(rewardAccount: Cardano.RewardAccount): Crypto.Ed25519KeyHashHex;
+    toHash(rewardAccount: Cardano.RewardAccount): Crypto.Hash28ByteBase16;
     fromCredential(credential: Cardano.Credential, networkId: Cardano.NetworkId): Cardano.RewardAccount;
     toNetworkId(rewardAccount: Cardano.RewardAccount): Cardano.NetworkId;
 };
 type RewardAccount = Cardano.RewardAccount;
 declare const Hash: typeof Serialization.Hash;
 type Hash<T extends string> = Serialization.Hash<T>;
-declare const DatumHash: {
-    (value: string): Crypto.Hash32ByteBase16;
-    fromHexBlob<T>(value: _cardano_sdk_util.HexBlob): T;
-};
+declare const DatumHash: (value: string) => Crypto.Hash32ByteBase16;
 type DatumHash = Crypto.Hash32ByteBase16;
 declare const Datum: typeof Serialization.Datum;
 type Datum = PlutusData | DatumHash;
@@ -208,20 +216,52 @@ type DRepID = Cardano.DRepID;
 declare const DRepID: {
     (value: string): Cardano.DRepID;
     isValid(value: string): boolean;
-    canSign(value: string): boolean;
+    cip105FromCredential(credential: Cardano.Credential): Cardano.DRepID;
+    cip129FromCredential(credential: Cardano.Credential): Cardano.DRepID;
+    toCredential(drepId: Cardano.DRepID): Cardano.Credential;
+    toCip105DRepID(drepId: Cardano.DRepID): Cardano.DRepID;
+    toCip129DRepID(drepId: Cardano.DRepID): Cardano.DRepID;
+    toAddress(drepId: Cardano.DRepID): Cardano.EnterpriseAddress | undefined;
 };
 type DRep = Serialization.DRep;
 declare const DRep: typeof Serialization.DRep;
 type StakeCredentialStatus = Cardano.StakeCredentialStatus;
 declare const StakeCredentialStatus: typeof Cardano.StakeCredentialStatus;
+type Metadatum = Cardano.Metadatum;
+type HexBlob = HexBlob$1;
+declare const HexBlob: {
+    (target: string): HexBlob$1;
+    fromBytes(bytes: Uint8Array): HexBlob$1;
+    fromBase64(rawData: string): HexBlob$1;
+    toTypedBech32<T>(prefix: string, hexString: HexBlob$1): T;
+};
+type TxCBOR = Serialization.TxCBOR;
+declare const TxCBOR: {
+    (tx: string): Serialization.TxCBOR;
+    serialize(tx: Cardano.Tx): Serialization.TxCBOR;
+    deserialize(tx: Serialization.TxCBOR): Cardano.Tx;
+};
+type Ed25519PrivateKey = Crypto.Ed25519PrivateKey;
+declare const Ed25519PrivateKey: typeof Crypto.Ed25519PrivateKey;
+declare const computeAuxiliaryDataHash: (data: Cardano.AuxiliaryData | undefined) => Crypto.Hash32ByteBase16 | undefined;
+declare const blake2b: typeof Crypto.blake2b;
+type BootstrapWitness = Serialization.BootstrapWitness;
+declare const BootstrapWitness: typeof Serialization.BootstrapWitness;
+type ByronAttributes = Cardano.ByronAttributes;
 
 type Signer = {
     address: Address;
-    key: StricaPrivateKey;
+    key: Ed25519PrivateKey;
 };
 
-/** @param address - Optional Bech32 string of a stake, stake_test1, addr, or addr_test1 address. If provided, this function will validate the signer's address against this value. */
-declare const checkSignature: (data: string, { key, signature }: DataSignature, address?: string) => boolean;
+/**
+ * Check the signature of a given data string
+ * @param data The data string to verify the signature against
+ * @param {key, signature} The signature obtained by `signData`
+ * @param address Optional Bech32 string of a stake, stake_test1, addr, or addr_test1 address. If provided, this function will validate the signer's address against this value.
+ * @returns boolean
+ */
+declare const checkSignature: (data: string, { key, signature }: DataSignature, address?: string) => Promise<boolean>;
 
 declare class CoseSign1 {
     private protectedMap;
@@ -229,10 +269,10 @@ declare class CoseSign1 {
     private payload;
     private signature;
     constructor(payload: {
-        protectedMap: Map<any, any>;
-        unProtectedMap: Map<any, any>;
-        payload: Buffer$1 | null;
-        signature?: Buffer$1;
+        protectedMap: CborMap;
+        unProtectedMap: CborMap;
+        payload: CborBytes | null;
+        signature?: CborBytes;
     });
     static fromCbor(cbor: string): CoseSign1;
     createSigStructure(externalAad?: Buffer$1): Buffer$1;
@@ -250,89 +290,79 @@ declare class CoseSign1 {
 declare const getPublicKeyFromCoseKey: (cbor: string) => Buffer$1;
 declare const getCoseKeyFromPublicKey: (cbor: string) => Buffer$1;
 
+/**
+ * Generate a nonce string
+ * @param label The label to prepend to the nonce
+ * @param length The length of the nonce
+ * @returns The generated nonce in hex format
+ */
 declare const generateNonce: (label?: string, length?: number) => string;
 
+/**
+ * Sign the data string using the provided signer
+ * @param data The data string to sign
+ * @param signer The signer object containing the key and address
+ * @returns DataSignature for verification
+ */
 declare const signData: (data: string, signer: Signer) => DataSignature;
 
-declare const resolveDataHash: (data: Data) => string;
-declare const resolveNativeScriptAddress: (script: NativeScript$1, networkId?: number) => Cardano.PaymentAddress | Cardano.RewardAccount;
+declare const resolveDataHash: (rawData: BuilderData["content"], type?: PlutusDataType) => string;
+declare const resolveNativeScriptAddress: (script: NativeScript$1, networkId?: number) => string;
 declare const resolveNativeScriptHash: (script: NativeScript$1) => string;
 declare const resolvePaymentKeyHash: (bech32: string) => string;
-declare const resolvePlutusScriptAddress: (script: PlutusScript, networkId?: number) => Cardano.PaymentAddress | Cardano.RewardAccount;
+declare const resolvePlutusScriptAddress: (script: PlutusScript, networkId?: number) => string;
 declare const resolvePlutusScriptHash: (bech32: string) => string;
 declare const resolvePoolId: (hash: string) => string;
 declare const resolvePrivateKey: (words: string[]) => string;
 declare const resolveScriptRef: (script: PlutusScript | NativeScript$1) => string;
-declare const resolveRewardAddress: (bech32: string) => Cardano.PaymentAddress | Cardano.RewardAccount;
+declare const resolveRewardAddress: (bech32: string) => string;
 declare const resolveStakeKeyHash: (bech32: string) => string;
-declare const resolveTxHash: (txHex: string) => Cardano.TransactionId;
+declare const resolveTxHash: (txHex: string) => string;
+declare const resolveScriptHashDRepId: (scriptHash: string) => string;
+declare const resolveEd25519KeyHash: (bech32: string) => string;
 
 declare class CardanoSDKSerializer implements IMeshTxSerializer {
-    verbose: boolean;
-    private txBody;
-    private txWitnessSet;
-    private utxoContext;
-    private redeemerContext;
-    private scriptsProvided;
-    private datumsProvided;
-    private usedLanguages;
-    constructor(verbose?: boolean);
+    protocolParams: Protocol;
+    constructor(protocolParams?: Protocol);
     serializeRewardAddress(stakeKeyHash: string, isScriptHash?: boolean, network_id?: 0 | 1): string;
     serializePoolId(hash: string): string;
-    serializeAddress(address: DeserializedAddress, networkId?: 0 | 1): string;
+    serializeAddress(address: Partial<DeserializedAddress>, networkId?: 0 | 1): string;
     serializeData(data: BuilderData): string;
     deserializer: IDeserializer;
     resolver: IResolver;
-    serializeTxBody: (txBuilderBody: MeshTxBuilderBody, protocolParams: Protocol) => string;
+    serializeTxBody: (txBuilderBody: MeshTxBuilderBody, protocolParams?: Protocol) => string;
+    serializeTxBodyWithMockSignatures(txBuilderBody: MeshTxBuilderBody, protocolParams: Protocol): string;
     addSigningKeys: (txHex: string, signingKeys: string[]) => string;
-    private addAllInputs;
-    private addTxIn;
-    private addScriptTxIn;
-    private addSimpleScriptTxIn;
-    private addAllOutputs;
-    private addOutput;
-    private addAllReferenceInputs;
-    private addReferenceIput;
-    private addAllMints;
-    private addMint;
-    private addAllCollateralInputs;
-    private addCollateralInput;
-    private setValidityInterval;
-    private buildWitnessSet;
-    private balanceTx;
-    private createDummyTx;
+    serializeValue(value: Asset[]): string;
+    serializeOutput(output: Output): string;
 }
 
-type StricaPrivateKey = cjsBip32ed25519.PrivateKey;
-declare const StricaPrivateKey: typeof cjsBip32ed25519.PrivateKey;
-type StricaPublicKey = cjsBip32ed25519.PublicKey;
-declare const StricaPublicKey: typeof cjsBip32ed25519.PublicKey;
-type StricaBip32PrivateKey = cjsBip32ed25519.Bip32PrivateKey;
-declare const StricaBip32PrivateKey: typeof cjsBip32ed25519.Bip32PrivateKey;
-type StricaBip32PublicKey = cjsBip32ed25519.Bip32PublicKey;
-declare const StricaBip32PublicKey: typeof cjsBip32ed25519.Bip32PublicKey;
-
-declare const StricaEncoder: {
-    encode: (input: any, options?: {
-        collapseBigNumber: Boolean;
-    }) => Buffer;
-};
-declare const StricaDecoder: typeof cjsCbors.Decoder;
-type StricaDecoder = cjsCbors.Decoder;
-
 declare const buildBaseAddress: (networkId: number, paymentKeyHash: Hash28ByteBase16, stakeKeyHash: Hash28ByteBase16) => BaseAddress;
 declare const buildEnterpriseAddress: (networkId: number, paymentKeyHash: Hash28ByteBase16) => EnterpriseAddress;
+declare const clampScalar: (scalar: Buffer) => Buffer;
 declare const buildBip32PrivateKey: (entropy: string, password?: string) => Bip32PrivateKey;
 declare const buildRewardAddress: (networkId: number, stakeKeyHash: Hash28ByteBase16) => RewardAddress;
-declare const buildKeys: (entropy: string | [string, string], accountIndex: number, keyIndex?: number) => {
-    paymentKey: StricaPrivateKey;
-    stakeKey: StricaPrivateKey;
-    dRepKey?: StricaPrivateKey;
+/**
+ * Build a set of keys from a given private key
+ *
+ * NOTE - Must be called after `await Crypto.Ready()`
+ *
+ * @param privateKeyHex - The BIP32 private key hex to derive keys from
+ * @param accountIndex - The account index to derive keys for
+ * @param keyIndex - The key index to derive keys for
+ * @returns The payment and stake keys, and optionally the dRep key if a Bip32PrivateKey is provided
+ */
+declare const buildKeys: (privateKeyHex: string | [string, string], accountIndex: number, keyIndex?: number) => {
+    paymentKey: Ed25519PrivateKey;
+    stakeKey: Ed25519PrivateKey;
+    dRepKey?: Ed25519PrivateKey;
 };
+declare const buildEd25519PrivateKeyFromSecretKey: (secretKeyHex: string) => Crypto.Ed25519PrivateKey;
 declare const buildScriptPubkey: (keyHash: Ed25519KeyHash) => NativeScript;
 declare const buildDRepID: (dRepKey: Ed25519PublicKeyHex, networkId?: NetworkId, addressType?: AddressType) => DRepID;
 
 declare const toAddress: (bech32: string) => Address;
+declare const toCardanoAddress: (address: string) => Address;
 declare const toBaseAddress: (bech32: string) => BaseAddress | undefined;
 declare const toEnterpriseAddress: (bech32: string) => EnterpriseAddress | undefined;
 declare const toRewardAddress: (bech32: string) => RewardAddress | undefined;
@@ -344,13 +374,14 @@ declare const toScriptRef: (script: PlutusScript | NativeScript$1) => Script;
 declare const fromScriptRef: (scriptRef: string) => PlutusScript | NativeScript$1 | undefined;
 declare const fromNativeScript: (script: NativeScript) => NativeScript$1;
 declare const toNativeScript: (script: NativeScript$1) => Serialization.NativeScript;
-declare const toPlutusData: (data: Data) => PlutusData;
 declare const toValue: (assets: Asset[]) => Serialization.Value;
+declare const toDRep: (dRepId: string) => Serialization.DRep;
+declare const getDRepIds: (dRepId: string) => {
+    cip105: string;
+    cip129: string;
+};
 
-declare const deserializeAddress: (address: string) => Address;
 declare const deserializeEd25519KeyHash: (ed25519KeyHash: string) => Crypto.Ed25519KeyHash;
-declare const deserializeDataHash: (dataHash: string) => DatumHash;
-declare const deserializePlutusData: (plutusData: string) => PlutusData;
 declare const deserializePlutusScript: (plutusScript: string, version: LanguageVersion) => PlutusV1Script | PlutusV2Script | PlutusV3Script;
 declare const deserializeNativeScript: (nativeScript: string) => NativeScript;
 declare const deserializeScriptHash: (scriptHash: string) => Crypto.Hash28ByteBase16;
@@ -367,29 +398,39 @@ declare function negatives(v: Value): Value;
 declare function assetTypes(v: Value): number;
 declare function empty(v: Value): boolean;
 
-/**
- * MIT License
- *
- * Copyright (c) 2024 Evgenii Lisitskii
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
+declare const toPlutusData: (data: Data) => PlutusData;
+declare const fromJsonToPlutusData: (data: object) => PlutusData;
+declare const fromBuilderToPlutusData: (data: BuilderData) => PlutusData;
+declare const fromPlutusDataToJson: (data: PlutusData) => object;
+declare const parseDatumCbor: <T = any>(datumCbor: string) => T;
+declare const parseInlineDatum: <T extends {
+    inline_datum?: string;
+}, X>(utxo: T) => X;
+declare const deserializeDataHash: (dataHash: string) => DatumHash;
+declare const deserializePlutusData: (plutusData: string) => PlutusData;
+
+declare const serialzeAddress: (deserializedAddress: Partial<DeserializedAddress>, networkId?: number) => string;
+declare const addrBech32ToPlutusDataHex: (bech32: string) => string;
+declare const addrBech32ToPlutusDataObj: <T>(bech32: string) => T;
+declare const serializeAddressObj: (plutusDataAddressObject: PubKeyAddress | ScriptAddress, networkId?: number) => string;
+declare const serializePlutusAddressToBech32: (plutusHex: string, networkId?: number) => string;
+declare const deserializeBech32Address: (bech32Addr: string) => DeserializedAddress;
+declare const deserializeAddress: (address: string) => Address;
+declare const scriptHashToBech32: (scriptHash: string, stakeCredentialHash?: string, networkId?: number, isScriptStakeCredentialHash?: boolean) => string;
+declare const v2ScriptToBech32: (scriptCbor: string, stakeCredential?: string, networkId?: number, isScriptStakeCredential?: boolean) => string;
+declare const scriptHashToRewardAddress: (hash: string, networkId?: number) => string;
+declare const keyHashToRewardAddress: (hash: string, networkId?: number) => string;
+
+declare const bytesToHex: (bytes: Uint8Array) => HexBlob$1;
+declare const hexToBytes: (hex: HexBlob$1) => Uint8Array;
+declare const utf8ToBytes: (str: string) => Uint8Array;
+declare const utf8ToHex: (str: string) => HexBlob$1;
+declare const hexToBech32: (prefix: string, hex: string) => string;
+
+declare const addVKeyWitnessSetToTransaction: (txHex: string, vkeyWitnessSet: string) => string;
+
+declare const calculateFees: (minFeeA: number, minFeeB: number, minFeeRefScriptCostPerByte: number, priceMem: number, priceStep: number, tx: Transaction, refScriptSize: number) => bigint;
+
 type OutputEncoding = "SingleCBOR" | "DoubleCBOR" | "PurePlutusScriptBytes";
 /**
  * Normalizes a Plutus script by extracting its pure Plutus bytes and applying a specified encoding.
@@ -408,5 +449,7 @@ type OutputEncoding = "SingleCBOR" | "DoubleCBOR" | "PurePlutusScriptBytes";
  * - The normalization process does not modify the logical content of the script, only its representation.
  */
 declare const normalizePlutusScript: (plutusScript: string, encoding: OutputEncoding) => string;
+declare const applyEncoding: (plutusScript: Uint8Array, outputEncoding: OutputEncoding) => Uint8Array;
+declare const applyParamsToScript: (rawScript: string, params: object[] | Data[], type?: PlutusDataType) => string;
 
-export { Address, AddressType, AssetFingerprint, AssetId, AssetName, BaseAddress, Bip32PrivateKey, Bip32PrivateKeyHex, CardanoSDKSerializer, CborSet, CborWriter, Certificate, CertificateType, ConstrPlutusData, CoseSign1, CostModel, type CostModels, Costmdls, Credential, type CredentialCore, CredentialType, DRep, DRepID, Datum, DatumHash, DatumKind, Ed25519KeyHash, Ed25519KeyHashHex, Ed25519PrivateExtendedKeyHex, Ed25519PrivateNormalKeyHex, Ed25519PublicKey, Ed25519PublicKeyHex, Ed25519Signature, Ed25519SignatureHex, EnterpriseAddress, ExUnits, Hash, Hash28ByteBase16, Hash32ByteBase16, NativeScript, NetworkId, type OutputEncoding, PaymentAddress, PlutusData, PlutusLanguageVersion, PlutusList, PlutusMap, PlutusV1Script, PlutusV2Script, PlutusV3Script, PolicyId, PoolId, Redeemer, RedeemerPurpose, RedeemerTag, Redeemers, RequireAllOf, RequireAnyOf, RequireNOf, RequireSignature, RequireTimeAfter, RequireTimeBefore, RewardAccount, RewardAddress, Script, ScriptHash, ScriptPubkey, type Signatures, type Signer, Slot, StakeCredentialStatus, StakeDelegation, type StakeDelegationCertificate, StakeRegistration, StricaBip32PrivateKey, StricaBip32PrivateKey as StricaBip32PrivateKeyType, StricaBip32PublicKey, StricaBip32PublicKey as StricaBip32PublicKeyType, StricaDecoder, StricaEncoder, StricaPrivateKey, StricaPrivateKey as StricaPrivateKeyType, StricaPublicKey, StricaPublicKey as StricaPublicKeyType, type TokenMap, Transaction, TransactionBody, TransactionId, TransactionInput, type TransactionInputSet, TransactionOutput, TransactionUnspentOutput, type TransactionWitnessPlutusData, TransactionWitnessSet, Value, VkeyWitness, VrfVkBech32, type Witness, addressToBech32, assetTypes, buildBaseAddress, buildBip32PrivateKey, buildDRepID, buildEnterpriseAddress, buildKeys, buildRewardAddress, buildScriptPubkey, checkSignature, deserializeAddress, deserializeDataHash, deserializeEd25519KeyHash, deserializeNativeScript, deserializePlutusData, deserializePlutusScript, deserializeScriptHash, deserializeScriptRef, deserializeTx, deserializeTxHash, deserializeTxUnspentOutput, deserializeValue, empty, fromNativeScript, fromScriptRef, fromTxUnspentOutput, fromValue, generateNonce, getCoseKeyFromPublicKey, getPublicKeyFromCoseKey, mergeValue, negateValue, negatives, normalizePlutusScript, resolveDataHash, resolveNativeScriptAddress, resolveNativeScriptHash, resolvePaymentKeyHash, resolvePlutusScriptAddress, resolvePlutusScriptHash, resolvePoolId, resolvePrivateKey, resolveRewardAddress, resolveScriptRef, resolveStakeKeyHash, resolveTxHash, signData, subValue, toAddress, toBaseAddress, toEnterpriseAddress, toNativeScript, toPlutusData, toRewardAddress, toScriptRef, toTxUnspentOutput, toValue };
+export { Address, AddressType, AssetFingerprint, AssetId, AssetName, type AuxiliaryData, AuxilliaryData, BaseAddress, Bip32PrivateKey, Bip32PrivateKeyHex, Bip32PublicKey, Bip32PublicKeyHex, BootstrapWitness, type ByronAttributes, CardanoSDKSerializer, CborSet, CborWriter, CertIndex, Certificate, CertificateType, ConstrPlutusData, CoseSign1, CostModel, type CostModels, Costmdls, Credential, type CredentialCore, CredentialType, DRep, DRepID, Datum, DatumHash, DatumKind, Ed25519KeyHash, Ed25519KeyHashHex, Ed25519PrivateExtendedKeyHex, Ed25519PrivateKey, Ed25519PrivateNormalKeyHex, Ed25519PublicKey, Ed25519PublicKeyHex, Ed25519Signature, Ed25519SignatureHex, EnterpriseAddress, ExUnits, Hash, Hash28ByteBase16, Hash32ByteBase16, HexBlob, type Metadatum, MetadatumList, MetadatumMap, NativeScript, NetworkId, type OutputEncoding, PaymentAddress, PlutusData, PlutusDataKind, PlutusLanguageVersion, PlutusList, PlutusMap, PlutusV1Script, PlutusV2Script, PlutusV3Script, PointerAddress, PolicyId, PoolId, Redeemer, RedeemerPurpose, RedeemerTag, Redeemers, RequireAllOf, RequireAnyOf, RequireNOf, RequireSignature, RequireTimeAfter, RequireTimeBefore, RewardAccount, RewardAddress, Script, ScriptHash, ScriptPubkey, type Signatures, type Signer, Slot, StakeCredentialStatus, StakeDelegation, type StakeDelegationCertificate, StakeRegistration, type TokenMap, Transaction, TransactionBody, TransactionId, TransactionInput, type TransactionInputSet, TransactionMetadatum, TransactionOutput, TransactionUnspentOutput, type TransactionWitnessPlutusData, TransactionWitnessSet, TxCBOR, TxIndex, Value, VkeyWitness, VrfVkBech32, type Witness, addVKeyWitnessSetToTransaction, addrBech32ToPlutusDataHex, addrBech32ToPlutusDataObj, addressToBech32, applyEncoding, applyParamsToScript, assetTypes, blake2b, buildBaseAddress, buildBip32PrivateKey, buildDRepID, buildEd25519PrivateKeyFromSecretKey, buildEnterpriseAddress, buildKeys, buildRewardAddress, buildScriptPubkey, bytesToHex, calculateFees, checkSignature, clampScalar, computeAuxiliaryDataHash, deserializeAddress, deserializeBech32Address, deserializeDataHash, deserializeEd25519KeyHash, deserializeNativeScript, deserializePlutusData, deserializePlutusScript, deserializeScriptHash, deserializeScriptRef, deserializeTx, deserializeTxHash, deserializeTxUnspentOutput, deserializeValue, empty, fromBuilderToPlutusData, fromJsonToPlutusData, fromNativeScript, fromPlutusDataToJson, fromScriptRef, fromTxUnspentOutput, fromValue, generateNonce, getCoseKeyFromPublicKey, getDRepIds, getPublicKeyFromCoseKey, hexToBech32, hexToBytes, keyHashToRewardAddress, mergeValue, negateValue, negatives, normalizePlutusScript, parseDatumCbor, parseInlineDatum, resolveDataHash, resolveEd25519KeyHash, resolveNativeScriptAddress, resolveNativeScriptHash, resolvePaymentKeyHash, resolvePlutusScriptAddress, resolvePlutusScriptHash, resolvePoolId, resolvePrivateKey, resolveRewardAddress, resolveScriptHashDRepId, resolveScriptRef, resolveStakeKeyHash, resolveTxHash, scriptHashToBech32, scriptHashToRewardAddress, serializeAddressObj, serializePlutusAddressToBech32, serialzeAddress, signData, subValue, toAddress, toBaseAddress, toCardanoAddress, toDRep, toEnterpriseAddress, toNativeScript, toPlutusData, toRewardAddress, toScriptRef, toTxUnspentOutput, toValue, utf8ToBytes, utf8ToHex, v2ScriptToBech32 };