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

package/dist/src/lib/walletInitBuilder.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletInitBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const keyPair_1 = require("./keyPair");
+const utils_1 = __importDefault(require("./utils"));
+const walletInitTransaction_1 = require("./walletInitialization/walletInitTransaction");
+const constant_1 = require("./constant");
+class WalletInitBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._signatures = [];
+        this._localParticipantObservationOnly = false;
+        this._otherConfirmingParticipantUids = [];
+        this._confirmationThreshold = 1;
+        this._observingParticipantUids = [];
+        this._transaction = new walletInitTransaction_1.WalletInitTransaction(_coinConfig);
+    }
+    initBuilder(tx) {
+        this._transaction = tx;
+    }
+    buildImplementation() {
+        throw new Error('Not implemented');
+    }
+    fromImplementation(rawTransaction, isFirstSigner) {
+        throw new Error('Not implemented');
+    }
+    signImplementation(key) {
+        throw new Error('Not implemented');
+    }
+    get transaction() {
+        return this._transaction;
+    }
+    set transaction(transaction) {
+        this._transaction.preparedParty = transaction;
+    }
+    validateAddress(address, addressFormat) {
+        if (!utils_1.default.isValidAddress(address.address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address ' + address.address);
+        }
+    }
+    validateKey(key) {
+        let keyPair;
+        try {
+            keyPair = new keyPair_1.KeyPair({ prv: key.key });
+        }
+        catch {
+            throw new sdk_core_1.BuildTransactionError('Invalid key');
+        }
+        if (!keyPair.getKeys().prv) {
+            throw new sdk_core_1.BuildTransactionError('Invalid key');
+        }
+    }
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction || !this._transaction.preparedParty) {
+            throw new sdk_core_1.BuildTransactionError('invalid raw transaction');
+        }
+        const localHash = utils_1.default.computeHashFromCreatePartyResponse(rawTransaction);
+        if (localHash !== this._transaction.preparedParty.multiHash) {
+            throw new sdk_core_1.BuildTransactionError('invalid raw transaction, hash not matching');
+        }
+    }
+    validateTransaction(transaction) {
+        if (!transaction?.preparedParty) {
+            return;
+        }
+        const localHash = utils_1.default.computeHashFromCreatePartyResponse(transaction.preparedParty.topologyTransactions);
+        if (localHash !== this._transaction.preparedParty.multiHash) {
+            throw new sdk_core_1.BuildTransactionError('invalid transaction');
+        }
+    }
+    // not implemented because wallet initialization doesn't require any value
+    validateValue(value) {
+        throw new Error('Not implemented');
+    }
+    /** @inheritDoc */
+    addSignature(publicKey, signature) {
+        if (!this.transaction) {
+            throw new sdk_core_1.InvalidTransactionError('transaction is empty!');
+        }
+        this._signatures.push({ publicKey, signature });
+        this.transaction.signatures = signature.toString('base64');
+    }
+    /**
+     * Sets the public key used for signing.
+     *
+     * @param key - The public key of the wallet.
+     * @returns The current builder instance for chaining.
+     * @throws Error if key is not a valid public key
+     */
+    publicKey(key) {
+        utils_1.default.isValidPublicKey(key);
+        this._publicKey = {
+            format: constant_1.PUBLIC_KEY_FORMAT,
+            keyData: key,
+            keySpec: constant_1.PUBLIC_KEY_SPEC,
+        };
+        return this;
+    }
+    /**
+     * Sets the party hint (alias or name) used during wallet initialization.
+     *
+     * @param hint - A 5-character non-empty string representing the party hint.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the hint is empty or more than 5 characters long.
+     */
+    partyHint(hint) {
+        const trimmedHint = hint.trim();
+        if (!trimmedHint) {
+            throw new Error('partyHint cannot be empty');
+        }
+        if (trimmedHint.length > 5) {
+            throw new Error('partyHint must be less than 6 characters long');
+        }
+        this._partyHint = trimmedHint;
+        return this;
+    }
+    /**
+     * Sets whether the local participant should be added in observation-only mode.
+     *
+     * @param flag - Boolean flag indicating observation-only status.
+     * @returns The current builder instance for chaining.
+     */
+    localParticipantObservationOnly(flag) {
+        this._localParticipantObservationOnly = flag;
+        return this;
+    }
+    /**
+     * Adds a confirming participant UID to the list of other confirming participants.
+     *
+     * @param uid - A non-empty string UID of another confirming participant.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the UID is empty.
+     */
+    otherConfirmingParticipantUid(uid) {
+        const trimmedUid = uid.trim();
+        if (!trimmedUid) {
+            throw new Error('otherConfirmingParticipantUid cannot be empty');
+        }
+        if (!this._otherConfirmingParticipantUids) {
+            this._otherConfirmingParticipantUids = [];
+        }
+        this._otherConfirmingParticipantUids.push(trimmedUid);
+        return this;
+    }
+    /**
+     * Sets the confirmation threshold for the wallet initialization.
+     *
+     * @param threshold - A positive integer indicating how many confirmations are required.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the threshold is not a positive integer.
+     */
+    confirmationThreshold(threshold) {
+        if (!Number.isInteger(threshold) || threshold <= 0) {
+            throw new Error('confirmationThreshold must be a positive integer');
+        }
+        this._confirmationThreshold = threshold;
+        return this;
+    }
+    /**
+     * Adds an observing participant UID to the list of observers.
+     *
+     * @param uid - A non-empty string UID of the observing participant.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the UID is empty.
+     */
+    observingParticipantUid(uid) {
+        const trimmedUid = uid.trim();
+        if (!trimmedUid) {
+            throw new Error('observingParticipantUid cannot be empty');
+        }
+        if (!this._observingParticipantUids) {
+            this._observingParticipantUids = [];
+        }
+        this._observingParticipantUids.push(trimmedUid);
+        return this;
+    }
+    /**
+     * Builds and returns the WalletInitRequest object from the builder's internal state.
+     *
+     * This method performs validation before constructing the object. If required fields are
+     * missing or invalid, it throws an error.
+     *
+     * @returns {WalletInitRequest} - A fully constructed and validated request object for wallet initialization.
+     * @throws {Error} If any required field is missing or fails validation.
+     */
+    toRequestObject() {
+        this.validate();
+        return {
+            publicKey: this._publicKey,
+            partyHint: this._partyHint,
+            localParticipantObservationOnly: this._localParticipantObservationOnly,
+            otherConfirmingParticipantUids: this._otherConfirmingParticipantUids,
+            confirmationThreshold: this._confirmationThreshold,
+            observingParticipantUids: this._observingParticipantUids,
+        };
+    }
+    /**
+     * Validates the internal state of the builder before building the request object.
+     *
+     * Checks for:
+     * - Presence of a synchronizer ID.
+     * - `partyHint` must not be empty and must be at most 5 characters long.
+     * - Public key must include `keyData`, `format`, and `keySpec`.
+     * - Confirmation threshold must be a positive integer.
+     * - Confirming and observing participant UID lists must be arrays.
+     *
+     * @private
+     * @throws {Error} If any required field is missing or invalid.
+     */
+    validate() {
+        if (!this._partyHint || this._partyHint.length > 5)
+            throw new Error('Invalid partyHint');
+        if (!this._publicKey || !this._publicKey.keyData || !this._publicKey.format || !this._publicKey.keySpec) {
+            throw new Error('Invalid publicKey');
+        }
+        if (!Number.isInteger(this._confirmationThreshold) || this._confirmationThreshold <= 0) {
+            throw new Error('Invalid confirmationThreshold');
+        }
+        if (!Array.isArray(this._otherConfirmingParticipantUids)) {
+            throw new Error('otherConfirmingParticipantUids must be an array');
+        }
+        if (!Array.isArray(this._observingParticipantUids)) {
+            throw new Error('observingParticipantUids must be an array');
+        }
+    }
+}
+exports.WalletInitBuilder = WalletInitBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletInitBuilder.js","sourceRoot":"","sources":["../../../src/lib/walletInitBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import BigNumber from 'bignumber.js';\n\nimport {\n  BaseAddress,\n  BaseKey,\n  BaseTransactionBuilder,\n  BuildTransactionError,\n  InvalidTransactionError,\n  PublicKey,\n  Signature,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\n\nimport { KeyPair } from './keyPair';\nimport { IPublicKey, PreparedParty, WalletInitRequest } from './iface';\nimport utils from './utils';\nimport { WalletInitTransaction } from './walletInitialization/walletInitTransaction';\nimport { PUBLIC_KEY_FORMAT, PUBLIC_KEY_SPEC } from './constant';\n\nexport class WalletInitBuilder extends BaseTransactionBuilder {\n  private _transaction: WalletInitTransaction;\n  private _signatures: Signature[] = [];\n\n  private _publicKey: IPublicKey;\n  private _partyHint: string;\n  private _localParticipantObservationOnly = false;\n  private _otherConfirmingParticipantUids: string[] = [];\n  private _confirmationThreshold = 1;\n  private _observingParticipantUids: string[] = [];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new WalletInitTransaction(_coinConfig);\n  }\n\n  initBuilder(tx: WalletInitTransaction): void {\n    this._transaction = tx;\n  }\n\n  protected buildImplementation(): Promise<WalletInitTransaction> {\n    throw new Error('Not implemented');\n  }\n\n  protected fromImplementation(rawTransaction: any, isFirstSigner?: boolean): WalletInitTransaction {\n    throw new Error('Not implemented');\n  }\n\n  protected signImplementation(key: BaseKey): WalletInitTransaction {\n    throw new Error('Not implemented');\n  }\n\n  get transaction(): WalletInitTransaction {\n    return this._transaction;\n  }\n\n  set transaction(transaction: PreparedParty) {\n    this._transaction.preparedParty = transaction;\n  }\n\n  validateAddress(address: BaseAddress, addressFormat?: string): void {\n    if (!utils.isValidAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address ' + address.address);\n    }\n  }\n\n  validateKey(key: BaseKey): void {\n    let keyPair: KeyPair;\n    try {\n      keyPair = new KeyPair({ prv: key.key });\n    } catch {\n      throw new BuildTransactionError('Invalid key');\n    }\n    if (!keyPair.getKeys().prv) {\n      throw new BuildTransactionError('Invalid key');\n    }\n  }\n\n  validateRawTransaction(rawTransaction: string[]): void {\n    if (!rawTransaction || !this._transaction.preparedParty) {\n      throw new BuildTransactionError('invalid raw transaction');\n    }\n    const localHash = utils.computeHashFromCreatePartyResponse(rawTransaction);\n    if (localHash !== this._transaction.preparedParty.multiHash) {\n      throw new BuildTransactionError('invalid raw transaction, hash not matching');\n    }\n  }\n\n  validateTransaction(transaction?: WalletInitTransaction): void {\n    if (!transaction?.preparedParty) {\n      return;\n    }\n    const localHash = utils.computeHashFromCreatePartyResponse(transaction.preparedParty.topologyTransactions);\n    if (localHash !== this._transaction.preparedParty.multiHash) {\n      throw new BuildTransactionError('invalid transaction');\n    }\n  }\n\n  // not implemented because wallet initialization doesn't require any value\n  validateValue(value: BigNumber): void {\n    throw new Error('Not implemented');\n  }\n\n  /** @inheritDoc */\n  addSignature(publicKey: PublicKey, signature: Buffer): void {\n    if (!this.transaction) {\n      throw new InvalidTransactionError('transaction is empty!');\n    }\n    this._signatures.push({ publicKey, signature });\n    this.transaction.signatures = signature.toString('base64');\n  }\n\n  /**\n   * Sets the public key used for signing.\n   *\n   * @param key - The public key of the wallet.\n   * @returns The current builder instance for chaining.\n   * @throws Error if key is not a valid public key\n   */\n  publicKey(key: string): this {\n    utils.isValidPublicKey(key);\n    this._publicKey = {\n      format: PUBLIC_KEY_FORMAT,\n      keyData: key,\n      keySpec: PUBLIC_KEY_SPEC,\n    };\n    return this;\n  }\n\n  /**\n   * Sets the party hint (alias or name) used during wallet initialization.\n   *\n   * @param hint - A 5-character non-empty string representing the party hint.\n   * @returns The current builder instance for chaining.\n   * @throws Error if the hint is empty or more than 5 characters long.\n   */\n  partyHint(hint: string): this {\n    const trimmedHint = hint.trim();\n    if (!trimmedHint) {\n      throw new Error('partyHint cannot be empty');\n    }\n    if (trimmedHint.length > 5) {\n      throw new Error('partyHint must be less than 6 characters long');\n    }\n    this._partyHint = trimmedHint;\n    return this;\n  }\n\n  /**\n   * Sets whether the local participant should be added in observation-only mode.\n   *\n   * @param flag - Boolean flag indicating observation-only status.\n   * @returns The current builder instance for chaining.\n   */\n  localParticipantObservationOnly(flag: boolean): this {\n    this._localParticipantObservationOnly = flag;\n    return this;\n  }\n\n  /**\n   * Adds a confirming participant UID to the list of other confirming participants.\n   *\n   * @param uid - A non-empty string UID of another confirming participant.\n   * @returns The current builder instance for chaining.\n   * @throws Error if the UID is empty.\n   */\n  otherConfirmingParticipantUid(uid: string): this {\n    const trimmedUid = uid.trim();\n    if (!trimmedUid) {\n      throw new Error('otherConfirmingParticipantUid cannot be empty');\n    }\n    if (!this._otherConfirmingParticipantUids) {\n      this._otherConfirmingParticipantUids = [];\n    }\n    this._otherConfirmingParticipantUids.push(trimmedUid);\n    return this;\n  }\n\n  /**\n   * Sets the confirmation threshold for the wallet initialization.\n   *\n   * @param threshold - A positive integer indicating how many confirmations are required.\n   * @returns The current builder instance for chaining.\n   * @throws Error if the threshold is not a positive integer.\n   */\n  confirmationThreshold(threshold: number): this {\n    if (!Number.isInteger(threshold) || threshold <= 0) {\n      throw new Error('confirmationThreshold must be a positive integer');\n    }\n    this._confirmationThreshold = threshold;\n    return this;\n  }\n\n  /**\n   * Adds an observing participant UID to the list of observers.\n   *\n   * @param uid - A non-empty string UID of the observing participant.\n   * @returns The current builder instance for chaining.\n   * @throws Error if the UID is empty.\n   */\n  observingParticipantUid(uid: string): this {\n    const trimmedUid = uid.trim();\n    if (!trimmedUid) {\n      throw new Error('observingParticipantUid cannot be empty');\n    }\n    if (!this._observingParticipantUids) {\n      this._observingParticipantUids = [];\n    }\n    this._observingParticipantUids.push(trimmedUid);\n    return this;\n  }\n\n  /**\n   * Builds and returns the WalletInitRequest object from the builder's internal state.\n   *\n   * This method performs validation before constructing the object. If required fields are\n   * missing or invalid, it throws an error.\n   *\n   * @returns {WalletInitRequest} - A fully constructed and validated request object for wallet initialization.\n   * @throws {Error} If any required field is missing or fails validation.\n   */\n  toRequestObject(): WalletInitRequest {\n    this.validate();\n    return {\n      publicKey: this._publicKey,\n      partyHint: this._partyHint,\n      localParticipantObservationOnly: this._localParticipantObservationOnly,\n      otherConfirmingParticipantUids: this._otherConfirmingParticipantUids,\n      confirmationThreshold: this._confirmationThreshold,\n      observingParticipantUids: this._observingParticipantUids,\n    };\n  }\n\n  /**\n   * Validates the internal state of the builder before building the request object.\n   *\n   * Checks for:\n   * - Presence of a synchronizer ID.\n   * - `partyHint` must not be empty and must be at most 5 characters long.\n   * - Public key must include `keyData`, `format`, and `keySpec`.\n   * - Confirmation threshold must be a positive integer.\n   * - Confirming and observing participant UID lists must be arrays.\n   *\n   * @private\n   * @throws {Error} If any required field is missing or invalid.\n   */\n  private validate(): void {\n    if (!this._partyHint || this._partyHint.length > 5) throw new Error('Invalid partyHint');\n    if (!this._publicKey || !this._publicKey.keyData || !this._publicKey.format || !this._publicKey.keySpec) {\n      throw new Error('Invalid publicKey');\n    }\n    if (!Number.isInteger(this._confirmationThreshold) || this._confirmationThreshold <= 0) {\n      throw new Error('Invalid confirmationThreshold');\n    }\n    if (!Array.isArray(this._otherConfirmingParticipantUids)) {\n      throw new Error('otherConfirmingParticipantUids must be an array');\n    }\n    if (!Array.isArray(this._observingParticipantUids)) {\n      throw new Error('observingParticipantUids must be an array');\n    }\n  }\n}\n"]}

package/dist/src/lib/walletInitialization/walletInitTransaction.d.ts

@@ -0,0 +1,17 @@
+import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { PreparedParty, TransactionExplanation, WalletInitTxData } from '../iface';
+export declare class WalletInitTransaction extends BaseTransaction {
+    private _preparedParty;
+    constructor(coinConfig: Readonly<CoinConfig>);
+    get preparedParty(): PreparedParty;
+    set preparedParty(transaction: PreparedParty);
+    canSign(key: BaseKey): boolean;
+    set signatures(signature: string);
+    toBroadcastFormat(): string;
+    toJson(): WalletInitTxData;
+    get signablePayload(): Buffer;
+    fromRawTransaction(rawTx: string): void;
+    explainTransaction(): TransactionExplanation;
+}
+//# sourceMappingURL=walletInitTransaction.d.ts.map

package/dist/src/lib/walletInitialization/walletInitTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletInitTransaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/walletInitialization/walletInitTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAA4C,MAAM,sBAAsB,CAAC;AAC1G,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAGL,aAAa,EACb,sBAAsB,EAEtB,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAGlB,qBAAa,qBAAsB,SAAQ,eAAe;IACxD,OAAO,CAAC,cAAc,CAAgB;gBAE1B,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI5C,IAAI,aAAa,IAAI,aAAa,CAEjC;IAED,IAAI,aAAa,CAAC,WAAW,EAAE,aAAa,EAI3C;IAED,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAI9B,IAAI,UAAU,CAAC,SAAS,EAAE,MAAM,EAE/B;IAED,iBAAiB,IAAI,MAAM;IA6B3B,MAAM,IAAI,gBAAgB;IAY1B,IAAI,eAAe,IAAI,MAAM,CAK5B;IAED,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAgBvC,kBAAkB,IAAI,sBAAsB;CAa7C"}

package/dist/src/lib/walletInitialization/walletInitTransaction.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletInitTransaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const constant_1 = require("../constant");
+class WalletInitTransaction extends sdk_core_1.BaseTransaction {
+    constructor(coinConfig) {
+        super(coinConfig);
+    }
+    get preparedParty() {
+        return this._preparedParty;
+    }
+    set preparedParty(transaction) {
+        this._preparedParty = transaction;
+        this._id = transaction.multiHash;
+        this._type = sdk_core_1.TransactionType.WalletInitialization;
+    }
+    canSign(key) {
+        return false;
+    }
+    set signatures(signature) {
+        this._signatures.push(signature);
+    }
+    toBroadcastFormat() {
+        if (!this._preparedParty) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        const multiHashSignatures = [];
+        if (this.signature.length > 0) {
+            this.signature.map((signature) => {
+                const multiHashSignature = {
+                    format: constant_1.SIGNATURE_FORMAT,
+                    signature: signature,
+                    signedBy: this._preparedParty.publicKeyFingerprint,
+                    signingAlgorithmSpec: constant_1.SIGNATURE_ALGORITHM_SPEC,
+                };
+                multiHashSignatures.push(multiHashSignature);
+            });
+        }
+        const walletInitBroadcastData = {
+            preparedParty: this._preparedParty,
+            onboardingTransactions: this._preparedParty.topologyTransactions.map((txn) => {
+                const onboardingTransaction = {
+                    transaction: txn,
+                };
+                return onboardingTransaction;
+            }),
+            multiHashSignatures: multiHashSignatures,
+        };
+        return Buffer.from(JSON.stringify(walletInitBroadcastData)).toString('base64');
+    }
+    toJson() {
+        if (!this._preparedParty) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        const result = {
+            id: this.id,
+            type: this._type,
+            preparedParty: this._preparedParty,
+        };
+        return result;
+    }
+    get signablePayload() {
+        if (!this._preparedParty) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction data');
+        }
+        return Buffer.from(this._preparedParty.multiHash, 'base64');
+    }
+    fromRawTransaction(rawTx) {
+        try {
+            const decoded = JSON.parse(Buffer.from(rawTx, 'base64').toString('utf8'));
+            this._preparedParty = decoded.preparedParty;
+            this._type = sdk_core_1.TransactionType.WalletInitialization;
+            this._id = decoded.preparedParty.multiHash;
+            if (decoded.multiHashSignatures.length > 0) {
+                decoded.multiHashSignatures.map((multiHashSignature) => {
+                    this.signatures = multiHashSignature.signature;
+                });
+            }
+        }
+        catch (e) {
+            throw new sdk_core_1.InvalidTransactionError('Unable to parse raw transaction data');
+        }
+    }
+    explainTransaction() {
+        const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'];
+        return {
+            id: this.id,
+            displayOrder,
+            outputs: [],
+            outputAmount: '0',
+            changeOutputs: [],
+            changeAmount: '0',
+            fee: { fee: '0' },
+            type: this.type,
+        };
+    }
+}
+exports.WalletInitTransaction = WalletInitTransaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"walletInitTransaction.js","sourceRoot":"","sources":["../../../../src/lib/walletInitialization/walletInitTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseKey, BaseTransaction, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport {\n  MultiHashSignature,\n  OnboardingTransaction,\n  PreparedParty,\n  TransactionExplanation,\n  WalletInitBroadcastData,\n  WalletInitTxData,\n} from '../iface';\nimport { SIGNATURE_ALGORITHM_SPEC, SIGNATURE_FORMAT } from '../constant';\n\nexport class WalletInitTransaction extends BaseTransaction {\n  private _preparedParty: PreparedParty;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n  }\n\n  get preparedParty(): PreparedParty {\n    return this._preparedParty;\n  }\n\n  set preparedParty(transaction: PreparedParty) {\n    this._preparedParty = transaction;\n    this._id = transaction.multiHash;\n    this._type = TransactionType.WalletInitialization;\n  }\n\n  canSign(key: BaseKey): boolean {\n    return false;\n  }\n\n  set signatures(signature: string) {\n    this._signatures.push(signature);\n  }\n\n  toBroadcastFormat(): string {\n    if (!this._preparedParty) {\n      throw new InvalidTransactionError('Empty transaction data');\n    }\n    const multiHashSignatures: MultiHashSignature[] = [];\n    if (this.signature.length > 0) {\n      this.signature.map((signature) => {\n        const multiHashSignature: MultiHashSignature = {\n          format: SIGNATURE_FORMAT,\n          signature: signature,\n          signedBy: this._preparedParty.publicKeyFingerprint,\n          signingAlgorithmSpec: SIGNATURE_ALGORITHM_SPEC,\n        };\n        multiHashSignatures.push(multiHashSignature);\n      });\n    }\n    const walletInitBroadcastData: WalletInitBroadcastData = {\n      preparedParty: this._preparedParty,\n      onboardingTransactions: this._preparedParty.topologyTransactions.map((txn) => {\n        const onboardingTransaction: OnboardingTransaction = {\n          transaction: txn,\n        };\n        return onboardingTransaction;\n      }),\n      multiHashSignatures: multiHashSignatures,\n    };\n    return Buffer.from(JSON.stringify(walletInitBroadcastData)).toString('base64');\n  }\n\n  toJson(): WalletInitTxData {\n    if (!this._preparedParty) {\n      throw new InvalidTransactionError('Empty transaction data');\n    }\n    const result: WalletInitTxData = {\n      id: this.id,\n      type: this._type as TransactionType,\n      preparedParty: this._preparedParty,\n    };\n    return result;\n  }\n\n  get signablePayload(): Buffer {\n    if (!this._preparedParty) {\n      throw new InvalidTransactionError('Empty transaction data');\n    }\n    return Buffer.from(this._preparedParty.multiHash, 'base64');\n  }\n\n  fromRawTransaction(rawTx: string): void {\n    try {\n      const decoded: WalletInitBroadcastData = JSON.parse(Buffer.from(rawTx, 'base64').toString('utf8'));\n      this._preparedParty = decoded.preparedParty;\n      this._type = TransactionType.WalletInitialization;\n      this._id = decoded.preparedParty.multiHash;\n      if (decoded.multiHashSignatures.length > 0) {\n        decoded.multiHashSignatures.map((multiHashSignature: MultiHashSignature) => {\n          this.signatures = multiHashSignature.signature;\n        });\n      }\n    } catch (e) {\n      throw new InvalidTransactionError('Unable to parse raw transaction data');\n    }\n  }\n\n  explainTransaction(): TransactionExplanation {\n    const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'type'];\n    return {\n      id: this.id,\n      displayOrder,\n      outputs: [],\n      outputAmount: '0',\n      changeOutputs: [],\n      changeAmount: '0',\n      fee: { fee: '0' },\n      type: this.type,\n    };\n  }\n}\n"]}

