dash-platform-sdk 1.3.0-dev.5 → 1.3.0-dev.6

package/src/voting/index.js

@@ -0,0 +1,55 @@
+import createVote from './createVote';
+import { IdentifierWASM, MasternodeVoteTransitionWASM, ResourceVoteChoiceWASM } from 'pshenmic-dpp';
+import { createVoterIdentityId } from '../utils/createVoterIdentityId';
+/**
+ * Voting controller for performing masternode votes
+ *
+ * @hideconstructor
+ */
+export class VotingController {
+    /**
+     * Creates an {IdentifierWASM} from masternode pro tx hash and voting address (public key hash)
+     *
+     * @param proTxHash {string} voter's masternode pro tx hash
+     * @param publicKeyHash {string} voter address's public key hash
+     *
+     * @return {Promise<IdentifierWASM>}
+     */
+    async createVoterIdentityId(proTxHash, publicKeyHash) {
+        return await createVoterIdentityId(proTxHash, publicKeyHash);
+    }
+    /**
+       * Creates a {VoteWASM} with all information about the vote, such as data contract id, choice, and target index
+       *
+       * @param dataContractId {DataContractWASM}
+       * @param documentTypeName {string}
+       * @param indexName {string}
+       * @param indexValues {string[]}
+       * @param choice {ResourceVoteChoice}
+       */
+    createVote(dataContractId, documentTypeName, indexName, indexValues, choice) {
+        let resourceVoteChoice;
+        if (choice === 'lock') {
+            resourceVoteChoice = ResourceVoteChoiceWASM.Lock();
+        }
+        else if (choice === 'abstain') {
+            resourceVoteChoice = ResourceVoteChoiceWASM.Abstain();
+        }
+        else {
+            resourceVoteChoice = ResourceVoteChoiceWASM.TowardsIdentity(new IdentifierWASM(choice));
+        }
+        return createVote(new IdentifierWASM(dataContractId), documentTypeName, indexName, indexValues, resourceVoteChoice);
+    }
+    /**
+       * Creates a {StateTransitionWASM} from masternoe protxhash and voter identity
+       *
+       * @param voteWASM {VoteWASM} vote instance from .createMsternodeVote() method
+       * @param proTxHash {string} pro tx hash of the masternode as hex
+       * @param voterIdentity {IdentifierWASM} voter identity identifier
+       * @param identityNonce {BigInt} identity nonce
+       */
+    createStateTransition(voteWASM, proTxHash, voterIdentity, identityNonce) {
+        const transition = new MasternodeVoteTransitionWASM(IdentifierWASM.fromHex(proTxHash), new IdentifierWASM(voterIdentity), voteWASM, identityNonce);
+        return transition.toStateTransition();
+    }
+}

package/test/unit/ContestedResources.spec.js

