pshenmic-dpp 2.0.0-dev.20 → 2.0.0-dev.22

package/dist/binaries/wasm.d.ts

@@ -1,3 +1,5 @@
+export const orchardOvkFromSeed: any;
+export const recoverNotes: any;
 export const verifyAddressesInfos: any;
 export const verifyAddressInfo: any;
 export const verifyContractProof: any;
@@ -10,6 +12,12 @@ export const verifyIdentityByUniqueKeyHashProof: any;
 export const verifyIdentityContractNonceProof: any;
 export const verifyIdentityKeysByIdentifierProof: any;
 export const verifyIdentityNonceProof: any;
+export const verifyMostRecentShieldedAnchorProof: any;
+export const verifyShieldedAnchorsProof: any;
+export const verifyShieldedEncryptedNotesProof: any;
+export const verifyShieldedNotesCountProof: any;
+export const verifyShieldedNullifiersProof: any;
+export const verifyShieldedPoolStateProof: any;
 export const verifySignatureDigest: any;
 export const verifyStateTransitionResult: any;
 export const verifyTokenBalancesForIdentitiesProof: any;
@@ -34,6 +42,7 @@ export const BlockBasedDistributionNAPI: any;
 export const BlockInfoNAPI: any;
 export const ChainAssetLockProofNAPI: any;
 export const ChangeControlRulesNAPI: any;
+export const CommitmentTreeNAPI: any;
 export const ConsensusErrorNAPI: any;
 export const ContenderWithSerializedDocumentNAPI: any;
 export const ContestedDocumentVotePollQueryExecutionResultNAPI: any;
@@ -59,6 +68,7 @@ export const GroupNAPI: any;
 export const GroupStateTransitionInfoNAPI: any;
 export const IdentifierNAPI: any;
 export const IdentityCreateFromAddressesTransitionNAPI: any;
+export const IdentityCreateFromShieldedPoolResultNAPI: any;
 export const IdentityCreateFromShieldedPoolTransitionNAPI: any;
 export const IdentityCreateTransitionNAPI: any;
 export const IdentityCreditTransferNAPI: any;
@@ -77,6 +87,10 @@ export const InputAddressNAPI: any;
 export const InstantAssetLockProofNAPI: any;
 export const InstantLockNAPI: any;
 export const MasternodeVoteTransitionNAPI: any;
+export const MerklePathNAPI: any;
+export const NoteNAPI: any;
+export const OrchardAddressNAPI: any;
+export const OrchardProverNAPI: any;
 export const OutPointNAPI: any;
 export const OutputAddressNAPI: any;
 export const OutputAddressNullableCreditsNAPI: any;
@@ -87,14 +101,19 @@ export const PrefundedVotingBalanceNAPI: any;
 export const PrivateEncryptedNoteNAPI: any;
 export const PrivateKeyNAPI: any;
 export const PublicKeyNAPI: any;
+export const RecoveredNoteNAPI: any;
 export const ResourceVoteChoiceNAPI: any;
 export const RewardDistributionTypeNAPI: any;
 export const SerializedActionNAPI: any;
 export const SharedEncryptedNoteNAPI: any;
+export const ShieldedBuilderNAPI: any;
+export const ShieldedMemoNAPI: any;
 export const ShieldedTransferTransitionNAPI: any;
+export const ShieldedWithdrawalResultNAPI: any;
 export const ShieldedWithdrawalTransitionNAPI: any;
 export const ShieldFromAssetLockTransitionNAPI: any;
 export const ShieldTransitionNAPI: any;
+export const SpendableNoteNAPI: any;
 export const StateTransitionNAPI: any;
 export const StoredAssetLockInfoNAPI: any;
 export const TimeBasedDistributionNAPI: any;
@@ -146,8 +165,16 @@ export const VerifiedIdentityKeysByIdentifierNAPI: any;
 export const VerifiedIdentityNonceNAPI: any;
 export const VerifiedIdentityTokenInfoNAPI: any;
 export const VerifiedIdentityWithAddressInfosNAPI: any;
+export const VerifiedMostRecentShieldedAnchorNAPI: any;
 export const VerifiedPlatformAddressesInfosNAPI: any;
 export const VerifiedPlatformAddressInfoNAPI: any;
+export const VerifiedShieldedAnchorsNAPI: any;
+export const VerifiedShieldedEncryptedNoteNAPI: any;
+export const VerifiedShieldedEncryptedNotesNAPI: any;
+export const VerifiedShieldedNotesCountNAPI: any;
+export const VerifiedShieldedNullifierNAPI: any;
+export const VerifiedShieldedNullifiersNAPI: any;
+export const VerifiedShieldedPoolStateNAPI: any;
 export const VerifiedStateTransitionResultNAPI: any;
 export const VerifiedTokenBalancesForIdentitiesNAPI: any;
 export const VerifiedTokenContractInfoNAPI: any;

package/dist/binaries/wasm.js

@@ -1,2 +1,2 @@
 import * as protocol from "./wasmCreation.cjs";
