pshenmic-dpp 1.1.2-dev.8 → 2.0.0-dev.10

package/dist/src/dpp/structs/AddressTransitions/entities/AddressFundsFeeStrategyStep.d.ts

@@ -0,0 +1,12 @@
+import type { AddressFundsFeeStrategyStepNAPI } from '../../../../../binaries/bindingsTypes.js';
+export declare class AddressFundsFeeStrategyStepWASM {
+    /** @private **/
+    _rawAddressFundsFeeStrategyStep: AddressFundsFeeStrategyStepNAPI;
+    private constructor();
+    getValue(): number;
+    setValue(value: number): void;
+    getValueType(): string;
+    static DeductFromInput(input: number): AddressFundsFeeStrategyStepWASM;
+    static ReduceOutput(output: number): AddressFundsFeeStrategyStepWASM;
+    static createFromRawInstance(rawInstance: AddressFundsFeeStrategyStepNAPI): AddressFundsFeeStrategyStepWASM;
+}

package/dist/src/dpp/structs/AddressTransitions/entities/AddressFundsFeeStrategyStep.js

@@ -0,0 +1,26 @@
+import { dppProvider } from '../../../provider.js';
+export class AddressFundsFeeStrategyStepWASM {
+    /** @private **/
+    _rawAddressFundsFeeStrategyStep;
+    constructor(addressFundsFeeStrategyStep) {
+        this._rawAddressFundsFeeStrategyStep = addressFundsFeeStrategyStep;
+    }
+    getValue() {
+        return this._rawAddressFundsFeeStrategyStep.getValue();
+    }
+    setValue(value) {
+        this._rawAddressFundsFeeStrategyStep.setValue(value);
+    }
+    getValueType() {
+        return this._rawAddressFundsFeeStrategyStep.getValueType();
+    }
+    static DeductFromInput(input) {
+        return new AddressFundsFeeStrategyStepWASM(dppProvider.dpp.AddressFundsFeeStrategyStepNAPI.DeductFromInput(input));
+    }
+    static ReduceOutput(output) {
+        return new AddressFundsFeeStrategyStepWASM(dppProvider.dpp.AddressFundsFeeStrategyStepNAPI.ReduceOutput(output));
+    }
+    static createFromRawInstance(rawInstance) {
+        return new AddressFundsFeeStrategyStepWASM(rawInstance);
+    }
+}

package/dist/src/dpp/structs/AddressTransitions/entities/InputAddress.d.ts