@@ -0,0 +1,259 @@
+import { DataContractWASM, PlatformVersionWASM, PrivateKeyWASM } from 'pshenmic-dpp';
+import stringToIndexValueBytes from '../../src/utils/stringToIndexValueBytes';
+import { DashPlatformSDK } from '../../src/DashPlatformSDK';
+import { ContestedStateResultType } from '../../src/types';
+let sdk;
+let contract;
+describe('Contested Resources', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+        contract = new DataContractWASM('11111111111111111111111111111111', BigInt(1), {
+            domain: {
+                type: 'object',
+                indices: [
+                    {
+                        name: 'parentNameAndLabel',
+                        unique: true,
+                        contested: {
+                            resolution: 0,
+                            description: 'If the normalized label part of this index is less than 20 characters (all alphabet a-z, A-Z, 0, 1, and -) then a masternode vote contest takes place to give out the name',
+                            fieldMatches: [
+                                {
+                                    field: 'normalizedLabel',
+                                    regexPattern: '^[a-zA-Z01-]{3,19}$'
+                                }
+                            ]
+                        },
+                        properties: [
+                            {
+                                normalizedParentDomainName: 'asc'
+                            },
+                            {
+                                normalizedLabel: 'asc'
+                            }
+                        ]
+                    },
+                    {
+                        name: 'identityId',
+                        properties: [
+                            {
+                                'records.identity': 'asc'
+                            }
+                        ],
+                        nullSearchable: false
+                    }
+                ],
+                $comment: "In order to register a domain you need to create a preorder. The preorder step is needed to prevent man-in-the-middle attacks. normalizedLabel + '.' + normalizedParentDomain must not be longer than 253 chars length as defined by RFC 1035. Domain documents are immutable: modification and deletion are restricted",
+                required: [
+                    '$createdAt',
+                    '$updatedAt',
+                    '$transferredAt',
+                    'label',
+                    'normalizedLabel',
+                    'normalizedParentDomainName',
+                    'preorderSalt',
+                    'records',
+                    'subdomainRules'
+                ],
+                tradeMode: 1,
+                transient: [
+                    'preorderSalt'
+                ],
+                properties: {
+                    label: {
+                        type: 'string',
+                        pattern: '^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]$',
+                        position: 0,
+                        maxLength: 63,
+                        minLength: 3,
+                        description: "Domain label. e.g. 'Bob'."
+                    },
+                    records: {
+                        type: 'object',
+                        position: 5,
+                        properties: {
+                            identity: {
+                                type: 'array',
+                                maxItems: 32,
+                                minItems: 32,
+                                position: 1,
+                                byteArray: true,
+                                description: 'Identifier name record that refers to an Identity',
+                                contentMediaType: 'application/x.dash.dpp.identifier'
+                            }
+                        },
+                        minProperties: 1,
+                        additionalProperties: false
+                    },
+                    preorderSalt: {
+                        type: 'array',
+                        maxItems: 32,
+                        minItems: 32,
+                        position: 4,
+                        byteArray: true,
+                        description: 'Salt used in the preorder document'
+                    },
+                    subdomainRules: {
+                        type: 'object',
+                        position: 6,
+                        required: [
+                            'allowSubdomains'
+                        ],
+                        properties: {
+                            allowSubdomains: {
+                                type: 'boolean',
+                                $comment: 'Only the domain owner is allowed to create subdomains for non top-level domains',
+                                position: 0,
+                                description: 'This option defines who can create subdomains: true - anyone; false - only the domain owner'
+                            }
+                        },
+                        description: 'Subdomain rules allow domain owners to define rules for subdomains',
+                        additionalProperties: false
+                    },
+                    normalizedLabel: {
+                        type: 'string',
+                        pattern: '^[a-hj-km-np-z0-9][a-hj-km-np-z0-9-]{0,61}[a-hj-km-np-z0-9]$',
+                        $comment: 'Must be equal to the label in lowercase. "o", "i" and "l" must be replaced with "0" and "1".',
+                        position: 1,
+                        maxLength: 63,
+                        description: "Domain label converted to lowercase for case-insensitive uniqueness validation. \"o\", \"i\" and \"l\" replaced with \"0\" and \"1\" to mitigate homograph attack. e.g. 'b0b'"
+                    },
+                    parentDomainName: {
+                        type: 'string',
+                        pattern: '^$|^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]$',
+                        position: 2,
+                        maxLength: 63,
+                        minLength: 0,
+                        description: "A full parent domain name. e.g. 'dash'."
+                    },
+                    normalizedParentDomainName: {
+                        type: 'string',
+                        pattern: '^$|^[a-hj-km-np-z0-9][a-hj-km-np-z0-9-\\.]{0,61}[a-hj-km-np-z0-9]$',
+                        $comment: 'Must either be equal to an existing domain or empty to create a top level domain. "o", "i" and "l" must be replaced with "0" and "1". Only the data contract owner can create top level domains.',
+                        position: 3,
+                        maxLength: 63,
+                        minLength: 0,
+                        description: "A parent domain name in lowercase for case-insensitive uniqueness validation. \"o\", \"i\" and \"l\" replaced with \"0\" and \"1\" to mitigate homograph attack. e.g. 'dash'"
+                    }
+                },
+                canBeDeleted: true,
+                transferable: 1,
+                documentsMutable: false,
+                additionalProperties: false
+            },
+            preorder: {
+                type: 'object',
+                indices: [
+                    {
+                        name: 'saltedHash',
+                        unique: true,
+                        properties: [
+                            {
+                                saltedDomainHash: 'asc'
+                            }
+                        ]
+                    }
+                ],
+                $comment: 'Preorder documents are immutable: modification and deletion are restricted',
+                required: [
+                    'saltedDomainHash'
+                ],
+                properties: {
+                    saltedDomainHash: {
+                        type: 'array',
+                        maxItems: 32,
+                        minItems: 32,
+                        position: 0,
+                        byteArray: true,
+                        description: 'Double sha-256 of the concatenation of a 32 byte random salt and a normalized domain name'
+                    }
+                },
+                canBeDeleted: true,
+                documentsMutable: false,
+                additionalProperties: false
+            }
+        }, undefined, undefined, true, PlatformVersionWASM.PLATFORM_V9);
+        contract.id = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+    });
+    test('should be able to get contested resource vote state with finishedVoteInfo', async () => {
+        const voteState = await sdk.contestedResources.getContestedResourceVoteState(contract, 'domain', 'parentNameAndLabel', [
+            'dash',
+            'asdmaye1ght'
+        ].map(stringToIndexValueBytes), ContestedStateResultType.DOCUMENTS_AND_VOTE_TALLY, true);
+        expect(voteState.finishedVoteInfo).toBeTruthy();
+        expect(voteState.contenders).toBeTruthy();
+        expect(voteState.contenders.length).toBeGreaterThan(0);
+        expect(voteState.abstainVoteTally).toBeDefined();
+        expect(voteState.lockVoteTally).toBeDefined();
+    });
+    test('should be able to get contested resource vote state for incorrect values', async () => {
+        try {
+            await sdk.contestedResources.getContestedResourceVoteState(contract, 'domain', 'parentNameAndLabel', [
+                'dash',
+                'agreatma1n'
+            ].map(stringToIndexValueBytes), ContestedStateResultType.DOCUMENTS_AND_VOTE_TALLY, false);
+        }
+        catch (e) {
+            expect(true).toBeTruthy();
+            return;
+        }
+        expect(false).toBeTruthy();
+    });
+    test('should be able to create TowardsIdentity vote', async () => {
+        const dataContactId = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+        const documentTypeName = 'domain';
+        const indexName = 'parentNameAndLabel';
+        const indexValues = ['dash', sdk.names.normalizeLabel('testidentity')];
+        const proTxHash = 'd9b090cfc19caf2e27d512e69c43812a274bdf29c081d0ade4fd272ad56a5f89';
+        const choice = 'CKKYnVeKoxCbvuEhiT6MDoQaRyXgDECwtxoKL5cqucZE';
+        const privateKey = PrivateKeyWASM.fromWIF('cPGCETHtoevguQoyTSdsowCEF91yqhrcikcvBNK2CuTwpSLV7m9Z');
+        const voterIdentifier = await sdk.voting.createVoterIdentityId(proTxHash, privateKey.getPublicKeyHash());
+        expect(voterIdentifier.base58()).toEqual('HqfLeB9PLg3t9CL25tRNkEDPjAnDaHAMmthRNe8ucn8q');
+        const voterIdentity = await sdk.identities.getIdentityByIdentifier(voterIdentifier);
+        const [identityPublicKey] = voterIdentity.getPublicKeys().filter(identityPublicKey => privateKey.getPublicKeyHash() === identityPublicKey.getPublicKeyHash());
+        const identityNonce = await sdk.identities.getIdentityNonce(voterIdentity.id);
+        const vote = sdk.voting.createVote(dataContactId, documentTypeName, indexName, indexValues, choice);
+        const stateTransition = sdk.voting.createStateTransition(vote, proTxHash, voterIdentity.id, identityNonce + BigInt(1));
+        // test key disabled
+        identityPublicKey.removeDisabledAt();
+        stateTransition.sign(privateKey, identityPublicKey);
+    });
+    test('should be able to create Abstain vote', async () => {
+        const dataContactId = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+        const documentTypeName = 'domain';
+        const indexName = 'parentNameAndLabel';
+        const indexValues = ['dash', sdk.names.normalizeLabel('testidentity')];
+        const proTxHash = 'd9b090cfc19caf2e27d512e69c43812a274bdf29c081d0ade4fd272ad56a5f89';
+        const choice = 'abstain';
+        const privateKey = PrivateKeyWASM.fromWIF('cPGCETHtoevguQoyTSdsowCEF91yqhrcikcvBNK2CuTwpSLV7m9Z');
+        const voterIdentifier = await sdk.voting.createVoterIdentityId(proTxHash, privateKey.getPublicKeyHash());
+        expect(voterIdentifier.base58()).toEqual('HqfLeB9PLg3t9CL25tRNkEDPjAnDaHAMmthRNe8ucn8q');
+        const voterIdentity = await sdk.identities.getIdentityByIdentifier(voterIdentifier);
+        const [identityPublicKey] = voterIdentity.getPublicKeys().filter(identityPublicKey => privateKey.getPublicKeyHash() === identityPublicKey.getPublicKeyHash());
+        const identityNonce = await sdk.identities.getIdentityNonce(voterIdentity.id);
+        const vote = sdk.voting.createVote(dataContactId, documentTypeName, indexName, indexValues, choice);
+        const stateTransition = sdk.voting.createStateTransition(vote, proTxHash, voterIdentity.id, identityNonce + BigInt(1));
+        // test key disabled
+        identityPublicKey.removeDisabledAt();
+        stateTransition.sign(privateKey, identityPublicKey);
+    });
+    test('should be able to create Lock vote', async () => {
+        const dataContactId = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+        const documentTypeName = 'domain';
+        const indexName = 'parentNameAndLabel';
+        const indexValues = ['dash', sdk.names.normalizeLabel('testidentity')];
+        const proTxHash = 'd9b090cfc19caf2e27d512e69c43812a274bdf29c081d0ade4fd272ad56a5f89';
+        const choice = 'lock';
+        const privateKey = PrivateKeyWASM.fromWIF('cPGCETHtoevguQoyTSdsowCEF91yqhrcikcvBNK2CuTwpSLV7m9Z');
+        const voterIdentifier = await sdk.voting.createVoterIdentityId(proTxHash, privateKey.getPublicKeyHash());
+        expect(voterIdentifier.base58()).toEqual('HqfLeB9PLg3t9CL25tRNkEDPjAnDaHAMmthRNe8ucn8q');
+        const voterIdentity = await sdk.identities.getIdentityByIdentifier(voterIdentifier);
+        const [identityPublicKey] = voterIdentity.getPublicKeys().filter(identityPublicKey => privateKey.getPublicKeyHash() === identityPublicKey.getPublicKeyHash());
+        const identityNonce = await sdk.identities.getIdentityNonce(voterIdentity.id);
+        const vote = sdk.voting.createVote(dataContactId, documentTypeName, indexName, indexValues, choice);
+        const stateTransition = sdk.voting.createStateTransition(vote, proTxHash, voterIdentity.id, identityNonce + BigInt(1));
+        // test key disabled
+        identityPublicKey.removeDisabledAt();
+        stateTransition.sign(privateKey, identityPublicKey);
+    });
+});

