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

package/dist/src/dpp/structs/AddressTransitions/IdentityTopUpFromAddressesTransition.js

@@ -0,0 +1,76 @@
+import { dppProvider } from '../../provider.js';
+import { InputAddressWASM } from './entities/InputAddress.js';
+import { AddressFundsFeeStrategyStepWASM } from './entities/AddressFundsFeeStrategyStep.js';
+import { AddressWitnessWASM } from '../Address/AddressWitness.js';
+import { OutputAddressWASM } from './entities/OutputAddress.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class IdentityTopUpFromAddressesTransitionWASM {
+    /** @private **/
+    _rawIdentityTopUpFromAddressesTransition;
+    constructor(identifier, inputs, feeStrategy, userFeeIncrease, inputWitness, output) {
+        this._rawIdentityTopUpFromAddressesTransition = new dppProvider.dpp.IdentityTopUpFromAddressesTransitionNAPI(prepareIdentifierValue(identifier), inputs.map(i => i._rawInputAddress), feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep), userFeeIncrease, inputWitness.map(w => w._rawWitness), output?._rawOutputAddress);
+    }
+    get inputs() {
+        return this._rawIdentityTopUpFromAddressesTransition.inputs.map(InputAddressWASM.createFromRawInstance);
+    }
+    set inputs(inputs) {
+        this._rawIdentityTopUpFromAddressesTransition.inputs = inputs.map(i => i._rawInputAddress);
+    }
+    get output() {
+        const output = this._rawIdentityTopUpFromAddressesTransition.output;
+        if (output != null) {
+            return OutputAddressWASM.createFromRawInstance(output);
+        }
+    }
+    set output(output) {
+        this._rawIdentityTopUpFromAddressesTransition.output = output?._rawOutputAddress;
+    }
+    get feeStrategy() {
+        return this._rawIdentityTopUpFromAddressesTransition.feeStrategy.map(AddressFundsFeeStrategyStepWASM.createFromRawInstance);
+    }
+    set feeStrategy(feeStrategy) {
+        this._rawIdentityTopUpFromAddressesTransition.feeStrategy = feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep);
+    }
+    get userFeeIncrease() {
+        return this._rawIdentityTopUpFromAddressesTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(userFeeIncrease) {
+        this._rawIdentityTopUpFromAddressesTransition.userFeeIncrease = userFeeIncrease;
+    }
+    get inputWitness() {
+        return this._rawIdentityTopUpFromAddressesTransition.inputWitness.map(AddressWitnessWASM.createFromRawInstance);
+    }
+    set inputWitness(addressWitness) {
+        this._rawIdentityTopUpFromAddressesTransition.inputWitness = addressWitness.map(w => w._rawWitness);
+    }
+    bytes() {
+        return this._rawIdentityTopUpFromAddressesTransition.bytes();
+    }
+    hex() {
+        return this._rawIdentityTopUpFromAddressesTransition.hex();
+    }
+    base64() {
+        return this._rawIdentityTopUpFromAddressesTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawIdentityTopUpFromAddressesTransition.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return IdentityTopUpFromAddressesTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpFromAddressesTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return IdentityTopUpFromAddressesTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpFromAddressesTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return IdentityTopUpFromAddressesTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpFromAddressesTransitionNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return IdentityTopUpFromAddressesTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpFromAddressesTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawIdentityTopUpFromAddressesTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,12 @@
+import { 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,14 @@
+import { InputAddressNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { PlatformAddressWASM } from '../../Address/PlatformAddress.js';
+export declare class InputAddressWASM {
+    /** @private **/
+    _rawInputAddress: InputAddressNAPI;
+    constructor(address: PlatformAddressWASM, nonce: number, credits: bigint);
+    get address(): PlatformAddressWASM;
+    set address(value: PlatformAddressWASM);
+    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,32 @@
+import { PlatformAddressWASM } from '../../Address/PlatformAddress.js';
+import { dppProvider } from '../../../provider.js';
+export class InputAddressWASM {
+    /** @private **/
+    _rawInputAddress;
+    constructor(address, nonce, credits) {
+        this._rawInputAddress = new dppProvider.dpp.InputAddressNAPI(address._rawPlatformAddress, nonce, credits.toString());
+    }
+    get address() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawInputAddress.address);
+    }
+    set address(value) {
+        this._rawInputAddress.address = value._rawPlatformAddress;
+    }
+    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(this.prototype);
+        instance._rawInputAddress = rawInstance;
+        return instance;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { OutputAddressNullableCreditsNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { PlatformAddressWASM } from '../../Address/PlatformAddress.js';
+export declare class OutputAddressNullableCreditsWASM {
+    /** @private **/
+    _rawOutputAddressNullableCredits: OutputAddressNullableCreditsNAPI;
+    constructor(address: PlatformAddressWASM, credits?: bigint);
+    get address(): PlatformAddressWASM;
+    set address(address: PlatformAddressWASM);
+    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,29 @@
+import { PlatformAddressWASM } from '../../Address/PlatformAddress.js';
+import { dppProvider } from '../../../provider.js';
+export class OutputAddressNullableCreditsWASM {
+    /** @private **/
+    _rawOutputAddressNullableCredits;
+    constructor(address, credits) {
+        this._rawOutputAddressNullableCredits = new dppProvider.dpp.OutputAddressNullableCreditsNAPI(address._rawPlatformAddress, credits?.toString());
+    }
+    get address() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawOutputAddressNullableCredits.address);
+    }
+    set address(address) {
+        this._rawOutputAddressNullableCredits.address = address._rawPlatformAddress;
+    }
+    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(this.prototype);
+        instance._rawOutputAddressNullableCredits = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { 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,51 @@
+import { AssetLockProofNAPI } from '../../../../binaries/bindingsTypes.js';
+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(AssetLockProofNAPI.fromHex(value));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawAssetLockProof = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { 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);
+    }
+    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(this.prototype);
+        instance._rawLockProof = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { 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(this.prototype);
+        instance._rawLockProof = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { 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(this.prototype);
+        instance._rawOutPoint = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { 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(this.prototype);
+        instance._rawTransaction = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { 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(this.prototype);
+        instance._rawTxIn = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { 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;
+}