@bitgo-beta/sdk-coin-canton 1.0.1-beta.82 → 1.0.1-beta.821

package/dist/test/unit/canton.js

@@ -0,0 +1,853 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const src_1 = require("../../src");
+const resources_1 = require("../resources");
+/**
+ * Builds a base64-encoded raw transaction for a OneStepPreApproval (enable token flow).
+ * For TSS wallets (which Canton always is), verifyTransaction receives txParams.enableTokens,
+ * not txParams.recipients. The wallet SDK's buildTokenEnablements passes enableTokens through
+ * unchanged for TSS wallets rather than converting them to recipients.
+ */
+function buildOneStepPreApprovalRawTx(prepareResponse, commandId) {
+    const data = {
+        prepareCommandResponse: prepareResponse,
+        txType: 'OneStepPreApproval',
+        preparedTransaction: '',
+        partySignatures: { signatures: [] },
+        deduplicationPeriod: { Empty: {} },
+        submissionId: commandId,
+        hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2',
+        minLedgerTime: { time: { Empty: {} } },
+    };
+    return Buffer.from(JSON.stringify(data)).toString('base64');
+}
+/** Returns a mock wallet whose coinSpecific().rootAddress matches the given party ID. */
+function walletWithRootAddress(rootAddress) {
+    return { coinSpecific: () => ({ rootAddress }) };
+}
+/** Builds a base64-encoded raw transaction for a non-OneStep txType (e.g. AllocationReject). */
+function buildRawTx(txType, prepareResponse, commandId) {
+    const data = {
+        prepareCommandResponse: prepareResponse,
+        txType,
+        preparedTransaction: '',
+        partySignatures: { signatures: [] },
+        deduplicationPeriod: { Empty: {} },
+        submissionId: commandId,
+        hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2',
+        minLedgerTime: { time: { Empty: {} } },
+    };
+    return Buffer.from(JSON.stringify(data)).toString('base64');
+}
+describe('Canton coin:', function () {
+    let bitgo;
+    let basecoin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('canton', src_1.Canton.createInstance);
+        bitgo.safeRegister('tcanton', src_1.Tcanton.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tcanton');
+    });
+    describe('supportsMessageSigning', function () {
+        it('should return true', function () {
+            basecoin.supportsMessageSigning().should.equal(true);
+        });
+    });
+});
+describe('Canton verifyTransaction:', function () {
+    let bitgo;
+    let basecoin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('canton', src_1.Canton.createInstance);
+        bitgo.safeRegister('tcanton', src_1.Tcanton.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tcanton');
+    });
+    describe('OneStepPreApproval (enable token flow):', function () {
+        it('should return true when txParams has no type (non-enabletoken flow)', async function () {
+            const txHex = buildOneStepPreApprovalRawTx(resources_1.OneStepPreApprovalPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {},
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when enableTokens is absent', async function () {
+            const txHex = buildOneStepPreApprovalRawTx(resources_1.OneStepPreApprovalPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { type: 'enabletoken' },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when enableTokens is empty', async function () {
+            const txHex = buildOneStepPreApprovalRawTx(resources_1.OneStepPreApprovalPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { type: 'enabletoken', enableTokens: [] },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        describe('coin pre-approval (TransferPreapprovalProposal):', function () {
+            let txHex;
+            let receiver;
+            before(function () {
+                txHex = buildOneStepPreApprovalRawTx(resources_1.OneStepPreApprovalPrepareResponse, resources_1.OneStepEnablement.commandId);
+                // Dynamically derive receiver from parsed transaction to avoid hardcoding protobuf-decoded addresses
+                const txBuilder = new src_1.TransactionBuilderFactory(statics_1.coins.get('tcanton')).from(txHex);
+                receiver = txBuilder.transaction.toJson().receiver;
+            });
+            it('should return true when wallet has no coinSpecific (receiver check skipped)', async function () {
+                // Typical case: wallet mock has no coinSpecific() method, and no address in enableTokens
+                const result = await basecoin.verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'canton' }],
+                    },
+                    wallet: {},
+                });
+                result.should.equal(true);
+            });
+            it('should return true when wallet rootAddress matches receiver', async function () {
+                // Typical UI flow: enableTokens has no address, receiver validated from wallet.coinSpecific().rootAddress
+                const result = await basecoin.verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'canton' }],
+                    },
+                    wallet: walletWithRootAddress(receiver),
+                });
+                result.should.equal(true);
+            });
+            it('should return true when enableToken.address matches receiver (explicit address)', async function () {
+                const result = await basecoin.verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'canton', address: receiver }],
+                    },
+                    wallet: {},
+                });
+                result.should.equal(true);
+            });
+            it('should throw when wallet rootAddress does not match receiver', async function () {
+                const wrongAddress = 'wrong-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+                await basecoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'canton' }],
+                    },
+                    wallet: walletWithRootAddress(wrongAddress),
+                })
+                    .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);
+            });
+            it('should throw when explicit enableToken.address does not match receiver', async function () {
+                const wrongAddress = 'wrong-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+                await basecoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'canton', address: wrongAddress }],
+                    },
+                    wallet: {},
+                })
+                    .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);
+            });
+        });
+        describe('token pre-approval (TransferPreapproval):', function () {
+            let txHex;
+            let receiver;
+            before(function () {
+                const commandId = '7d99789d-2f22-49e1-85cb-79d2ce5a69c1';
+                txHex = buildOneStepPreApprovalRawTx(resources_1.CantonTokenPreApprovalPrepareResponse, commandId);
+                const txBuilder = new src_1.TransactionBuilderFactory(statics_1.coins.get('tcanton')).from(txHex);
+                receiver = txBuilder.transaction.toJson().receiver;
+            });
+            it('should return true when wallet rootAddress matches receiver', async function () {
+                const result = await basecoin.verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'tcanton:testcoin1' }],
+                    },
+                    wallet: walletWithRootAddress(receiver),
+                });
+                result.should.equal(true);
+            });
+            it('should return true when enableToken.address matches receiver (explicit address)', async function () {
+                const result = await basecoin.verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'tcanton:testcoin1', address: receiver }],
+                    },
+                    wallet: {},
+                });
+                result.should.equal(true);
+            });
+            it('should throw when wallet rootAddress does not match receiver', async function () {
+                const wrongAddress = 'wrong-party::1220bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+                await basecoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'tcanton:testcoin1' }],
+                    },
+                    wallet: walletWithRootAddress(wrongAddress),
+                })
+                    .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);
+            });
+            it('should throw when explicit enableToken.address does not match receiver', async function () {
+                const wrongAddress = 'wrong-party::1220bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+                await basecoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex },
+                    txParams: {
+                        type: 'enabletoken',
+                        enableTokens: [{ name: 'tcanton:testcoin1', address: wrongAddress }],
+                    },
+                    wallet: {},
+                })
+                    .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);
+            });
+        });
+    });
+    describe('TransferPreapprovalCancel (disable token flow):', function () {
+        // Real captured TransferPreapproval_Cancel exercise-node fixture: parsed sender === receiver
+        // === CancelParty, matching the actual on-chain choice/actingParties shape.
+        it('should return true when txParams has no type (non-disabletoken flow)', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {},
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when enableTokens is absent', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { type: 'disabletoken' },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when enableTokens is empty', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: { type: 'disabletoken', enableTokens: [] },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when wallet has no coinSpecific and no explicit address (receiver check skipped)', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    type: 'disabletoken',
+                    enableTokens: [{ name: 'canton' }],
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when wallet rootAddress matches the parsed receiver', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    type: 'disabletoken',
+                    enableTokens: [{ name: 'canton' }],
+                },
+                wallet: walletWithRootAddress(resources_1.CancelParty),
+            });
+            result.should.equal(true);
+        });
+        it('should return true when explicit enableToken.address matches the parsed receiver', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    type: 'disabletoken',
+                    enableTokens: [{ name: 'canton', address: resources_1.CancelParty }],
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should throw when wallet rootAddress does not match the parsed receiver', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const someAddress = 'some-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    type: 'disabletoken',
+                    enableTokens: [{ name: 'canton' }],
+                },
+                wallet: walletWithRootAddress(someAddress),
+            })
+                .should.be.rejectedWith(/TransferPreapprovalCancel receiver mismatch/);
+        });
+        it('should throw when explicit enableToken.address does not match the parsed receiver', async function () {
+            const txHex = buildRawTx('TransferPreapprovalCancel', resources_1.TransferPreapprovalCancelPrepareResponse, resources_1.OneStepEnablement.commandId);
+            const someAddress = 'some-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    type: 'disabletoken',
+                    enableTokens: [{ name: 'canton', address: someAddress }],
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/TransferPreapprovalCancel receiver mismatch/);
+        });
+    });
+});
+describe('Canton verifyTransaction - AllocationReject:', function () {
+    let bitgo;
+    let basecoin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('canton', src_1.Canton.createInstance);
+        bitgo.safeRegister('tcanton', src_1.Tcanton.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tcanton');
+    });
+    it('should return true for an AllocationReject transaction (no recipient info to verify)', async function () {
+        const txHex = buildRawTx('AllocationReject', resources_1.CantonAllocationRejectPrepareResponse, resources_1.AllocationRejection.commandId);
+        const result = await basecoin.verifyTransaction({
+            txPrebuild: { txHex },
+            txParams: {},
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+});
+describe('Canton explainTransaction - AllocationReject:', function () {
+    it('should return an empty explanation (no funds move on an AllocationRequest reject)', function () {
+        // AllocationRequest_Reject fires before the actor has allocated their leg — no Holding
+        // was ever locked for this trade, so nothing is returned. Unlike TransferReject (which
+        // unwinds a real fund movement), this is a pure "decline to trade" signal with no
+        // balance impact, so it intentionally falls through to the default (empty) explanation
+        // rather than being reported as an input.
+        const tx = new src_1.Transaction(statics_1.coins.get('tcanton'));
+        tx.id = resources_1.AllocationRejection.commandId;
+        tx.transactionType = sdk_core_1.TransactionType.AllocationReject;
+        tx.prepareCommand = resources_1.CantonAllocationRejectPrepareResponse;
+        const explanation = tx.explainTransaction();
+        explanation.inputs.length.should.equal(0);
+        explanation.inputAmount.should.equal('0');
+        explanation.outputs.length.should.equal(0);
+        explanation.outputAmount.should.equal('0');
+    });
+});
+// --------------- ExerciseCommand verification tests ---------------
+const CANTON_CMD_ACT_AS = 'RegRegistrar::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5';
+const CANTON_CMD_TEMPLATE_ID = '7a75ef6e69f69395a4e60919e228528bb8f3881150ccfde3f31bcc73864b18ab:Utility.Registry.App.V0.Service.AllocationFactory:AllocationFactory';
+const CANTON_CMD_CONTRACT_ID = '00f3afdce846a40c6f3f618c4b584b022a0197010057ecd59458200183ab27de0aca1212204aef7ede37a5f41b674a1d95446d42a404461c5558c4e6d1860b65560120ef18';
+const CANTON_CMD_CHOICE = 'AllocationFactory_OfferMint';
+function buildCantonCommandRawTx(prepareResponse, commandId) {
+    const data = {
+        prepareCommandResponse: prepareResponse,
+        txType: 'CantonCommand',
+        preparedTransaction: '',
+        partySignatures: { signatures: [] },
+        deduplicationPeriod: { Empty: {} },
+        submissionId: commandId,
+        hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2',
+        minLedgerTime: { time: { Empty: {} } },
+    };
+    return Buffer.from(JSON.stringify(data)).toString('base64');
+}
+describe('Canton verifyTransaction - CantonCommand:', function () {
+    let bitgo;
+    let basecoin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('canton', src_1.Canton.createInstance);
+        bitgo.safeRegister('tcanton', src_1.Tcanton.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tcanton');
+    });
+    describe('Happy path tests:', function () {
+        let txHex;
+        before(function () {
+            txHex = buildCantonCommandRawTx(resources_1.CantonExerciseCommandPrepareResponse, 'test-canton-cmd-001');
+        });
+        it('should return true when cantonCommandParams is undefined (no user params to verify)', async function () {
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {},
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true for matching ExerciseCommand (templateId, choice, contractId, actAs, argument)', async function () {
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                contractId: CANTON_CMD_CONTRACT_ID,
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {
+                                    expectedAdmin: CANTON_CMD_ACT_AS,
+                                    mint: {
+                                        instrumentId: {
+                                            admin: CANTON_CMD_ACT_AS,
+                                            id: 'TESTTOKEN',
+                                        },
+                                        amount: '100',
+                                        holder: 'RegIssuer::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5',
+                                        reference: 'test-prepare-mint',
+                                    },
+                                },
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                        readAs: [],
+                    },
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when contractId is omitted (IMS-resolved)', async function () {
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                        readAs: [],
+                    },
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true with resolveContracts injectAs skipping contractId (empty contractId)', async function () {
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                contractId: '',
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                        readAs: [],
+                        resolveContracts: [
+                            {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                actAs: [CANTON_CMD_ACT_AS],
+                                injectAs: 'command.ExerciseCommand.contractId',
+                            },
+                        ],
+                    },
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true with resolveContracts injectAs skipping non-empty contractId mismatch', async function () {
+            // User supplies a placeholder contractId that doesn't match what's on-chain;
+            // resolveContracts marks it as IMS-injected, so the mismatch must be ignored.
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                contractId: '00placeholder_contract_id_not_on_chain',
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                        readAs: [],
+                        resolveContracts: [
+                            {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                actAs: [CANTON_CMD_ACT_AS],
+                                injectAs: 'command.ExerciseCommand.contractId',
+                            },
+                        ],
+                    },
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+    });
+    describe('Error cases:', function () {
+        let txHex;
+        before(function () {
+            txHex = buildCantonCommandRawTx(resources_1.CantonExerciseCommandPrepareResponse, 'test-canton-cmd-002');
+        });
+        it('should throw when preparedTransaction is missing on tx prebuild', async function () {
+            const emptyPrepare = { ...resources_1.CantonExerciseCommandPrepareResponse, preparedTransaction: undefined };
+            const badTx = buildCantonCommandRawTx(emptyPrepare, 'cmd-bad');
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex: badTx },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: { templateId: CANTON_CMD_TEMPLATE_ID, choice: CANTON_CMD_CHOICE, choiceArgument: {} },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/missing preparedTransaction/);
+        });
+        it('should throw when user command has neither CreateCommand nor ExerciseCommand', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: { UnknownCommand: {} },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/must contain a CreateCommand or ExerciseCommand/);
+        });
+        it('should throw when user command contains both CreateCommand and ExerciseCommand', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            CreateCommand: { templateId: CANTON_CMD_TEMPLATE_ID, createArguments: {} },
+                            ExerciseCommand: { templateId: CANTON_CMD_TEMPLATE_ID, choice: CANTON_CMD_CHOICE, choiceArgument: {} },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/exactly one of CreateCommand or ExerciseCommand/);
+        });
+        it('should throw on invalid user templateId format', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: 'InvalidFormat',
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/invalid user templateId/);
+        });
+        it('should throw on templateId module/entity mismatch', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: 'SomePkg:Wrong.Module:WrongEntity',
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/templateId mismatch/);
+        });
+        it('should throw on submitterInfo.actAs mismatch', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: ['WrongParty::1220aaaa'],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/submitterInfo.actAs.*does not match user actAs/);
+        });
+        it('should throw on choice mismatch for ExerciseCommand', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                choice: 'WrongChoice',
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/choice mismatch/);
+        });
+        it('should throw on contractId mismatch when user provides explicit contractId', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                contractId: '00wrongcontractid',
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {},
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/contractId mismatch/);
+        });
+        it('should throw on argument deep mismatch', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            ExerciseCommand: {
+                                templateId: CANTON_CMD_TEMPLATE_ID,
+                                choice: CANTON_CMD_CHOICE,
+                                choiceArgument: {
+                                    expectedAdmin: 'WrongParty::totally-different',
+                                },
+                            },
+                        },
+                        actAs: [CANTON_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/mismatch/);
+        });
+    });
+});
+// --------------- CreateCommand verification tests ---------------
+const CREATE_CMD_ACT_AS = 'RegProvider::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5';
+const CREATE_CMD_TEMPLATE_ID = '7a75ef6e69f69395a4e60919e228528bb8f3881150ccfde3f31bcc73864b18ab:Utility.Registry.App.V0.Service.Provider:ProviderServiceRequest';
+const CREATE_CMD_OPERATOR = 'RegOperator::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5';
+describe('Canton verifyTransaction - CreateCommand:', function () {
+    let bitgo;
+    let basecoin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('canton', src_1.Canton.createInstance);
+        bitgo.safeRegister('tcanton', src_1.Tcanton.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tcanton');
+    });
+    describe('Happy path tests:', function () {
+        let txHex;
+        before(function () {
+            txHex = buildCantonCommandRawTx(resources_1.CantonCreateCommandPrepareResponse, 'test-create-cmd-001');
+        });
+        it('should return true for matching CreateCommand (templateId, createArguments, actAs)', async function () {
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            CreateCommand: {
+                                templateId: CREATE_CMD_TEMPLATE_ID,
+                                createArguments: {
+                                    operator: CREATE_CMD_OPERATOR,
+                                    provider: CREATE_CMD_ACT_AS,
+                                },
+                            },
+                        },
+                        actAs: [CREATE_CMD_ACT_AS],
+                        readAs: [],
+                    },
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true when createArguments is empty (no deep-compare)', async function () {
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            CreateCommand: {
+                                templateId: CREATE_CMD_TEMPLATE_ID,
+                                createArguments: {},
+                            },
+                        },
+                        actAs: [CREATE_CMD_ACT_AS],
+                        readAs: [],
+                    },
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+        it('should return true with resolveContracts injectAs skipping createArguments field', async function () {
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            CreateCommand: {
+                                templateId: CREATE_CMD_TEMPLATE_ID,
+                                createArguments: {
+                                    operator: 'placeholder-operator-id',
+                                    provider: CREATE_CMD_ACT_AS,
+                                },
+                            },
+                        },
+                        actAs: [CREATE_CMD_ACT_AS],
+                        readAs: [],
+                        resolveContracts: [
+                            {
+                                templateId: 'some-template',
+                                actAs: [CREATE_CMD_ACT_AS],
+                                injectAs: 'command.CreateCommand.createArguments.operator',
+                            },
+                        ],
+                    },
+                },
+                wallet: {},
+            });
+            result.should.equal(true);
+        });
+    });
+    describe('Error cases:', function () {
+        let txHex;
+        before(function () {
+            txHex = buildCantonCommandRawTx(resources_1.CantonCreateCommandPrepareResponse, 'test-create-cmd-err');
+        });
+        it('should throw on templateId mismatch for CreateCommand', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            CreateCommand: {
+                                templateId: 'WrongPkg:Wrong.Module:WrongEntity',
+                                createArguments: {},
+                            },
+                        },
+                        actAs: [CREATE_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/templateId mismatch/);
+        });
+        it('should throw on createArguments deep mismatch', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            CreateCommand: {
+                                templateId: CREATE_CMD_TEMPLATE_ID,
+                                createArguments: {
+                                    operator: 'WrongOperator::totally-different',
+                                    provider: CREATE_CMD_ACT_AS,
+                                },
+                            },
+                        },
+                        actAs: [CREATE_CMD_ACT_AS],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/mismatch/);
+        });
+        it('should throw on actAs mismatch for CreateCommand', async function () {
+            await basecoin
+                .verifyTransaction({
+                txPrebuild: { txHex },
+                txParams: {
+                    cantonCommandParams: {
+                        command: {
+                            CreateCommand: {
+                                templateId: CREATE_CMD_TEMPLATE_ID,
+                                createArguments: {},
+                            },
+                        },
+                        actAs: ['WrongParty::1220aaaa'],
+                    },
+                },
+                wallet: {},
+            })
+                .should.be.rejectedWith(/submitterInfo.actAs.*does not match user actAs/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canton.js","sourceRoot":"","sources":["../../../test/unit/canton.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { CantonCommand, IWallet, TransactionType } from '@bitgo-beta/sdk-core';\nimport { coins } from '@bitgo-beta/statics';\n\nimport { Canton, CantonTransactionParams, Tcanton, Transaction, TransactionBuilderFactory } from '../../src';\nimport { CantonPrepareCommandResponse } from '../../src/lib/iface';\nimport {\n  AllocationRejection,\n  CantonAllocationRejectPrepareResponse,\n  CantonExerciseCommandPrepareResponse,\n  CantonCreateCommandPrepareResponse,\n  CantonTokenPreApprovalPrepareResponse,\n  CancelParty,\n  OneStepEnablement,\n  OneStepPreApprovalPrepareResponse,\n  TransferPreapprovalCancelPrepareResponse,\n} from '../resources';\n\n/**\n * Builds a base64-encoded raw transaction for a OneStepPreApproval (enable token flow).\n * For TSS wallets (which Canton always is), verifyTransaction receives txParams.enableTokens,\n * not txParams.recipients. The wallet SDK's buildTokenEnablements passes enableTokens through\n * unchanged for TSS wallets rather than converting them to recipients.\n */\nfunction buildOneStepPreApprovalRawTx(\n  prepareResponse: typeof OneStepPreApprovalPrepareResponse,\n  commandId: string\n): string {\n  const data = {\n    prepareCommandResponse: prepareResponse,\n    txType: 'OneStepPreApproval',\n    preparedTransaction: '',\n    partySignatures: { signatures: [] },\n    deduplicationPeriod: { Empty: {} },\n    submissionId: commandId,\n    hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2',\n    minLedgerTime: { time: { Empty: {} } },\n  };\n  return Buffer.from(JSON.stringify(data)).toString('base64');\n}\n\n/** Returns a mock wallet whose coinSpecific().rootAddress matches the given party ID. */\nfunction walletWithRootAddress(rootAddress: string): IWallet {\n  return { coinSpecific: () => ({ rootAddress }) } as unknown as IWallet;\n}\n\n/** Builds a base64-encoded raw transaction for a non-OneStep txType (e.g. AllocationReject). */\nfunction buildRawTx(txType: string, prepareResponse: unknown, commandId: string): string {\n  const data = {\n    prepareCommandResponse: prepareResponse,\n    txType,\n    preparedTransaction: '',\n    partySignatures: { signatures: [] },\n    deduplicationPeriod: { Empty: {} },\n    submissionId: commandId,\n    hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2',\n    minLedgerTime: { time: { Empty: {} } },\n  };\n  return Buffer.from(JSON.stringify(data)).toString('base64');\n}\n\ndescribe('Canton coin:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin: Canton;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('canton', Canton.createInstance);\n    bitgo.safeRegister('tcanton', Tcanton.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tcanton') as Canton;\n  });\n\n  describe('supportsMessageSigning', function () {\n    it('should return true', function () {\n      basecoin.supportsMessageSigning().should.equal(true);\n    });\n  });\n});\n\ndescribe('Canton verifyTransaction:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin: Canton;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('canton', Canton.createInstance);\n    bitgo.safeRegister('tcanton', Tcanton.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tcanton') as Canton;\n  });\n\n  describe('OneStepPreApproval (enable token flow):', function () {\n    it('should return true when txParams has no type (non-enabletoken flow)', async function () {\n      const txHex = buildOneStepPreApprovalRawTx(OneStepPreApprovalPrepareResponse, OneStepEnablement.commandId);\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {},\n        wallet: {} as any,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when enableTokens is absent', async function () {\n      const txHex = buildOneStepPreApprovalRawTx(OneStepPreApprovalPrepareResponse, OneStepEnablement.commandId);\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: { type: 'enabletoken' },\n        wallet: {} as any,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when enableTokens is empty', async function () {\n      const txHex = buildOneStepPreApprovalRawTx(OneStepPreApprovalPrepareResponse, OneStepEnablement.commandId);\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: { type: 'enabletoken', enableTokens: [] },\n        wallet: {} as any,\n      });\n      result.should.equal(true);\n    });\n\n    describe('coin pre-approval (TransferPreapprovalProposal):', function () {\n      let txHex: string;\n      let receiver: string;\n\n      before(function () {\n        txHex = buildOneStepPreApprovalRawTx(OneStepPreApprovalPrepareResponse, OneStepEnablement.commandId);\n        // Dynamically derive receiver from parsed transaction to avoid hardcoding protobuf-decoded addresses\n        const txBuilder = new TransactionBuilderFactory(coins.get('tcanton')).from(txHex);\n        receiver = (txBuilder.transaction as any).toJson().receiver as string;\n      });\n\n      it('should return true when wallet has no coinSpecific (receiver check skipped)', async function () {\n        // Typical case: wallet mock has no coinSpecific() method, and no address in enableTokens\n        const result = await basecoin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'canton' }],\n          },\n          wallet: {} as any,\n        });\n        result.should.equal(true);\n      });\n\n      it('should return true when wallet rootAddress matches receiver', async function () {\n        // Typical UI flow: enableTokens has no address, receiver validated from wallet.coinSpecific().rootAddress\n        const result = await basecoin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'canton' }],\n          },\n          wallet: walletWithRootAddress(receiver),\n        });\n        result.should.equal(true);\n      });\n\n      it('should return true when enableToken.address matches receiver (explicit address)', async function () {\n        const result = await basecoin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'canton', address: receiver }],\n          },\n          wallet: {} as any,\n        });\n        result.should.equal(true);\n      });\n\n      it('should throw when wallet rootAddress does not match receiver', async function () {\n        const wrongAddress = 'wrong-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\n        await basecoin\n          .verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: {\n              type: 'enabletoken',\n              enableTokens: [{ name: 'canton' }],\n            },\n            wallet: walletWithRootAddress(wrongAddress),\n          })\n          .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);\n      });\n\n      it('should throw when explicit enableToken.address does not match receiver', async function () {\n        const wrongAddress = 'wrong-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\n        await basecoin\n          .verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: {\n              type: 'enabletoken',\n              enableTokens: [{ name: 'canton', address: wrongAddress }],\n            },\n            wallet: {} as any,\n          })\n          .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);\n      });\n    });\n\n    describe('token pre-approval (TransferPreapproval):', function () {\n      let txHex: string;\n      let receiver: string;\n\n      before(function () {\n        const commandId = '7d99789d-2f22-49e1-85cb-79d2ce5a69c1';\n        txHex = buildOneStepPreApprovalRawTx(CantonTokenPreApprovalPrepareResponse, commandId);\n        const txBuilder = new TransactionBuilderFactory(coins.get('tcanton')).from(txHex);\n        receiver = (txBuilder.transaction as any).toJson().receiver as string;\n      });\n\n      it('should return true when wallet rootAddress matches receiver', async function () {\n        const result = await basecoin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'tcanton:testcoin1' }],\n          },\n          wallet: walletWithRootAddress(receiver),\n        });\n        result.should.equal(true);\n      });\n\n      it('should return true when enableToken.address matches receiver (explicit address)', async function () {\n        const result = await basecoin.verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'tcanton:testcoin1', address: receiver }],\n          },\n          wallet: {} as any,\n        });\n        result.should.equal(true);\n      });\n\n      it('should throw when wallet rootAddress does not match receiver', async function () {\n        const wrongAddress = 'wrong-party::1220bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';\n        await basecoin\n          .verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: {\n              type: 'enabletoken',\n              enableTokens: [{ name: 'tcanton:testcoin1' }],\n            },\n            wallet: walletWithRootAddress(wrongAddress),\n          })\n          .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);\n      });\n\n      it('should throw when explicit enableToken.address does not match receiver', async function () {\n        const wrongAddress = 'wrong-party::1220bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';\n        await basecoin\n          .verifyTransaction({\n            txPrebuild: { txHex },\n            txParams: {\n              type: 'enabletoken',\n              enableTokens: [{ name: 'tcanton:testcoin1', address: wrongAddress }],\n            },\n            wallet: {} as any,\n          })\n          .should.be.rejectedWith(/OneStepPreApproval receiver mismatch/);\n      });\n    });\n  });\n\n  describe('TransferPreapprovalCancel (disable token flow):', function () {\n    // Real captured TransferPreapproval_Cancel exercise-node fixture: parsed sender === receiver\n    // === CancelParty, matching the actual on-chain choice/actingParties shape.\n    it('should return true when txParams has no type (non-disabletoken flow)', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {},\n        wallet: {} as unknown as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when enableTokens is absent', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: { type: 'disabletoken' },\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when enableTokens is empty', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: { type: 'disabletoken', enableTokens: [] },\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when wallet has no coinSpecific and no explicit address (receiver check skipped)', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          type: 'disabletoken',\n          enableTokens: [{ name: 'canton' }],\n        },\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when wallet rootAddress matches the parsed receiver', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          type: 'disabletoken',\n          enableTokens: [{ name: 'canton' }],\n        },\n        wallet: walletWithRootAddress(CancelParty),\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when explicit enableToken.address matches the parsed receiver', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          type: 'disabletoken',\n          enableTokens: [{ name: 'canton', address: CancelParty }],\n        },\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should throw when wallet rootAddress does not match the parsed receiver', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const someAddress = 'some-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            type: 'disabletoken',\n            enableTokens: [{ name: 'canton' }],\n          },\n          wallet: walletWithRootAddress(someAddress),\n        })\n        .should.be.rejectedWith(/TransferPreapprovalCancel receiver mismatch/);\n    });\n\n    it('should throw when explicit enableToken.address does not match the parsed receiver', async function () {\n      const txHex = buildRawTx(\n        'TransferPreapprovalCancel',\n        TransferPreapprovalCancelPrepareResponse,\n        OneStepEnablement.commandId\n      );\n      const someAddress = 'some-party::1220aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            type: 'disabletoken',\n            enableTokens: [{ name: 'canton', address: someAddress }],\n          },\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/TransferPreapprovalCancel receiver mismatch/);\n    });\n  });\n});\n\ndescribe('Canton verifyTransaction - AllocationReject:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin: Canton;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('canton', Canton.createInstance);\n    bitgo.safeRegister('tcanton', Tcanton.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tcanton') as Canton;\n  });\n\n  it('should return true for an AllocationReject transaction (no recipient info to verify)', async function () {\n    const txHex = buildRawTx('AllocationReject', CantonAllocationRejectPrepareResponse, AllocationRejection.commandId);\n    const result = await basecoin.verifyTransaction({\n      txPrebuild: { txHex },\n      txParams: {},\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n});\n\ndescribe('Canton explainTransaction - AllocationReject:', function () {\n  it('should return an empty explanation (no funds move on an AllocationRequest reject)', function () {\n    // AllocationRequest_Reject fires before the actor has allocated their leg — no Holding\n    // was ever locked for this trade, so nothing is returned. Unlike TransferReject (which\n    // unwinds a real fund movement), this is a pure \"decline to trade\" signal with no\n    // balance impact, so it intentionally falls through to the default (empty) explanation\n    // rather than being reported as an input.\n    const tx = new Transaction(coins.get('tcanton'));\n    tx.id = AllocationRejection.commandId;\n    tx.transactionType = TransactionType.AllocationReject;\n    tx.prepareCommand = CantonAllocationRejectPrepareResponse;\n\n    const explanation = tx.explainTransaction();\n\n    explanation.inputs!.length.should.equal(0);\n    explanation.inputAmount!.should.equal('0');\n    explanation.outputs!.length.should.equal(0);\n    explanation.outputAmount!.should.equal('0');\n  });\n});\n\n// --------------- ExerciseCommand verification tests ---------------\n\nconst CANTON_CMD_ACT_AS = 'RegRegistrar::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5';\nconst CANTON_CMD_TEMPLATE_ID =\n  '7a75ef6e69f69395a4e60919e228528bb8f3881150ccfde3f31bcc73864b18ab:Utility.Registry.App.V0.Service.AllocationFactory:AllocationFactory';\nconst CANTON_CMD_CONTRACT_ID =\n  '00f3afdce846a40c6f3f618c4b584b022a0197010057ecd59458200183ab27de0aca1212204aef7ede37a5f41b674a1d95446d42a404461c5558c4e6d1860b65560120ef18';\nconst CANTON_CMD_CHOICE = 'AllocationFactory_OfferMint';\n\nfunction buildCantonCommandRawTx(prepareResponse: Partial<CantonPrepareCommandResponse>, commandId: string): string {\n  const data = {\n    prepareCommandResponse: prepareResponse,\n    txType: 'CantonCommand',\n    preparedTransaction: '',\n    partySignatures: { signatures: [] },\n    deduplicationPeriod: { Empty: {} },\n    submissionId: commandId,\n    hashingSchemeVersion: 'HASHING_SCHEME_VERSION_V2',\n    minLedgerTime: { time: { Empty: {} } },\n  };\n  return Buffer.from(JSON.stringify(data)).toString('base64');\n}\n\ndescribe('Canton verifyTransaction - CantonCommand:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin: Canton;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('canton', Canton.createInstance);\n    bitgo.safeRegister('tcanton', Tcanton.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tcanton') as Canton;\n  });\n\n  describe('Happy path tests:', function () {\n    let txHex: string;\n\n    before(function () {\n      txHex = buildCantonCommandRawTx(CantonExerciseCommandPrepareResponse, 'test-canton-cmd-001');\n    });\n\n    it('should return true when cantonCommandParams is undefined (no user params to verify)', async function () {\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {},\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true for matching ExerciseCommand (templateId, choice, contractId, actAs, argument)', async function () {\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          cantonCommandParams: {\n            command: {\n              ExerciseCommand: {\n                templateId: CANTON_CMD_TEMPLATE_ID,\n                contractId: CANTON_CMD_CONTRACT_ID,\n                choice: CANTON_CMD_CHOICE,\n                choiceArgument: {\n                  expectedAdmin: CANTON_CMD_ACT_AS,\n                  mint: {\n                    instrumentId: {\n                      admin: CANTON_CMD_ACT_AS,\n                      id: 'TESTTOKEN',\n                    },\n                    amount: '100',\n                    holder: 'RegIssuer::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5',\n                    reference: 'test-prepare-mint',\n                  },\n                },\n              },\n            },\n            actAs: [CANTON_CMD_ACT_AS],\n            readAs: [],\n          },\n        } as CantonTransactionParams,\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when contractId is omitted (IMS-resolved)', async function () {\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          cantonCommandParams: {\n            command: {\n              ExerciseCommand: {\n                templateId: CANTON_CMD_TEMPLATE_ID,\n                choice: CANTON_CMD_CHOICE,\n                choiceArgument: {},\n              },\n            },\n            actAs: [CANTON_CMD_ACT_AS],\n            readAs: [],\n          },\n        } as CantonTransactionParams,\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true with resolveContracts injectAs skipping contractId (empty contractId)', async function () {\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          cantonCommandParams: {\n            command: {\n              ExerciseCommand: {\n                templateId: CANTON_CMD_TEMPLATE_ID,\n                contractId: '',\n                choice: CANTON_CMD_CHOICE,\n                choiceArgument: {},\n              },\n            },\n            actAs: [CANTON_CMD_ACT_AS],\n            readAs: [],\n            resolveContracts: [\n              {\n                templateId: CANTON_CMD_TEMPLATE_ID,\n                actAs: [CANTON_CMD_ACT_AS],\n                injectAs: 'command.ExerciseCommand.contractId',\n              },\n            ],\n          },\n        } as CantonTransactionParams,\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true with resolveContracts injectAs skipping non-empty contractId mismatch', async function () {\n      // User supplies a placeholder contractId that doesn't match what's on-chain;\n      // resolveContracts marks it as IMS-injected, so the mismatch must be ignored.\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          cantonCommandParams: {\n            command: {\n              ExerciseCommand: {\n                templateId: CANTON_CMD_TEMPLATE_ID,\n                contractId: '00placeholder_contract_id_not_on_chain',\n                choice: CANTON_CMD_CHOICE,\n                choiceArgument: {},\n              },\n            },\n            actAs: [CANTON_CMD_ACT_AS],\n            readAs: [],\n            resolveContracts: [\n              {\n                templateId: CANTON_CMD_TEMPLATE_ID,\n                actAs: [CANTON_CMD_ACT_AS],\n                injectAs: 'command.ExerciseCommand.contractId',\n              },\n            ],\n          },\n        } as CantonTransactionParams,\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n  });\n\n  describe('Error cases:', function () {\n    let txHex: string;\n\n    before(function () {\n      txHex = buildCantonCommandRawTx(CantonExerciseCommandPrepareResponse, 'test-canton-cmd-002');\n    });\n\n    it('should throw when preparedTransaction is missing on tx prebuild', async function () {\n      const emptyPrepare = { ...CantonExerciseCommandPrepareResponse, preparedTransaction: undefined };\n      const badTx = buildCantonCommandRawTx(emptyPrepare, 'cmd-bad');\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex: badTx },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                ExerciseCommand: { templateId: CANTON_CMD_TEMPLATE_ID, choice: CANTON_CMD_CHOICE, choiceArgument: {} },\n              },\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/missing preparedTransaction/);\n    });\n\n    it('should throw when user command has neither CreateCommand nor ExerciseCommand', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: { UnknownCommand: {} } as unknown as CantonCommand,\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/must contain a CreateCommand or ExerciseCommand/);\n    });\n\n    it('should throw when user command contains both CreateCommand and ExerciseCommand', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                CreateCommand: { templateId: CANTON_CMD_TEMPLATE_ID, createArguments: {} },\n                ExerciseCommand: { templateId: CANTON_CMD_TEMPLATE_ID, choice: CANTON_CMD_CHOICE, choiceArgument: {} },\n              } as unknown as CantonCommand,\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/exactly one of CreateCommand or ExerciseCommand/);\n    });\n\n    it('should throw on invalid user templateId format', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                ExerciseCommand: {\n                  templateId: 'InvalidFormat',\n                  choice: CANTON_CMD_CHOICE,\n                  choiceArgument: {},\n                },\n              },\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/invalid user templateId/);\n    });\n\n    it('should throw on templateId module/entity mismatch', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                ExerciseCommand: {\n                  templateId: 'SomePkg:Wrong.Module:WrongEntity',\n                  choice: CANTON_CMD_CHOICE,\n                  choiceArgument: {},\n                },\n              },\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/templateId mismatch/);\n    });\n\n    it('should throw on submitterInfo.actAs mismatch', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                ExerciseCommand: {\n                  templateId: CANTON_CMD_TEMPLATE_ID,\n                  choice: CANTON_CMD_CHOICE,\n                  choiceArgument: {},\n                },\n              },\n              actAs: ['WrongParty::1220aaaa'],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/submitterInfo.actAs.*does not match user actAs/);\n    });\n\n    it('should throw on choice mismatch for ExerciseCommand', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                ExerciseCommand: {\n                  templateId: CANTON_CMD_TEMPLATE_ID,\n                  choice: 'WrongChoice',\n                  choiceArgument: {},\n                },\n              },\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/choice mismatch/);\n    });\n\n    it('should throw on contractId mismatch when user provides explicit contractId', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                ExerciseCommand: {\n                  templateId: CANTON_CMD_TEMPLATE_ID,\n                  contractId: '00wrongcontractid',\n                  choice: CANTON_CMD_CHOICE,\n                  choiceArgument: {},\n                },\n              },\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/contractId mismatch/);\n    });\n\n    it('should throw on argument deep mismatch', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                ExerciseCommand: {\n                  templateId: CANTON_CMD_TEMPLATE_ID,\n                  choice: CANTON_CMD_CHOICE,\n                  choiceArgument: {\n                    expectedAdmin: 'WrongParty::totally-different',\n                  },\n                },\n              },\n              actAs: [CANTON_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/mismatch/);\n    });\n  });\n});\n\n// --------------- CreateCommand verification tests ---------------\n\nconst CREATE_CMD_ACT_AS = 'RegProvider::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5';\nconst CREATE_CMD_TEMPLATE_ID =\n  '7a75ef6e69f69395a4e60919e228528bb8f3881150ccfde3f31bcc73864b18ab:Utility.Registry.App.V0.Service.Provider:ProviderServiceRequest';\nconst CREATE_CMD_OPERATOR = 'RegOperator::1220508e54fb709dcb1a9b4096408ad415d2217d8881ad9034a9850752933ba88ad5';\n\ndescribe('Canton verifyTransaction - CreateCommand:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin: Canton;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('canton', Canton.createInstance);\n    bitgo.safeRegister('tcanton', Tcanton.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tcanton') as Canton;\n  });\n\n  describe('Happy path tests:', function () {\n    let txHex: string;\n\n    before(function () {\n      txHex = buildCantonCommandRawTx(CantonCreateCommandPrepareResponse, 'test-create-cmd-001');\n    });\n\n    it('should return true for matching CreateCommand (templateId, createArguments, actAs)', async function () {\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          cantonCommandParams: {\n            command: {\n              CreateCommand: {\n                templateId: CREATE_CMD_TEMPLATE_ID,\n                createArguments: {\n                  operator: CREATE_CMD_OPERATOR,\n                  provider: CREATE_CMD_ACT_AS,\n                },\n              },\n            },\n            actAs: [CREATE_CMD_ACT_AS],\n            readAs: [],\n          },\n        } as CantonTransactionParams,\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true when createArguments is empty (no deep-compare)', async function () {\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          cantonCommandParams: {\n            command: {\n              CreateCommand: {\n                templateId: CREATE_CMD_TEMPLATE_ID,\n                createArguments: {},\n              },\n            },\n            actAs: [CREATE_CMD_ACT_AS],\n            readAs: [],\n          },\n        } as CantonTransactionParams,\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n\n    it('should return true with resolveContracts injectAs skipping createArguments field', async function () {\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex },\n        txParams: {\n          cantonCommandParams: {\n            command: {\n              CreateCommand: {\n                templateId: CREATE_CMD_TEMPLATE_ID,\n                createArguments: {\n                  operator: 'placeholder-operator-id',\n                  provider: CREATE_CMD_ACT_AS,\n                },\n              },\n            },\n            actAs: [CREATE_CMD_ACT_AS],\n            readAs: [],\n            resolveContracts: [\n              {\n                templateId: 'some-template',\n                actAs: [CREATE_CMD_ACT_AS],\n                injectAs: 'command.CreateCommand.createArguments.operator',\n              },\n            ],\n          },\n        } as CantonTransactionParams,\n        wallet: {} as IWallet,\n      });\n      result.should.equal(true);\n    });\n  });\n\n  describe('Error cases:', function () {\n    let txHex: string;\n\n    before(function () {\n      txHex = buildCantonCommandRawTx(CantonCreateCommandPrepareResponse, 'test-create-cmd-err');\n    });\n\n    it('should throw on templateId mismatch for CreateCommand', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                CreateCommand: {\n                  templateId: 'WrongPkg:Wrong.Module:WrongEntity',\n                  createArguments: {},\n                },\n              },\n              actAs: [CREATE_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/templateId mismatch/);\n    });\n\n    it('should throw on createArguments deep mismatch', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                CreateCommand: {\n                  templateId: CREATE_CMD_TEMPLATE_ID,\n                  createArguments: {\n                    operator: 'WrongOperator::totally-different',\n                    provider: CREATE_CMD_ACT_AS,\n                  },\n                },\n              },\n              actAs: [CREATE_CMD_ACT_AS],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/mismatch/);\n    });\n\n    it('should throw on actAs mismatch for CreateCommand', async function () {\n      await basecoin\n        .verifyTransaction({\n          txPrebuild: { txHex },\n          txParams: {\n            cantonCommandParams: {\n              command: {\n                CreateCommand: {\n                  templateId: CREATE_CMD_TEMPLATE_ID,\n                  createArguments: {},\n                },\n              },\n              actAs: ['WrongParty::1220aaaa'],\n            },\n          } as CantonTransactionParams,\n          wallet: {} as IWallet,\n        })\n        .should.be.rejectedWith(/submitterInfo.actAs.*does not match user actAs/);\n    });\n  });\n});\n"]}