Skip to content

Commit 2c7b644

Browse files
rg911rg911
committed
JAV-20 Added metadata transaction service
1 parent d747838 commit 2c7b644

19 files changed

+927
-57
lines changed

‎e2e/service/MetadataTransactionService.spec.ts‎

Lines changed: 264 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,264 @@
1+
import { expect } from 'chai';
2+
import { Listener } from '../../src/infrastructure/Listener';
3+
import { MetadataHttp } from '../../src/infrastructure/MetadataHttp';
4+
import { TransactionHttp } from '../../src/infrastructure/TransactionHttp';
5+
import { Account } from '../../src/model/account/Account';
6+
import { NetworkType } from '../../src/model/blockchain/NetworkType';
7+
import { MetadataType } from '../../src/model/metadata/MetadataType';
8+
import { MosaicFlags } from '../../src/model/mosaic/MosaicFlags';
9+
import { MosaicId } from '../../src/model/mosaic/MosaicId';
10+
import { MosaicNonce } from '../../src/model/mosaic/MosaicNonce';
11+
import { NamespaceId } from '../../src/model/namespace/NamespaceId';
12+
import { AccountMetadataTransaction } from '../../src/model/transaction/AccountMetadataTransaction';
13+
import { AggregateTransaction } from '../../src/model/transaction/AggregateTransaction';
14+
import { Deadline } from '../../src/model/transaction/Deadline';
15+
import { MosaicDefinitionTransaction } from '../../src/model/transaction/MosaicDefinitionTransaction';
16+
import { MosaicMetadataTransaction } from '../../src/model/transaction/MosaicMetadataTransaction';
17+
import { NamespaceMetadataTransaction } from '../../src/model/transaction/NamespaceMetadataTransaction';
18+
import { NamespaceRegistrationTransaction } from '../../src/model/transaction/NamespaceRegistrationTransaction';
19+
import { TransactionType } from '../../src/model/transaction/TransactionType';
20+
import { UInt64 } from '../../src/model/UInt64';
21+
import { MetadataTransactionService } from '../../src/service/MetadataTransactionService';
22+
23+
describe('MetadataTransactionService', () => {
24+
const deadline = Deadline.create();
25+
const key = UInt64.fromUint(123);
26+
const newValue = 'new test value';
27+
let targetAccount: Account;
28+
let metadataHttp: MetadataHttp;
29+
let transactionHttp: TransactionHttp;
30+
let mosaicId: MosaicId;
31+
let namespaceId: NamespaceId;
32+
let config;
33+
let generationHash: string;
34+
35+
before((done) => {
36+
const path = require('path');
37+
require('fs').readFile(path.resolve(__dirname, '../conf/network.conf'), (err, data) => {
38+
if (err) {
39+
throw err;
40+
}
41+
const json = JSON.parse(data);
42+
config = json;
43+
targetAccount = Account.createFromPrivateKey(json.testAccount.privateKey, NetworkType.MIJIN_TEST);
44+
generationHash = json.generationHash;
45+
metadataHttp = new MetadataHttp(json.apiUrl);
46+
transactionHttp = new TransactionHttp(json.apiUrl);
47+
done();
48+
});
49+
});
50+
51+
/**
52+
* =========================
53+
* Setup test data
54+
* =========================
55+
*/
56+
57+
describe('MosaicDefinitionTransaction', () => {
58+
let listener: Listener;
59+
before (() => {
60+
listener = new Listener(config.apiUrl);
61+
return listener.open();
62+
});
63+
after(() => {
64+
return listener.close();
65+
});
66+
it('standalone', (done) => {
67+
const nonce = MosaicNonce.createRandom();
68+
mosaicId = MosaicId.createFromNonce(nonce, targetAccount.publicAccount);
69+
const mosaicDefinitionTransaction = MosaicDefinitionTransaction.create(
70+
Deadline.create(),
71+
nonce,
72+
mosaicId,
73+
MosaicFlags.create( true, true, true),
74+
3,
75+
UInt64.fromUint(1000),
76+
NetworkType.MIJIN_TEST,
77+
);
78+
const signedTransaction = mosaicDefinitionTransaction.signWith(targetAccount, generationHash);
79+
listener.confirmed(targetAccount.address).subscribe(() => {
80+
done();
81+
});
82+
listener.status(targetAccount.address).subscribe((error) => {
83+
console.log('Error:', error);
84+
done();
85+
});
86+
transactionHttp.announce(signedTransaction);
87+
});
88+
});
89+
90+
describe('Setup test NamespaceId', () => {
91+
let listener: Listener;
92+
before (() => {
93+
listener = new Listener(config.apiUrl);
94+
return listener.open();
95+
});
96+
after(() => {
97+
return listener.close();
98+
});
99+
it('Announce NamespaceRegistrationTransaction', (done) => {
100+
const namespaceName = 'root-test-namespace-' + Math.floor(Math.random() * 10000);
101+
const registerNamespaceTransaction = NamespaceRegistrationTransaction.createRootNamespace(
102+
Deadline.create(),
103+
namespaceName,
104+
UInt64.fromUint(9),
105+
NetworkType.MIJIN_TEST,
106+
);
107+
namespaceId = new NamespaceId(namespaceName);
108+
const signedTransaction = registerNamespaceTransaction.signWith(targetAccount, generationHash);
109+
listener.confirmed(targetAccount.address).subscribe(() => {
110+
done();
111+
});
112+
listener.status(targetAccount.address).subscribe((error) => {
113+
console.log('Error:', error);
114+
done();
115+
});
116+
transactionHttp.announce(signedTransaction);
117+
});
118+
});
119+
120+
describe('MosaicMetadataTransaction', () => {
121+
let listener: Listener;
122+
before (() => {
123+
listener = new Listener(config.apiUrl);
124+
return listener.open();
125+
});
126+
after(() => {
127+
return listener.close();
128+
});
129+
it('aggregate', (done) => {
130+
const mosaicMetadataTransaction = MosaicMetadataTransaction.create(
131+
Deadline.create(),
132+
targetAccount.publicKey,
133+
key,
134+
mosaicId,
135+
newValue.length,
136+
newValue,
137+
NetworkType.MIJIN_TEST,
138+
);
139+
140+
const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),
141+
[mosaicMetadataTransaction.toAggregate(targetAccount.publicAccount)],
142+
NetworkType.MIJIN_TEST,
143+
[],
144+
);
145+
const signedTransaction = aggregateTransaction.signWith(targetAccount, generationHash);
146+
listener.confirmed(targetAccount.address).subscribe(() => {
147+
done();
148+
});
149+
listener.status(targetAccount.address).subscribe((error) => {
150+
console.log('Error:', error);
151+
done();
152+
});
153+
transactionHttp.announce(signedTransaction);
154+
});
155+
});
156+
157+
describe('NamespaceMetadataTransaction', () => {
158+
let listener: Listener;
159+
before (() => {
160+
listener = new Listener(config.apiUrl);
161+
return listener.open();
162+
});
163+
after(() => {
164+
return listener.close();
165+
});
166+
it('aggregate', (done) => {
167+
const namespaceMetadataTransaction = NamespaceMetadataTransaction.create(
168+
Deadline.create(),
169+
targetAccount.publicKey,
170+
key,
171+
namespaceId,
172+
newValue.length,
173+
newValue,
174+
NetworkType.MIJIN_TEST,
175+
);
176+
177+
const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),
178+
[namespaceMetadataTransaction.toAggregate(targetAccount.publicAccount)],
179+
NetworkType.MIJIN_TEST,
180+
[],
181+
);
182+
const signedTransaction = aggregateTransaction.signWith(targetAccount, generationHash);
183+
listener.confirmed(targetAccount.address).subscribe(() => {
184+
done();
185+
});
186+
listener.status(targetAccount.address).subscribe((error) => {
187+
console.log('Error:', error);
188+
done();
189+
});
190+
transactionHttp.announce(signedTransaction);
191+
});
192+
});
193+
194+
/**
195+
* =========================
196+
* Test
197+
* =========================
198+
*/
199+
describe('Test new services', () => {
200+
it('should create AccountMetadataTransaction - no current metadata', (done) => {
201+
const metaDataService = new MetadataTransactionService(metadataHttp);
202+
203+
return metaDataService.createMetadataTransaction(
204+
deadline,
205+
NetworkType.MIJIN_TEST,
206+
MetadataType.Account,
207+
targetAccount.publicAccount,
208+
key.toHex(),
209+
newValue,
210+
targetAccount.publicAccount,
211+
).subscribe((transaction: AccountMetadataTransaction) => {
212+
expect(transaction.type).to.be.equal(TransactionType.ACCOUNT_METADATA_TRANSACTION);
213+
expect(transaction.scopedMetadataKey.toHex()).to.be.equal(key.toHex());
214+
expect(transaction.value).to.be.equal(newValue);
215+
expect(transaction.targetPublicKey).to.be.equal(targetAccount.publicKey);
216+
done();
217+
});
218+
});
219+
it('should create MosaicMetadataTransaction', (done) => {
220+
const metaDataService = new MetadataTransactionService(metadataHttp);
221+
222+
return metaDataService.createMetadataTransaction(
223+
deadline,
224+
NetworkType.MIJIN_TEST,
225+
MetadataType.Mosaic,
226+
targetAccount.publicAccount,
227+
key.toHex(),
228+
newValue + '1',
229+
targetAccount.publicAccount,
230+
mosaicId,
231+
).subscribe((transaction: MosaicMetadataTransaction) => {
232+
expect(transaction.type).to.be.equal(TransactionType.MOSAIC_METADATA_TRANSACTION);
233+
expect(transaction.scopedMetadataKey.toHex()).to.be.equal(key.toHex());
234+
expect(transaction.valueSizeDelta).to.be.equal(1);
235+
expect(transaction.value).to.be.equal(newValue + '1');
236+
expect(transaction.targetPublicKey).to.be.equal(targetAccount.publicKey);
237+
expect(transaction.targetMosaicId.toHex()).to.be.equal(mosaicId.toHex());
238+
done();
239+
});
240+
});
241+
it('should create NamespaceMetadataTransaction', (done) => {
242+
const metaDataService = new MetadataTransactionService(metadataHttp);
243+
244+
return metaDataService.createMetadataTransaction(
245+
deadline,
246+
NetworkType.MIJIN_TEST,
247+
MetadataType.Namespace,
248+
targetAccount.publicAccount,
249+
key.toHex(),
250+
newValue + '1',
251+
targetAccount.publicAccount,
252+
namespaceId,
253+
).subscribe((transaction: NamespaceMetadataTransaction) => {
254+
expect(transaction.type).to.be.equal(TransactionType.NAMESPACE_METADATA_TRANSACTION);
255+
expect(transaction.scopedMetadataKey.toHex()).to.be.equal(key.toHex());
256+
expect(transaction.valueSizeDelta).to.be.equal(1);
257+
expect(transaction.value).to.be.equal(newValue + '1');
258+
expect(transaction.targetPublicKey).to.be.equal(targetAccount.publicKey);
259+
expect(transaction.targetNamespaceId.toHex()).to.be.equal(namespaceId.toHex());
260+
done();
261+
});
262+
});
263+
});
264+
});

