@bitgo-beta/sdk-coin-canton 1.0.1-beta.91 → 1.0.1-beta.910

package/dist/src/canton.d.ts

@@ -1,11 +1,17 @@
-import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, KeyPair, MPCAlgorithm, MultisigType, ParsedTransaction, ParseTransactionOptions, SignedTransaction, SignTransactionOptions, TransactionType, TssVerifyAddressOptions, VerifyTransactionOptions, TransactionExplanation as BaseTransactionExplanation, PopulatedIntent, PrebuildTransactionWithIntentOptions } from '@bitgo-beta/sdk-core';
+import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, CantonCommandParams, KeyPair, MPCAlgorithm, MultisigType, ParsedTransaction, ParseTransactionOptions, PopulatedIntent, PrebuildTransactionWithIntentOptions, SignedTransaction, SignTransactionOptions, TokenEnablementConfig, TransactionExplanation as BaseTransactionExplanation, TransactionParams, TransactionType, TssVerifyAddressOptions, VerifyTransactionOptions } from '@bitgo-beta/sdk-core';
 import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
+import { BroadridgeCommandParams } from './lib/iface';
 export interface TransactionExplanation extends BaseTransactionExplanation {
     type: TransactionType;
 }
 export interface ExplainTransactionOptions {
     txHex: string;
 }