package/test/unit/DataContract.spec.js

@@ -0,0 +1,75 @@
+import { DataContractWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DashPlatformSDK } from '../../src/types';
+let sdk;
+let ownerIdentifier;
+let identityNonce;
+let config;
+let schema;
+describe('DataContract', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+        ownerIdentifier = 'GARSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+        identityNonce = BigInt(11);
+        config = {
+            $format_version: '0',
+            canBeDeleted: true,
+            readonly: true,
+            keepsHistory: false,
+            documentsKeepHistoryContractDefault: false,
+            documentsMutableContractDefault: false,
+            documentsCanBeDeletedContractDefault: true,
+            requiresIdentityEncryptionBoundedKey: null,
+            requiresIdentityDecryptionBoundedKey: null
+        };
+        schema = {
+            note: {
+                type: 'object',
+                properties: {
+                    author: {
+                        type: 'string',
+                        position: 1
+                    },
+                    message: {
+                        type: 'string',
+                        position: 0
+                    }
+                },
+                additionalProperties: false
+            }
+        };
+    });
+    test('should be able to get data contract', async () => {
+        let dataContract;
+        // System Data Contract
+        dataContract = await sdk.dataContracts.getDataContractByIdentifier('GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec');
+        expect(dataContract).toEqual(expect.any(DataContractWASM));
+        // User Data Contract
+        dataContract = await sdk.dataContracts.getDataContractByIdentifier('Aukz296s36am6wKStoMbxm4YhC6kTpu3mERVrC7vHokP');
+        expect(dataContract).toEqual(expect.any(DataContractWASM));
+        // User Data Contract with keep history
+        dataContract = await sdk.dataContracts.getDataContractByIdentifier('DrEhmVJz56ukHbaFt8xLVRasnNWsrx3x8dGtcu9xg6rV');
+        expect(dataContract).toEqual(expect.any(DataContractWASM));
+        // Token Data Contract
+        dataContract = await sdk.dataContracts.getDataContractByIdentifier('3XtMFe9UPf75DAcLmLsX9CLTrLPNysNPMcnWCE1C39vm');
+        expect(dataContract).toEqual(expect.any(DataContractWASM));
+    });
+    test('should be able to create data contract', async () => {
+        const dataContract = sdk.dataContracts.create(ownerIdentifier, identityNonce, schema);
+        expect(dataContract).toEqual(expect.any(DataContractWASM));
+    });
+    test('should be able to create data contract with optional params', async () => {
+        const dataContract = sdk.dataContracts.create(ownerIdentifier, identityNonce, schema, true, undefined, config);
+        expect(dataContract).toEqual(expect.any(DataContractWASM));
+        expect(dataContract.getConfig()).toEqual(config);
+    });
+    test('should be able to create data contract create transition', async () => {
+        const dataContract = sdk.dataContracts.create(ownerIdentifier, identityNonce, schema);
+        const transition = sdk.dataContracts.createStateTransition(dataContract, 'create', identityNonce);
+        expect(transition).toEqual(expect.any(StateTransitionWASM));
+    });
+    test('should be able to create data contract update transition', async () => {
+        const dataContract = sdk.dataContracts.create(ownerIdentifier, identityNonce, schema);
+        const transition = sdk.dataContracts.createStateTransition(dataContract, 'update', identityNonce);
+        expect(transition).toEqual(expect.any(StateTransitionWASM));
+    });
+});

