@bitgo-beta/sdk-coin-canton 1.0.1-beta.6 → 1.0.1-beta.61

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,16 @@
+import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { PreparedParty, 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;
+}
+//# 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,EAEb,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;CAexC"}

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

@@ -0,0 +1,87 @@
+"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');
+        }
+    }
+}
+exports.WalletInitTransaction = WalletInitTransaction;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/register.d.ts

@@ -0,0 +1,3 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+export declare const register: (sdk: BitGoBase) => void;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAGzC,CAAC"}

package/dist/src/register.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const canton_1 = require("./canton");
+const tcanton_1 = require("./tcanton");
+const register = (sdk) => {
+    sdk.register('canton', canton_1.Canton.createInstance);
+    sdk.register('tcanton', tcanton_1.Tcanton.createInstance);
+};
+exports.register = register;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EscUNBQWtDO0FBQ2xDLHVDQUFvQztBQUU3QixNQUFNLFFBQVEsR0FBRyxDQUFDLEdBQWMsRUFBUSxFQUFFO0lBQy9DLEdBQUcsQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLGVBQU0sQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUM5QyxHQUFHLENBQUMsUUFBUSxDQUFDLFNBQVMsRUFBRSxpQkFBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDO0FBQ2xELENBQUMsQ0FBQztBQUhXLFFBQUEsUUFBUSxZQUduQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJpdEdvQmFzZSB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcbmltcG9ydCB7IENhbnRvbiB9IGZyb20gJy4vY2FudG9uJztcbmltcG9ydCB7IFRjYW50b24gfSBmcm9tICcuL3RjYW50b24nO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXIgPSAoc2RrOiBCaXRHb0Jhc2UpOiB2b2lkID0+IHtcbiAgc2RrLnJlZ2lzdGVyKCdjYW50b24nLCBDYW50b24uY3JlYXRlSW5zdGFuY2UpO1xuICBzZGsucmVnaXN0ZXIoJ3RjYW50b24nLCBUY2FudG9uLmNyZWF0ZUluc3RhbmNlKTtcbn07XG4iXX0=

package/dist/src/tcanton.d.ts

@@ -0,0 +1,17 @@
+import { BaseCoin, BitGoBase } from '@bitgo-beta/sdk-core';
+import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
+import { Canton } from './canton';
+export declare class Tcanton extends Canton {
+    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
+    protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
+    /**
+     * Identifier for the blockchain which supports this coin
+     */
+    getChain(): string;
+    /**
+     * Complete human-readable name of this coin
+     */
+    getFullName(): string;
+}
+//# sourceMappingURL=tcanton.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tcanton.d.ts","sourceRoot":"","sources":["../../src/tcanton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,OAAQ,SAAQ,MAAM;IACjC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC3D,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;;OAEG;IACI,QAAQ,IAAI,MAAM;IAIzB;;OAEG;IACI,WAAW,IAAI,MAAM;CAG7B"}

package/dist/src/tcanton.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tcanton = void 0;
+const canton_1 = require("./canton");
+class Tcanton extends canton_1.Canton {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this._staticsCoin = staticsCoin;
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Tcanton(bitgo, staticsCoin);
+    }
+    /**
+     * Identifier for the blockchain which supports this coin
+     */
+    getChain() {
+        return 'tcanton';
+    }
+    /**
+     * Complete human-readable name of this coin
+     */
+    getFullName() {
+        return 'Testnet Canton';
+    }
+}
+exports.Tcanton = Tcanton;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/test/integration/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90ZXN0L2ludGVncmF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIiXX0=