-export const { verifyAddressesInfos, verifyAddressInfo, verifyContractProof, verifyDocumentsProof, verifyEpochsInfoProof, verifyIdentifierByNonUniquePublicKeyHashProof, verifyIdentityBalanceProof, verifyIdentityByIdentifierProof, verifyIdentityByUniqueKeyHashProof, verifyIdentityContractNonceProof, verifyIdentityKeysByIdentifierProof, verifyIdentityNonceProof, verifySignatureDigest, verifyStateTransitionResult, verifyTokenBalancesForIdentitiesProof, verifyTokenContractInfoProof, verifyTokenDirectPurchasePrices, verifyTokensBalancesForIdentityProof, verifyTokenTotalSupplyProof, verifyTotalCreditsProof, verifyVotePollVoteStateProof, ActionTakerNAPI, AddressCreditWithdrawalTransitionNAPI, AddressFundingFromAssetLockTransitionNAPI, AddressFundsFeeStrategyStepNAPI, AddressFundsTransferTransitionNAPI, AddressWitnessNAPI, AssetLockProofNAPI, AssetLockValueNAPI, AuthorizedActionTakersNAPI, BatchedTransitionNAPI, BatchTransitionNAPI, BlockBasedDistributionNAPI, BlockInfoNAPI, ChainAssetLockProofNAPI, ChangeControlRulesNAPI, ConsensusErrorNAPI, ContenderWithSerializedDocumentNAPI, ContestedDocumentVotePollQueryExecutionResultNAPI, ContractBoundsNAPI, CoreScriptNAPI, DataContractCreateTransitionNAPI, DataContractNAPI, DataContractUpdateTransitionNAPI, DistributionFunctionNAPI, DocumentBaseTransitionNAPI, DocumentCreateTransitionNAPI, DocumentDeleteTransitionNAPI, DocumentNAPI, DocumentPurchaseTransitionNAPI, DocumentReplaceTransitionNAPI, DocumentTransferTransitionNAPI, DocumentTransitionNAPI, DocumentUpdatePriceTransitionNAPI, DynamicValue, EpochBasedDistributionNAPI, ExtendedEpochInfoNAPI, GroupNAPI, GroupStateTransitionInfoNAPI, IdentifierNAPI, IdentityCreateFromAddressesTransitionNAPI, IdentityCreateFromShieldedPoolTransitionNAPI, IdentityCreateTransitionNAPI, IdentityCreditTransferNAPI, IdentityCreditTransferToAddressesTransitionNAPI, IdentityCreditWithdrawalTransitionNAPI, IdentityNAPI, IdentityPublicKeyInCreationNAPI, IdentityPublicKeyNAPI, IdentityTokenBalanceNAPI, IdentityTokenBalanceOptionalNAPI, IdentityTokenInfoNAPI, IdentityTopUpFromAddressesTransitionNAPI, IdentityTopUpTransitionNAPI, IdentityUpdateTransitionNAPI, InputAddressNAPI, InstantAssetLockProofNAPI, InstantLockNAPI, MasternodeVoteTransitionNAPI, OutPointNAPI, OutputAddressNAPI, OutputAddressNullableCreditsNAPI, PartialIdentityNAPI, PlatformAddressInfoNAPI, PlatformAddressNAPI, PrefundedVotingBalanceNAPI, PrivateEncryptedNoteNAPI, PrivateKeyNAPI, PublicKeyNAPI, ResourceVoteChoiceNAPI, RewardDistributionTypeNAPI, SerializedActionNAPI, SharedEncryptedNoteNAPI, ShieldedTransferTransitionNAPI, ShieldedWithdrawalTransitionNAPI, ShieldFromAssetLockTransitionNAPI, ShieldTransitionNAPI, StateTransitionNAPI, StoredAssetLockInfoNAPI, TimeBasedDistributionNAPI, TokenBaseTransitionNAPI, TokenBurnTransitionNAPI, TokenClaimTransitionNAPI, TokenConfigUpdateTransitionNAPI, TokenConfigurationChangeItemNAPI, TokenConfigurationConventionNAPI, TokenConfigurationLocalizationNAPI, TokenConfigurationNAPI, TokenContractInfoNAPI, TokenDestroyFrozenFundsTransitionNAPI, TokenDirectPurchaseTransitionNAPI, TokenDistributionRecipientNAPI, TokenDistributionRulesNAPI, TokenEmergencyActionTransitionNAPI, TokenFreezeTransitionNAPI, TokenKeepsHistoryRulesNAPI, TokenMarketplaceRulesNAPI, TokenMintTransitionNAPI, TokenPaymentInfoNAPI, TokenPerpetualDistributionNAPI, TokenPreProgrammedDistributionNAPI, TokenPricingScheduleNAPI, TokenSetPriceForDirectPurchaseTransitionNAPI, TokenStatusNAPI, TokenTradeModeNAPI, TokenTransferTransitionNAPI, TokenTransitionNAPI, TokenUnFreezeTransitionNAPI, TotalSingleTokenBalanceNAPI, TransactionNAPI, TxInNAPI, TxOutNAPI, UnshieldTransitionNAPI, VerifiedBalanceTransferNAPI, VerifiedContractNAPI, VerifiedDocumentNAPI, VerifiedDocumentsNAPI, VerifiedEpochsInfoNAPI, VerifiedIdentifierByNonUniquePublicKeyHashNAPI, VerifiedIdentityBalanceRootHashNAPI, VerifiedIdentityByIdentifierNAPI, VerifiedIdentityByUniqueKeyHashNAPI, VerifiedIdentityContractNonceNAPI, VerifiedIdentityFullWithAddressInfosNAPI, VerifiedIdentityKeysByIdentifierNAPI, VerifiedIdentityNonceNAPI, VerifiedIdentityTokenInfoNAPI, VerifiedIdentityWithAddressInfosNAPI, VerifiedPlatformAddressesInfosNAPI, VerifiedPlatformAddressInfoNAPI, VerifiedStateTransitionResultNAPI, VerifiedTokenBalancesForIdentitiesNAPI, VerifiedTokenContractInfoNAPI, VerifiedTokenDirectPurchasePricesNAPI, VerifiedTokenGroupActionWithDocumentNAPI, VerifiedTokenGroupActionWithTokenBalanceNAPI, VerifiedTokenGroupActionWithTokenIdentityInfoNAPI, VerifiedTokenGroupActionWithTokenPricingScheduleNAPI, VerifiedTokenPricingScheduleNAPI, VerifiedTokensBalancesForIdentityNAPI, VerifiedTokenTotalSupplyNAPI, VerifiedTotalCreditsNAPI, VerifiedVoteStateNAPI, VoteNAPI, VotePollNAPI, WitnessNAPI, ActionGoalNAPI, AssetLockProofTypeNAPI, BatchTypeNAPI, GasFeesPaidByNAPI, GroupActionStatusNAPI, KeyTypeNAPI, NetworkNAPI, PlatformVersionNAPI, PoolingNAPI, PurposeNAPI, SecurityLevelNAPI, TokenDistributionTypeNAPI, TokenEmergencyActionNAPI, VoteStateResultTypeNAPI } = protocol.default;
+export const { orchardOvkFromSeed, recoverNotes, verifyAddressesInfos, verifyAddressInfo, verifyContractProof, verifyDocumentsProof, verifyEpochsInfoProof, verifyIdentifierByNonUniquePublicKeyHashProof, verifyIdentityBalanceProof, verifyIdentityByIdentifierProof, verifyIdentityByUniqueKeyHashProof, verifyIdentityContractNonceProof, verifyIdentityKeysByIdentifierProof, verifyIdentityNonceProof, verifyMostRecentShieldedAnchorProof, verifyShieldedAnchorsProof, verifyShieldedEncryptedNotesProof, verifyShieldedNotesCountProof, verifyShieldedNullifiersProof, verifyShieldedPoolStateProof, verifySignatureDigest, verifyStateTransitionResult, verifyTokenBalancesForIdentitiesProof, verifyTokenContractInfoProof, verifyTokenDirectPurchasePrices, verifyTokensBalancesForIdentityProof, verifyTokenTotalSupplyProof, verifyTotalCreditsProof, verifyVotePollVoteStateProof, ActionTakerNAPI, AddressCreditWithdrawalTransitionNAPI, AddressFundingFromAssetLockTransitionNAPI, AddressFundsFeeStrategyStepNAPI, AddressFundsTransferTransitionNAPI, AddressWitnessNAPI, AssetLockProofNAPI, AssetLockValueNAPI, AuthorizedActionTakersNAPI, BatchedTransitionNAPI, BatchTransitionNAPI, BlockBasedDistributionNAPI, BlockInfoNAPI, ChainAssetLockProofNAPI, ChangeControlRulesNAPI, CommitmentTreeNAPI, ConsensusErrorNAPI, ContenderWithSerializedDocumentNAPI, ContestedDocumentVotePollQueryExecutionResultNAPI, ContractBoundsNAPI, CoreScriptNAPI, DataContractCreateTransitionNAPI, DataContractNAPI, DataContractUpdateTransitionNAPI, DistributionFunctionNAPI, DocumentBaseTransitionNAPI, DocumentCreateTransitionNAPI, DocumentDeleteTransitionNAPI, DocumentNAPI, DocumentPurchaseTransitionNAPI, DocumentReplaceTransitionNAPI, DocumentTransferTransitionNAPI, DocumentTransitionNAPI, DocumentUpdatePriceTransitionNAPI, DynamicValue, EpochBasedDistributionNAPI, ExtendedEpochInfoNAPI, GroupNAPI, GroupStateTransitionInfoNAPI, IdentifierNAPI, IdentityCreateFromAddressesTransitionNAPI, IdentityCreateFromShieldedPoolResultNAPI, IdentityCreateFromShieldedPoolTransitionNAPI, IdentityCreateTransitionNAPI, IdentityCreditTransferNAPI, IdentityCreditTransferToAddressesTransitionNAPI, IdentityCreditWithdrawalTransitionNAPI, IdentityNAPI, IdentityPublicKeyInCreationNAPI, IdentityPublicKeyNAPI, IdentityTokenBalanceNAPI, IdentityTokenBalanceOptionalNAPI, IdentityTokenInfoNAPI, IdentityTopUpFromAddressesTransitionNAPI, IdentityTopUpTransitionNAPI, IdentityUpdateTransitionNAPI, InputAddressNAPI, InstantAssetLockProofNAPI, InstantLockNAPI, MasternodeVoteTransitionNAPI, MerklePathNAPI, NoteNAPI, OrchardAddressNAPI, OrchardProverNAPI, OutPointNAPI, OutputAddressNAPI, OutputAddressNullableCreditsNAPI, PartialIdentityNAPI, PlatformAddressInfoNAPI, PlatformAddressNAPI, PrefundedVotingBalanceNAPI, PrivateEncryptedNoteNAPI, PrivateKeyNAPI, PublicKeyNAPI, RecoveredNoteNAPI, ResourceVoteChoiceNAPI, RewardDistributionTypeNAPI, SerializedActionNAPI, SharedEncryptedNoteNAPI, ShieldedBuilderNAPI, ShieldedMemoNAPI, ShieldedTransferTransitionNAPI, ShieldedWithdrawalResultNAPI, ShieldedWithdrawalTransitionNAPI, ShieldFromAssetLockTransitionNAPI, ShieldTransitionNAPI, SpendableNoteNAPI, StateTransitionNAPI, StoredAssetLockInfoNAPI, TimeBasedDistributionNAPI, TokenBaseTransitionNAPI, TokenBurnTransitionNAPI, TokenClaimTransitionNAPI, TokenConfigUpdateTransitionNAPI, TokenConfigurationChangeItemNAPI, TokenConfigurationConventionNAPI, TokenConfigurationLocalizationNAPI, TokenConfigurationNAPI, TokenContractInfoNAPI, TokenDestroyFrozenFundsTransitionNAPI, TokenDirectPurchaseTransitionNAPI, TokenDistributionRecipientNAPI, TokenDistributionRulesNAPI, TokenEmergencyActionTransitionNAPI, TokenFreezeTransitionNAPI, TokenKeepsHistoryRulesNAPI, TokenMarketplaceRulesNAPI, TokenMintTransitionNAPI, TokenPaymentInfoNAPI, TokenPerpetualDistributionNAPI, TokenPreProgrammedDistributionNAPI, TokenPricingScheduleNAPI, TokenSetPriceForDirectPurchaseTransitionNAPI, TokenStatusNAPI, TokenTradeModeNAPI, TokenTransferTransitionNAPI, TokenTransitionNAPI, TokenUnFreezeTransitionNAPI, TotalSingleTokenBalanceNAPI, TransactionNAPI, TxInNAPI, TxOutNAPI, UnshieldTransitionNAPI, VerifiedBalanceTransferNAPI, VerifiedContractNAPI, VerifiedDocumentNAPI, VerifiedDocumentsNAPI, VerifiedEpochsInfoNAPI, VerifiedIdentifierByNonUniquePublicKeyHashNAPI, VerifiedIdentityBalanceRootHashNAPI, VerifiedIdentityByIdentifierNAPI, VerifiedIdentityByUniqueKeyHashNAPI, VerifiedIdentityContractNonceNAPI, VerifiedIdentityFullWithAddressInfosNAPI, VerifiedIdentityKeysByIdentifierNAPI, VerifiedIdentityNonceNAPI, VerifiedIdentityTokenInfoNAPI, VerifiedIdentityWithAddressInfosNAPI, VerifiedMostRecentShieldedAnchorNAPI, VerifiedPlatformAddressesInfosNAPI, VerifiedPlatformAddressInfoNAPI, VerifiedShieldedAnchorsNAPI, VerifiedShieldedEncryptedNoteNAPI, VerifiedShieldedEncryptedNotesNAPI, VerifiedShieldedNotesCountNAPI, VerifiedShieldedNullifierNAPI, VerifiedShieldedNullifiersNAPI, VerifiedShieldedPoolStateNAPI, VerifiedStateTransitionResultNAPI, VerifiedTokenBalancesForIdentitiesNAPI, VerifiedTokenContractInfoNAPI, VerifiedTokenDirectPurchasePricesNAPI, VerifiedTokenGroupActionWithDocumentNAPI, VerifiedTokenGroupActionWithTokenBalanceNAPI, VerifiedTokenGroupActionWithTokenIdentityInfoNAPI, VerifiedTokenGroupActionWithTokenPricingScheduleNAPI, VerifiedTokenPricingScheduleNAPI, VerifiedTokensBalancesForIdentityNAPI, VerifiedTokenTotalSupplyNAPI, VerifiedTotalCreditsNAPI, VerifiedVoteStateNAPI, VoteNAPI, VotePollNAPI, WitnessNAPI, ActionGoalNAPI, AssetLockProofTypeNAPI, BatchTypeNAPI, GasFeesPaidByNAPI, GroupActionStatusNAPI, KeyTypeNAPI, NetworkNAPI, PlatformVersionNAPI, PoolingNAPI, PurposeNAPI, SecurityLevelNAPI, TokenDistributionTypeNAPI, TokenEmergencyActionNAPI, VoteStateResultTypeNAPI } = protocol.default;

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

