// ゲームコインモザイク特性定義
const supplyMutable = true; //供給量変更の可否
const transferable = false; //第三者への転送可否
const restrictable = true; //制限設定の可否
const revokable = true; //発行者からの還収可否

//モザイク生成トランザクション生成
const nonce = symbol.MosaicNonce.createRandom();
const mosaicDefTx = symbol.MosaicDefinitionTransaction.create(
    symbol.Deadline.create(epochAdjustment), 
    nonce,
    symbol.MosaicId.createFromNonce(nonce, alice.address), //モザイクID
    symbol.MosaicFlags.create(supplyMutable, transferable, restrictable, revokable), // モザイク特性フラグ
    0, //divisibility:可分性
    symbol.UInt64.fromUint(0), //duration:有効期限
    networkType
);

//モザイク数量変更トランザクション生成
const delta = 1000000000000000; // 数量
const mosaicChangeTx = symbol.MosaicSupplyChangeTransaction.create(
    symbol.Deadline.create(epochAdjustment),
    mosaicDefTx.mosaicId,
    symbol.MosaicSupplyChangeAction.Increase,
    symbol.UInt64.fromUint(delta * Math.pow(10, divisibility)),
    networkType,
);

const aggregateTx = symbol.AggregateTransaction.createComplete(
    symbol.Deadline.create(epochAdjustment),
    [
      mosaicDefTx.toAggregate(alice.publicAccount), // モザイク生成トランザクション
      mosaicChangeTx.toAggregate(alice.publicAccount), // モザイク数量変更トランザクション
    ],
    networkType,[],
).setMaxFeeForAggregate(100, 0);

signedTx = alice.sign(aggregateTx,generationHash);
await txRepo.announce(signedTx).toPromise();

const subNamespaceTx = symbol.NamespaceRegistrationTransaction.createSubNamespace(
    symbol.Deadline.create(epochAdjustment),
    "game-coin",  //作成するサブネームスペース
    "tenxym", //紐づけたいルートネームスペース
    networkType,
).setMaxFee(100);
const signedTx = alice.sign(subNamespaceTx,generationHash);
await txRepo.announce(signedTx).toPromise();

const namespaceId = new symbol.NamespaceId("tenxym.game-coin");
const mosaicId = new symbol.MosaicId("116E2C1423585B81"); // tenxym.game-coinモザイクID
const tx = symbol.AliasTransaction.createForMosaic(
    symbol.Deadline.create(epochAdjustment),
    symbol.AliasAction.Link,
    namespaceId,
    mosaicId,
    networkType
).setMaxFee(100);
const signedTx = alice.sign(tx,generationHash);
await txRepo.announce(signedTx).toPromise();

// アドレスのアカウント情報を取得
const getAccountInformation = async (rawAddress) => {
    const repositoryFactoryHttp = new symbol.RepositoryFactoryHttp(nodeUrl)
    const accountRepository = repositoryFactoryHttp.createAccountRepository();
    const address = symbol.Address.createFromRawAddress(rawAddress);
    return  await accountRepository.getAccountInfo(address).toPromise();
}

// アドレスのアカウントの所有モザイクからピックアップモザイクを1つランダムに抽出する
const getPickupMosaicRandom = async (rawAddress, pickupMosaics) => {
    // アカウント情報を取得
    const account = await getAccountInformation(rawAddress, pickupMosaics)
    // 所有モザイクの中にピックアップモザイクがあればそのモザイク情報を取得
    const haveMosaics = account.mosaics.filter((mosaic) => {
        return pickupMosaics.includes(mosaic.id.toHex());
    }, pickupMosaics);
    // 所有中のピックアップモザイクからランダムに1つ取り出す
    return haveMosaics[Math.floor(Math.random() * haveMosaics.length)];
}

// モザイクのIDと数量を返す
const getMosaicDetail = (mosaic) => {
        return {
            id: mosaic.id.toHex(),
            amount: Number(mosaic.amount.toString()),
        }
}

