Skip to content

Commit 37ed3a8

Browse files
rg911rg911
authored
Merge branch 'master' into task/g316_expose_internal_classes
2 parents 45c1187 + 739591e commit 37ed3a8

File tree

5 files changed

+161
-66
lines changed

5 files changed

+161
-66
lines changed

‎.gitignore

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,7 @@ fabric.properties
8383
modules.xml
8484
.idea/
8585
*.ipr
86+
*.iml
8687

8788
# End of https://www.gitignore.io/api/intellij+iml
8889
dist/

‎src/core/format/RawAddress.ts

Lines changed: 3 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,6 @@ export class RawAddress {
7070
if (RawAddress.constants.sizes.addressDecoded !== decoded.length) {
7171
throw Error(`${Convert.uint8ToHex(decoded)} does not represent a valid decoded address`);
7272
}
73-
7473
return Base32.Base32Encode(decoded);
7574
}
7675

@@ -112,6 +111,9 @@ export class RawAddress {
112111
* @returns {boolean} true if the decoded address is valid, false otherwise.
113112
*/
114113
public static isValidAddress = (decoded: Uint8Array, networkType: NetworkType): boolean => {
114+
if (RawAddress.constants.sizes.addressDecoded !== decoded.length) {
115+
return false;
116+
}
115117
const signSchema = SHA3Hasher.resolveSignSchema(networkType);
116118
const hash = signSchema === SignSchema.SHA3 ? sha3_256.create() : keccak256.create();
117119
const checksumBegin = RawAddress.constants.sizes.addressDecoded - RawAddress.constants.sizes.checksum;
@@ -120,22 +122,4 @@ export class RawAddress {
120122
RawArray.copy(checksum, RawArray.uint8View(hash.arrayBuffer()), RawAddress.constants.sizes.checksum);
121123
return RawArray.deepEqual(checksum, decoded.subarray(checksumBegin));
122124
}
123-
124-
/**
125-
* Determines the validity of an encoded address string.
126-
* @param {string} encoded The encoded address string.
127-
* @param {NetworkType} networkType The network identifier.
128-
* @returns {boolean} true if the encoded address string is valid, false otherwise.
129-
*/
130-
public static isValidEncodedAddress = (encoded: string, networkType: NetworkType): boolean => {
131-
if (RawAddress.constants.sizes.addressEncoded !== encoded.length) {
132-
return false;
133-
}
134-
try {
135-
const decoded = RawAddress.stringToAddress(encoded);
136-
return RawAddress.isValidAddress(decoded, networkType);
137-
} catch (err) {
138-
return false;
139-
}
140-
}
141125
}

‎src/model/account/Address.ts

Lines changed: 47 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -13,8 +13,10 @@
1313
* See the License for the specific language governing permissions and
1414
* limitations under the License.
1515
*/
16-
import { Convert, RawAddress } from '../../core/format';
17-
import {NetworkType} from '../blockchain/NetworkType';
16+
import { Convert, RawAddress, RawArray } from '../../core/format';
17+
import { NetworkType } from '../blockchain/NetworkType';
18+
import { SHA3Hasher, SignSchema } from "../../core/crypto";
19+
import { keccak256, sha3_256 } from "js-sha3";
1820

1921
/**
2022
* The address structure describes an address with its network
@@ -30,7 +32,7 @@ export class Address {
3032
networkType: NetworkType): Address {
3133
const publicKeyUint8 = Convert.hexToUint8(publicKey);
3234
const address = RawAddress
33-
.addressToString(RawAddress.publicKeyToAddress(publicKeyUint8, networkType));
35+
.addressToString(RawAddress.publicKeyToAddress(publicKeyUint8, networkType));
3436
return new Address(address, networkType);
3537
}
3638

@@ -43,9 +45,9 @@ export class Address {
4345
public static createFromRawAddress(rawAddress: string): Address {
4446
let networkType: NetworkType;
4547
const addressTrimAndUpperCase: string = rawAddress
46-
.trim()
47-
.toUpperCase()
48-
.replace(/-/g, '');
48+
.trim()
49+
.toUpperCase()
50+
.replace(/-/g, '');
4951
if (addressTrimAndUpperCase.length !== 40) {
5052
throw new Error('Address ' + addressTrimAndUpperCase + ' has to be 40 characters long');
5153
}
@@ -65,12 +67,41 @@ export class Address {
6567

6668
/**
6769
* Create an Address from a given encoded address.
68-
* @param {string} encoded
70+
* @param {string} encoded address. Expected format: 9085215E4620D383C2DF70235B9EF7607F6A28EF6D16FD7B9C.
6971
* @return {Address}
7072
*/
7173
public static createFromEncoded(encoded: string): Address {
7274
return Address.createFromRawAddress(RawAddress
73-
.addressToString(Convert.hexToUint8(encoded)));
75+
.addressToString(Convert.hexToUint8(encoded)));
76+
}
77+
78+
79+
/**
80+
* Determines the validity of an raw address string.
81+
* @param {string} rawAddress The raw address string. Expected format SCHCZBZ6QVJAHGJTKYVPW5FBSO2IXXJQBPV5XE6P
82+
* @param {NetworkType} networkType The network identifier.
83+
* @returns {boolean} true if the raw address string is valid, false otherwise.
84+
*/
85+
public static isValidRawAddress = (rawAddress: string, networkType: NetworkType): boolean => {
86+
try {
87+
return RawAddress.isValidAddress(RawAddress.stringToAddress(rawAddress), networkType);
88+
} catch (err) {
89+
return false;
90+
}
91+
}
92+
93+
/**
94+
* Determines the validity of an encoded address string.
95+
* @param {string} encoded The encoded address string. Expected format: 9085215E4620D383C2DF70235B9EF7607F6A28EF6D16FD7B9C
96+
* @param {NetworkType} networkType The network identifier.
97+
* @returns {boolean} true if the encoded address string is valid, false otherwise.
98+
*/
99+
public static isValidEncodedAddress = (encoded: string, networkType: NetworkType): boolean => {
100+
try {
101+
return RawAddress.isValidAddress(Convert.hexToUint8(encoded), networkType);
102+
} catch (err) {
103+
return false;
104+
}
74105
}
75106

