@payburner/keyburner-sidewinder-core
Version:
Core library for Keyburner Sidewinder
609 lines • 38.8 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const npm_1 = require("@payburner/keyburner-sidewinder-model/dist/npm");
const CoreProcessor_1 = require("../processing/CoreProcessor");
const MemoryGlobalAddressService_1 = require("../services/impl/memory/MemoryGlobalAddressService");
const MemoryTokenService_1 = require("../services/impl/memory/MemoryTokenService");
const CommonErrorCodes_1 = require("../model/CommonErrorCodes");
const assert = require("assert");
const __1 = require("..");
test('Test Signing and Decoding', () => __awaiter(void 0, void 0, void 0, function* () {
const api = new __1.Api();
api.newAddress();
const factory = new npm_1.TransactionFactory();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), new MemoryTokenService_1.MemoryTokenService());
const payload = factory.newCreateTokenTransaction(0, 'NONE', "XRP", "prod", 10, 7, true, false, false);
const signedTransaction = api.signTokenCreateRequest(payload);
const decodedTransaction = yield coreProcessor.decodeTransaction(signedTransaction.signedTransaction);
assert(coreProcessor.getTransactionType(decodedTransaction) === npm_1.TransactionTypes.CreateToken);
assert(decodedTransaction.verified);
}));
test('Test Token Creation with Initial Amount', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Token Creation with Initial Amount. ==============');
const api = new __1.Api();
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
api.newAddress();
const factory = new npm_1.TransactionFactory();
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", 10, 7, true, false, false);
payload.initial_amount = 10000;
assert(payload.environment === "PROD");
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.data.token_issuer_address === api.address);
const token = yield tokenService.getToken("PROD", "XRP");
assert(typeof token.minimum_transfer_amount === 'undefined');
assert(typeof token.maximum_transfer_amount === 'undefined');
assert(typeof token.maximum_balance === 'undefined');
const payload2 = factory.newCreateTokenTransaction(1, signedTransaction.id, "PROD", "XRP", 10, 7, true, false, false);
const signedTransaction2 = api.signTokenCreateRequest(payload2);
let result2 = yield coreProcessor.decodeAndProcessTransaction(signedTransaction2.signedTransaction);
assert(result2.status === 400);
const account = yield tokenService.getTokenAccount("PROD", "XRP", api.address);
assert(account.total_balance === 10000);
assert(account.available_balance === 10000);
}));
test('Test Invalid Decimal Precision', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Invalid Decimal Precision. ==============');
const api = new __1.Api();
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
api.newAddress();
const factory = new npm_1.TransactionFactory();
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", 10, -7, true, false, false);
payload.initial_amount = 10000;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 400);
assert(result.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_SETUP_INVALID_DECIMAL_PRECISION.error_code);
}));
test('Test Invalid Transaction Fee', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Invalid Transaction Free. ==============');
const api = new __1.Api();
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const globalService = new MemoryGlobalAddressService_1.MemoryGlobalAddressService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(globalService, tokenService);
api.newAddress();
const factory = new npm_1.TransactionFactory();
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", -10, 7, true, false, false);
payload.initial_amount = 10000;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 400);
assert(result.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_SETUP_INVALID_TRANSACTION_FEE.error_code);
}
{
const lastTxnId = yield globalService.getEnvironmentAddressState(api.getAddress(), "PROD");
const payload = factory.newCreateTokenTransaction(1, lastTxnId.last_txn_id, "PROD", "XRP", 10, 7, true, false, false);
payload.initial_amount = 10000;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 200);
}
}));
test('Test Malformed Initial amount', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Malformed Initial Amount ==============');
const api = new __1.Api();
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const globalService = new MemoryGlobalAddressService_1.MemoryGlobalAddressService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(globalService, tokenService);
api.newAddress();
const factory = new npm_1.TransactionFactory();
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", -10, 7, true, false, false);
let testPayload = null;
testPayload = payload;
testPayload.initial_amount = "doggy";
const signedTransaction = api.signTokenCreateRequest(testPayload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
console.log('MALFORMED RESPONSE:' + JSON.stringify(result, null, 2));
assert(result.status === 400);
assert(result.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_SETUP_MALFORMED_INITIAL_AMOUNT.error_code);
}
}));
test('Test Bad Min/Max Transfer Amount', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Bad Min/Max Transfer Amount. ==============');
const api = new __1.Api();
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const globalService = new MemoryGlobalAddressService_1.MemoryGlobalAddressService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(globalService, tokenService);
api.newAddress();
const factory = new npm_1.TransactionFactory();
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.minimum_transfer_amount = 1000;
payload.maximum_transfer_amount = 50;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 400);
assert(result.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_SETUP_MINIMUM_TRANSFER_AMOUNTER_GREATER_THAN_MAXIMUM_TRANSFER_AMOUNT.error_code);
}
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(api.getAddress(), "PROD");
const payload = factory.newCreateTokenTransaction(1, environmentAddressState.last_txn_id, "PROD", "XRP1", 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.minimum_transfer_amount = 1000;
payload.maximum_transfer_amount = 1000;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 200);
}
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(api.getAddress(), "PROD");
const payload = factory.newCreateTokenTransaction(2, environmentAddressState.last_txn_id, "PROD", "XRP2", 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.minimum_transfer_amount = 999;
payload.maximum_transfer_amount = 1000;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 200);
}
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(api.getAddress(), "PROD");
const payload = factory.newCreateTokenTransaction(3, environmentAddressState.last_txn_id, "PROD", "XRP3", 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.minimum_transfer_amount = -1000;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 400);
assert(result.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_SETUP_MINIMUM_TRANSFER_AMOUNT_LESS_THAN_OR_EQUAL_ZERO.error_code);
}
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(api.getAddress(), "PROD");
const payload = factory.newCreateTokenTransaction(4, environmentAddressState.last_txn_id, "PROD", "XRP3", 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.maximum_transfer_amount = -50;
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 400);
assert(result.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_SETUP_MAXIMUM_TRANSFER_AMOUNT_LESS_THAN_OR_EQUAL_ZERO.error_code);
}
}));
test('Test No Way to Get Funds In', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test No Way to Get Funds In. ==============');
const api = new __1.Api();
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
api.newAddress();
const factory = new npm_1.TransactionFactory();
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", 10, -7, true, false, false);
const signedTransaction = api.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.status === 400);
assert(result.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_SETUP_NO_INITIAL_AMOUNT_AND_NO_UNDERLYING.error_code);
}));
test('Test Token is Frozen', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Token is Frozen. ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const globalService = new MemoryGlobalAddressService_1.MemoryGlobalAddressService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(globalService, tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const tokenThirdPartyApi = new __1.Api();
tokenThirdPartyApi.newAddress();
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", 10, 7, true, false, true);
payload.initial_amount = 10000;
assert(payload.environment === "PROD");
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
console.log('Signed Transaction:' + JSON.stringify(signedTransaction, null, 2));
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.data.token_issuer_address === tokenOwnerApi.address);
assert(result.data.frozen);
const token_symbol = 'XRP';
const environment = 'PROD';
console.log('============= SEGMENT: Transaction fails on frozen token ==============');
try {
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 1);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_IS_FROZEN.error_code);
}
console.log('============= SEGMENT: Transaction succeeds on un-frozen token ==============');
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(tokenOwnerApi.getAddress(), "PROD");
const unfreeze = factory.newUpdateTokenTransaction(2, environmentAddressState.last_txn_id, environment, token_symbol, 10, undefined, undefined, undefined, false);
const signedUnfreezeTransaction = tokenOwnerApi.signTokenUpdateRequest(unfreeze);
let unfreezeResult = yield coreProcessor.decodeAndProcessTransaction(signedUnfreezeTransaction.signedTransaction);
assert(unfreezeResult.status === 200);
assert(!unfreezeResult.data.frozen);
console.log('-->');
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 3);
console.log('<--');
}
console.log('============= SEGMENT: Freeze again ==============');
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(tokenOwnerApi.getAddress(), "PROD");
const freeze = factory.newUpdateTokenTransaction(4, environmentAddressState.last_txn_id, environment, token_symbol, 10, undefined, undefined, undefined, true);
const signedFreezeTransaction = tokenOwnerApi.signTokenUpdateRequest(freeze);
let freezeResult = yield coreProcessor.decodeAndProcessTransaction(signedFreezeTransaction.signedTransaction);
assert(freezeResult.status === 200);
assert(freezeResult.data.frozen);
}
console.log('============= SEGMENT: Fail again on frozen ==============');
try {
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 5);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_IS_FROZEN.error_code);
}
console.log('============= SEGMENT: Only issuer can freeze or unfreeze ==============');
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(tokenOwnerApi.getAddress(), "PROD");
const badboyFreeze = factory.newUpdateTokenTransaction(0, environmentAddressState.last_txn_id, environment, token_symbol, 10, undefined, undefined, undefined, true);
const signedBadboyFreezeTransaction = tokenReceiverApi.signTokenUpdateRequest(badboyFreeze);
let badboyFreezeResult = yield coreProcessor.decodeAndProcessTransaction(signedBadboyFreezeTransaction.signedTransaction);
assert(badboyFreezeResult.status === 403);
}
console.log('============= SEGMENT: Account level freezes ==============');
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(tokenOwnerApi.getAddress(), "PROD");
const unfreeze = factory.newUpdateTokenTransaction(6, environmentAddressState.last_txn_id, environment, token_symbol, 10, undefined, undefined, undefined, false);
const signedUnfreezeTransaction = tokenOwnerApi.signTokenUpdateRequest(unfreeze);
let unfreezeResult = yield coreProcessor.decodeAndProcessTransaction(signedUnfreezeTransaction.signedTransaction);
assert(unfreezeResult.status === 200);
assert(!unfreezeResult.data.frozen);
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 7);
}
console.log('============= SEGMENT: Freeze token account ==============');
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(tokenOwnerApi.getAddress(), "PROD");
const freeze = factory.newUpdateTokenAccountFreezeStatusTransaction(8, environmentAddressState.last_txn_id, environment, token_symbol, tokenReceiverApi.address, true);
const freezeTransaction = tokenOwnerApi.signTokenUpdateTokenAccountRequest(freeze);
let freezeResult = yield coreProcessor.decodeAndProcessTransaction(freezeTransaction.signedTransaction);
assert(freezeResult.status === 200);
assert(freezeResult.data.frozen);
try {
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 9);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_ACCOUNT_RECEIVER_ACCOUNT_IS_FROZEN.error_code);
}
}
console.log('============= SEGMENT: Unfreeze token account ==============');
{
const environmentAddressState = yield globalService.getEnvironmentAddressState(tokenOwnerApi.getAddress(), "PROD");
const freeze = factory.newUpdateTokenAccountFreezeStatusTransaction(10, environmentAddressState.last_txn_id, environment, token_symbol, tokenReceiverApi.address, false);
const freezeTransaction = tokenOwnerApi.signTokenUpdateTokenAccountRequest(freeze);
let freezeResult = yield coreProcessor.decodeAndProcessTransaction(freezeTransaction.signedTransaction);
assert(freezeResult.status === 200);
assert(!freezeResult.data.frozen);
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 11);
}
}));
test('Test Token is permissioned', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Token is permissioned. ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const thirdPartyAPi = new __1.Api();
thirdPartyAPi.newAddress();
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", 10, 7, true, true, false);
payload.initial_amount = 10000;
assert(payload.environment === "PROD");
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.data.token_issuer_address === tokenOwnerApi.address);
assert(result.data.is_permissioned);
const token_symbol = 'XRP';
const environment = 'PROD';
console.log('============= SEGMENT: From token owner to token receiver ==============');
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 100, coreProcessor, tokenService, 1);
console.log('============= SEGMENT: From token receiver to token owner ==============');
yield doTransfer(tokenReceiverApi, tokenOwnerApi, environment, token_symbol, 50, coreProcessor, tokenService, 0);
console.log('============= SEGMENT: Should fail ==============');
try {
yield doTransfer(tokenReceiverApi, thirdPartyAPi, environment, token_symbol, 50, coreProcessor, tokenService, 1);
assert(false);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_ACCOUNT_RECEIVER_ACCOUNT_NO_ACCESS_TO_TOKEN.error_code);
}
}));
test('Test transfers and insufficient balance', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test transfers and insufficient balance. ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const thirdPartyAPi = new __1.Api();
thirdPartyAPi.newAddress();
const token_symbol = 'XRP';
const environment = 'PROD';
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', environment, token_symbol, 10, 7, true, false, false);
payload.initial_amount = 10000;
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
}
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 200, coreProcessor, tokenService, 1);
yield doTransfer(tokenReceiverApi, thirdPartyAPi, environment, token_symbol, 50, coreProcessor, tokenService, 0);
yield doTransfer(tokenReceiverApi, thirdPartyAPi, environment, token_symbol, 50, coreProcessor, tokenService, 1);
yield doTransfer(tokenReceiverApi, thirdPartyAPi, environment, token_symbol, 50, coreProcessor, tokenService, 2);
try {
yield doTransfer(tokenReceiverApi, thirdPartyAPi, environment, token_symbol, 50, coreProcessor, tokenService, 3);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.INSUFFICIENT_BALANCE.error_code);
}
yield doTransfer(tokenReceiverApi, thirdPartyAPi, environment, token_symbol, 10, coreProcessor, tokenService, 4);
}));
test('Test allow transfers between accounts', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test allow transfers between accounts. ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const thirdPartyAPi = new __1.Api();
thirdPartyAPi.newAddress();
const token_symbol = 'XRP';
const environment = 'PROD';
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', environment, token_symbol, 10, 7, false, false, false);
payload.initial_amount = 10000;
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
}
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 200, coreProcessor, tokenService, 1);
try {
yield doTransfer(tokenReceiverApi, thirdPartyAPi, environment, token_symbol, 50, coreProcessor, tokenService, 0);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_NO_INTER_ACCOUNT_TRANSFERS.error_code);
}
yield doTransfer(tokenReceiverApi, tokenOwnerApi, environment, token_symbol, 10, coreProcessor, tokenService, 1);
}));
test('Test sender account does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test sender account does not exist. ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const token_symbol = 'XRP';
const environment = 'PROD';
console.log('============= SEGMENT: Create token ==============');
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', environment, token_symbol, 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.maximum_balance = 200;
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
const token = yield tokenService.getToken(environment, token_symbol);
assert(token.maximum_balance === 200);
}
console.log('============= SEGMENT: Expect failure sender account does not exist. ==============');
try {
yield doTransfer(tokenReceiverApi, tokenOwnerApi, environment, token_symbol, 300, coreProcessor, tokenService, 0);
}
catch (error) {
const castError = error;
assert(castError.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_ACCOUNT_SENDER_ACCOUNT_DOES_NOT_EXIST.error_code);
}
}));
test('Test transfers and maximum balance', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test transfers and maximum balance ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const token_symbol = 'XRP';
const environment = 'PROD';
console.log('============= SEGMENT: Create token ==============');
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', environment, token_symbol, 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.maximum_balance = 200;
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
const token = yield tokenService.getToken(environment, token_symbol);
assert(token.maximum_balance === 200);
}
console.log('============= SEGMENT: Expect failure for max balance when no receiver account exists. ==============');
try {
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 300, coreProcessor, tokenService, 1);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_DESTINATION_ACCOUNT_EXCEED_MAXIMUM_BALANCE_NO_ACCOUNT.error_code);
}
console.log('============= SEGMENT: Do Ok Transfer ==============');
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 150, coreProcessor, tokenService, 2);
console.log('============= SEGMENT: Expect failure for max balance when receiver account does exist. ==============');
try {
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 100, coreProcessor, tokenService, 3);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_DESTINATION_ACCOUNT_EXCEED_MAXIMUM_BALANCE.error_code);
}
console.log('============= SEGMENT: Expect ok within balance ==============');
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 10, coreProcessor, tokenService, 4);
}));
test('Test minimum transfer amount', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test transfers and maximum balance ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const token_symbol = 'XRP';
const environment = 'PROD';
console.log('============= SEGMENT: Create token ==============');
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', environment, token_symbol, 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.minimum_transfer_amount = 50;
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
const token = yield tokenService.getToken(environment, token_symbol);
assert(token.minimum_transfer_amount === 50);
}
console.log('============= SEGMENT: Expect failure for max balance when no receiver account exists. ==============');
try {
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 40, coreProcessor, tokenService, 1);
assert(false);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_TRANSFER_AMOUNT_LESS_THAN_MINIMUM_TRANSFER.error_code);
}
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 2);
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 60, coreProcessor, tokenService, 3);
}));
test('Test Token Account Not found on update', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test Token Account Not found on update ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const payload = factory.newCreateTokenTransaction(0, 'NONE', "PROD", "XRP", 10, 7, true, false, false);
payload.initial_amount = 10000;
assert(payload.environment === "PROD");
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
let result = yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
assert(result.data.token_issuer_address === tokenOwnerApi.address);
const token_symbol = 'XRP';
const environment = 'PROD';
{
const freeze = factory.newUpdateTokenAccountFreezeStatusTransaction(1, 'NONE', environment, token_symbol, tokenReceiverApi.address, false);
const freezeTransaction = tokenOwnerApi.signTokenUpdateTokenAccountRequest(freeze);
let freezeResult = yield coreProcessor.decodeAndProcessTransaction(freezeTransaction.signedTransaction);
console.log('FREEZE RESULT:' + JSON.stringify(freezeResult, null, 2));
assert(freezeResult.status === 404);
}
}));
test('Test maximum transfer amount', () => __awaiter(void 0, void 0, void 0, function* () {
console.log('============= TEST: Test transfers and maximum balance ==============');
const tokenService = new MemoryTokenService_1.MemoryTokenService();
const coreProcessor = new CoreProcessor_1.CoreProcessor(new MemoryGlobalAddressService_1.MemoryGlobalAddressService(), tokenService);
const factory = new npm_1.TransactionFactory();
const tokenOwnerApi = new __1.Api();
tokenOwnerApi.newAddress();
const tokenReceiverApi = new __1.Api();
tokenReceiverApi.newAddress();
const token_symbol = 'XRP';
const environment = 'PROD';
console.log('============= SEGMENT: Create token ==============');
{
const payload = factory.newCreateTokenTransaction(0, 'NONE', environment, token_symbol, 10, 7, true, false, false);
payload.initial_amount = 10000;
payload.maximum_transfer_amount = 50;
const signedTransaction = tokenOwnerApi.signTokenCreateRequest(payload);
yield coreProcessor.decodeAndProcessTransaction(signedTransaction.signedTransaction);
const token = yield tokenService.getToken(environment, token_symbol);
assert(token.maximum_transfer_amount === 50);
}
console.log('============= SEGMENT: Expect failure for max balance when no receiver account exists. ==============');
try {
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 60, coreProcessor, tokenService, 1);
assert(false);
}
catch (error) {
const transferResult2 = error;
assert(transferResult2.error_code === CommonErrorCodes_1.CommonErrorCodes.TOKEN_TRANSFER_AMOUNT_GREATER_THAN_MAXIMUM_TRANSFER.error_code);
}
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 50, coreProcessor, tokenService, 2);
yield doTransfer(tokenOwnerApi, tokenReceiverApi, environment, token_symbol, 1, coreProcessor, tokenService, 3);
}));
const doTransfer = function (senderApi, receiverApi, environment, token_symbol, amount, coreProcessor, tokenService, sequence) {
return __awaiter(this, void 0, void 0, function* () {
const factory = new npm_1.TransactionFactory();
let receiversAccountPre = null;
let preReceiverBalance = 0;
try {
receiversAccountPre = yield tokenService.getTokenAccount(environment, token_symbol, receiverApi.getAddress());
preReceiverBalance = receiversAccountPre.available_balance;
}
catch (error) {
}
let sendersAccountPre = null;
let sendersBalancePre = 0;
try {
sendersAccountPre = yield tokenService.getTokenAccount(environment, token_symbol, senderApi.getAddress());
sendersBalancePre = sendersAccountPre.available_balance;
console.log('SENDER PRE:' + JSON.stringify(sendersAccountPre, null, 2));
}
catch (error) {
}
const token = yield tokenService.getToken(environment, token_symbol);
const transferTransaction = factory.newTransferTransaction(sequence, 'TEMP', environment, token_symbol, senderApi.getAddress(), receiverApi.getAddress(), amount);
const signedTransfer = senderApi.signTransferRequest(transferTransaction);
let transferResult = yield coreProcessor.decodeAndProcessTransaction(signedTransfer.signedTransaction);
console.log('TRANSFER RESULT:' + JSON.stringify(transferResult, null, 2));
if (transferResult.status !== 200) {
throw transferResult;
}
let receiversAccount = yield tokenService.getTokenAccount(environment, token_symbol, receiverApi.getAddress());
assert(receiversAccount.account_owner_address === receiverApi.getAddress());
if (token.token_issuer_address === receiversAccount.account_owner_address) {
if (receiversAccountPre !== null) {
console.log('PRE RECEIVER: pre1:' + preReceiverBalance + ', current:' + receiversAccount.available_balance + ', amount:' + amount);
assert((receiversAccount.available_balance) === (preReceiverBalance) + amount + 10);
}
else {
console.log('PRE RECEIVER: pre2:' + preReceiverBalance + ', current:' + receiversAccount.available_balance + ', amount:' + amount);
assert((receiversAccount.available_balance) === amount + 10);
}
}
else {
if (receiversAccountPre !== null) {
console.log('PRE RECEIVER: pre3:' + preReceiverBalance + ', current:' + receiversAccount.available_balance + ', amount:' + amount);
assert((receiversAccount.available_balance) === (preReceiverBalance) + amount);
}
else {
console.log('=> PRE RECEIVER: pre4:' + preReceiverBalance + ', current:' + receiversAccount.available_balance + ', amount:' + amount + ', eq=' + ((receiversAccount.available_balance) === amount) + ', t=' + (typeof receiversAccount.available_balance) + ' ' + (typeof amount));
assert((receiversAccount.available_balance) === amount);
console.log('<= PRE RECEIVER: pre4:' + preReceiverBalance + ', current:' + receiversAccount.available_balance + ', amount:' + amount);
}
}
let sendersAccount = yield tokenService.getTokenAccount(environment, token_symbol, senderApi.getAddress());
console.log('SENDER POST:' + JSON.stringify(sendersAccount, null, 2));
if (token.token_issuer_address === sendersAccount.account_owner_address) {
assert((sendersAccount.available_balance) === ((sendersBalancePre) - amount));
}
else {
assert((sendersAccount.available_balance) === ((sendersBalancePre) - amount) - 10);
}
});
};
//# sourceMappingURL=Api.test.js.map