@@ -117,3 +117,20 @@ export { verifyTokenTotalSupplyProof } from './verify/Tokens/verifyTokenTotalSup
 export { verifyTokensBalancesForIdentityProof } from './verify/Tokens/verifyTokensBalancesForIdentityProof.js';
 export { verifyPlatformAddressInfo } from './verify/PlatformAddress/verifyPlatformAddressInfo.js';
 export { verifyPlatformAddressesInfos } from './verify/PlatformAddress/verifyPlatformAddressesInfos.js';
+export { verifyShieldedEncryptedNotesProof } from './verify/Shielded/verifyShieldedEncryptedNotesProof.js';
+export { verifyShieldedAnchorsProof } from './verify/Shielded/verifyShieldedAnchorsProof.js';
+export { verifyMostRecentShieldedAnchorProof } from './verify/Shielded/verifyMostRecentShieldedAnchorProof.js';
+export { verifyShieldedPoolStateProof } from './verify/Shielded/verifyShieldedPoolStateProof.js';
+export { verifyShieldedNotesCountProof } from './verify/Shielded/verifyShieldedNotesCountProof.js';
+export { verifyShieldedNullifiersProof } from './verify/Shielded/verifyShieldedNullifiersProof.js';
+export { OrchardAddressWASM, orchardOvkFromSeed } from './structs/Orchard/OrchardAddress.js';
+export { ShieldedMemoWASM } from './structs/Orchard/ShieldedMemo.js';
+export { NoteWASM } from './structs/Orchard/Note.js';
+export { MerklePathWASM } from './structs/Orchard/MerklePath.js';
+export { SpendableNoteWASM } from './structs/Orchard/SpendableNote.js';
+export { CommitmentTreeWASM } from './structs/Orchard/CommitmentTree.js';
+export { OrchardProverWASM } from './structs/Orchard/OrchardProver.js';
+export { ShieldedWithdrawalResultWASM } from './structs/Orchard/ShieldedWithdrawalResult.js';
+export { RecoveredNoteWASM, recoverNotes } from './structs/Orchard/RecoveredNote.js';
+export { ShieldedBuilderWASM } from './structs/Orchard/ShieldedBuilder.js';
+export { IdentityCreateFromShieldedPoolResultWASM } from './structs/Orchard/IdentityCreateFromShieldedPoolResult.js';

