Migration V5 → V6

public constructor() {
    super();
    // registration of stores and events
    this.events.register(NewHelloEvent, new NewHelloEvent(this.name));
}

const newHelloEvent = this.events.get(NewHelloEvent);
newHelloEvent.add(context, {
    senderAddress: context.transaction.senderAddress,
    message: context.params.message
},[ context.transaction.senderAddress ]);

curl --location --request POST 'http://localhost:7887/rpc' \
--header 'Content-Type: application/json' \
--data-raw '{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "chain_getEvents",
    "params": {
        "height": 123
    }
}'

import { TokenMethod } from '../../../token';

export class SidechainRegistrationCommand extends BaseInteroperabilityCommand {
	public schema = sidechainRegParams;
	private _tokenMethod!: TokenMethod;

	public addDependencies(tokenMethod: TokenMethod) {
		this._tokenMethod = tokenMethod;
	}
    public async verify(
		context: CommandVerifyContext<SidechainRegistrationParams>,
	): Promise<VerificationResult> {
        // ...
        // Sender must have enough balance to pay for extra command fee.
		const availableBalance = await this._tokenMethod.getAvailableBalance(
			context.getMethodContext(),
			senderAddress,
			TOKEN_ID_KLY,
		);
		if (availableBalance < REGISTRATION_FEE) {
            // ...
		}
        // ...
	}
}

export class TokenModule extends BaseModule {
	// [...]
	public reducers = {
		credit: async (params: Record<string, unknown>, stateStore: StateStore): Promise<void> => {
			// [...]
		},
		debit: async (params: Record<string, unknown>, stateStore: StateStore): Promise<void> => {
			// [...]
		},
		getBalance: async (
			params: Record<string, unknown>,
			stateStore: StateStore,
		): Promise<bigint> => {
			const { address } = params;
			if (!Buffer.isBuffer(address)) {
				throw new Error('Address must be a buffer');
			}
			const account = await stateStore.account.getOrDefault<TokenAccount>(address);
			return account.token.balance;
		}
	};
    // [...]
}

await reducerHandler.invoke("token:debit", {
  address: senderAddress,
  amount: asset.initValue,
});

import { BaseEndpoint, ModuleEndpointContext, cryptography } from 'klayr-sdk';
import { MessageStore, MessageStoreData } from './stores/message';

export class HelloEndpoint extends BaseEndpoint {
    public async getHello(ctx: ModuleEndpointContext): Promise<MessageStoreData> {
        // 1. Get message store
        const messageSubStore = this.stores.get(MessageStore);
        // 2. Get the address from the endpoint params
        const { address } = ctx.params;
        // 3. Validate address
        if (typeof address !== 'string') {
            throw new Error('Parameter address must be a string.');
        }
        cryptography.address.validateKlayr32Address(address);
        // 4. Get the Hello message for the address from the message store
        const helloMessage = await messageSubStore.get(
            ctx,
            cryptography.address.getAddressFromKlayr32Address(address),
        );
        // 5. Return the Hello message
        return helloMessage;
    }
}

curl --location --request GET 'http://localhost:7887/rpc' \
--header 'Content-Type: application/json' \
--data-raw '{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "hello_getHello",
    "params": {
        "address": "klyuz5p98kz3mqzxnu68qdrjxtvdvr2o7pprtj4yv"
    }
}'

const data = await client.invoke('namespace_endpointName', input);
console.log(data);

export class HelloModule extends BaseModule {

    // ...

    public actions = {
        amountOfHellos: async () => {
            const res = await this._dataAccess.getChainState(CHAIN_STATE_HELLO_COUNTER);
            const count = codec.decode(
                helloCounterSchema,
                res
            );
            return count;
        },
    };

    // ...
}

const data = await client.invoke('app:actionName', input);