‎src/infrastructure/api/accountRoutesApi.ts‎

Lines changed: 42 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -139,7 +139,10 @@ export class AccountRoutesApi {
139139
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
140140
resolve({ response: response, body: body });
141141
} else {
142-
reject({ response: response, body: body });
142+
reject({ response: {
143+
statusCode: response.statusCode,
144+
statusMessage: response.statusMessage,
145+
}, body });
143146
}
144147
}
145148
});
@@ -195,7 +198,10 @@ export class AccountRoutesApi {
195198
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
196199
resolve({ response: response, body: body });
197200
} else {
198-
reject({ response: response, body: body });
201+
reject({ response: {
202+
statusCode: response.statusCode,
203+
statusMessage: response.statusMessage,
204+
}, body });
199205
}
200206
}
201207
});
@@ -251,8 +257,13 @@ export class AccountRoutesApi {
251257
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
252258
resolve({ response: response, body: body });
253259
} else {
254-
reject({ response: response, body: body });
260+
reject({ response: {
261+
statusCode: response.statusCode,
262+
statusMessage: response.statusMessage,
263+
}, body });
255264
}
265+
266+
reject();
256267
}
257268
});
258269
});
@@ -302,7 +313,10 @@ export class AccountRoutesApi {
302313
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
303314
resolve({ response: response, body: body });
304315
} else {
305-
reject({ response: response, body: body });
316+
reject({ response: {
317+
statusCode: response.statusCode,
318+
statusMessage: response.statusMessage,
319+
}, body });
306320
}
307321
}
308322
});
@@ -353,7 +367,10 @@ export class AccountRoutesApi {
353367
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
354368
resolve({ response: response, body: body });
355369
} else {
356-
reject({ response: response, body: body });
370+
reject({ response: {
371+
statusCode: response.statusCode,
372+
statusMessage: response.statusMessage,
373+
}, body });
357374
}
358375
}
359376
});
@@ -424,7 +441,10 @@ export class AccountRoutesApi {
424441
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
425442
resolve({ response: response, body: body });
426443
} else {
427-
reject({ response: response, body: body });
444+
reject({ response: {
445+
statusCode: response.statusCode,
446+
statusMessage: response.statusMessage,
447+
}, body });
428448
}
429449
}
430450
});
@@ -495,7 +515,10 @@ export class AccountRoutesApi {
495515
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
496516
resolve({ response: response, body: body });
497517
} else {
498-
reject({ response: response, body: body });
518+
reject({ response: {
519+
statusCode: response.statusCode,
520+
statusMessage: response.statusMessage,
521+
}, body });
499522
}
500523
}
501524
});
@@ -566,7 +589,10 @@ export class AccountRoutesApi {
566589
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
567590
resolve({ response: response, body: body });
568591
} else {
569-
reject({ response: response, body: body });
592+
reject({ response: {
593+
statusCode: response.statusCode,
594+
statusMessage: response.statusMessage,
595+
}, body });
570596
}
571597
}
572598
});
@@ -637,7 +663,10 @@ export class AccountRoutesApi {
637663
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
638664
resolve({ response: response, body: body });
639665
} else {
640-
reject({ response: response, body: body });
666+
reject({ response: {
667+
statusCode: response.statusCode,
668+
statusMessage: response.statusMessage,
669+
}, body });
641670
}
642671
}
643672
});
@@ -708,7 +737,10 @@ export class AccountRoutesApi {
708737
if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
709738
resolve({ response: response, body: body });
710739
} else {
711-
reject({ response: response, body: body });
740+
reject({ response: {
741+
statusCode: response.statusCode,
742+
statusMessage: response.statusMessage,
743+
}, body });
712744
}
713745
}
714746
});

0 commit comments

Comments
 (0)