package/dist/src/dpp/dpp.js

@@ -117,3 +117,20 @@ export { verifyTokenTotalSupplyProof } from './verify/Tokens/verifyTokenTotalSup
 export { verifyTokensBalancesForIdentityProof } from './verify/Tokens/verifyTokensBalancesForIdentityProof.js';
 export { verifyPlatformAddressInfo } from './verify/PlatformAddress/verifyPlatformAddressInfo.js';
 export { verifyPlatformAddressesInfos } from './verify/PlatformAddress/verifyPlatformAddressesInfos.js';
+export { verifyShieldedEncryptedNotesProof } from './verify/Shielded/verifyShieldedEncryptedNotesProof.js';
+export { verifyShieldedAnchorsProof } from './verify/Shielded/verifyShieldedAnchorsProof.js';
+export { verifyMostRecentShieldedAnchorProof } from './verify/Shielded/verifyMostRecentShieldedAnchorProof.js';
+export { verifyShieldedPoolStateProof } from './verify/Shielded/verifyShieldedPoolStateProof.js';
+export { verifyShieldedNotesCountProof } from './verify/Shielded/verifyShieldedNotesCountProof.js';
+export { verifyShieldedNullifiersProof } from './verify/Shielded/verifyShieldedNullifiersProof.js';
+export { OrchardAddressWASM, orchardOvkFromSeed } from './structs/Orchard/OrchardAddress.js';
+export { ShieldedMemoWASM } from './structs/Orchard/ShieldedMemo.js';
+export { NoteWASM } from './structs/Orchard/Note.js';
+export { MerklePathWASM } from './structs/Orchard/MerklePath.js';
+export { SpendableNoteWASM } from './structs/Orchard/SpendableNote.js';
+export { CommitmentTreeWASM } from './structs/Orchard/CommitmentTree.js';
+export { OrchardProverWASM } from './structs/Orchard/OrchardProver.js';
+export { ShieldedWithdrawalResultWASM } from './structs/Orchard/ShieldedWithdrawalResult.js';
+export { RecoveredNoteWASM, recoverNotes } from './structs/Orchard/RecoveredNote.js';
+export { ShieldedBuilderWASM } from './structs/Orchard/ShieldedBuilder.js';
+export { IdentityCreateFromShieldedPoolResultWASM } from './structs/Orchard/IdentityCreateFromShieldedPoolResult.js';

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