package/test/unit/Document.spec.js

@@ -0,0 +1,109 @@
+import { DocumentWASM, GasFeesPaidByWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DashPlatformSDK } from '../../src/DashPlatformSDK';
+let sdk;
+let dataContract;
+let identity;
+let documentType;
+let revision;
+let data;
+describe('Document', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+        dataContract = '6QMfQTdKpC3Y9uWBcTwXeY3KdzRLDqASUsDnQ4MEc9XC';
+        identity = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';
+        revision = BigInt(1);
+        documentType = 'pool';
+        data = {
+            name: 'MyPool',
+            type: 'EVONODE',
+            status: 'INACTIVE',
+            description: 'test pool'
+        };
+    });
+    test('should be able to create document', async () => {
+        const document = sdk.documents.create(dataContract, documentType, data, identity, revision);
+        expect(document).toEqual(expect.any(DocumentWASM));
+    });
+    test('should be able to get documents', async () => {
+        const dataContract = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+        const documentType = 'domain';
+        const [document] = await sdk.documents.query(dataContract, documentType);
+        expect(document.createdAtBlockHeight).toEqual(undefined);
+        expect(document.dataContractId.base58()).toEqual(dataContract);
+        expect(document).toEqual(expect.any(DocumentWASM));
+    });
+    test('should be able to get document', async () => {
+        const dataContract = '6hVQW16jyvZyGSQk2YVty4ND6bgFXozizYWnPt753uW5';
+        const documentType = 'torrent';
+        const limit = 100;
+        // @ts-expect-error
+        const [document] = await sdk.documents.query(dataContract, documentType, null, null, limit);
+        expect(document.createdAtBlockHeight).toEqual(undefined);
+        expect(document.dataContractId.base58()).toEqual(dataContract);
+        expect(document).toEqual(expect.any(DocumentWASM));
+    });
+    describe('should be able to create state transition', () => {
+        test('should be able to create a create transition', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity);
+            const identityContractNonce = BigInt(1);
+            const stateTransition = sdk.documents.createStateTransition(document, 'create', { identityContractNonce });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able to create a contested document transition', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity);
+            const identityContractNonce = BigInt(1);
+            // 0.2 Dash typically
+            const contestedFee = BigInt(20000000000);
+            const indexName = 'parentNameAndLabel';
+            const prefundedVotingBalance = { indexName, amount: contestedFee };
+            const stateTransition = sdk.documents.createStateTransition(document, 'create', { identityContractNonce, prefundedVotingBalance });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able to create a document with token payment info', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity);
+            const identityContractNonce = BigInt(1);
+            const tokenPaymentInfo = {
+                tokenContractId: '6hVQW16jyvZyGSQk2YVty4ND6bgFXozizYWnPt753uW5',
+                tokenContractPosition: 0,
+                minimumTokenCost: BigInt(1000),
+                maximumTokenCost: BigInt(100000),
+                gasFeesPaidBy: GasFeesPaidByWASM.ContractOwner
+            };
+            const stateTransition = sdk.documents.createStateTransition(document, 'create', { identityContractNonce, tokenPaymentInfo });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able to create a replace transition', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity, revision + BigInt(1));
+            const identityContractNonce = BigInt(1);
+            const stateTransition = sdk.documents.createStateTransition(document, 'replace', { identityContractNonce });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able to create a delete transition', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity, revision + BigInt(1));
+            const identityContractNonce = BigInt(1);
+            const stateTransition = sdk.documents.createStateTransition(document, 'delete', { identityContractNonce });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able to create a transfer transition', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity, revision + BigInt(1));
+            const identityContractNonce = BigInt(1);
+            const recipientId = '6hVQW16jyvZyGSQk2YVty4ND6bgFXozizYWnPt753uW5';
+            const stateTransition = sdk.documents.createStateTransition(document, 'transfer', { identityContractNonce, recipientId });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able to create an updatePrice transition', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity, revision + BigInt(1));
+            const identityContractNonce = BigInt(1);
+            const price = BigInt(10000000);
+            const stateTransition = sdk.documents.createStateTransition(document, 'updatePrice', { identityContractNonce, price });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+        test('should be able to create a purchase transition', async () => {
+            const document = sdk.documents.create(dataContract, documentType, data, identity, revision + BigInt(1));
+            const identityContractNonce = BigInt(1);
+            const amount = BigInt(10000000);
+            const stateTransition = sdk.documents.createStateTransition(document, 'purchase', { identityContractNonce, amount });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        });
+    });
+});