@@ -0,0 +1,15 @@
+import type { InputAddressNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { PlatformAddressWASM } from '../../PlatformAddress/PlatformAddress.js';
+import { PlatformAddressLike } from '../../../types.js';
+export declare class InputAddressWASM {
+    /** @private **/
+    _rawInputAddress: InputAddressNAPI;
+    constructor(address: PlatformAddressLike, nonce: number, credits: bigint);
+    get address(): PlatformAddressWASM;
+    set address(value: PlatformAddressLike);
+    get nonce(): number;
+    set nonce(value: number);
+    get credits(): bigint;
+    set credits(value: bigint);
+    static createFromRawInstance(rawInstance: InputAddressNAPI): InputAddressWASM;
+}

package/dist/src/dpp/structs/AddressTransitions/entities/InputAddress.js

@@ -0,0 +1,33 @@
+import { PlatformAddressWASM } from '../../PlatformAddress/PlatformAddress.js';
+import { dppProvider } from '../../../provider.js';
+import { preparePlatformAddressValue } from '../../../utils.js';
+export class InputAddressWASM {
+    /** @private **/
+    _rawInputAddress;
+    constructor(address, nonce, credits) {
+        this._rawInputAddress = new dppProvider.dpp.InputAddressNAPI(preparePlatformAddressValue(address), nonce, credits.toString());
+    }
+    get address() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawInputAddress.address);
+    }
+    set address(value) {
+        this._rawInputAddress.address = preparePlatformAddressValue(value);
+    }
+    get nonce() {
+        return this._rawInputAddress.nonce;
+    }
+    set nonce(value) {
+        this._rawInputAddress.nonce = value;
+    }
+    get credits() {
+        return BigInt(this._rawInputAddress.credits);
+    }
+    set credits(value) {
+        this._rawInputAddress.credits = value.toString();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(InputAddressWASM.prototype);
+        instance._rawInputAddress = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AddressTransitions/entities/OutputAddress.d.ts

@@ -0,0 +1,13 @@
+import type { OutputAddressNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { PlatformAddressWASM } from '../../PlatformAddress/PlatformAddress.js';
+import { PlatformAddressLike } from '../../../types.js';
+export declare class OutputAddressWASM {
+    /** @private **/
+    _rawOutputAddress: OutputAddressNAPI;
+    constructor(address: PlatformAddressLike, credits: bigint);
+    get address(): PlatformAddressWASM;
+    set address(address: PlatformAddressLike);
+    get credits(): bigint;
+    set credits(credits: bigint);
+    static createFromRawInstance(rawInstance: OutputAddressNAPI): OutputAddressWASM;
+}

package/dist/src/dpp/structs/AddressTransitions/entities/OutputAddress.js

@@ -0,0 +1,27 @@
+import { dppProvider } from '../../../provider.js';
+import { PlatformAddressWASM } from '../../PlatformAddress/PlatformAddress.js';
+import { preparePlatformAddressValue } from '../../../utils.js';
+export class OutputAddressWASM {
+    /** @private **/
+    _rawOutputAddress;
+    constructor(address, credits) {
+        this._rawOutputAddress = new dppProvider.dpp.OutputAddressNAPI(preparePlatformAddressValue(address), credits.toString());
+    }
+    get address() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawOutputAddress.address);
+    }
+    set address(address) {
+        this._rawOutputAddress.address = preparePlatformAddressValue(address);
+    }
+    get credits() {
+        return BigInt(this._rawOutputAddress.credits);
+    }
+    set credits(credits) {
+        this._rawOutputAddress.credits = credits.toString();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(OutputAddressWASM.prototype);
+        instance._rawOutputAddress = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AddressTransitions/entities/OutputAddressNullableCredits.d.ts

@@ -0,0 +1,13 @@
+import type { OutputAddressNullableCreditsNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { PlatformAddressWASM } from '../../PlatformAddress/PlatformAddress.js';
+import { PlatformAddressLike } from '../../../types.js';
+export declare class OutputAddressNullableCreditsWASM {
+    /** @private **/
+    _rawOutputAddressNullableCredits: OutputAddressNullableCreditsNAPI;
+    constructor(address: PlatformAddressLike, credits?: bigint);
+    get address(): PlatformAddressWASM;
+    set address(address: PlatformAddressLike);
+    get credits(): BigInt | undefined;
+    set credits(value: BigInt | undefined);
+    static createFromRawInstance(rawInstance: OutputAddressNullableCreditsNAPI): OutputAddressNullableCreditsWASM;
+}

package/dist/src/dpp/structs/AddressTransitions/entities/OutputAddressNullableCredits.js

@@ -0,0 +1,30 @@
+import { PlatformAddressWASM } from '../../PlatformAddress/PlatformAddress.js';
+import { dppProvider } from '../../../provider.js';
+import { preparePlatformAddressValue } from '../../../utils.js';
+export class OutputAddressNullableCreditsWASM {
+    /** @private **/
+    _rawOutputAddressNullableCredits;
+    constructor(address, credits) {
+        this._rawOutputAddressNullableCredits = new dppProvider.dpp.OutputAddressNullableCreditsNAPI(preparePlatformAddressValue(address), credits?.toString());
+    }
+    get address() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawOutputAddressNullableCredits.address);
+    }
+    set address(address) {
+        this._rawOutputAddressNullableCredits.address = preparePlatformAddressValue(address);
+    }
+    get credits() {
+        const credits = this._rawOutputAddressNullableCredits.credits;
+        if (credits != null) {
+            return BigInt(credits);
+        }
+    }
+    set credits(value) {
+        this._rawOutputAddressNullableCredits.credits = value?.toString();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(OutputAddressNullableCreditsWASM.prototype);
+        instance._rawOutputAddressNullableCredits = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/AssetLockProof.d.ts

@@ -0,0 +1,19 @@
+import type { AssetLockProofNAPI } from '../../../../binaries/bindingsTypes.js';
+import { InstantAssetLockProofWASM } from './InstantAssetLockProof.js';
+import { ChainAssetLockProofWASM } from './ChainAssetLockProof.js';
+import { OutPointWASM } from './OutPoint.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class AssetLockProofWASM {
+    _rawAssetLockProof: AssetLockProofNAPI;
+    constructor(lockProof: InstantAssetLockProofWASM | ChainAssetLockProofWASM);
+    static createInstantAssetLockProof(instantLock: Uint8Array, transaction: Uint8Array, outputIndex: number): AssetLockProofWASM;
+    static createChainAssetLockProof(coreChainLockedHeight: number, outPoint: OutPointWASM): AssetLockProofWASM;
+    getLockType(): string;
+    getInstantLockProof(): InstantAssetLockProofWASM;
+    getChainLockProof(): ChainAssetLockProofWASM;
+    getOutPoint(): OutPointWASM | null;
+    createIdentityId(): IdentifierWASM;
+    hex(): string;
+    static fromHex(value: string): AssetLockProofWASM;
+    static createFromRawInstance(rawInstance: AssetLockProofNAPI): AssetLockProofWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/AssetLockProof.js

@@ -0,0 +1,50 @@
+import { InstantAssetLockProofWASM } from './InstantAssetLockProof.js';
+import { ChainAssetLockProofWASM } from './ChainAssetLockProof.js';
+import { dppProvider } from '../../provider.js';
+import { OutPointWASM } from './OutPoint.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class AssetLockProofWASM {
+    _rawAssetLockProof;
+    constructor(lockProof) {
+        this._rawAssetLockProof = new dppProvider.dpp.AssetLockProofNAPI(lockProof._rawLockProof);
+    }
+    static createInstantAssetLockProof(instantLock, transaction, outputIndex) {
+        return AssetLockProofWASM.createFromRawInstance(dppProvider
+            .dpp
+            .AssetLockProofNAPI
+            .createInstantAssetLockProof(instantLock, transaction, outputIndex));
+    }
+    static createChainAssetLockProof(coreChainLockedHeight, outPoint) {
+        return AssetLockProofWASM.createFromRawInstance(dppProvider
+            .dpp
+            .AssetLockProofNAPI
+            .createChainAssetLockProof(coreChainLockedHeight, outPoint._rawOutPoint));
+    }
+    getLockType() {
+        return this._rawAssetLockProof.getLockType();
+    }
+    getInstantLockProof() {
+        return InstantAssetLockProofWASM.createFromRawInstance(this._rawAssetLockProof.getInstantLockProof());
+    }
+    getChainLockProof() {
+        return ChainAssetLockProofWASM.createFromRawInstance(this._rawAssetLockProof.getChainLockProof());
+    }
+    getOutPoint() {
+        const outPoint = this._rawAssetLockProof.getOutPoint();
+        return (outPoint != null) ? OutPointWASM.createFromRawInstance(outPoint) : null;
+    }
+    createIdentityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawAssetLockProof.createIdentityId());
+    }
+    hex() {
+        return this._rawAssetLockProof.hex();
+    }
+    static fromHex(value) {
+        return AssetLockProofWASM.createFromRawInstance(dppProvider.dpp.AssetLockProofNAPI.fromHex(value));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(AssetLockProofWASM.prototype);
+        instance._rawAssetLockProof = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/ChainAssetLockProof.d.ts

@@ -0,0 +1,17 @@
+import type { ChainAssetLockProofNAPI } from '../../../../binaries/bindingsTypes.js';
+import { OutPointWASM } from './OutPoint.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class ChainAssetLockProofWASM {
+    _rawLockProof: ChainAssetLockProofNAPI;
+    constructor(coreChainLockedHeight: number, outPoint: OutPointWASM);
+    set coreChainLockedHeight(height: number);
+    get coreChainLockedHeight(): number;
+    set outPoint(outPoint: OutPointWASM);
+    get outPoint(): OutPointWASM;
+    createIdentityId(): IdentifierWASM;
+    static fromRawObject(obj: {
+        coreChainLockedHeight: number;
+        outPoint: OutPointWASM | Uint8Array;
+    }): ChainAssetLockProofWASM;
+    static createFromRawInstance(rawInstance: ChainAssetLockProofNAPI): ChainAssetLockProofWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/ChainAssetLockProof.js

@@ -0,0 +1,36 @@
+import { OutPointWASM } from './OutPoint.js';
+import { dppProvider } from '../../provider.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class ChainAssetLockProofWASM {
+    _rawLockProof;
+    constructor(coreChainLockedHeight, outPoint) {
+        this._rawLockProof = new dppProvider.dpp.ChainAssetLockProofNAPI(coreChainLockedHeight, outPoint._rawOutPoint);
+    }
+    set coreChainLockedHeight(height) {
+        this._rawLockProof.coreChainLockedHeight = height;
+    }
+    get coreChainLockedHeight() {
+        return this._rawLockProof.coreChainLockedHeight;
+    }
+    set outPoint(outPoint) {
+        this._rawLockProof.outPoint = outPoint._rawOutPoint;
+    }
+    get outPoint() {
+        return OutPointWASM.createFromRawInstance(this._rawLockProof.outPoint);
+    }
+    createIdentityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawLockProof.createIdentityId());
+    }
+    static fromRawObject(obj) {
+        const outPoint = obj.outPoint instanceof Uint8Array ? obj.outPoint : obj.outPoint.bytes();
+        return ChainAssetLockProofWASM.createFromRawInstance(dppProvider.dpp.ChainAssetLockProofNAPI.fromRawObject({
+            coreChainLockedHeight: obj.coreChainLockedHeight,
+            outPoint
+        }));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ChainAssetLockProofWASM.prototype);
+        instance._rawLockProof = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/InstantAssetLockProof.d.ts