package/dist/test/helper.d.ts

@@ -0,0 +1,3 @@
+import { TransactionBuilderFactory } from '../src';
+export declare function getCantonBuilderFactory(coinName: string): TransactionBuilderFactory;
+//# sourceMappingURL=helper.d.ts.map

package/dist/test/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../test/helper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC;AAEnD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,yBAAyB,CAEnF"}

package/dist/test/helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCantonBuilderFactory = getCantonBuilderFactory;
+const statics_1 = require("@bitgo-beta/statics");
+const src_1 = require("../src");
+function getCantonBuilderFactory(coinName) {
+    return new src_1.TransactionBuilderFactory(statics_1.coins.get(coinName));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdGVzdC9oZWxwZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSwwREFFQztBQUxELGlEQUE0QztBQUM1QyxnQ0FBbUQ7QUFFbkQsU0FBZ0IsdUJBQXVCLENBQUMsUUFBZ0I7SUFDdEQsT0FBTyxJQUFJLCtCQUF5QixDQUFDLGVBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztBQUM1RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29pbnMgfSBmcm9tICdAYml0Z28tYmV0YS9zdGF0aWNzJztcbmltcG9ydCB7IFRyYW5zYWN0aW9uQnVpbGRlckZhY3RvcnkgfSBmcm9tICcuLi9zcmMnO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0Q2FudG9uQnVpbGRlckZhY3RvcnkoY29pbk5hbWU6IHN0cmluZyk6IFRyYW5zYWN0aW9uQnVpbGRlckZhY3Rvcnkge1xuICByZXR1cm4gbmV3IFRyYW5zYWN0aW9uQnVpbGRlckZhY3RvcnkoY29pbnMuZ2V0KGNvaW5OYW1lKSk7XG59XG4iXX0=

package/dist/test/integration/canton.integration.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=canton.integration.d.ts.map

package/dist/test/integration/canton.integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canton.integration.d.ts","sourceRoot":"","sources":["../../../test/integration/canton.integration.ts"],"names":[],"mappings":""}

package/dist/test/integration/canton.integration.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const helper_1 = require("../helper");
+const resources_1 = require("../resources");
+describe('Canton integration tests', function () {
+    describe('Explain raw transaction', function () {
+        const factory = (0, helper_1.getCantonBuilderFactory)('tcanton');
+        it('should explain raw wallet init transaction', function () {
+            const builder = factory.from(resources_1.WalletInitRawTransaction);
+            const txn = builder.transaction;
+            const explainTxData = txn.explainTransaction();
+            (0, assert_1.default)(explainTxData);
+            assert_1.default.equal(explainTxData.id, resources_1.GenerateTopologyResponse.multiHash);
+            assert_1.default.equal(explainTxData.type, sdk_core_1.TransactionType.WalletInitialization);
+        });
+        it('should explain raw transfer acceptance transaction', function () {
+            const builder = factory.from(resources_1.TransferAcceptRawTransaction);
+            const txn = builder.transaction;
+            const explainTxData = txn.explainTransaction();
+            (0, assert_1.default)(explainTxData);
+            (0, assert_1.default)(explainTxData.id);
+            assert_1.default.equal(explainTxData.type, sdk_core_1.TransactionType.TransferAccept);
+            assert_1.default.equal(explainTxData.inputAmount, '5.0000000000');
+        });
+        it('should explain raw transfer rejection transaction', function () {
+            const builder = factory.from(resources_1.TransferRejectRawTransaction);
+            const txn = builder.transaction;
+            const explainTxData = txn.explainTransaction();
+            (0, assert_1.default)(explainTxData);
+            assert_1.default.equal(explainTxData.type, sdk_core_1.TransactionType.TransferReject);
+            assert_1.default.equal(explainTxData.inputAmount, '5.0000000000');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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