76107
/**
@@ -96,6 +127,14 @@ export class Address {
96127
return this.address;
97128
}
98129

130+
/**
131+
* Get address in the encoded format ex: NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFH.
132+
* @returns {string}
133+
*/
134+
public encoded(): string {
135+
return Convert.uint8ToHex(RawAddress.stringToAddress(this.address));
136+
}
137+
99138
/**
100139
* Get address in pretty format ex: SB3KUB-HATFCP-V7UZQL-WAQ2EU-R6SIHB-SBEOED-DDF3.
101140
* @returns {string}

‎test/core/format/RawAddress.spec.ts

Lines changed: 0 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -192,42 +192,6 @@ describe('address', () => {
192192
});
193193
});
194194

195-
describe('isValidEncodedAddress', () => {
196-
it('returns true for valid encoded address', () => {
197-
// Arrange:
198-
const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFG';
199-
200-
// Assert:
201-
expect(address.isValidEncodedAddress(encoded, NetworkType.MIJIN_TEST)).to.equal(true);
202-
});
203-
204-
it('returns false for invalid encoded address', () => {
205-
// Arrange: changed last char
206-
const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFH';
207-
208-
// Assert:
209-
expect(address.isValidEncodedAddress(encoded, NetworkType.MIJIN_TEST)).to.equal(false);
210-
});
211-
212-
it('returns false for encoded address with wrong length', () => {
213-
// Arrange: added ABC
214-
const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFGABC';
215-
216-
// Assert:
217-
expect(address.isValidEncodedAddress(encoded, NetworkType.MIJIN_TEST)).to.equal(false);
218-
});
219-
220-
it('adding leading or trailing white space invalidates encoded address', () => {
221-
// Arrange:
222-
const encoded = 'NAR3W7B4BCOZSZMFIZRYB3N5YGOUSWIYJCJ6HDFG';
223-
224-
// Assert:
225-
expect(address.isValidEncodedAddress(` \t ${encoded}`, NetworkType.MIJIN_TEST)).to.equal(false);
226-
expect(address.isValidEncodedAddress(`${encoded} \t `, NetworkType.MIJIN_TEST)).to.equal(false);
227-
expect(address.isValidEncodedAddress(` \t ${encoded} \t `, NetworkType.MIJIN_TEST)).to.equal(false);
228-
});
229-
});
230-
231195
/**
232196
* @see https://raw.githubusercontent.com/nemtech/test-vectors/master/1.test-address-nis1.json
233197
*/