(async () => {
    // 送信対象のピックアップモザイクリスト
    const mosaics = [
        '613E6D0FC11F4530', // toshi.tomato
        '5A8F12439B09B33E', // shizui.tomato
        '310378C18A140D1B' // xembook.tomato
    ];
    // SSSに登録されているアカウントの所有モザイクの中からピックアップモザイクを1つランダムに抽出する
    const mosaic = await getPickupMosaicRandom(window.SSS?.activeAddress, mosaics)
    if (mosaic !== undefined) {
        const mosaicDetail = getMosaicDetail(mosaic);
        console.log(`pickup mosaic amount : ${mosaicDetail.amount}`)
    }
})();

// ゲーム側へモザイクを送信するTransferTransaction
const transferTransaction = async (mosaicId) => {
    const repositoryFactory = new symbol.RepositoryFactoryHttp(nodeUrl;
    const networkRepository = repositoryFactory.createNetworkRepository();
    // ゲーム側へモザイクを1枚送信するトランザクションを作成
    let medianFee = null;
    medianFee = (await networkRepository.getTransactionFees().toPromise()).medianFeeMultiplier;
    const tx = symbol.TransferTransaction.create(
        symbol.Deadline.create(EPOCH_ADJUSTMENT),
        symbol.Address.createFromRawAddress(gameRawAddress),
        [new symbol.Mosaic(new symbol.MosaicId(senderMosaicId), symbol.UInt64.fromUint(1))],
        symbol.PlainMessage.create(""),
        networkType,
    ).setMaxFee(medianFee)

    // 作成したトランザクションをSSSにセット
    window.SSS.setTransaction(tx)

    // SSSでの署名を受け取る
    const  signedTx = await window.SSS.requestSign().then(signedTx => {
        return signedTx;
    })

    // 署名済みのトランザクションをアナウンス
    new symbol.TransactionHttp(nodeUrl)
        .announce(signedTx)
        .subscribe((x) => console.log(x), (err) => console.error(err))

}
(async() => {
    // 前処理で抽出したモザイクIDのモザイクをゲーム側アカウントに送る
    await transferTransaction(transferMosaicId).catch((e) => console.log(e));
})();

// 特定のモザイク数量を取得
const getMosaicAmount = async (rawAddress, mosaicId) => {
    const repositoryFactoryHttp = new symbol.RepositoryFactoryHttp(nodeUrl);
    const accountRepository = repositoryFactoryHttp.createAccountRepository();
    const address = symbol.Address.createFromRawAddress(rawAddress);
    const account = await accountRepository.getAccountInfo(address).toPromise();
    const mosaic = account.mosaics.find(mosaic => mosaic.id.toHex() === mosaicId);

    // 持ってなかったら表示用に0をセットしとく
    let amount = 0;
    if (mosaic !== undefined) {
        amount = Number(mosaic.amount.toString());
    }
    return amount;
}
(async () => {
    // ゲームコイン枚数を取得してゲーム画面表示用の変数にセット
    $gameVariables.setValue(501, await getMosaicAmount(window.SSS.activeAddress, $gameVariables.value(35)));
})();

// 交換のアグリゲートトランザクションを提起してSSSにセットする
const createExchangeAggregateTransaction = async (playerAddress, cosignerAddress, releaseMosaicId, receiveMosaicId, releaseMosaicAmount, receiveMosaicAmount) => {
    // Repository作成
    const repositoryFactory = new symbol.RepositoryFactoryHttp(NODE_URL);
    const accountRepository = repositoryFactory.createAccountRepository();

    // プレイヤーPublicAccount
    const playerPublicAccount = symbol.PublicAccount.createFromPublicKey(
        window.SSS.activePublicKey,
        networkType,
    );
    // 連署用ゲームAccount
    const cosignerAccountAddress = symbol.Address.createFromRawAddress(cosignerAddress);
    const cosignerAccountInfo = await accountRepository.getAccountInfo(cosignerAccountAddress).toPromise();
    const cosignerPublicAccount = symbol.PublicAccount.createFromPublicKey(
        cosignerAccountInfo.publicKey,
        networkType,
    );

    // プレイヤーからゲームへのトランザクション
    const innerTx1 = symbol.TransferTransaction.create(
        symbol.Deadline.create(epochAdjustment),
        symbol.Address.createFromRawAddress(cosignerAddress),
        [new symbol.Mosaic(new
            symbol.MosaicId(releaseMosaicId),
            symbol.UInt64.fromUint(releaseMosaicAmount))],
        symbol.PlainMessage.create('tenxym exchange'),
        networkType
    );

    // ゲームからプレイヤーへのトランザクション
    const innerTx2 = symbol.TransferTransaction.create(
        symbol.Deadline.create(epochAdjustment),
        symbol.Address.createFromRawAddress(playerAddress),
        [new symbol.Mosaic(new
            symbol.MosaicId(receiveMosaicId),
            symbol.UInt64.fromUint(receiveMosaicAmount))],
        symbol.PlainMessage.create('tenxym exchange'),
        networkType
    );

    // アグリゲートトランザクションを作成
    const aggregateTx = symbol.AggregateTransaction.createComplete(
        symbol.Deadline.create(epochAdjustment),
        [
            innerTx1.toAggregate(playerPublicAccount),
            innerTx2.toAggregate(cosignerPublicAccount)
        ],
        networkType,
        [],
    ).setMaxFeeForAggregate(100, 1);

    // SSSでの署名を求めるトランザクションをSSSにセット
    window.SSS.setTransaction(aggregateTx)
    const signedTx = await window.SSS.requestSign().then(signedTx => {
        return signedTx;
    });

    // 署名済みのペイロードをセット
    const signedPayload = signedTx.payload;

    console.log(signedTx.payload);
}
// ゲーム側が出す交換数量を返す
const calcExchangeGameCoinAmount = (releaseMosaicAmount) => {
    return releaseMosaicAmount * 10 // ゲーム側はプレイヤーが交換に出す数量の10倍を交換に出す
}
(async () => {
    const sssActiveAddress = window.SSS.activeAddress; // SSSのアクティブ
    const cosignerAddress = $gameVariables.value(36); // ゲーム側アドレスを取得 
    const releaseMosaicId = $gameVariables.value(508); // プレイヤーが交換に出すモザイクIDを取得(事前にプレイヤーに入力させたもの)
    const receiveMosaicId = $gameVariables.value(502); // ゲーム側が交換に出すモザイクIDを取得(事前にプレイヤーに選択させたもの)
    const releaseMosaicAmount = $gameVariables.value(59); // プレイヤーが交換に出すモザイク数量を取得(事前にプレイヤーに入力させたもの)
    const receiveMosaicAmount = calcExchangeGameCoinAmount(releaseMosaicAmount); // プレイヤーが交換に出すモザイクからゲーム側が交換に出すモザイク数量を算出(レートが1:1でない場合に使用)

    // 交換のアグリゲートトランザクションを提起してSSSにセットする
    await createExchangeAggregateTransaction(sssActiveAddress, cosignerAddress, releaseMosaicId, receiveMosaicId, releaseMosaicAmount, receiveMosaicAmount).catch((e) => console.log(e));

})()

    const repositoryFactory = new symbol.RepositoryFactoryHttp(getRandomNodeUrl(type));
    const txRepo = repositoryFactory.createTransactionRepository();

    // ゲーム側秘密鍵からアカウントを復元
    const privateKey = getTenXymMasterAccount(type)
    const tenXymMasterAccount = symbol.Account.createFromPrivateKey(
        privateKey,
        networkType,
    );

    // ペイロードからトランザクションを復元
    const tx = symbol.TransactionMapping.createFromPayload(signedPayload);


 /*******************************************************************/
 /* 
 /* ここで復元したトランザクションが妥当な内容のものか検証する。本記事では省略。
 /* 
 /*******************************************************************/


    const tenXymMasterSignedTx = symbol.CosignatureTransaction.signTransactionPayload(tenXymMasterAccount, signedPayload, GENERATION_HASH);
    const tenXymMasterSignedTxSignature = tenXymMasterSignedTx.signature;
    const tenXymMasterTxSignerPublicKey = tenXymMasterSignedTx.signerPublicKey;

    // プレイヤーの署名済みペイロードにゲーム側アカウントで連署
    signedHash = symbol.Transaction.createTransactionHash(signedPayload,Buffer.from(GENERATION_HASH, 'hex'));
    cosignSignedTxs = [
        new symbol.CosignatureSignedTransaction(signedHash,tenXymMasterSignedTxSignature,tenXymMasterTxSignerPublicKey)
    ];
    recreatedTx = symbol.TransactionMapping.createFromPayload(signedPayload);
    cosignSignedTxs.forEach((cosignedTx) => {
        signedPayload += cosignedTx.version.toHex() + cosignedTx.signerPublicKey + cosignedTx.signature;
    });
    size = `00000000${(signedPayload.length / 2).toString(16)}`;
    formatedSize = size.substr(size.length - 8, size.length);
    littleEndianSize = formatedSize.substr(6, 2) + formatedSize.substr(4, 2) + formatedSize.substr(2, 2) + formatedSize.substr(0, 2);

    signedPayload = littleEndianSize + signedPayload.substr(8, signedPayload.length - 8);
    signedTx = new symbol.SignedTransaction(signedPayload, signedHash, fromAddressPublicKey, recreatedTx.type, recreatedTx.networkType);

    // 連署したトランザクションをネットワークにアナウンス
    txRepo.announce(signedTx).toPromise();

    const repositoryFactory = new symbol.RepositoryFactoryHttp(nodeUrl);
    const networkRepository = repositoryFactory.createNetworkRepository();
    const transactionHttp = repositoryFactory.createTransactionRepository();

    // ゲーム側秘密鍵からアカウントを復元
    const privateKey = getTenXymMasterAccount(type)
    const account = symbol.Account.createFromPrivateKey(
        privateKey,
        networkType,
    );

    // リボーカブルトランザクション作成
    let medianFee = null;
    let medianFee = (await networkRepository.getTransactionFees().toPromise()).medianFeeMultiplier;
    const tx = symbol.TransferTransaction.create(
        symbol.Deadline.create(EPOCH_ADJUSTMENT),
        symbol.Address.createFromRawAddress(playerAddress),
        [new symbol.Mosaic(new symbol.MosaicId(gameCoinMosaicId), symbol.UInt64.fromUint(amount))],
        symbol.PlainMessage.create("WIN REWARD"),
        networkType,
    ).setMaxFee(medianFee)

    // 署名
    const signedTransaction = account.sign(tx, GENERATION_HASH);
    // ネットワークにアナウンス
    transactionHttp.announce(signedTransaction).subscribe(
        (x) => console.log(x),
        (err) => console.error(err),
    );

■特定ブロック高到達によるイベント発生

const repositoryFactory = new symbol.RepositoryFactoryHttp(nodeUrl);
const chainHttp = repositoryFactory.createChainRepository();
// ブロック高を取得してイベント解禁フラグのON/OFFを判断
chainHttp.getChainInfo().subscribe((info) =>
    blockHeightChecker(info.height.compact())
    , (err) => console.error(err));

// ブロック高が特定ブロックに達したときにイベント解禁フラグをON
const blockHeightChecker(blockHeight){
    if(blockHeight >= 1533846){
        // イベント解禁フラグをON
        $gameSwitches.setValue(49, true);
    }
}

なるほど、と思える内容はあったでしょうか。もしあったのであれば幸いです。

速習Symbol無くしては今回の実装、特に連署用の秘密鍵をクライアント側に置かずに連署が可能な交換の仕組みの肝となっているオフライン署名を組み込むことは出来ませんでした。
また、署名用Chrome拡張機能のSSS Extensionも無くしては実現できない内容でした。
速習Symbol著者XEMBookさん、SSS Extension開発者いなたつさん、素晴らしいものを世に出していただきありがとうございます。

ここまでお読みいただきありがとうございました。