@@ -11,6 +11,9 @@ export class IdentifierWASM {
             const id = new dpp.DynamicValue(rawId);
             this._rawIdentifier = new dpp.IdentifierNAPI(id);
         }
+        else if (rawId instanceof dpp.IdentifierNAPI) {
+            this._rawIdentifier = rawId;
+        }
         else {
             throw new Error('Invalid raw ID');
         }

package/dist/src/dpp/structs/Orchard/CommitmentTree.d.ts

@@ -0,0 +1,14 @@
+import type { CommitmentTreeNAPI } from '../../../../binaries/bindingsTypes.js';
+import { MerklePathWASM } from './MerklePath.js';
+export declare class CommitmentTreeWASM {
+    /** @private **/
+    _rawCommitmentTree: CommitmentTreeNAPI;
+    constructor(maxCheckpoints?: number);
+    /** Appends a note commitment (cmx). `marked` = spendable (can be witnessed). */
+    append(cmx: Uint8Array, marked: boolean): void;
+    checkpoint(checkpointId: number): boolean;
+    maxLeafPosition(): number | null;
+    witness(position: number, checkpointDepth?: number): MerklePathWASM | null;
+    anchor(): Uint8Array;
+    static createFromRawInstance(rawInstance: CommitmentTreeNAPI): CommitmentTreeWASM;
+}

package/dist/src/dpp/structs/Orchard/CommitmentTree.js