‎test/model/account/Address.spec.ts

Lines changed: 110 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,13 @@
1414
* limitations under the License.
1515
*/
1616

17-
import {expect} from 'chai';
18-
import {Address} from '../../../src/model/account/Address';
19-
import {NetworkType} from '../../../src/model/blockchain/NetworkType';
17+
import { expect } from 'chai';
18+
import { Address } from '../../../src/model/account/Address';
19+
import { NetworkType } from '../../../src/model/blockchain/NetworkType';
20+
import { Convert as convert, RawAddress } from "../../../src/core/format";
21+
import { Account } from "../../../src/model/account/Account";
22+
23+
const Address_Decoded_Size = 25;
2024

2125
describe('Address', () => {
2226
const publicKey = 'c2f93346e27ce6ad1a9f8f5e3066f8326593a406bdf357acb041e2f9ab402efe'.toUpperCase();
@@ -122,4 +126,107 @@ describe('Address', () => {
122126
const compareAddress = Address.createFromRawAddress('TCTMW23D2MN5VE4AQ4TZIDZENGNOZXPRPSDRSFRF');
123127
expect(address.equals(compareAddress)).to.be.equal(false);
124128
});
129+
130+
it('It creates the address from an encoded value', () => {
131+
let encoded = '917E7E29A01014C2F300000000000000000000000000000000';
132+
const address = Address.createFromEncoded(encoded);
133+
expect(address.encoded()).to.be.equal(encoded);
134+
});
135+
136+
describe('isValidRawAddress', () => {
137+
138+
139+
it('returns true for valid address when generated', () => {
140+
// Assert:
141+
expect(Address.isValidRawAddress(Account.generateNewAccount(NetworkType.MIJIN_TEST).address.plain(), NetworkType.MIJIN_TEST)).to.equal(true);
142+
expect(Address.isValidRawAddress(Account.generateNewAccount(NetworkType.MAIN_NET).address.plain(), NetworkType.MAIN_NET)).to.equal(true);
143+
expect(Address.isValidRawAddress(Account.generateNewAccount(NetworkType.MIJIN).address.plain(), NetworkType.MIJIN)).to.equal(true);
144+
expect(Address.isValidRawAddress(Account.generateNewAccount(NetworkType.TEST_NET).address.plain(), NetworkType.TEST_NET)).to.equal(true);
145+
});
146+
147+
it('returns true for valid address', () => {
148+
// Arrange:
149+
const rawAddress = 'SCHCZBZ6QVJAHGJTKYVPW5FBSO2IXXJQBPV5XE6P';
150+
151+
// Assert:
152+
expect(Address.isValidRawAddress(rawAddress, NetworkType.MIJIN_TEST)).to.equal(true);
153+
});
154+
155+
it('returns false for address with invalid checksum', () => {
156+
// Arrange:
157+
const rawAddress = 'SCHCZBZ6QVJAHGJTKYAPW5FBSO2IXXJQBPV5XE6P';
158+
159+
// Assert:
160+
expect(Address.isValidRawAddress(rawAddress, NetworkType.MIJIN_TEST)).to.equal(false);
161+
});
162+
163+
it('returns false for address with invalid hash', () => {
164+
// Arrange:
165+
const rawAddress = 'SCHCZBZ6QVJAHGJTKYVPW5FBSO2IXXJQBPV5XE7P';
166+
167+
// Assert:
168+
expect(Address.isValidRawAddress(rawAddress, NetworkType.MIJIN_TEST)).to.equal(false);
169+
});
170+
171+
it('returns false for address with invalid prefix', () => {
172+
// Arrange:
173+
const rawAddress = 'ACHCZBZ6QVJAHGJTKYVPW5FBSO2IXXJQBPV5XE6P';
174+
175+
// Assert:
176+
expect(Address.isValidRawAddress(rawAddress, NetworkType.MIJIN_TEST)).to.equal(false);
177+
});
178+
});
179+
180+
describe('isValidEncodedAddress', () => {
181+
182+
it('returns true for valid address when generated', () => {
183+
// Assert:
184+
expect(Address.isValidEncodedAddress(Account.generateNewAccount(NetworkType.MIJIN_TEST).address.encoded(), NetworkType.MIJIN_TEST)).to.equal(true);
185+
expect(Address.isValidEncodedAddress(Account.generateNewAccount(NetworkType.MAIN_NET).address.encoded(), NetworkType.MAIN_NET)).to.equal(true);
186+
expect(Address.isValidEncodedAddress(Account.generateNewAccount(NetworkType.MIJIN).address.encoded(), NetworkType.MIJIN)).to.equal(true);
187+
expect(Address.isValidEncodedAddress(Account.generateNewAccount(NetworkType.TEST_NET).address.encoded(), NetworkType.TEST_NET)).to.equal(true);
188+
});
189+
190+
it('returns true for valid encoded address', () => {
191+
// Arrange:
192+
const encoded = '9085215E4620D383C2DF70235B9EF7507F6A28EF6D16FD7B9C';
193+
194+
// Assert:
195+
expect(Address.isValidEncodedAddress(encoded, NetworkType.MIJIN_TEST)).to.equal(true);
196+
});
197+
198+
it('returns false for invalid hex encoded address', () => {
199+
// Arrange:
200+
const encoded = 'Z085215E4620D383C2DF70235B9EF7507F6A28EF6D16FD7B9C';
201+
202+
// Assert:
203+
expect(Address.isValidEncodedAddress(encoded, NetworkType.MIJIN_TEST)).to.equal(false);
204+
});
205+
206+
it('returns false for invalid encoded address', () => {
207+
// Arrange: changed last char
208+
const encoded = '9085215E4620D383C2DF70235B9EF7507F6A28EF6D16FD7B9D';
209+
210+
// Assert:
211+
expect(Address.isValidEncodedAddress(encoded, NetworkType.MIJIN_TEST)).to.equal(false);
212+
});
213+
214+
it('returns false for encoded address with wrong length', () => {
215+
// Arrange: added ABC
216+
const encoded = '9085215E4620D383C2DF70235B9EF7607F6A28EF6D16FD7B9C';
217+
218+
// Assert:
219+
expect(Address.isValidEncodedAddress(encoded, NetworkType.MIJIN_TEST)).to.equal(false);
220+
});
221+
222+
it('adding leading or trailing white space invalidates encoded address', () => {
223+
// Arrange:
224+
const encoded = '9085215E4620D383C2DF70235B9EF7507F6A28EF6D16FD7B9C';
225+
226+
// Assert:
227+
expect(Address.isValidEncodedAddress(` \t ${encoded}`, NetworkType.MIJIN_TEST)).to.equal(false);
228+
expect(Address.isValidEncodedAddress(`${encoded} \t `, NetworkType.MIJIN_TEST)).to.equal(false);
229+
expect(Address.isValidEncodedAddress(` \t ${encoded} \t `, NetworkType.MIJIN_TEST)).to.equal(false);
230+
});
231+
});
125232
});

0 commit comments

Comments
 (0)