@@ -0,0 +1,24 @@
+import type { InstantAssetLockProofNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TxOutWASM } from './TxOut.js';
+import { OutPointWASM } from './OutPoint.js';
+import { InstantLockWASM } from '../InstantLock.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class InstantAssetLockProofWASM {
+    _rawLockProof: InstantAssetLockProofNAPI;
+    constructor(instantLock: Uint8Array, transaction: Uint8Array, outputIndex: number);
+    get outputIndex(): number;
+    set outputIndex(value: number);
+    get instantLock(): InstantLockWASM;
+    set instantLock(instantLock: InstantLockWASM);
+    getOutput(): TxOutWASM | null;
+    getOutPoint(): OutPointWASM | null;
+    getTransaction(): Uint8Array;
+    getInstantLockBytes(): Uint8Array;
+    createIdentityId(): IdentifierWASM;
+    static fromRawObject(obj: {
+        instantLock: Uint8Array;
+        transaction: Uint8Array;
+        outputIndex: number;
+    }): InstantAssetLockProofWASM;
+    static createFromRawInstance(rawInstance: InstantAssetLockProofNAPI): InstantAssetLockProofWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/InstantAssetLockProof.js

@@ -0,0 +1,48 @@
+import { dppProvider } from '../../provider.js';
+import { TxOutWASM } from './TxOut.js';
+import { OutPointWASM } from './OutPoint.js';
+import { InstantLockWASM } from '../InstantLock.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class InstantAssetLockProofWASM {
+    _rawLockProof;
+    constructor(instantLock, transaction, outputIndex) {
+        this._rawLockProof = new dppProvider.dpp.InstantAssetLockProofNAPI(instantLock, transaction, outputIndex);
+    }
+    get outputIndex() {
+        return this._rawLockProof.outputIndex;
+    }
+    set outputIndex(value) {
+        this._rawLockProof.outputIndex = value;
+    }
+    get instantLock() {
+        return InstantLockWASM.createFromRawInstance(this._rawLockProof.instantLock);
+    }
+    set instantLock(instantLock) {
+        this._rawLockProof.instantLock = instantLock._rawInstantLock;
+    }
+    getOutput() {
+        const out = this._rawLockProof.getOutput();
+        return out instanceof dppProvider.dpp.TxOutNAPI ? TxOutWASM.createFromRawInstance(out) : out;
+    }
+    getOutPoint() {
+        const out = this._rawLockProof.getOutPoint();
+        return out instanceof dppProvider.dpp.OutPointNAPI ? OutPointWASM.createFromRawInstance(out) : out;
+    }
+    getTransaction() {
+        return this._rawLockProof.getTransaction();
+    }
+    getInstantLockBytes() {
+        return this._rawLockProof.getInstantLockBytes();
+    }
+    createIdentityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawLockProof.createIdentityId());
+    }
+    static fromRawObject(obj) {
+        return InstantAssetLockProofWASM.createFromRawInstance(dppProvider.dpp.InstantAssetLockProofNAPI.fromRawObject(obj));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(InstantAssetLockProofWASM.prototype);
+        instance._rawLockProof = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/OutPoint.d.ts

@@ -0,0 +1,15 @@
+import type { OutPointNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class OutPointWASM {
+    /** @private **/
+    _rawOutPoint: OutPointNAPI;
+    constructor(txId: string, vout: number);
+    getVOUT(): number;
+    getTXID(): string;
+    bytes(): Uint8Array;
+    base64(): string;
+    hex(): string;
+    static fromBytes(bytes: Uint8Array): OutPointWASM;
+    static fromHex(bytes: string): OutPointWASM;
+    static fromBase64(bytes: string): OutPointWASM;
+    static createFromRawInstance(rawInstance: OutPointNAPI): OutPointWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/OutPoint.js

@@ -0,0 +1,40 @@
+import { dppProvider } from '../../provider.js';
+export class OutPointWASM {
+    /** @private **/
+    _rawOutPoint;
+    constructor(txId, vout) {
+        this._rawOutPoint = new dppProvider.dpp.OutPointNAPI(txId, vout);
+    }
+    getVOUT() {
+        return this._rawOutPoint.getVOUT();
+    }
+    getTXID() {
+        return this._rawOutPoint.getTXID();
+    }
+    bytes() {
+        return this._rawOutPoint.bytes();
+    }
+    base64() {
+        return this._rawOutPoint.base64();
+    }
+    hex() {
+        return this._rawOutPoint.hex();
+    }
+    static fromBytes(bytes) {
+        const instance = dppProvider.dpp.OutPointNAPI.fromBytes(bytes);
+        return OutPointWASM.createFromRawInstance(instance);
+    }
+    static fromHex(bytes) {
+        const instance = dppProvider.dpp.OutPointNAPI.fromHex(bytes);
+        return OutPointWASM.createFromRawInstance(instance);
+    }
+    static fromBase64(bytes) {
+        const instance = dppProvider.dpp.OutPointNAPI.fromBase64(bytes);
+        return OutPointWASM.createFromRawInstance(instance);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(OutPointWASM.prototype);
+        instance._rawOutPoint = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/Transaction.d.ts

@@ -0,0 +1,20 @@
+import type { TransactionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TxInWASM } from './TxIn.js';
+import { TxOutWASM } from './TxOut.js';
+export declare class TransactionWASM {
+    /** @private **/
+    _rawTransaction: TransactionNAPI;
+    constructor(version: number, lockTime: number | Date, inputs: TxInWASM[], outputs: TxOutWASM[]);
+    get version(): number;
+    set version(version: number);
+    get lockTime(): number;
+    set lockTime(lockTime: number | Date);
+    get input(): TxInWASM[];
+    set input(input: TxInWASM[]);
+    get output(): TxOutWASM[];
+    set output(output: TxOutWASM[]);
+    isCoinBase(): boolean;
+    getTxType(): string;
+    getTxId(): string;
+    static createFromRawInstance(rawInstance: TransactionNAPI): TransactionWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/Transaction.js

@@ -0,0 +1,49 @@
+import { TxInWASM } from './TxIn.js';
+import { TxOutWASM } from './TxOut.js';
+import { dppProvider } from '../../provider.js';
+export class TransactionWASM {
+    /** @private **/
+    _rawTransaction;
+    constructor(version, lockTime, inputs, outputs) {
+        const normalLockTime = typeof lockTime === 'number' ? lockTime : lockTime.getTime();
+        this._rawTransaction = new dppProvider.dpp.TransactionNAPI(version, normalLockTime, inputs.map(input => input._rawTxIn), outputs.map(output => output._rawTxOut));
+    }
+    get version() {
+        return this._rawTransaction.version;
+    }
+    set version(version) {
+        this._rawTransaction.version = version;
+    }
+    get lockTime() {
+        return this._rawTransaction.lockTime;
+    }
+    set lockTime(lockTime) {
+        this._rawTransaction.lockTime = typeof lockTime === 'number' ? lockTime : lockTime.getTime();
+    }
+    get input() {
+        return this._rawTransaction.input.map(TxInWASM.createFromRawInstance);
+    }
+    set input(input) {
+        this._rawTransaction.input = input.map(input => input._rawTxIn);
+    }
+    get output() {
+        return this._rawTransaction.output.map(TxOutWASM.createFromRawInstance);
+    }
+    set output(output) {
+        this._rawTransaction.output = output.map(output => output._rawTxOut);
+    }
+    isCoinBase() {
+        return this._rawTransaction.isCoinBase();
+    }
+    getTxType() {
+        return this._rawTransaction.getTxType();
+    }
+    getTxId() {
+        return this._rawTransaction.getTxId();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TransactionWASM.prototype);
+        instance._rawTransaction = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/TxIn.d.ts

@@ -0,0 +1,17 @@
+import type { TxInNAPI } from '../../../../binaries/bindingsTypes.js';
+import { OutPointWASM } from './OutPoint.js';
+import { WitnessWASM } from './Witness.js';
+export declare class TxInWASM {
+    /** @private **/
+    _rawTxIn: TxInNAPI;
+    constructor(previousOutPoint: OutPointWASM, scriptSig: Uint8Array, sequency: number, witness: WitnessWASM);
+    get previousOutput(): OutPointWASM;
+    set previousOutput(previousOutput: OutPointWASM);
+    get scriptSig(): Uint8Array;
+    set scriptSig(sig: Uint8Array);
+    get sequence(): number;
+    set sequence(sequence: number);
+    get witnesses(): WitnessWASM;
+    set witnesses(witness: WitnessWASM);
+    static createFromRawInstance(rawInstance: TxInNAPI): TxInWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/TxIn.js

@@ -0,0 +1,39 @@
+import { OutPointWASM } from './OutPoint.js';
+import { WitnessWASM } from './Witness.js';
+import { dppProvider } from '../../provider.js';
+export class TxInWASM {
+    /** @private **/
+    _rawTxIn;
+    constructor(previousOutPoint, scriptSig, sequency, witness) {
+        this._rawTxIn = new dppProvider.dpp.TxInNAPI(previousOutPoint._rawOutPoint, scriptSig, sequency, witness._rawWitness);
+    }
+    get previousOutput() {
+        return OutPointWASM.createFromRawInstance(this._rawTxIn.previousOutput);
+    }
+    set previousOutput(previousOutput) {
+        this._rawTxIn.previousOutput = previousOutput._rawOutPoint;
+    }
+    get scriptSig() {
+        return this._rawTxIn.scriptSig;
+    }
+    set scriptSig(sig) {
+        this._rawTxIn.scriptSig = sig;
+    }
+    get sequence() {
+        return this._rawTxIn.sequence;
+    }
+    set sequence(sequence) {
+        this._rawTxIn.sequence = sequence;
+    }
+    get witnesses() {
+        return WitnessWASM.createFromRawInstance(this._rawTxIn.witnesses);
+    }
+    set witnesses(witness) {
+        this._rawTxIn.witnesses = witness._rawWitness;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TxInWASM.prototype);
+        instance._rawTxIn = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/TxOut.d.ts

@@ -0,0 +1,13 @@
+import type { TxOutNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TxOutWASM {
+    _rawTxOut: TxOutNAPI;
+    constructor(value: bigint, scriptPubKey: Uint8Array);
+    get value(): bigint;
+    set value(value: bigint);
+    get scriptPubKeyHex(): string;
+    set scriptPubKeyHex(script: string);
+    get scriptPubKeyBytes(): Uint8Array;
+    set scriptPubKeyBytes(script: Uint8Array);
+    getScriptPubKeyASM(): string;
+    static createFromRawInstance(rawInstance: TxOutNAPI): TxOutWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/TxOut.js

@@ -0,0 +1,34 @@
+import { dppProvider } from '../../provider.js';
+export class TxOutWASM {
+    _rawTxOut;
+    constructor(value, scriptPubKey) {
+        const rsValue = value.toString();
+        this._rawTxOut = new dppProvider.dpp.TxOutNAPI(rsValue, scriptPubKey);
+    }
+    get value() {
+        return BigInt(this._rawTxOut.value);
+    }
+    set value(value) {
+        this._rawTxOut.value = value.toString();
+    }
+    get scriptPubKeyHex() {
+        return this._rawTxOut.scriptPubKeyHex;
+    }
+    set scriptPubKeyHex(script) {
+        this._rawTxOut.scriptPubKeyHex = script;
+    }
+    get scriptPubKeyBytes() {
+        return this._rawTxOut.scriptPubKeyBytes;
+    }
+    set scriptPubKeyBytes(script) {
+        this._rawTxOut.scriptPubKeyBytes = script;
+    }
+    getScriptPubKeyASM() {
+        return this._rawTxOut.getScriptPubKeyASM();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TxOutWASM.prototype);
+        instance._rawTxOut = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/Witness.d.ts

@@ -0,0 +1,11 @@
+import type { WitnessNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class WitnessWASM {
+    /** @private **/
+    _rawWitness: WitnessNAPI;
+    constructor(bytes?: Uint8Array[]);
+    getBytes(): Uint8Array[];
+    isEmpty(): boolean;
+    clear(): void;
+    push(value: Uint8Array): void;
+    static createFromRawInstance(rawInstance: WitnessNAPI): WitnessWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/Witness.js

@@ -0,0 +1,25 @@
+import { dppProvider } from '../../provider.js';
+export class WitnessWASM {
+    /** @private **/
+    _rawWitness;
+    constructor(bytes) {
+        this._rawWitness = new dppProvider.dpp.WitnessNAPI(bytes);
+    }
+    getBytes() {
+        return this._rawWitness.getBytes();
+    }
+    isEmpty() {
+        return this._rawWitness.isEmpty();
+    }
+    clear() {
+        this._rawWitness.clear();
+    }
+    push(value) {
+        this._rawWitness.push(value);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(WitnessWASM.prototype);
+        instance._rawWitness = rawInstance;
+        return instance;
+    }
+}