@@ -0,0 +1,31 @@
+import { dppProvider } from '../../provider.js';
+import { MerklePathWASM } from './MerklePath.js';
+export class CommitmentTreeWASM {
+    /** @private **/
+    _rawCommitmentTree;
+    constructor(maxCheckpoints) {
+        this._rawCommitmentTree = new dppProvider.dpp.CommitmentTreeNAPI(maxCheckpoints);
+    }
+    /** Appends a note commitment (cmx). `marked` = spendable (can be witnessed). */
+    append(cmx, marked) {
+        this._rawCommitmentTree.append(cmx, marked);
+    }
+    checkpoint(checkpointId) {
+        return this._rawCommitmentTree.checkpoint(checkpointId);
+    }
+    maxLeafPosition() {
+        return this._rawCommitmentTree.maxLeafPosition();
+    }
+    witness(position, checkpointDepth) {
+        const path = this._rawCommitmentTree.witness(position, checkpointDepth);
+        return path != null ? MerklePathWASM.createFromRawInstance(path) : null;
+    }
+    anchor() {
+        return this._rawCommitmentTree.anchor();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(CommitmentTreeWASM.prototype);
+        instance._rawCommitmentTree = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Orchard/IdentityCreateFromShieldedPoolResult.d.ts

@@ -0,0 +1,21 @@
+import type { IdentityCreateFromShieldedPoolResultNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { SerializedActionWASM } from '../ShieldedTransitions/SerializedAction.js';
+/**
+ * Result of `identityCreateFromShieldedPool`: the new identity's keys (with
+ * proof-of-possession signatures), the proven Orchard bundle fields, the derived
+ * identity id, and the client-predicted fee.
+ */
+export declare class IdentityCreateFromShieldedPoolResultWASM {
+    /** @private **/
+    _rawIdentityCreateFromShieldedPoolResult: IdentityCreateFromShieldedPoolResultNAPI;
+    get publicKeys(): IdentityPublicKeyInCreationWASM[];
+    get identityId(): IdentifierWASM;
+    get predictedFee(): bigint;
+    get actions(): SerializedActionWASM[];
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    static createFromRawInstance(rawInstance: IdentityCreateFromShieldedPoolResultNAPI): IdentityCreateFromShieldedPoolResultWASM;
+}

package/dist/src/dpp/structs/Orchard/IdentityCreateFromShieldedPoolResult.js

@@ -0,0 +1,38 @@
+import { IdentifierWASM } from '../Identifier.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { SerializedActionWASM } from '../ShieldedTransitions/SerializedAction.js';
+/**
+ * Result of `identityCreateFromShieldedPool`: the new identity's keys (with
+ * proof-of-possession signatures), the proven Orchard bundle fields, the derived
+ * identity id, and the client-predicted fee.
+ */
+export class IdentityCreateFromShieldedPoolResultWASM {
+    /** @private **/
+    _rawIdentityCreateFromShieldedPoolResult;
+    get publicKeys() {
+        return this._rawIdentityCreateFromShieldedPoolResult.publicKeys.map(IdentityPublicKeyInCreationWASM.createFromRawInstance);
+    }
+    get identityId() {
+        return new IdentifierWASM(this._rawIdentityCreateFromShieldedPoolResult.identityId);
+    }
+    get predictedFee() {
+        return BigInt(this._rawIdentityCreateFromShieldedPoolResult.predictedFee);
+    }
+    get actions() {
+        return this._rawIdentityCreateFromShieldedPoolResult.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    get anchor() {
+        return this._rawIdentityCreateFromShieldedPoolResult.anchor;
+    }
+    get proof() {
+        return this._rawIdentityCreateFromShieldedPoolResult.proof;
+    }
+    get bindingsSignature() {
+        return this._rawIdentityCreateFromShieldedPoolResult.bindingsSignature;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityCreateFromShieldedPoolResultWASM.prototype);
+        instance._rawIdentityCreateFromShieldedPoolResult = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Orchard/MerklePath.d.ts

@@ -0,0 +1,11 @@
+import type { MerklePathNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class MerklePathWASM {
+    /** @private **/
+    _rawMerklePath: MerklePathNAPI;
+    constructor(position: number, authPath: Uint8Array[]);
+    get position(): number;
+    set position(value: number);
+    get authPath(): Uint8Array[];
+    set authPath(value: Uint8Array[]);
+    static createFromRawInstance(rawInstance: MerklePathNAPI): MerklePathWASM;
+}

package/dist/src/dpp/structs/Orchard/MerklePath.js

@@ -0,0 +1,25 @@
+import { dppProvider } from '../../provider.js';
+export class MerklePathWASM {
+    /** @private **/
+    _rawMerklePath;
+    constructor(position, authPath) {
+        this._rawMerklePath = new dppProvider.dpp.MerklePathNAPI(position, authPath);
+    }
+    get position() {
+        return this._rawMerklePath.position;
+    }
+    set position(value) {
+        this._rawMerklePath.position = value;
+    }
+    get authPath() {
+        return this._rawMerklePath.authPath;
+    }
+    set authPath(value) {
+        this._rawMerklePath.authPath = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(MerklePathWASM.prototype);
+        instance._rawMerklePath = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Orchard/Note.d.ts

@@ -0,0 +1,18 @@
+import type { NoteNAPI } from '../../../../binaries/bindingsTypes.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+export declare class NoteWASM {
+    /** @private **/
+    _rawNote: NoteNAPI;
+    constructor(address: OrchardAddressWASM, value: bigint, rho: Uint8Array, rseed: Uint8Array);
+    get address(): OrchardAddressWASM;
+    set address(value: OrchardAddressWASM);
+    get value(): bigint;
+    set value(value: bigint);
+    get rho(): Uint8Array;
+    set rho(value: Uint8Array);
+    get rseed(): Uint8Array;
+    set rseed(value: Uint8Array);
+    /** The note commitment (cmx, 32 bytes) — its leaf in the commitment tree. */
+    get cmx(): Uint8Array;
+    static createFromRawInstance(rawInstance: NoteNAPI): NoteWASM;
+}

package/dist/src/dpp/structs/Orchard/Note.js

@@ -0,0 +1,42 @@
+import { dppProvider } from '../../provider.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+export class NoteWASM {
+    /** @private **/
+    _rawNote;
+    constructor(address, value, rho, rseed) {
+        this._rawNote = new dppProvider.dpp.NoteNAPI(address._rawOrchardAddress, value.toString(), rho, rseed);
+    }
+    get address() {
+        return OrchardAddressWASM.createFromRawInstance(this._rawNote.address);
+    }
+    set address(value) {
+        this._rawNote.address = value._rawOrchardAddress;
+    }
+    get value() {
+        return BigInt(this._rawNote.value);
+    }
+    set value(value) {
+        this._rawNote.value = value.toString();
+    }
+    get rho() {
+        return this._rawNote.rho;
+    }
+    set rho(value) {
+        this._rawNote.rho = value;
+    }
+    get rseed() {
+        return this._rawNote.rseed;
+    }
+    set rseed(value) {
+        this._rawNote.rseed = value;
+    }
+    /** The note commitment (cmx, 32 bytes) — its leaf in the commitment tree. */
+    get cmx() {
+        return this._rawNote.cmx;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(NoteWASM.prototype);
+        instance._rawNote = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Orchard/OrchardAddress.d.ts

@@ -0,0 +1,15 @@
+import type { OrchardAddressNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NetworkLike } from '../../types.js';
+export declare class OrchardAddressWASM {
+    /** @private **/
+    _rawOrchardAddress: OrchardAddressNAPI;
+    toBech32m(network: NetworkLike): string;
+    bytes(): Uint8Array;
+    static fromBech32m(bech32m: string): OrchardAddressWASM;
+    static fromBytes(bytes: Uint8Array): OrchardAddressWASM;
+    /** Derives the address from a BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). */
+    static fromSeed(seed: Uint8Array, coinType: number, account: number, diversifierIndex?: number): OrchardAddressWASM;
+    static createFromRawInstance(rawInstance: OrchardAddressNAPI): OrchardAddressWASM;
+}
+/** Derives the sender's Orchard outgoing viewing key (32 bytes) from a BIP-39 seed. */
+export declare function orchardOvkFromSeed(seed: Uint8Array, coinType: number, account: number): Uint8Array;

package/dist/src/dpp/structs/Orchard/OrchardAddress.js

@@ -0,0 +1,31 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export class OrchardAddressWASM {
+    /** @private **/
+    _rawOrchardAddress;
+    toBech32m(network) {
+        return this._rawOrchardAddress.toBech32m(valueToDynamicValue(network));
+    }
+    bytes() {
+        return this._rawOrchardAddress.bytes();
+    }
+    static fromBech32m(bech32m) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromBech32m(bech32m));
+    }
+    static fromBytes(bytes) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromBytes(bytes));
+    }
+    /** Derives the address from a BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). */
+    static fromSeed(seed, coinType, account, diversifierIndex) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromSeed(seed, coinType, account, diversifierIndex));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(OrchardAddressWASM.prototype);
+        instance._rawOrchardAddress = rawInstance;
+        return instance;
+    }
+}
+/** Derives the sender's Orchard outgoing viewing key (32 bytes) from a BIP-39 seed. */
+export function orchardOvkFromSeed(seed, coinType, account) {
+    return dppProvider.dpp.orchardOvkFromSeed(seed, coinType, account);
+}

package/dist/src/dpp/structs/Orchard/OrchardProver.d.ts

@@ -0,0 +1,12 @@
+import type { OrchardProverNAPI } from '../../../../binaries/bindingsTypes.js';
+/**
+ * Reusable Orchard prover holding the Halo 2 proving key. Building it is
+ * expensive (~seconds); construct once and reuse. (The `ShieldedBuilderWASM`
+ * already builds its own prover internally — this is exposed for standalone use.)
+ */
+export declare class OrchardProverWASM {
+    /** @private **/
+    _rawOrchardProver: OrchardProverNAPI;
+    constructor();
+    static createFromRawInstance(rawInstance: OrchardProverNAPI): OrchardProverWASM;
+}

package/dist/src/dpp/structs/Orchard/OrchardProver.js

@@ -0,0 +1,18 @@
+import { dppProvider } from '../../provider.js';
+/**
+ * Reusable Orchard prover holding the Halo 2 proving key. Building it is
+ * expensive (~seconds); construct once and reuse. (The `ShieldedBuilderWASM`
+ * already builds its own prover internally — this is exposed for standalone use.)
+ */
+export class OrchardProverWASM {
+    /** @private **/
+    _rawOrchardProver;
+    constructor() {
+        this._rawOrchardProver = new dppProvider.dpp.OrchardProverNAPI();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(OrchardProverWASM.prototype);
+        instance._rawOrchardProver = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Orchard/RecoveredNote.d.ts

@@ -0,0 +1,18 @@
+import type { RecoveredNoteNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NoteWASM } from './Note.js';
+import { SerializedActionWASM } from '../ShieldedTransitions/SerializedAction.js';
+/** A note recovered from a shielded action by trial-decryption. */
+export declare class RecoveredNoteWASM {
+    /** @private **/
+    _rawRecoveredNote: RecoveredNoteNAPI;
+    /** The action's global leaf position in the commitment tree. */
+    get index(): number;
+    get note(): NoteWASM;
+    static createFromRawInstance(rawInstance: RecoveredNoteNAPI): RecoveredNoteWASM;
+}
+/**
+ * Recovers your own notes from a set of shielded actions by trial-decrypting
+ * each with the viewing key derived from `seed` (ZIP-32 m/32'/coinType'/account').
+ * Only actions addressed to you are returned; `index` is the global leaf position.
+ */
+export declare function recoverNotes(actions: SerializedActionWASM[], seed: Uint8Array, coinType: number, account: number): RecoveredNoteWASM[];

package/dist/src/dpp/structs/Orchard/RecoveredNote.js

@@ -0,0 +1,29 @@
+import { dppProvider } from '../../provider.js';
+import { NoteWASM } from './Note.js';
+/** A note recovered from a shielded action by trial-decryption. */
+export class RecoveredNoteWASM {
+    /** @private **/
+    _rawRecoveredNote;
+    /** The action's global leaf position in the commitment tree. */
+    get index() {
+        return this._rawRecoveredNote.index;
+    }
+    get note() {
+        return NoteWASM.createFromRawInstance(this._rawRecoveredNote.note);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(RecoveredNoteWASM.prototype);
+        instance._rawRecoveredNote = rawInstance;
+        return instance;
+    }
+}
+/**
+ * Recovers your own notes from a set of shielded actions by trial-decrypting
+ * each with the viewing key derived from `seed` (ZIP-32 m/32'/coinType'/account').
+ * Only actions addressed to you are returned; `index` is the global leaf position.
+ */
+export function recoverNotes(actions, seed, coinType, account) {
+    return dppProvider.dpp
+        .recoverNotes(actions.map(a => a._rawSerializedAction), seed, coinType, account)
+        .map(RecoveredNoteWASM.createFromRawInstance);
+}

package/dist/src/dpp/structs/Orchard/ShieldedBuilder.d.ts

@@ -0,0 +1,40 @@
+import type { PlatformVersionNAPI, ShieldedBuilderNAPI } from '../../../../binaries/bindingsTypes.js';
+import { PlatformAddressLike, PoolingLike } from '../../types.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+import { ShieldedMemoWASM } from './ShieldedMemo.js';
+import { SpendableNoteWASM } from './SpendableNote.js';
+import { ShieldedWithdrawalResultWASM } from './ShieldedWithdrawalResult.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { PrivateKeyWASM } from '../PrivateKey.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+import { InputAddressWASM } from '../AddressTransitions/entities/InputAddress.js';
+import { AddressFundsFeeStrategyStepWASM } from '../AddressTransitions/entities/AddressFundsFeeStrategyStep.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { IdentityCreateFromShieldedPoolResultWASM } from './IdentityCreateFromShieldedPoolResult.js';
+/**
+ * Builds and proves shielded (Orchard) state transitions. Construction builds
+ * the Halo 2 proving key (~seconds), so create one instance and reuse it.
+ *
+ * Deposits (`shield`, `shieldFromAssetLock`) don't need pool notes. Spends
+ * (`shieldedWithdrawal`, `unshield`, `shieldedTransfer`) need a `SpendableNote`
+ * witnessed against an on-chain anchor — rebuild the tree from the full pool
+ * note set (getShieldedEncryptedNotes) with `CommitmentTreeWASM`.
+ */
+export declare class ShieldedBuilderWASM {
+    /** @private **/
+    _rawShieldedBuilder: ShieldedBuilderNAPI;
+    constructor();
+    /** Asset lock -> pool (deposit). */
+    shieldFromAssetLock(recipient: OrchardAddressWASM, shieldAmount: bigint, assetLockProof: AssetLockProofWASM, privateKey: PrivateKeyWASM, memo: ShieldedMemoWASM, dummyOutputs: number, senderOvk?: Uint8Array, surplusOutput?: PlatformAddressLike, platformVersion?: PlatformVersionNAPI): StateTransitionWASM;
+    /** Transparent platform addresses -> pool (deposit). One private key per input. */
+    shield(recipient: OrchardAddressWASM, shieldAmount: bigint, inputs: InputAddressWASM[], privateKeys: PrivateKeyWASM[], feeStrategy: AddressFundsFeeStrategyStepWASM[], userFeeIncrease: number, memo: ShieldedMemoWASM, senderOvk?: Uint8Array, platformVersion?: PlatformVersionNAPI): StateTransitionWASM;
+    /** Pool -> core L1 (spend). */
+    shieldedWithdrawal(spends: SpendableNoteWASM[], withdrawalAmount: bigint, outputScript: CoreScriptWASM, coreFeePerByte: number, pooling: PoolingLike, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): ShieldedWithdrawalResultWASM;
+    /** Pool -> platform identity balance (spend). */
+    unshield(spends: SpendableNoteWASM[], outputAddress: PlatformAddressLike, unshieldAmount: bigint, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): ShieldedWithdrawalResultWASM;
+    /** Pool -> pool (spend). */
+    shieldedTransfer(spends: SpendableNoteWASM[], recipient: OrchardAddressWASM, transferAmount: bigint, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): ShieldedWithdrawalResultWASM;
+    /** Pool -> new identity (spend). One private key per public key, same order. */
+    identityCreateFromShieldedPool(publicKeys: IdentityPublicKeyInCreationWASM[], privateKeys: PrivateKeyWASM[], denomination: bigint, sendToAddressOnCreationFailure: PlatformAddressLike, spends: SpendableNoteWASM[], changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): IdentityCreateFromShieldedPoolResultWASM;
+}

package/dist/src/dpp/structs/Orchard/ShieldedBuilder.js

@@ -0,0 +1,45 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+import { ShieldedWithdrawalResultWASM } from './ShieldedWithdrawalResult.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+import { IdentityCreateFromShieldedPoolResultWASM } from './IdentityCreateFromShieldedPoolResult.js';
+/**
+ * Builds and proves shielded (Orchard) state transitions. Construction builds
+ * the Halo 2 proving key (~seconds), so create one instance and reuse it.
+ *
+ * Deposits (`shield`, `shieldFromAssetLock`) don't need pool notes. Spends
+ * (`shieldedWithdrawal`, `unshield`, `shieldedTransfer`) need a `SpendableNote`
+ * witnessed against an on-chain anchor — rebuild the tree from the full pool
+ * note set (getShieldedEncryptedNotes) with `CommitmentTreeWASM`.
+ */
+export class ShieldedBuilderWASM {
+    /** @private **/
+    _rawShieldedBuilder;
+    constructor() {
+        this._rawShieldedBuilder = new dppProvider.dpp.ShieldedBuilderNAPI();
+    }
+    /** Asset lock -> pool (deposit). */
+    shieldFromAssetLock(recipient, shieldAmount, assetLockProof, privateKey, memo, dummyOutputs, senderOvk, surplusOutput, platformVersion) {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedBuilder.shieldFromAssetLock(recipient._rawOrchardAddress, shieldAmount.toString(), assetLockProof._rawAssetLockProof, privateKey._rawPrivateKey, memo._rawShieldedMemo, dummyOutputs, senderOvk, surplusOutput != null ? preparePlatformAddressValue(surplusOutput) : undefined, platformVersion));
+    }
+    /** Transparent platform addresses -> pool (deposit). One private key per input. */
+    shield(recipient, shieldAmount, inputs, privateKeys, feeStrategy, userFeeIncrease, memo, senderOvk, platformVersion) {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedBuilder.shield(recipient._rawOrchardAddress, shieldAmount.toString(), inputs.map(i => i._rawInputAddress), privateKeys.map(k => k._rawPrivateKey), feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep), userFeeIncrease, memo._rawShieldedMemo, senderOvk, platformVersion));
+    }
+    /** Pool -> core L1 (spend). */
+    shieldedWithdrawal(spends, withdrawalAmount, outputScript, coreFeePerByte, pooling, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.shieldedWithdrawal(spends.map(s => s._rawSpendableNote), withdrawalAmount.toString(), outputScript._rawCoreScript, coreFeePerByte, valueToDynamicValue(pooling), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+    /** Pool -> platform identity balance (spend). */
+    unshield(spends, outputAddress, unshieldAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.unshield(spends.map(s => s._rawSpendableNote), preparePlatformAddressValue(outputAddress), unshieldAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+    /** Pool -> pool (spend). */
+    shieldedTransfer(spends, recipient, transferAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.shieldedTransfer(spends.map(s => s._rawSpendableNote), recipient._rawOrchardAddress, transferAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+    /** Pool -> new identity (spend). One private key per public key, same order. */
+    identityCreateFromShieldedPool(publicKeys, privateKeys, denomination, sendToAddressOnCreationFailure, spends, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return IdentityCreateFromShieldedPoolResultWASM.createFromRawInstance(this._rawShieldedBuilder.identityCreateFromShieldedPool(publicKeys.map(k => k._rawKeyInCreation), privateKeys.map(k => k._rawPrivateKey), denomination.toString(), preparePlatformAddressValue(sendToAddressOnCreationFailure), spends.map(s => s._rawSpendableNote), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+}

package/dist/src/dpp/structs/Orchard/ShieldedMemo.d.ts

@@ -0,0 +1,11 @@
+import type { ShieldedMemoNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class ShieldedMemoWASM {
+    /** @private **/
+    _rawShieldedMemo: ShieldedMemoNAPI;
+    toString(): string;
+    toBytes(): Uint8Array;
+    static empty(): ShieldedMemoWASM;
+    static fromString(value: string): ShieldedMemoWASM;
+    static other(kind: number, payload: Uint8Array): ShieldedMemoWASM;
+    static createFromRawInstance(rawInstance: ShieldedMemoNAPI): ShieldedMemoWASM;
+}

package/dist/src/dpp/structs/Orchard/ShieldedMemo.js

@@ -0,0 +1,25 @@
+import { dppProvider } from '../../provider.js';
+export class ShieldedMemoWASM {
+    /** @private **/
+    _rawShieldedMemo;
+    toString() {
+        return this._rawShieldedMemo.toString();
+    }
+    toBytes() {
+        return this._rawShieldedMemo.toBytes();
+    }
+    static empty() {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.empty());
+    }
+    static fromString(value) {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.fromString(value));
+    }
+    static other(kind, payload) {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.other(kind, payload));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedMemoWASM.prototype);
+        instance._rawShieldedMemo = rawInstance;
+        return instance;
+    }
+}