@bitgo-beta/sdk-coin-canton 1.0.1-beta.62 → 1.0.1-beta.621

package/dist/test/unit/canton.js

@@ -0,0 +1,705 @@
+"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 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 }) };
+}
+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/);
+            });
+        });
+    });
+});
+// --------------- 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 } from '@bitgo-beta/sdk-core';\nimport { coins } from '@bitgo-beta/statics';\n\nimport { Canton, CantonTransactionParams, Tcanton, TransactionBuilderFactory } from '../../src';\nimport { CantonPrepareCommandResponse } from '../../src/lib/iface';\nimport {\n  CantonExerciseCommandPrepareResponse,\n  CantonCreateCommandPrepareResponse,\n  CantonTokenPreApprovalPrepareResponse,\n  OneStepEnablement,\n  OneStepPreApprovalPrepareResponse,\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\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\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"]}