+export interface CantonTransactionParams extends TransactionParams {
+    cantonCommandParams?: CantonCommandParams;
+    broadridgeCommandParams?: BroadridgeCommandParams;
+    executorPartyId?: string;
+}
 export declare class Canton extends BaseCoin {
     protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
     protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
@@ -21,6 +27,8 @@ export declare class Canton extends BaseCoin {
     getFullName(): string;
     /** @inheritDoc */
     supportsTss(): boolean;
+    /** @inheritDoc */
+    supportsMessageSigning(): boolean;
     /** inherited doc */
     getDefaultMultisigType(): MultisigType;
     /** inherited doc */
@@ -28,6 +36,10 @@ export declare class Canton extends BaseCoin {
     getMPCAlgorithm(): MPCAlgorithm;
     /** @inheritDoc */
     verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
+    private verifyBroadridgeStandingDelegationTransaction;
+    private verifyBroadridgeCommandTransaction;
+    private verifyCantonCommandTransaction;
+    private relativeSkipPaths;
     /** @inheritDoc */
     isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean>;
     /** @inheritDoc */
@@ -41,10 +53,15 @@ export declare class Canton extends BaseCoin {
     /** @inheritDoc */
     isValidAddress(address: string): boolean;
     /** @inheritDoc */
+    getTokenEnablementConfig(): TokenEnablementConfig;
+    getAddressFromPublicKey(publicKeyHex: string): string;
+    /** @inheritDoc */
     signTransaction(params: SignTransactionOptions): Promise<SignedTransaction>;
     /** @inheritDoc */
     auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void;
     /** @inheritDoc */
-    setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void;
+    setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions & {
+        executorPartyId?: string;
+    }): void;
 }
 //# sourceMappingURL=canton.d.ts.map

package/dist/src/canton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canton.d.ts","sourceRoot":"","sources":["../../src/canton.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,SAAS,EACT,OAAO,EACP,YAAY,EACZ,YAAY,EAEZ,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,eAAe,EACf,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,IAAI,0BAA0B,EAEpD,eAAe,EACf,oCAAoC,EACrC,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,MAAM,qBAAqB,CAAC;AAKzE,MAAM,WAAW,sBAAuB,SAAQ,0BAA0B;IACxE,IAAI,EAAE,eAAe,CAAC;CACvB;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,MAAO,SAAQ,QAAQ;IAClC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAE3D,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,OAAO,CAAC,UAAU;IAIlB,kBAAkB;IACX,aAAa,IAAI,MAAM;IAI9B,kBAAkB;IACX,QAAQ,IAAI,MAAM;IAIzB,kBAAkB;IACX,SAAS,IAAI,MAAM;IAI1B,kBAAkB;IACX,WAAW,IAAI,MAAM;IAI5B,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAItC,oBAAoB;IACpB,uCAAuC,IAAI,OAAO;IAIlD,eAAe,IAAI,YAAY;IAI/B,kBAAkB;IACZ,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB3E,kBAAkB;IAClB,eAAe,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlE,kBAAkB;IAClB,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI7E,kBAAkB;IAClB,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAYvC,kBAAkB;IAClB,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAatF,kBAAkB;IAClB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAMxC,kBAAkB;IAClB,eAAe,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI3E,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,uBAAuB,GAAG,IAAI;IAOlF,kBAAkB;IAClB,6BAA6B,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,oCAAoC,GAAG,IAAI;CAK3G"}
+{"version":3,"file":"canton.d.ts","sourceRoot":"","sources":["../../src/canton.ts"],"names":[],"mappings":"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"}

package/dist/src/canton.js

@@ -9,6 +9,7 @@ const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
 const statics_1 = require("@bitgo-beta/statics");
 const lib_1 = require("./lib");
 const keyPair_1 = require("./lib/keyPair");
+const broadridge_1 = require("./lib/broadridge");
 const utils_1 = __importDefault(require("./lib/utils"));
 class Canton extends sdk_core_1.BaseCoin {
     constructor(bitgo, staticsCoin) {
@@ -44,6 +45,10 @@ class Canton extends sdk_core_1.BaseCoin {
     supportsTss() {
         return true;
     }
+    /** @inheritDoc */
+    supportsMessageSigning() {
+        return true;
+    }
     /** inherited doc */
     getDefaultMultisigType() {
         return sdk_core_1.multisigTypes.tss;
@@ -58,31 +63,311 @@ class Canton extends sdk_core_1.BaseCoin {
     /** @inheritDoc */
     async verifyTransaction(params) {
         const coinConfig = statics_1.coins.get(this.getChain());
-        // extract `txParams` when verifying other transaction types
-        const { txPrebuild: txPrebuild } = params;
+        const { txPrebuild: txPrebuild, txParams } = params;
         const rawTx = txPrebuild.txHex;
         if (!rawTx) {
             throw new Error('missing required tx prebuild property txHex');
         }
         const txBuilder = new lib_1.TransactionBuilderFactory(coinConfig).from(rawTx);
         const transaction = txBuilder.transaction;
+        const explainedTx = transaction.explainTransaction();
+        const broadridgeParams = txParams.broadridgeCommandParams;
+        if (broadridgeParams) {
+            return this.verifyBroadridgeCommandTransaction(transaction, broadridgeParams);
+        }
+        if (txParams.type === 'cantonBroadridgeStandingDelegation') {
+            const executorPartyId = txParams.executorPartyId;
+            if (!executorPartyId) {
+                throw new Error('cantonBroadridgeStandingDelegation verifyTransaction: missing executorPartyId');
+            }
+            return this.verifyBroadridgeStandingDelegationTransaction(transaction, executorPartyId);
+        }
         switch (transaction.type) {
-            case sdk_core_1.TransactionType.WalletInitialization: {
-                // there is no input for this type of transaction, so always return true
+            case sdk_core_1.TransactionType.WalletInitialization:
+            case sdk_core_1.TransactionType.TransferAccept:
+            case sdk_core_1.TransactionType.TransferReject:
+            case sdk_core_1.TransactionType.TransferAcknowledge:
+            case sdk_core_1.TransactionType.TransferOfferWithdrawn:
+            case sdk_core_1.TransactionType.CosignDelegationAccept:
+            case sdk_core_1.TransactionType.CosignDelegationProposal:
+            case sdk_core_1.TransactionType.AllocationAllocate:
+            case sdk_core_1.TransactionType.AllocationRequest:
+            case sdk_core_1.TransactionType.AllocationReject:
+            case sdk_core_1.TransactionType.EndInvestorOnboardingOffer:
+            case sdk_core_1.TransactionType.AllocationAllocateWithdrawn:
+                // There is no recipient info to verify for these transaction types, so always return true.
+                return true;
+            case sdk_core_1.TransactionType.CantonCommand:
+                return this.verifyCantonCommandTransaction(transaction, txParams.cantonCommandParams);
+            case sdk_core_1.TransactionType.OneStepPreApproval:
+                // Canton is always a TSS wallet. The SDK's buildTokenEnablements passes enableTokens
+                // through unchanged for TSS wallets (no conversion to recipients), so txParams.enableTokens
+                // is the only source of user intent here.
+                //
+                // Receiver validation: the receiver of a OneStepPreApproval is always the wallet's root address.
+                // We use enableToken.address if explicitly provided, otherwise fall back to
+                // wallet.coinSpecific().rootAddress (the Canton party ID stored at wallet creation time).
+                // Token name validation: checked when the token is resolvable from statics.
+                if (txParams.type === 'enabletoken' &&
+                    txParams.enableTokens !== undefined &&
+                    txParams.enableTokens.length > 0) {
+                    const txData = transaction.toJson();
+                    const enableToken = txParams.enableTokens[0];
+                    const walletRootAddress = params.wallet?.coinSpecific?.()?.rootAddress;
+                    const expectedReceiver = enableToken.address ?? walletRootAddress;
+                    if (expectedReceiver) {
+                        // Strip ?memoId suffix if present in the stored address
+                        const [expectedReceiverBase] = expectedReceiver.split('?memoId=');
+                        if (txData.receiver !== expectedReceiverBase) {
+                            throw new Error(`OneStepPreApproval receiver mismatch: expected '${expectedReceiverBase}', got '${txData.receiver}'`);
+                        }
+                    }
+                    if (txData.token !== undefined && txData.token !== enableToken.name) {
+                        throw new Error(`OneStepPreApproval token name mismatch: expected '${enableToken.name}', got '${txData.token}'`);
+                    }
+                }
+                return true;
+            case sdk_core_1.TransactionType.TransferPreapprovalCancel:
+                // Mirrors OneStepPreApproval's receiver/token validation above, opposite direction.
+                // The cancel is self-service (the wallet's own party exercises the choice on its own
+                // TransferPreapproval), so sender === receiver on the parsed transaction; both must match
+                // the wallet's rootAddress (or the explicit enableToken.address, if provided).
+                if (txParams.type === 'disabletoken' &&
+                    txParams.enableTokens !== undefined &&
+                    txParams.enableTokens.length > 0) {
+                    const txData = transaction.toJson();
+                    const disableToken = txParams.enableTokens[0];
+                    const walletRootAddress = params.wallet?.coinSpecific?.()?.rootAddress;
+                    const expectedParty = disableToken.address ?? walletRootAddress;
+                    if (expectedParty) {
+                        const [expectedPartyBase] = expectedParty.split('?memoId=');
+                        if (txData.receiver !== expectedPartyBase) {
+                            throw new Error(`TransferPreapprovalCancel receiver mismatch: expected '${expectedPartyBase}', got '${txData.receiver}'`);
+                        }
+                    }
+                    if (txData.token !== undefined && txData.token !== disableToken.name) {
+                        throw new Error(`TransferPreapprovalCancel token name mismatch: expected '${disableToken.name}', got '${txData.token}'`);
+                    }
+                }
+                return true;
+            case sdk_core_1.TransactionType.Send:
+                if (txParams.recipients !== undefined) {
+                    const filteredRecipients = txParams.recipients?.map((recipient) => {
+                        const { address, amount, tokenName } = recipient;
+                        const [addressPart, memoId] = address.split('?memoId=');
+                        return {
+                            address: addressPart,
+                            amount,
+                            ...(memoId && { memo: memoId }),
+                            ...(tokenName && { tokenName }),
+                        };
+                    });
+                    const filteredOutputs = explainedTx.outputs?.map((output) => {
+                        const { address, amount, tokenName, memo } = output;
+                        return {
+                            address,
+                            amount,
+                            ...(memo && { memo }),
+                            ...(tokenName && { tokenName }),
+                        };
+                    });
+                    if (JSON.stringify(filteredRecipients) !== JSON.stringify(filteredOutputs)) {
+                        throw new Error('Tx outputs do not match with expected txParams recipients');
+                    }
+                }
                 return true;
-            }
             default: {
                 throw new Error(`unknown transaction type, ${transaction.type}`);
             }
         }
     }
+    verifyBroadridgeStandingDelegationTransaction(transaction, executorPartyId) {
+        const rawPrepared = transaction.prepareCommand?.preparedTransaction;
+        if (!rawPrepared) {
+            throw new Error('Broadridge standing delegation verifyTransaction: missing preparedTransaction protobuf');
+        }
+        const actual = utils_1.default.extractCantonCommandInfo(rawPrepared);
+        if (actual.kind !== 'CreateCommand' || actual.choice !== undefined) {
+            throw new Error('Broadridge standing delegation verifyTransaction: expected a StandingDelegationImpl_v1 CreateCommand');
+        }
+        const descriptor = (0, broadridge_1.broadridgeDescriptorFromCommand)(actual);
+        if (!descriptor ||
+            descriptor.standard !== 'CIP-56' ||
+            descriptor.entityName !== 'StandingDelegationImpl_v1' ||
+            descriptor.role !== 'client') {
+            throw new Error('Broadridge standing delegation verifyTransaction: unsupported prepared command');
+        }
+        const parsed = (0, broadridge_1.parseBroadridgeSettlementAuthorization)(actual);
+        if (parsed?.executor !== executorPartyId) {
+            throw new Error(`Broadridge standing delegation executor mismatch: expected '${executorPartyId}', got '${parsed?.executor ?? ''}'`);
+        }
+        return true;
+    }
+    verifyBroadridgeCommandTransaction(transaction, params) {
+        const rawPrepared = transaction.prepareCommand?.preparedTransaction;
+        if (!rawPrepared) {
+            throw new Error('Broadridge verifyTransaction: missing preparedTransaction protobuf');
+        }
+        const actual = utils_1.default.extractCantonCommandInfo(rawPrepared);
+        const actualDescriptor = (0, broadridge_1.broadridgeDescriptorFromCommand)(actual);
+        if (!actualDescriptor) {
+            throw new Error('Broadridge verifyTransaction: prepared command is not a supported Broadridge template');
+        }
+        const expected = params.descriptor;
+        const expectedTemplate = utils_1.default.parseCantonTemplateId(expected.templateId);
+        if (!expectedTemplate || expected.protocol !== 'broadridge') {
+            throw new Error('Broadridge verifyTransaction: invalid protocol descriptor');
+        }
+        if (expected.standard !== actualDescriptor.standard ||
+            expectedTemplate.pkg !== actualDescriptor.packageId ||
+            expectedTemplate.moduleName !== actualDescriptor.moduleName ||
+            expectedTemplate.entityName !== actualDescriptor.entityName ||
+            expected.choice !== actualDescriptor.choice ||
+            expected.role !== actualDescriptor.role) {
+            throw new Error('Broadridge verifyTransaction: template, package, protocol, choice, or role mismatch');
+        }
+        if (!utils_1.default.sameElements(expected.actors, actualDescriptor.actors)) {
+            throw new Error('Broadridge verifyTransaction: actor set mismatch');
+        }
+        const expectedContractId = expected.contractId ?? expected.requestCid ?? expected.agreementCid;
+        if (expectedContractId !== undefined && expectedContractId !== actual.contractId) {
+            throw new Error('Broadridge verifyTransaction: contract/request/agreement CID mismatch');
+        }
+        if (params.argument !== undefined) {
+            utils_1.default.assertDeepCantonMatch(params.argument, actual.argument, new Set());
+        }
+        return true;
+    }
+    verifyCantonCommandTransaction(transaction, userParams) {
+        if (!userParams) {
+            return true;
+        }
+        const cantonTx = transaction;
+        const rawPrepared = cantonTx.prepareCommand?.preparedTransaction;
+        if (!rawPrepared) {
+            throw new Error('CantonCommand verifyTransaction: missing preparedTransaction protobuf on tx prebuild');
+        }
+        const decodedCommand = utils_1.default.extractCantonCommandInfo(rawPrepared);
+        const userCommand = userParams.command;
+        // Input shape is enforced by mpcUtils at build time; here we resolve which branch is present.
+        const hasCreate = 'CreateCommand' in userCommand && utils_1.default.isPlainObject(userCommand.CreateCommand);
+        const hasExercise = 'ExerciseCommand' in userCommand && utils_1.default.isPlainObject(userCommand.ExerciseCommand);
+        if (!hasCreate && !hasExercise) {
+            throw new Error(`CantonCommand verifyTransaction: command must contain a CreateCommand or ExerciseCommand wrapper`);
+        }
+        if (hasCreate && hasExercise) {
+            throw new Error(`CantonCommand verifyTransaction: command must contain exactly one of CreateCommand or ExerciseCommand, not both`);
+        }
+        const userKind = hasCreate ? 'CreateCommand' : 'ExerciseCommand';
+        if (decodedCommand.kind !== userKind) {
+            throw new Error(`CantonCommand verifyTransaction: command kind mismatch — expected ${userKind}, got ${decodedCommand.kind}`);
+        }
+        const userInner = userKind === 'CreateCommand'
+            ? userCommand.CreateCommand
+            : userCommand.ExerciseCommand;
+        if (!userInner?.templateId) {
+            throw new Error(`CantonCommand verifyTransaction: ${userKind}.templateId must be a non-empty string`);
+        }
+        // templateId (moduleName + entityName; package id is mutable, so ignored)
+        const parsed = utils_1.default.parseCantonTemplateId(userInner.templateId);
+        if (!parsed) {
+            throw new Error(`CantonCommand verifyTransaction: invalid user templateId '${userInner.templateId}' — expected format 'Pkg:Module:Entity'`);
+        }
+        if (decodedCommand.templateId.moduleName !== parsed.moduleName ||
+            decodedCommand.templateId.entityName !== parsed.entityName) {
+            throw new Error(`CantonCommand verifyTransaction: templateId mismatch — expected '${parsed.moduleName}:${parsed.entityName}', got '${decodedCommand.templateId.moduleName}:${decodedCommand.templateId.entityName}'`);
+        }
+        // Build the inject-as skip set once for use across the contractId and argument checks
+        const skipPaths = utils_1.default.normalizeInjectAs(userParams.resolveContracts);
+        // metadata.submitterInfo.actAs must contain exactly the same parties as the user's actAs
+        if (!Array.isArray(userParams.actAs) || userParams.actAs.length === 0) {
+            throw new Error(`CantonCommand verifyTransaction: actAs must be a non-empty array of party IDs`);
+        }
+        if (!userParams.actAs.every((p) => typeof p === 'string' && p.trim() !== '')) {
+            throw new Error(`CantonCommand verifyTransaction: all actAs entries must be non-empty strings`);
+        }
+        const submitterActAs = cantonTx.cantonCommandActAsParties ?? [];
+        if (!utils_1.default.sameElements(submitterActAs, userParams.actAs)) {
+            throw new Error(`CantonCommand verifyTransaction: submitterInfo.actAs [${submitterActAs.join(', ')}] does not match user actAs [${userParams.actAs.join(', ')}]`);
+        }
+        if (userKind === 'ExerciseCommand') {
+            const exerciseInner = userInner;
+            // choice id
+            if (decodedCommand.choice !== exerciseInner.choice) {
+                throw new Error(`CantonCommand verifyTransaction: choice mismatch — expected '${exerciseInner.choice}', got '${decodedCommand.choice ?? ''}'`);
+            }
+            // every on-chain actingParty must be in the user's actAs (prevents privilege escalation)
+            const onChainActors = decodedCommand.actingParties ?? [];
+            for (const actor of onChainActors) {
+                if (!userParams.actAs.includes(actor)) {
+                    throw new Error(`CantonCommand verifyTransaction: unauthorized acting party '${actor}' on root exercise (not in user actAs)`);
+                }
+            }
+            // contractId — skip when absent/empty or when IMS will inject it via resolveContracts
+            if (exerciseInner.contractId !== undefined &&
+                exerciseInner.contractId !== '' &&
+                !skipPaths.has('ExerciseCommand.contractId')) {
+                if (decodedCommand.contractId !== exerciseInner.contractId) {
+                    throw new Error(`CantonCommand verifyTransaction: contractId mismatch — expected '${exerciseInner.contractId}', got '${decodedCommand.contractId ?? ''}'`);
+                }
+            }
+            // deep argument compare
+            const argumentSkipPaths = this.relativeSkipPaths(skipPaths, 'ExerciseCommand.choiceArgument.');
+            utils_1.default.assertDeepCantonMatch(exerciseInner.choiceArgument, decodedCommand.argument, argumentSkipPaths);
+        }
+        else {
+            const createInner = userInner;
+            // deep argument compare
+            const argumentSkipPaths = this.relativeSkipPaths(skipPaths, 'CreateCommand.createArguments.');
+            utils_1.default.assertDeepCantonMatch(createInner.createArguments, decodedCommand.argument, argumentSkipPaths);
+        }
+        return true;
+    }
+    relativeSkipPaths(skipPaths, prefix) {
+        const out = new Set();
+        for (const p of skipPaths) {
+            if (p.startsWith(prefix)) {
+                const stripped = p.slice(prefix.length);
+                if (stripped)
+                    out.add(stripped);
+            }
+        }
+        return out;
+    }
     /** @inheritDoc */
-    isWalletAddress(params) {
-        throw new Error('Method not implemented.');
+    async isWalletAddress(params) {
+        // TODO: refactor this and use the `verifyEddsaMemoBasedWalletAddress` once published from sdk-core
+        // https://bitgoinc.atlassian.net/browse/COIN-6347
+        const { keychains, address: newAddress, index } = params;
+        const [addressPart, memoId] = newAddress.split('?memoId=');
+        if (!this.isValidAddress(addressPart)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${newAddress}`);
+        }
+        if (memoId && memoId !== `${index}`) {
+            throw new sdk_core_1.InvalidAddressError(`invalid memoId index: ${memoId}`);
+        }
+        const commonKeychain = (0, sdk_core_1.extractCommonKeychain)(keychains);
+        const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        const derivationPath = 'm/0';
+        const derivedPublicKey = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);
+        const publicKeyBase64 = Buffer.from(derivedPublicKey, 'hex').toString('base64');
+        const rootAddressFingerprint = utils_1.default.getAddressFromPublicKey(publicKeyBase64);
+        const rootAddress = `${rootAddressFingerprint.slice(0, 5)}::${rootAddressFingerprint}`;
+        return addressPart === rootAddress;
     }
     /** @inheritDoc */
-    parseTransaction(params) {
-        throw new Error('Method not implemented.');
+    async parseTransaction(params) {
+        const txHex = params.txHex;
+        if (!txHex) {
+            // Message-only signing requests (e.g. CANTON_SIGN_TRANSACTION, CANTON_SIGN_TOPOLOGY)
+            // have no transaction hex to parse — return an empty result.
+            return {};
+        }
+        const transactionExplanation = await this.explainTransaction({ txHex });
+        if (!transactionExplanation) {
+            throw new Error('Invalid transaction');
+        }
+        return transactionExplanation;
     }
     /** @inheritDoc */
     generateKeyPair(seed) {
@@ -121,6 +406,17 @@ class Canton extends sdk_core_1.BaseCoin {
         return utils_1.default.isValidAddress(address);
     }
     /** @inheritDoc */
+    getTokenEnablementConfig() {
+        return {
+            requiresTokenEnablement: true,
+            supportsMultipleTokenEnablements: false,
+        };
+    }
+    getAddressFromPublicKey(publicKeyHex) {
+        const publicKeyBase64 = Buffer.from(publicKeyHex, 'hex').toString('base64');
+        return utils_1.default.getAddressFromPublicKey(publicKeyBase64);
+    }
+    /** @inheritDoc */
     signTransaction(params) {
         throw new Error('Method not implemented.');
     }
@@ -136,7 +432,43 @@ class Canton extends sdk_core_1.BaseCoin {
         if (params.txRequestId) {
             intent.txRequestId = params.txRequestId;
         }
+        if (params.transferOfferId) {
+            intent.transferOfferId = params.transferOfferId;
+        }
+        if (params.unspents) {
+            intent.unspents = params.unspents;
+        }
+        if (params.cantonCommandParams) {
+            intent.cantonCommandParams = params.cantonCommandParams;
+        }
+        if (params.executorPartyId) {
+            intent.executorPartyId = params.executorPartyId;
+        }
+        if (params.endInvestorPartyId) {
+            intent.endInvestorPartyId = params.endInvestorPartyId;
+        }
+        if (params.reason) {
+            intent.reason = params.reason;
+        }
+        if (params.operator) {
+            intent.operator = params.operator;
+        }
+        if (params.provider) {
+            intent.provider = params.provider;
+        }
+        if (params.compliance) {
+            intent.compliance = params.compliance;
+        }
+        if (params.registrar) {
+            intent.registrar = params.registrar;
+        }
+        if (params.clientOnboarder) {
+            intent.clientOnboarder = params.clientOnboarder;
+        }
+        if (params.expirationIso) {
+            intent.expirationIso = params.expirationIso;
+        }
     }
 }
 exports.Canton = Canton;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canton.js","sourceRoot":"","sources":["../../src/canton.ts"],"names":[],"mappings":";;;;;;AAAA,mDAmB8B;AAC9B,yDAA+D;AAC/D,iDAAyE;AACzE,+BAAkD;AAClD,2CAAyD;AACzD,wDAAgC;AAUhC,MAAa,MAAO,SAAQ,mBAAQ;IAGlC,YAAsB,KAAgB,EAAE,WAAuC;QAC7E,KAAK,CAAC,KAAK,CAAC,CAAC;QAEb,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,KAAgB,EAAE,WAAuC;QAC7E,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACxC,CAAC;IAEO,UAAU;QAChB,OAAO,IAAI,+BAAyB,CAAC,eAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,kBAAkB;IACX,aAAa;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IACX,QAAQ;QACb,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,kBAAkB;IACX,SAAS;QACd,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,kBAAkB;IACX,WAAW;QAChB,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,kBAAkB;IAClB,WAAW;QACT,OAAO,IAAI,CAAC;IACd,CAAC;IAED,oBAAoB;IACpB,sBAAsB;QACpB,OAAO,wBAAa,CAAC,GAAG,CAAC;IAC3B,CAAC;IAED,oBAAoB;IACpB,uCAAuC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,eAAe;QACb,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,kBAAkB;IAClB,KAAK,CAAC,iBAAiB,CAAC,MAAgC;QACtD,MAAM,UAAU,GAAG,eAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC9C,4DAA4D;QAC5D,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;QAC1C,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC/B,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,+BAAyB,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxE,MAAM,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QAC1C,QAAQ,WAAW,CAAC,IAAI,EAAE,CAAC;YACzB,KAAK,0BAAe,CAAC,oBAAoB,CAAC,CAAC,CAAC;gBAC1C,wEAAwE;gBACxE,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,CAAC,CAAC,CAAC;gBACR,MAAM,IAAI,KAAK,CAAC,6BAA6B,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;IACH,CAAC;IAED,kBAAkB;IAClB,eAAe,CAAC,MAA+B;QAC7C,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,kBAAkB;IAClB,gBAAgB,CAAC,MAA+B;QAC9C,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,kBAAkB;IAClB,eAAe,CAAC,IAAa;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,iBAAa,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,iBAAa,EAAE,CAAC;QACzE,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QACD,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAC;IACJ,CAAC;IAED,kBAAkB;IAClB,kBAAkB,CAAC,MAAiC;QAClD,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,IAAI,kBAAmC,CAAC;QACxC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtC,kBAAkB,GAAG,SAAS,CAAC,WAAW,CAAC;QAC7C,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,OAAO,kBAAkB,CAAC,kBAAkB,EAAE,CAAC;IACjD,CAAC;IAED,kBAAkB;IAClB,UAAU,CAAC,GAAW;QACpB,OAAO,eAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAED,kBAAkB;IAClB,cAAc,CAAC,OAAe;QAC5B,2DAA2D;QAC3D,uEAAuE;QACvE,OAAO,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED,kBAAkB;IAClB,eAAe,CAAC,MAA8B;QAC5C,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,EAA2B;QACzE,IAAI,YAAY,KAAK,wBAAa,CAAC,GAAG,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QACD,IAAA,kCAAoB,EAAC,GAAG,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED,kBAAkB;IAClB,6BAA6B,CAAC,MAAuB,EAAE,MAA4C;QACjG,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;YACvB,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;QAC1C,CAAC;IACH,CAAC;CACF;AAtJD,wBAsJC","sourcesContent":["import {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SignTransactionOptions,\n  TransactionType,\n  TssVerifyAddressOptions,\n  VerifyTransactionOptions,\n  TransactionExplanation as BaseTransactionExplanation,\n  BaseTransaction,\n  PopulatedIntent,\n  PrebuildTransactionWithIntentOptions,\n} from '@bitgo-beta/sdk-core';\nimport { auditEddsaPrivateKey } from '@bitgo-beta/sdk-lib-mpc';\nimport { BaseCoin as StaticsBaseCoin, coins } from '@bitgo-beta/statics';\nimport { TransactionBuilderFactory } from './lib';\nimport { KeyPair as CantonKeyPair } from './lib/keyPair';\nimport utils from './lib/utils';\n\nexport interface TransactionExplanation extends BaseTransactionExplanation {\n  type: TransactionType;\n}\n\nexport interface ExplainTransactionOptions {\n  txHex: string;\n}\n\nexport class Canton extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Canton(bitgo, staticsCoin);\n  }\n\n  private getBuilder(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /** @inheritDoc */\n  public getBaseFactor(): number {\n    return 1e10;\n  }\n\n  /** @inheritDoc */\n  public getChain(): string {\n    return 'canton';\n  }\n\n  /** @inheritDoc */\n  public getFamily(): string {\n    return 'canton';\n  }\n\n  /** @inheritDoc */\n  public getFullName(): string {\n    return 'Canton';\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  /** inherited doc */\n  requiresWalletInitializationTransaction(): boolean {\n    return true;\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'eddsa';\n  }\n\n  /** @inheritDoc */\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const coinConfig = coins.get(this.getChain());\n    // extract `txParams` when verifying other transaction types\n    const { txPrebuild: txPrebuild } = params;\n    const rawTx = txPrebuild.txHex;\n    if (!rawTx) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    const txBuilder = new TransactionBuilderFactory(coinConfig).from(rawTx);\n    const transaction = txBuilder.transaction;\n    switch (transaction.type) {\n      case TransactionType.WalletInitialization: {\n        // there is no input for this type of transaction, so always return true\n        return true;\n      }\n      default: {\n        throw new Error(`unknown transaction type, ${transaction.type}`);\n      }\n    }\n  }\n\n  /** @inheritDoc */\n  isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritDoc */\n  parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritDoc */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new CantonKeyPair({ seed }) : new CantonKeyPair();\n    const keys = keyPair.getKeys();\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /** @inheritDoc */\n  explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const factory = this.getBuilder();\n    let rebuiltTransaction: BaseTransaction;\n    const txRaw = params.txHex;\n    try {\n      const txBuilder = factory.from(txRaw);\n      rebuiltTransaction = txBuilder.transaction;\n    } catch (e) {\n      throw new Error('Invalid transaction');\n    }\n    return rebuiltTransaction.explainTransaction();\n  }\n\n  /** @inheritDoc */\n  isValidPub(pub: string): boolean {\n    return utils.isValidPublicKey(pub);\n  }\n\n  /** @inheritDoc */\n  isValidAddress(address: string): boolean {\n    // canton addresses are of the form, partyHint::fingerprint\n    // where partyHint is of length 5 and fingerprint is 68 characters long\n    return utils.isValidAddress(address);\n  }\n\n  /** @inheritDoc */\n  signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void {\n    if (multiSigType !== multisigTypes.tss) {\n      throw new Error('Unsupported multiSigType');\n    }\n    auditEddsaPrivateKey(prv, publicKey ?? '');\n  }\n\n  /** @inheritDoc */\n  setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void {\n    if (params.txRequestId) {\n      intent.txRequestId = params.txRequestId;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canton.js","sourceRoot":"","sources":["../../src/canton.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BaseTransaction,\n  BitGoBase,\n  CantonCommand,\n  CantonCommandParams,\n  CantonCreateCommand,\n  CantonExerciseCommand,\n  EDDSAMethods,\n  extractCommonKeychain,\n  InvalidAddressError,\n  KeyPair,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  PopulatedIntent,\n  PrebuildTransactionWithIntentOptions,\n  SignedTransaction,\n  SignTransactionOptions,\n  TokenEnablementConfig,\n  TransactionExplanation as BaseTransactionExplanation,\n  TransactionParams,\n  TransactionType,\n  TssVerifyAddressOptions,\n  VerifyTransactionOptions,\n} from '@bitgo-beta/sdk-core';\nimport { auditEddsaPrivateKey } from '@bitgo-beta/sdk-lib-mpc';\nimport { BaseCoin as StaticsBaseCoin, coins } from '@bitgo-beta/statics';\nimport { TransactionBuilderFactory } from './lib';\nimport { KeyPair as CantonKeyPair } from './lib/keyPair';\nimport { BroadridgeCommandParams, CantonCommandKind, TxData } from './lib/iface';\nimport { broadridgeDescriptorFromCommand, parseBroadridgeSettlementAuthorization } from './lib/broadridge';\nimport { Transaction } from './lib/transaction/transaction';\nimport utils from './lib/utils';\n\nexport interface TransactionExplanation extends BaseTransactionExplanation {\n  type: TransactionType;\n}\n\nexport interface ExplainTransactionOptions {\n  txHex: string;\n}\n\nexport interface CantonTransactionParams extends TransactionParams {\n  cantonCommandParams?: CantonCommandParams;\n  broadridgeCommandParams?: BroadridgeCommandParams;\n  executorPartyId?: string;\n}\n\nexport class Canton extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Canton(bitgo, staticsCoin);\n  }\n\n  private getBuilder(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /** @inheritDoc */\n  public getBaseFactor(): number {\n    return 1e10;\n  }\n\n  /** @inheritDoc */\n  public getChain(): string {\n    return 'canton';\n  }\n\n  /** @inheritDoc */\n  public getFamily(): string {\n    return 'canton';\n  }\n\n  /** @inheritDoc */\n  public getFullName(): string {\n    return 'Canton';\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsMessageSigning(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  /** inherited doc */\n  requiresWalletInitializationTransaction(): boolean {\n    return true;\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'eddsa';\n  }\n\n  /** @inheritDoc */\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const coinConfig = coins.get(this.getChain());\n    const { txPrebuild: txPrebuild, txParams } = params;\n    const rawTx = txPrebuild.txHex;\n    if (!rawTx) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    const txBuilder = new TransactionBuilderFactory(coinConfig).from(rawTx);\n    const transaction = txBuilder.transaction;\n    const explainedTx = transaction.explainTransaction();\n    const broadridgeParams = (txParams as CantonTransactionParams).broadridgeCommandParams;\n    if (broadridgeParams) {\n      return this.verifyBroadridgeCommandTransaction(transaction, broadridgeParams);\n    }\n    if (txParams.type === 'cantonBroadridgeStandingDelegation') {\n      const executorPartyId = (txParams as CantonTransactionParams).executorPartyId;\n      if (!executorPartyId) {\n        throw new Error('cantonBroadridgeStandingDelegation verifyTransaction: missing executorPartyId');\n      }\n      return this.verifyBroadridgeStandingDelegationTransaction(transaction, executorPartyId);\n    }\n    switch (transaction.type) {\n      case TransactionType.WalletInitialization:\n      case TransactionType.TransferAccept:\n      case TransactionType.TransferReject:\n      case TransactionType.TransferAcknowledge:\n      case TransactionType.TransferOfferWithdrawn:\n      case TransactionType.CosignDelegationAccept:\n      case TransactionType.CosignDelegationProposal:\n      case TransactionType.AllocationAllocate:\n      case TransactionType.AllocationRequest:\n      case TransactionType.AllocationReject:\n      case TransactionType.EndInvestorOnboardingOffer:\n      case TransactionType.AllocationAllocateWithdrawn:\n        // There is no recipient info to verify for these transaction types, so always return true.\n        return true;\n      case TransactionType.CantonCommand:\n        return this.verifyCantonCommandTransaction(\n          transaction,\n          (txParams as CantonTransactionParams).cantonCommandParams\n        );\n      case TransactionType.OneStepPreApproval:\n        // Canton is always a TSS wallet. The SDK's buildTokenEnablements passes enableTokens\n        // through unchanged for TSS wallets (no conversion to recipients), so txParams.enableTokens\n        // is the only source of user intent here.\n        //\n        // Receiver validation: the receiver of a OneStepPreApproval is always the wallet's root address.\n        // We use enableToken.address if explicitly provided, otherwise fall back to\n        // wallet.coinSpecific().rootAddress (the Canton party ID stored at wallet creation time).\n        // Token name validation: checked when the token is resolvable from statics.\n        if (\n          txParams.type === 'enabletoken' &&\n          txParams.enableTokens !== undefined &&\n          txParams.enableTokens.length > 0\n        ) {\n          const txData = transaction.toJson() as TxData;\n          const enableToken = txParams.enableTokens[0];\n          const walletRootAddress = params.wallet?.coinSpecific?.()?.rootAddress;\n          const expectedReceiver = enableToken.address ?? walletRootAddress;\n          if (expectedReceiver) {\n            // Strip ?memoId suffix if present in the stored address\n            const [expectedReceiverBase] = expectedReceiver.split('?memoId=');\n            if (txData.receiver !== expectedReceiverBase) {\n              throw new Error(\n                `OneStepPreApproval receiver mismatch: expected '${expectedReceiverBase}', got '${txData.receiver}'`\n              );\n            }\n          }\n          if (txData.token !== undefined && txData.token !== enableToken.name) {\n            throw new Error(\n              `OneStepPreApproval token name mismatch: expected '${enableToken.name}', got '${txData.token}'`\n            );\n          }\n        }\n        return true;\n      case TransactionType.TransferPreapprovalCancel:\n        // Mirrors OneStepPreApproval's receiver/token validation above, opposite direction.\n        // The cancel is self-service (the wallet's own party exercises the choice on its own\n        // TransferPreapproval), so sender === receiver on the parsed transaction; both must match\n        // the wallet's rootAddress (or the explicit enableToken.address, if provided).\n        if (\n          txParams.type === 'disabletoken' &&\n          txParams.enableTokens !== undefined &&\n          txParams.enableTokens.length > 0\n        ) {\n          const txData = transaction.toJson() as TxData;\n          const disableToken = txParams.enableTokens[0];\n          const walletRootAddress = params.wallet?.coinSpecific?.()?.rootAddress;\n          const expectedParty = disableToken.address ?? walletRootAddress;\n          if (expectedParty) {\n            const [expectedPartyBase] = expectedParty.split('?memoId=');\n            if (txData.receiver !== expectedPartyBase) {\n              throw new Error(\n                `TransferPreapprovalCancel receiver mismatch: expected '${expectedPartyBase}', got '${txData.receiver}'`\n              );\n            }\n          }\n          if (txData.token !== undefined && txData.token !== disableToken.name) {\n            throw new Error(\n              `TransferPreapprovalCancel token name mismatch: expected '${disableToken.name}', got '${txData.token}'`\n            );\n          }\n        }\n        return true;\n      case TransactionType.Send:\n        if (txParams.recipients !== undefined) {\n          const filteredRecipients = txParams.recipients?.map((recipient) => {\n            const { address, amount, tokenName } = recipient;\n            const [addressPart, memoId] = address.split('?memoId=');\n            return {\n              address: addressPart,\n              amount,\n              ...(memoId && { memo: memoId }),\n              ...(tokenName && { tokenName }),\n            };\n          });\n          const filteredOutputs = explainedTx.outputs?.map((output) => {\n            const { address, amount, tokenName, memo } = output;\n            return {\n              address,\n              amount,\n              ...(memo && { memo }),\n              ...(tokenName && { tokenName }),\n            };\n          });\n          if (JSON.stringify(filteredRecipients) !== JSON.stringify(filteredOutputs)) {\n            throw new Error('Tx outputs do not match with expected txParams recipients');\n          }\n        }\n        return true;\n      default: {\n        throw new Error(`unknown transaction type, ${transaction.type}`);\n      }\n    }\n  }\n  private verifyBroadridgeStandingDelegationTransaction(\n    transaction: BaseTransaction,\n    executorPartyId: string\n  ): boolean {\n    const rawPrepared = (transaction as Transaction).prepareCommand?.preparedTransaction;\n    if (!rawPrepared) {\n      throw new Error('Broadridge standing delegation verifyTransaction: missing preparedTransaction protobuf');\n    }\n    const actual = utils.extractCantonCommandInfo(rawPrepared);\n    if (actual.kind !== 'CreateCommand' || actual.choice !== undefined) {\n      throw new Error(\n        'Broadridge standing delegation verifyTransaction: expected a StandingDelegationImpl_v1 CreateCommand'\n      );\n    }\n    const descriptor = broadridgeDescriptorFromCommand(actual);\n    if (\n      !descriptor ||\n      descriptor.standard !== 'CIP-56' ||\n      descriptor.entityName !== 'StandingDelegationImpl_v1' ||\n      descriptor.role !== 'client'\n    ) {\n      throw new Error('Broadridge standing delegation verifyTransaction: unsupported prepared command');\n    }\n    const parsed = parseBroadridgeSettlementAuthorization(actual);\n    if (parsed?.executor !== executorPartyId) {\n      throw new Error(\n        `Broadridge standing delegation executor mismatch: expected '${executorPartyId}', got '${\n          parsed?.executor ?? ''\n        }'`\n      );\n    }\n    return true;\n  }\n\n  private verifyBroadridgeCommandTransaction(transaction: BaseTransaction, params: BroadridgeCommandParams): boolean {\n    const rawPrepared = (transaction as Transaction).prepareCommand?.preparedTransaction;\n    if (!rawPrepared) {\n      throw new Error('Broadridge verifyTransaction: missing preparedTransaction protobuf');\n    }\n    const actual = utils.extractCantonCommandInfo(rawPrepared);\n    const actualDescriptor = broadridgeDescriptorFromCommand(actual);\n    if (!actualDescriptor) {\n      throw new Error('Broadridge verifyTransaction: prepared command is not a supported Broadridge template');\n    }\n    const expected = params.descriptor;\n    const expectedTemplate = utils.parseCantonTemplateId(expected.templateId);\n    if (!expectedTemplate || expected.protocol !== 'broadridge') {\n      throw new Error('Broadridge verifyTransaction: invalid protocol descriptor');\n    }\n    if (\n      expected.standard !== actualDescriptor.standard ||\n      expectedTemplate.pkg !== actualDescriptor.packageId ||\n      expectedTemplate.moduleName !== actualDescriptor.moduleName ||\n      expectedTemplate.entityName !== actualDescriptor.entityName ||\n      expected.choice !== actualDescriptor.choice ||\n      expected.role !== actualDescriptor.role\n    ) {\n      throw new Error('Broadridge verifyTransaction: template, package, protocol, choice, or role mismatch');\n    }\n    if (!utils.sameElements(expected.actors, actualDescriptor.actors)) {\n      throw new Error('Broadridge verifyTransaction: actor set mismatch');\n    }\n    const expectedContractId = expected.contractId ?? expected.requestCid ?? expected.agreementCid;\n    if (expectedContractId !== undefined && expectedContractId !== actual.contractId) {\n      throw new Error('Broadridge verifyTransaction: contract/request/agreement CID mismatch');\n    }\n    if (params.argument !== undefined) {\n      utils.assertDeepCantonMatch(params.argument, actual.argument, new Set());\n    }\n    return true;\n  }\n\n  private verifyCantonCommandTransaction(\n    transaction: BaseTransaction,\n    userParams: CantonCommandParams | undefined\n  ): boolean {\n    if (!userParams) {\n      return true;\n    }\n\n    const cantonTx = transaction as Transaction;\n    const rawPrepared = cantonTx.prepareCommand?.preparedTransaction;\n    if (!rawPrepared) {\n      throw new Error('CantonCommand verifyTransaction: missing preparedTransaction protobuf on tx prebuild');\n    }\n\n    const decodedCommand = utils.extractCantonCommandInfo(rawPrepared);\n    const userCommand = userParams.command as Partial<CantonCommand>;\n\n    // Input shape is enforced by mpcUtils at build time; here we resolve which branch is present.\n    const hasCreate = 'CreateCommand' in userCommand && utils.isPlainObject(userCommand.CreateCommand);\n    const hasExercise = 'ExerciseCommand' in userCommand && utils.isPlainObject(userCommand.ExerciseCommand);\n    if (!hasCreate && !hasExercise) {\n      throw new Error(\n        `CantonCommand verifyTransaction: command must contain a CreateCommand or ExerciseCommand wrapper`\n      );\n    }\n    if (hasCreate && hasExercise) {\n      throw new Error(\n        `CantonCommand verifyTransaction: command must contain exactly one of CreateCommand or ExerciseCommand, not both`\n      );\n    }\n    const userKind: CantonCommandKind = hasCreate ? 'CreateCommand' : 'ExerciseCommand';\n    if (decodedCommand.kind !== userKind) {\n      throw new Error(\n        `CantonCommand verifyTransaction: command kind mismatch — expected ${userKind}, got ${decodedCommand.kind}`\n      );\n    }\n\n    const userInner =\n      userKind === 'CreateCommand'\n        ? (userCommand as CantonCreateCommand).CreateCommand\n        : (userCommand as CantonExerciseCommand).ExerciseCommand;\n\n    if (!userInner?.templateId) {\n      throw new Error(`CantonCommand verifyTransaction: ${userKind}.templateId must be a non-empty string`);\n    }\n\n    // templateId (moduleName + entityName; package id is mutable, so ignored)\n    const parsed = utils.parseCantonTemplateId(userInner.templateId);\n    if (!parsed) {\n      throw new Error(\n        `CantonCommand verifyTransaction: invalid user templateId '${userInner.templateId}' — expected format 'Pkg:Module:Entity'`\n      );\n    }\n    if (\n      decodedCommand.templateId.moduleName !== parsed.moduleName ||\n      decodedCommand.templateId.entityName !== parsed.entityName\n    ) {\n      throw new Error(\n        `CantonCommand verifyTransaction: templateId mismatch — expected '${parsed.moduleName}:${parsed.entityName}', got '${decodedCommand.templateId.moduleName}:${decodedCommand.templateId.entityName}'`\n      );\n    }\n\n    // Build the inject-as skip set once for use across the contractId and argument checks\n    const skipPaths = utils.normalizeInjectAs(userParams.resolveContracts);\n\n    // metadata.submitterInfo.actAs must contain exactly the same parties as the user's actAs\n    if (!Array.isArray(userParams.actAs) || userParams.actAs.length === 0) {\n      throw new Error(`CantonCommand verifyTransaction: actAs must be a non-empty array of party IDs`);\n    }\n    if (!userParams.actAs.every((p) => typeof p === 'string' && p.trim() !== '')) {\n      throw new Error(`CantonCommand verifyTransaction: all actAs entries must be non-empty strings`);\n    }\n    const submitterActAs = cantonTx.cantonCommandActAsParties ?? [];\n    if (!utils.sameElements(submitterActAs, userParams.actAs)) {\n      throw new Error(\n        `CantonCommand verifyTransaction: submitterInfo.actAs [${submitterActAs.join(\n          ', '\n        )}] does not match user actAs [${userParams.actAs.join(', ')}]`\n      );\n    }\n\n    if (userKind === 'ExerciseCommand') {\n      const exerciseInner = userInner as CantonExerciseCommand['ExerciseCommand'];\n\n      // choice id\n      if (decodedCommand.choice !== exerciseInner.choice) {\n        throw new Error(\n          `CantonCommand verifyTransaction: choice mismatch — expected '${exerciseInner.choice}', got '${\n            decodedCommand.choice ?? ''\n          }'`\n        );\n      }\n\n      // every on-chain actingParty must be in the user's actAs (prevents privilege escalation)\n      const onChainActors = decodedCommand.actingParties ?? [];\n      for (const actor of onChainActors) {\n        if (!userParams.actAs.includes(actor)) {\n          throw new Error(\n            `CantonCommand verifyTransaction: unauthorized acting party '${actor}' on root exercise (not in user actAs)`\n          );\n        }\n      }\n\n      // contractId — skip when absent/empty or when IMS will inject it via resolveContracts\n      if (\n        exerciseInner.contractId !== undefined &&\n        exerciseInner.contractId !== '' &&\n        !skipPaths.has('ExerciseCommand.contractId')\n      ) {\n        if (decodedCommand.contractId !== exerciseInner.contractId) {\n          throw new Error(\n            `CantonCommand verifyTransaction: contractId mismatch — expected '${exerciseInner.contractId}', got '${\n              decodedCommand.contractId ?? ''\n            }'`\n          );\n        }\n      }\n\n      // deep argument compare\n      const argumentSkipPaths = this.relativeSkipPaths(skipPaths, 'ExerciseCommand.choiceArgument.');\n      utils.assertDeepCantonMatch(exerciseInner.choiceArgument, decodedCommand.argument, argumentSkipPaths);\n    } else {\n      const createInner = userInner as CantonCreateCommand['CreateCommand'];\n\n      // deep argument compare\n      const argumentSkipPaths = this.relativeSkipPaths(skipPaths, 'CreateCommand.createArguments.');\n      utils.assertDeepCantonMatch(createInner.createArguments, decodedCommand.argument, argumentSkipPaths);\n    }\n\n    return true;\n  }\n\n  private relativeSkipPaths(skipPaths: Set<string>, prefix: string): Set<string> {\n    const out = new Set<string>();\n    for (const p of skipPaths) {\n      if (p.startsWith(prefix)) {\n        const stripped = p.slice(prefix.length);\n        if (stripped) out.add(stripped);\n      }\n    }\n    return out;\n  }\n\n  /** @inheritDoc */\n  async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {\n    // TODO: refactor this and use the `verifyEddsaMemoBasedWalletAddress` once published from sdk-core\n    // https://bitgoinc.atlassian.net/browse/COIN-6347\n    const { keychains, address: newAddress, index } = params;\n    const [addressPart, memoId] = newAddress.split('?memoId=');\n    if (!this.isValidAddress(addressPart)) {\n      throw new InvalidAddressError(`invalid address: ${newAddress}`);\n    }\n    if (memoId && memoId !== `${index}`) {\n      throw new InvalidAddressError(`invalid memoId index: ${memoId}`);\n    }\n    const commonKeychain = extractCommonKeychain(keychains);\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n    const derivationPath = 'm/0';\n    const derivedPublicKey = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);\n    const publicKeyBase64 = Buffer.from(derivedPublicKey, 'hex').toString('base64');\n    const rootAddressFingerprint = utils.getAddressFromPublicKey(publicKeyBase64);\n    const rootAddress = `${rootAddressFingerprint.slice(0, 5)}::${rootAddressFingerprint}`;\n    return addressPart === rootAddress;\n  }\n\n  /** @inheritDoc */\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    const txHex = params.txHex as string | undefined;\n    if (!txHex) {\n      // Message-only signing requests (e.g. CANTON_SIGN_TRANSACTION, CANTON_SIGN_TOPOLOGY)\n      // have no transaction hex to parse — return an empty result.\n      return {};\n    }\n    const transactionExplanation = await this.explainTransaction({ txHex });\n    if (!transactionExplanation) {\n      throw new Error('Invalid transaction');\n    }\n    return transactionExplanation as unknown as ParsedTransaction;\n  }\n\n  /** @inheritDoc */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new CantonKeyPair({ seed }) : new CantonKeyPair();\n    const keys = keyPair.getKeys();\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /** @inheritDoc */\n  explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {\n    const factory = this.getBuilder();\n    let rebuiltTransaction: BaseTransaction;\n    const txRaw = params.txHex;\n    try {\n      const txBuilder = factory.from(txRaw);\n      rebuiltTransaction = txBuilder.transaction;\n    } catch (e) {\n      throw new Error('Invalid transaction');\n    }\n    return rebuiltTransaction.explainTransaction();\n  }\n\n  /** @inheritDoc */\n  isValidPub(pub: string): boolean {\n    return utils.isValidPublicKey(pub);\n  }\n\n  /** @inheritDoc */\n  isValidAddress(address: string): boolean {\n    // canton addresses are of the form, partyHint::fingerprint\n    // where partyHint is of length 5 and fingerprint is 68 characters long\n    return utils.isValidAddress(address);\n  }\n\n  /** @inheritDoc */\n  getTokenEnablementConfig(): TokenEnablementConfig {\n    return {\n      requiresTokenEnablement: true,\n      supportsMultipleTokenEnablements: false,\n    };\n  }\n\n  getAddressFromPublicKey(publicKeyHex: string): string {\n    const publicKeyBase64 = Buffer.from(publicKeyHex, 'hex').toString('base64');\n    return utils.getAddressFromPublicKey(publicKeyBase64);\n  }\n\n  /** @inheritDoc */\n  signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void {\n    if (multiSigType !== multisigTypes.tss) {\n      throw new Error('Unsupported multiSigType');\n    }\n    auditEddsaPrivateKey(prv, publicKey ?? '');\n  }\n\n  /** @inheritDoc */\n  setCoinSpecificFieldsInIntent(\n    intent: PopulatedIntent,\n    params: PrebuildTransactionWithIntentOptions & { executorPartyId?: string }\n  ): void {\n    if (params.txRequestId) {\n      intent.txRequestId = params.txRequestId;\n    }\n    if (params.transferOfferId) {\n      intent.transferOfferId = params.transferOfferId;\n    }\n    if (params.unspents) {\n      intent.unspents = params.unspents;\n    }\n    if (params.cantonCommandParams) {\n      intent.cantonCommandParams = params.cantonCommandParams;\n    }\n    if (params.executorPartyId) {\n      (intent as PopulatedIntent & { executorPartyId?: string }).executorPartyId = params.executorPartyId;\n    }\n    if (params.endInvestorPartyId) {\n      intent.endInvestorPartyId = params.endInvestorPartyId;\n    }\n    if (params.reason) {\n      intent.reason = params.reason;\n    }\n    if (params.operator) {\n      intent.operator = params.operator;\n    }\n    if (params.provider) {\n      intent.provider = params.provider;\n    }\n    if (params.compliance) {\n      intent.compliance = params.compliance;\n    }\n    if (params.registrar) {\n      intent.registrar = params.registrar;\n    }\n    if (params.clientOnboarder) {\n      intent.clientOnboarder = params.clientOnboarder;\n    }\n    if (params.expirationIso) {\n      intent.expirationIso = params.expirationIso;\n    }\n  }\n}\n"]}

package/dist/src/cantonToken.d.ts

@@ -0,0 +1,19 @@
+import { BitGoBase, CoinConstructor, NamedCoinConstructor } from '@bitgo-beta/sdk-core';
+import { CantonTokenConfig } from '@bitgo-beta/statics';
+import { Canton } from './canton';
+export declare class CantonToken extends Canton {
+    readonly tokenConfig: CantonTokenConfig;
+    constructor(bitgo: BitGoBase, tokenConfig: CantonTokenConfig);
+    static createTokenConstructor(config: CantonTokenConfig): CoinConstructor;
+    static createTokenConstructors(tokenConfig?: CantonTokenConfig[]): NamedCoinConstructor[];
+    get name(): string;
+    get coin(): string;
+    get baseUrl(): string;
+    get contractAddress(): string;
+    get decimalPlaces(): number;
+    getChain(): string;
+    getBaseChain(): string;
+    getFullName(): string;
+    getBaseFactor(): number;
+}
+//# sourceMappingURL=cantonToken.d.ts.map

package/dist/src/cantonToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cantonToken.d.ts","sourceRoot":"","sources":["../../src/cantonToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,EAAS,iBAAiB,EAAuB,MAAM,qBAAqB,CAAC;AAEpF,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,WAAY,SAAQ,MAAM;IACrC,SAAgB,WAAW,EAAE,iBAAiB,CAAC;gBAEnC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,iBAAiB;IAM5D,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe;IAIzE,MAAM,CAAC,uBAAuB,CAC5B,WAAW,GAAE,iBAAiB,EAAuE,GACpG,oBAAoB,EAAE;IASzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,MAAM;IAItB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM;CAGxB"}