Merge pull request #2072 from aeternity/api-docs-fixes

API docs fixes, deprecate and rename some exports

Author: davidyuk

docs/README.md

@@ -116,7 +116,7 @@ module.exports = {
 ### Vue@3
 
 Reactivity in Vue@3 [based on] Proxy class. Proxy is [not compatible] with private fields of ES
-classes. AeSdk, Contract and MemoryAccount classes uses private fields, so if you make an instance of these
+classes. AeSdk, Contract and AccountMemory classes uses private fields, so if you make an instance of these
 classes reactive then the app may fail with
 
 > TypeError: attempted to get private field on non-instance
@@ -126,7 +126,7 @@ to solve this issue we suggest to avoid making their instances reactive using
 Vue's integrated utility: [shallowRef]. The idea is to make reactive only the
 instance value, to don't make it reactive in deep.
 
-Alternatively, [toRaw] can unwrap the proxy object, returning an unmodified instance and allowing access to its private properties by its methods. It can be useful if you need a reactive array of MemoryAccount.
+Alternatively, [toRaw] can unwrap the proxy object, returning an unmodified instance and allowing access to its private properties by its methods. It can be useful if you need a reactive array of AccountMemory.
 
 You can find both approaches used in the [æpp example].
 

docs/guides/address-length.md

@@ -5,16 +5,16 @@ base58 it depends on the exact data to encode, e.g. it is shorter if encoded dat
 leading zeroes.
 
 Building an aepp you may need to know the range of possible address lengths to validate an
-user-provided addresses (though better to use [isAddressValid]) or for designs of address-related
+user-provided addresses (though better to use [isEncoded]) or for designs of address-related
 components. Doing manual tests you may conclude that account address length is between 52 and 53
 chars, but it is not correct.
 
 ```js
-import { MemoryAccount } from '@aeternity/aepp-sdk';
+import { AccountMemory } from '@aeternity/aepp-sdk';
 
 const result = new Array(10000)
   .fill()
-  .map(() => MemoryAccount.generate().address.length)
+  .map(() => AccountMemory.generate().address.length)
   .reduce((p, n) => ({ ...p, [n]: (p[n] ?? 0) + 1 }), {});
 
 console.log(result);
@@ -28,9 +28,9 @@ Theoretically there can be even shorter addresses if they lucky to be prefixed w
 sequence of `0`.
 
 ```js
-import { MemoryAccount, Encoding, encode, decode } from '@aeternity/aepp-sdk';
+import { AccountMemory, Encoding, encode, decode } from '@aeternity/aepp-sdk';
 
-const publicKey = decode(MemoryAccount.generate().address);
+const publicKey = decode(AccountMemory.generate().address);
 
 for (let i = -1; i < publicKey.length; i += 1) {
   if (i >= 0) publicKey[i] = 0;
@@ -80,5 +80,5 @@ Running the above code you would get output like
 Therefore the minimum address length is 41 chars. All these addresses valid, for example
 `ak_11111111111111111111111111111111273Yts` [used] to collect AENS name fees.
 
-[isAddressValid]: https://sdk.aeternity.io/v14.0.0/api/functions/isAddressValid.html
+[isEncoded]: https://sdk.aeternity.io/v14.1.0/api/functions/isEncoded.html
 [used]: https://mainnet.aeternity.io/v3/accounts/ak_11111111111111111111111111111111273Yts

docs/guides/contracts.md

@@ -10,9 +10,9 @@ Before interacting with contracts using the SDK you should get familiar with Sop
 
 ```js
 // node.js import
-const { AeSdk, MemoryAccount, Node } = require('@aeternity/aepp-sdk');
+const { AeSdk, AccountMemory, Node } = require('@aeternity/aepp-sdk');
 // ES import
-import { AeSdk, MemoryAccount, Node } from '@aeternity/aepp-sdk';
+import { AeSdk, AccountMemory, Node } from '@aeternity/aepp-sdk';
 // additionally you may need to import CompilerCli or CompilerHttp
 ```
 
@@ -42,7 +42,7 @@ When creating an instance of the SDK you need to provide an account which will b
 
 ```js
 const node = new Node('https://testnet.aeternity.io'); // ideally host your own node
-const account = new MemoryAccount(SECRET_KEY);
+const account = new AccountMemory(SECRET_KEY);
 
 const aeSdk = new AeSdk({
   nodes: [{ name: 'testnet', instance: node }],

docs/guides/error-handling.md

@@ -109,14 +109,14 @@ BaseError
 import {
   AeSdk,
   Node,
-  MemoryAccount,
+  AccountMemory,
   ArgumentError,
   InvalidAensNameError,
 } from '@aeternity/aepp-sdk';
 
 // setup
-const payerAccount = MemoryAccount.generate();
-const newUserAccount = MemoryAccount.generate();
+const payerAccount = AccountMemory.generate();
+const newUserAccount = AccountMemory.generate();
 const node = new Node('https://testnet.aeternity.io');
 const aeSdk = new AeSdk({
   nodes: [{ name: 'testnet', instance: node }],

docs/guides/jwt.md

@@ -5,9 +5,9 @@
 Use `signJwt` to generate a JWT signed by an account provided in arguments.
 
 ```ts
-import { MemoryAccount, signJwt } from '@aeternity/aepp-sdk';
+import { AccountMemory, signJwt } from '@aeternity/aepp-sdk';
 
-const account = MemoryAccount.generate();
+const account = AccountMemory.generate();
 const payload = { test: 'data' };
 const jwt = await signJwt(payload, account);
 ```

docs/guides/oracles.md

@@ -16,7 +16,7 @@ import { AeSdk, Oracle } from '@aeternity/aepp-sdk'
 // init an instance of the SDK using the AeSdk class
 const aeSdk = new AeSdk({ ... })
 // it should be an instance of AccountBase with non-zero balance
-const oracleAccount = new MemoryAccount(...)
+const oracleAccount = new AccountMemory(...)
 
 const oracle = new Oracle(oracleAccount, aeSdk.getContext())
 ```

docs/guides/typed-data.md

@@ -34,7 +34,7 @@ corresponds to the data
 
 ## Implementation
 
-- [AccountBase:signTypedData](https://github.com/aeternity/aepp-sdk-js/blob/568c291b92c030011ca9e68169f328be6ff79488/src/account/Base.ts#L63-L70) — calculates signature, supported in MemoryAccount and in aepp-wallet connection;
+- [AccountBase:signTypedData](https://github.com/aeternity/aepp-sdk-js/blob/568c291b92c030011ca9e68169f328be6ff79488/src/account/Base.ts#L63-L70) — calculates signature, supported in AccountMemory and in aepp-wallet connection;
 - [hashTypedData](https://github.com/aeternity/aepp-sdk-js/blob/568c291b92c030011ca9e68169f328be6ff79488/src/utils/typed-data.ts#L82-L96) — calculates the overall hash of typed data to sign;
 - [hashJson](https://github.com/aeternity/aepp-sdk-js/blob/568c291b92c030011ca9e68169f328be6ff79488/src/utils/typed-data.ts#L10-L12) — deterministic hashing of an arbitrary JS value, used to calculate `hash(aci)`;
 - [hashDomain](https://github.com/aeternity/aepp-sdk-js/blob/568c291b92c030011ca9e68169f328be6ff79488/src/utils/typed-data.ts#L56-L80) — use for debugging or to prepare the hash value for smart contract.

docs/guides/typescript.md

@@ -144,46 +144,46 @@ The problem is that TypeScript won't check if `address` is an `ak_`-encoded stri
 A more accurate solution would be to check the `address` in advance, providing user feedback if it is incorrect. For example:
 
 ```ts
-import { isAddressValid } from '@aeternity/aepp-sdk';
+import { isEncoded, Encoding } from '@aeternity/aepp-sdk';
 
-if (!isAddressValid(address)) {
+if (!isEncoded(address, Encoding.AccountAddress)) {
   alert('The address is not valid');
   return;
 }
 
 await aeSdk.spend(100, address);
 ```
 
-Please note that this method doesn't require explicit casting `string` to [`Encoded.AccountAddress`] because [`isAddressValid`] implicitly marks `address` as `ak_${string}` in case it returns `true`.
+Please note that this method doesn't require explicit casting `string` to [`Encoded.AccountAddress`] because [`isEncoded`] implicitly marks `address` as `ak_${string}` in case it returns `true`.
 
-Additionally, you can use [`isAddressValid`] to validate data against other address types:
+Additionally, you can use [`isEncoded`] to validate data against other address types:
 
 ```ts
 import { Encoding } from '@aeternity/aepp-sdk';
 
-isAddressValid(address, Encoding.ContractAddress, Encoding.OracleAddress);
+isEncoded(address, Encoding.ContractAddress, Encoding.OracleAddress);
 ```
 
 Or encoding types in general:
 
 ```ts
-isAddressValid(address, Encoding.Transaction);
+isEncoded(address, Encoding.Transaction);
 ```
 
 [`spend`]: https://sdk.aeternity.io/v14.0.0/api/functions/spend.html
 [`Encoded.AccountAddress`]: https://sdk.aeternity.io/v14.0.0/api/types/Encoded.AccountAddress.html
-[`isAddressValid`]: https://sdk.aeternity.io/v14.0.0/api/functions/isAddressValid.html
+[`isEncoded`]: https://sdk.aeternity.io/v14.0.0/api/functions/isEncoded.html
 
 ### AENS name validation
 
-The similar way [`isNameValid`] can be used
+The similar way [`isName`] can be used
 
 ```ts
-import { isNameValid } from '@aeternity/aepp-sdk';
+import { isName } from '@aeternity/aepp-sdk';
 
-console.log(isNameValid('name.chain')); // true
-console.log(isNameValid('мир.chain')); // true
-console.log(isNameValid('🙂.chain')); // false
+console.log(isName('name.chain')); // true
+console.log(isName('мир.chain')); // true
+console.log(isName('🙂.chain')); // false
 ```
 
 If you don't need to handle invalid names specially then you can use [`ensureName`]:
@@ -198,7 +198,7 @@ const name = new Name(nameAsString, options);
 
 Doing this way, [`ensureName`] will throw an exception if `nameAsString` is not a proper AENS name. TypeScript will handle `nameAsString` as `${string}.chain` in lines below [`ensureName`] invocation.
 
-[`isNameValid`]: https://sdk.aeternity.io/v14.0.0/api/functions/isNameValid.html
+[`isName`]: https://sdk.aeternity.io/v14.1.0/api/functions/isName.html
 [`ensureName`]: https://sdk.aeternity.io/v14.0.0/api/functions/ensureName.html
 
 ## Check types of contract methods

docs/quick-start.md

@@ -8,13 +8,13 @@ For more specific information on setups with Frameworks and TypeScript, please r
 For the following snippets in the guide you need to specify multiple imports.
 
 ```js
-const { AeSdk, MemoryAccount, Node, AE_AMOUNT_FORMATS } = require('@aeternity/aepp-sdk');
+const { AeSdk, AccountMemory, Node } = require('@aeternity/aepp-sdk');
 ```
 
 ## 2. Create a sender account
 
 ```js
-const sender = MemoryAccount.generate();
+const sender = AccountMemory.generate();
 console.log('Sender address:', sender.address);
 console.log('Sender secret key:', sender.secretKey);
 ```
@@ -28,12 +28,12 @@ To receive some _AE_ you can use the [Faucet](https://faucet.aepps.com/). Just p
 This example shows:
 
 - how to create an instance of the SDK using the `AeSdk` class
-- how to spend (send) 1 AE from the account the SDK instance was initialized with to some other AE address
+- how to spend (send) 1 _AE_ from the account the SDK instance was initialized with to some other AE address
 
 ```js
 const NODE_URL = 'https://testnet.aeternity.io';
 // replace <SENDER_SECRET_KEY> with the generated secretKey from step 2
-const sender = new MemoryAccount('<SENDER_SECRET_KEY>');
+const sender = new AccountMemory('<SENDER_SECRET_KEY>');
 
 (async function () {
   const node = new Node(NODE_URL);
@@ -43,16 +43,13 @@ const sender = new MemoryAccount('<SENDER_SECRET_KEY>');
   });
 
   // spend one AE
-  await aeSdk.spend(1, '<RECIPIENT_ADDRESS>', {
-    // replace <RECIPIENT_ADDRESS>, Ideally you use address from Superhero Wallet you have created before
-    denomination: AE_AMOUNT_FORMATS.AE,
-  });
+  await aeSdk.spend(1e18, '<RECIPIENT_ADDRESS>');
+  // replace <RECIPIENT_ADDRESS>, Ideally you use address from Superhero Wallet you have created before
 })();
 ```
 
 Note:
 
 - You may remove code from Step 2 as this serves only for one-time creation
-- By default the `spend` function expects the amount to be spent in `aettos` (the smallest possible unit)
-- Following the example snippet you would specify `AE` as denomination
+- The `spend` function expects the amount to be spent in `aettos` (the smallest possible unit, 1 _AE_ equal to 1 000 000 000 000 000 000 `aettos`)
 - See [Testnet Explorer](https://testnet.aescan.io/) and track your transactions

examples/browser/aepp/src/TypedData.vue

@@ -93,7 +93,7 @@
 
 <script>
 import { mapState } from 'vuex';
-import { hashTypedData, verify, decode } from '@aeternity/aepp-sdk';
+import { hashTypedData, verifySignature, decode } from '@aeternity/aepp-sdk';
 import { TypeResolver, ContractByteArrayEncoder } from '@aeternity/aepp-calldata';
 import Value from './components/Value.vue';
 import FieldAction from './components/FieldAction.vue';
@@ -148,7 +148,7 @@ export default {
       return this.aeSdk.signTypedData(this.dataEncoded, this.aciParsed, this.domain);
     },
     async verifyTypedData() {
-      return verify(this.hash, decode(this.verifySignature), this.verifyAddress);
+      return verifySignature(this.hash, decode(this.verifySignature), this.verifyAddress);
     },
   },
 };