@bitgo/sdk-coin-ton 4.0.4 → 4.0.6

package/dist/esm/lib/transactionBuilder.js

@@ -0,0 +1,145 @@
+import BigNumber from 'bignumber.js';
+import TonWeb from 'tonweb';
+import { BaseTransactionBuilder, BuildTransactionError, } from '@bitgo/sdk-core';
+import utils from './utils';
+export const WITHDRAW_OPCODE = '00001000';
+export class TransactionBuilder extends BaseTransactionBuilder {
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._signatures = [];
+    }
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    /** @inheritdoc */
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    /** @inheritdoc */
+    signImplementation(key) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritDoc */
+    addSignature(publicKey, signature) {
+        this.transaction.signature[0] = signature.toString('hex');
+    }
+    /**
+     * Sets the sender of this transaction.
+     * This account will be responsible for paying transaction fees.
+     *
+     * @param {string} senderAddress the account that is sending this transaction
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    sender(senderAddress) {
+        this.transaction.sender = senderAddress;
+        return this;
+    }
+    /**
+     * Sets the transaction to be bounceable or not.
+     *
+     * @param {string} bounceable whether the transaction can be bounced
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    bounceable(bounceable) {
+        this.transaction.bounceable = bounceable;
+        return this;
+    }
+    /**
+     * Sets the fromAddress to be in bounceable format or not.
+     *
+     * @param {string} bounceable whether the address format is bounceable
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    fromAddressBounceable(bounceable) {
+        this.transaction.fromAddressBounceable = bounceable;
+        this.sender(new TonWeb.Address(this.transaction.sender).toString(true, true, bounceable));
+        return this;
+    }
+    /**
+     * Sets the toAddress to be in bounceable format or not.
+     *
+     * @param {string} bounceable whether the address format is bounceable
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    toAddressBounceable(bounceable) {
+        this.transaction.toAddressBounceable = bounceable;
+        this.transaction.recipient.address = new TonWeb.Address(this.transaction.recipient.address).toString(true, true, bounceable);
+        return this;
+    }
+    fee(feeOptions) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        this.transaction.transactionType = this.transactionType;
+        this.transaction.fromRawTransaction(rawTransaction);
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        this.transaction.transactionType = this.transactionType;
+        await this.transaction.build();
+        this.transaction.loadInputsAndOutputs();
+        return this.transaction;
+    }
+    // region Validators
+    /** @inheritdoc */
+    validateAddress(address, addressFormat) {
+        if (!utils.isValidAddress(address.address)) {
+            throw new BuildTransactionError('Invalid address ' + address.address);
+        }
+    }
+    /** @inheritdoc */
+    validateKey(key) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction) {
+        return;
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        if (!transaction) {
+            throw new Error('transaction not defined');
+        }
+        this.validateAddress(transaction.recipient);
+        this.validateValue(new BigNumber(transaction.recipient.amount));
+    }
+    /** @inheritdoc */
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new BuildTransactionError('Value cannot be less than zero');
+        }
+    }
+    setMessage(msg) {
+        this.transaction.message = msg;
+        return this;
+    }
+    setWithdrawMessage() {
+        const queryId = '0000000000000000';
+        this.transaction.message = WITHDRAW_OPCODE + queryId + this.transaction.withdrawAmount;
+        return this;
+    }
+    sequenceNumber(number) {
+        this.transaction.seqno = number;
+        return this;
+    }
+    expireTime(number) {
+        this.transaction.expireTime = number;
+        return this;
+    }
+    publicKey(key) {
+        this.transaction.publicKey = key;
+        return this;
+    }
+    isV3ContractMessage(bool) {
+        this.transaction.isV3ContractMessage = bool;
+        return this;
+    }
+    subWalletId(id) {
+        this.transaction.sub_wallet_id = id;
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import BigNumber from 'bignumber.js';\nimport TonWeb from 'tonweb';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport {\n  BaseAddress,\n  BaseKey,\n  BaseTransactionBuilder,\n  BuildTransactionError,\n  FeeOptions,\n  PublicKey as BasePublicKey,\n  Signature,\n  TransactionType,\n} from '@bitgo/sdk-core';\nimport { Transaction } from './transaction';\nimport utils from './utils';\n\nexport const WITHDRAW_OPCODE = '00001000';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  private _signatures: Signature[] = [];\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n  }\n\n  // get and set region\n  /**\n   * The transaction type.\n   */\n  protected abstract get transactionType(): TransactionType;\n\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  /** @inheritdoc */\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): Transaction {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritDoc */\n  addSignature(publicKey: BasePublicKey, signature: Buffer): void {\n    this.transaction.signature[0] = signature.toString('hex');\n  }\n\n  /**\n   * Sets the sender of this transaction.\n   * This account will be responsible for paying transaction fees.\n   *\n   * @param {string} senderAddress the account that is sending this transaction\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  sender(senderAddress: string): this {\n    this.transaction.sender = senderAddress;\n    return this;\n  }\n\n  /**\n   * Sets the transaction to be bounceable or not.\n   *\n   * @param {string} bounceable whether the transaction can be bounced\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  bounceable(bounceable: boolean): this {\n    this.transaction.bounceable = bounceable;\n    return this;\n  }\n\n  /**\n   * Sets the fromAddress to be in bounceable format or not.\n   *\n   * @param {string} bounceable whether the address format is bounceable\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  fromAddressBounceable(bounceable: boolean): this {\n    this.transaction.fromAddressBounceable = bounceable;\n    this.sender(new TonWeb.Address(this.transaction.sender).toString(true, true, bounceable));\n    return this;\n  }\n\n  /**\n   * Sets the toAddress to be in bounceable format or not.\n   *\n   * @param {string} bounceable whether the address format is bounceable\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  toAddressBounceable(bounceable: boolean): this {\n    this.transaction.toAddressBounceable = bounceable;\n    this.transaction.recipient.address = new TonWeb.Address(this.transaction.recipient.address).toString(\n      true,\n      true,\n      bounceable\n    );\n    return this;\n  }\n\n  fee(feeOptions: FeeOptions): this {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    this.transaction.transactionType = this.transactionType;\n    this.transaction.fromRawTransaction(rawTransaction);\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    this.transaction.transactionType = this.transactionType;\n    await this.transaction.build();\n    this.transaction.loadInputsAndOutputs();\n    return this.transaction;\n  }\n\n  // region Validators\n  /** @inheritdoc */\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  /** @inheritdoc */\n  validateKey(key: BaseKey): void {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  validateRawTransaction(rawTransaction: string): void {\n    return;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: Transaction): void {\n    if (!transaction) {\n      throw new Error('transaction not defined');\n    }\n    this.validateAddress(transaction.recipient);\n    this.validateValue(new BigNumber(transaction.recipient.amount));\n  }\n\n  /** @inheritdoc */\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new BuildTransactionError('Value cannot be less than zero');\n    }\n  }\n\n  setMessage(msg: string): TransactionBuilder {\n    this.transaction.message = msg;\n    return this;\n  }\n\n  setWithdrawMessage(): TransactionBuilder {\n    const queryId = '0000000000000000';\n    this.transaction.message = WITHDRAW_OPCODE + queryId + this.transaction.withdrawAmount;\n    return this;\n  }\n\n  sequenceNumber(number: number): TransactionBuilder {\n    this.transaction.seqno = number;\n    return this;\n  }\n\n  expireTime(number: number): TransactionBuilder {\n    this.transaction.expireTime = number;\n    return this;\n  }\n\n  publicKey(key: string): TransactionBuilder {\n    this.transaction.publicKey = key;\n    return this;\n  }\n\n  isV3ContractMessage(bool: boolean): TransactionBuilder {\n    this.transaction.isV3ContractMessage = bool;\n    return this;\n  }\n  subWalletId(id: number): TransactionBuilder {\n    this.transaction.sub_wallet_id = id;\n    return this;\n  }\n}\n"]}

package/dist/esm/lib/transactionBuilderFactory.d.ts

@@ -0,0 +1,32 @@
+import { BaseTransactionBuilderFactory } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransactionBuilder } from './transactionBuilder';
+import { TransferBuilder } from './transferBuilder';
+import { SingleNominatorWithdrawBuilder } from './singleNominatorWithdrawBuilder';
+import { TokenTransferBuilder } from './tokenTransferBuilder';
+import { TonWhalesDepositBuilder } from './tonWhalesDepositBuilder';
+import { TonWhalesWithdrawalBuilder } from './tonWhalesWithdrawalBuilder';
+import { TonWhalesVestingDepositBuilder } from './tonWhalesVestingDepositBuilder';
+import { TonWhalesVestingWithdrawBuilder } from './tonWhalesVestingWithdrawBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    from(raw: string): TransactionBuilder;
+    /** @inheritdoc */
+    getTransferBuilder(): TransferBuilder;
+    /**
+     * Returns a specific builder to create a TON withdraw transaction
+     */
+    getSingleNominatorWithdrawBuilder(): SingleNominatorWithdrawBuilder;
+    /**
+     * Returns a specific builder to create a TON token transfer transaction
+     */
+    getTokenTransferBuilder(): TokenTransferBuilder;
+    /** @inheritdoc */
+    getWalletInitializationBuilder(): void;
+    getTonWhalesDepositBuilder(): TonWhalesDepositBuilder;
+    getTonWhalesWithdrawalBuilder(): TonWhalesWithdrawalBuilder;
+    getTonWhalesVestingDepositBuilder(): TonWhalesVestingDepositBuilder;
+    getTonWhalesVestingWithdrawBuilder(): TonWhalesVestingWithdrawBuilder;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

package/dist/esm/lib/transactionBuilderFactory.js

@@ -0,0 +1,96 @@
+import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { TransferBuilder } from './transferBuilder';
+import { SingleNominatorWithdrawBuilder } from './singleNominatorWithdrawBuilder';
+import { Transaction } from './transaction';
+import { TokenTransferBuilder } from './tokenTransferBuilder';
+import { TokenTransaction } from './tokenTransaction';
+import { TonWhalesDepositBuilder } from './tonWhalesDepositBuilder';
+import { TonWhalesWithdrawalBuilder } from './tonWhalesWithdrawalBuilder';
+import { TonWhalesVestingDepositBuilder } from './tonWhalesVestingDepositBuilder';
+import { TonWhalesVestingWithdrawBuilder } from './tonWhalesVestingWithdrawBuilder';
+export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /** @inheritdoc */
+    from(raw) {
+        let builder;
+        try {
+            const checkTx = new Transaction(this._coinConfig);
+            checkTx.fromRawTransaction(raw);
+            let tx;
+            if (checkTx.type === TransactionType.SendToken) {
+                // It's a token transaction, so use TokenTransaction for proper parsing
+                tx = new TokenTransaction(this._coinConfig);
+                tx.fromRawTransaction(raw);
+            }
+            else {
+                // It's a regular transaction, use the already parsed one
+                tx = checkTx;
+            }
+            switch (tx.type) {
+                case TransactionType.Send:
+                    builder = this.getTransferBuilder();
+                    break;
+                case TransactionType.SingleNominatorWithdraw:
+                    builder = this.getSingleNominatorWithdrawBuilder();
+                    break;
+                case TransactionType.SendToken:
+                    builder = this.getTokenTransferBuilder();
+                    break;
+                case TransactionType.TonWhalesDeposit:
+                    builder = this.getTonWhalesDepositBuilder();
+                    break;
+                case TransactionType.TonWhalesWithdrawal:
+                    builder = this.getTonWhalesWithdrawalBuilder();
+                    break;
+                case TransactionType.TonWhalesVestingDeposit:
+                    builder = this.getTonWhalesVestingDepositBuilder();
+                    break;
+                case TransactionType.TonWhalesVestingWithdrawal:
+                    builder = this.getTonWhalesVestingWithdrawBuilder();
+                    break;
+                default:
+                    throw new InvalidTransactionError('unsupported transaction');
+            }
+            builder.from(raw);
+            return builder;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /** @inheritdoc */
+    getTransferBuilder() {
+        return new TransferBuilder(this._coinConfig);
+    }
+    /**
+     * Returns a specific builder to create a TON withdraw transaction
+     */
+    getSingleNominatorWithdrawBuilder() {
+        return new SingleNominatorWithdrawBuilder(this._coinConfig);
+    }
+    /**
+     * Returns a specific builder to create a TON token transfer transaction
+     */
+    getTokenTransferBuilder() {
+        return new TokenTransferBuilder(this._coinConfig);
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder() {
+        throw new Error('Method not implemented.');
+    }
+    getTonWhalesDepositBuilder() {
+        return new TonWhalesDepositBuilder(this._coinConfig);
+    }
+    getTonWhalesWithdrawalBuilder() {
+        return new TonWhalesWithdrawalBuilder(this._coinConfig);
+    }
+    getTonWhalesVestingDepositBuilder() {
+        return new TonWhalesVestingDepositBuilder(this._coinConfig);
+    }
+    getTonWhalesVestingWithdrawBuilder() {
+        return new TonWhalesVestingWithdrawBuilder(this._coinConfig);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { TransferBuilder } from './transferBuilder';\nimport { SingleNominatorWithdrawBuilder } from './singleNominatorWithdrawBuilder';\nimport { Transaction } from './transaction';\nimport { TokenTransferBuilder } from './tokenTransferBuilder';\nimport { TokenTransaction } from './tokenTransaction';\nimport { TonWhalesDepositBuilder } from './tonWhalesDepositBuilder';\nimport { TonWhalesWithdrawalBuilder } from './tonWhalesWithdrawalBuilder';\nimport { TonWhalesVestingDepositBuilder } from './tonWhalesVestingDepositBuilder';\nimport { TonWhalesVestingWithdrawBuilder } from './tonWhalesVestingWithdrawBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n  /** @inheritdoc */\n  from(raw: string): TransactionBuilder {\n    let builder: TransactionBuilder;\n    try {\n      const checkTx = new Transaction(this._coinConfig);\n      checkTx.fromRawTransaction(raw);\n\n      let tx: Transaction;\n      if (checkTx.type === TransactionType.SendToken) {\n        // It's a token transaction, so use TokenTransaction for proper parsing\n        tx = new TokenTransaction(this._coinConfig);\n        tx.fromRawTransaction(raw);\n      } else {\n        // It's a regular transaction, use the already parsed one\n        tx = checkTx;\n      }\n      switch (tx.type) {\n        case TransactionType.Send:\n          builder = this.getTransferBuilder();\n          break;\n        case TransactionType.SingleNominatorWithdraw:\n          builder = this.getSingleNominatorWithdrawBuilder();\n          break;\n        case TransactionType.SendToken:\n          builder = this.getTokenTransferBuilder();\n          break;\n        case TransactionType.TonWhalesDeposit:\n          builder = this.getTonWhalesDepositBuilder();\n          break;\n        case TransactionType.TonWhalesWithdrawal:\n          builder = this.getTonWhalesWithdrawalBuilder();\n          break;\n        case TransactionType.TonWhalesVestingDeposit:\n          builder = this.getTonWhalesVestingDepositBuilder();\n          break;\n        case TransactionType.TonWhalesVestingWithdrawal:\n          builder = this.getTonWhalesVestingWithdrawBuilder();\n          break;\n        default:\n          throw new InvalidTransactionError('unsupported transaction');\n      }\n      builder.from(raw);\n      return builder;\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(): TransferBuilder {\n    return new TransferBuilder(this._coinConfig);\n  }\n\n  /**\n   * Returns a specific builder to create a TON withdraw transaction\n   */\n  getSingleNominatorWithdrawBuilder(): SingleNominatorWithdrawBuilder {\n    return new SingleNominatorWithdrawBuilder(this._coinConfig);\n  }\n\n  /**\n   * Returns a specific builder to create a TON token transfer transaction\n   */\n  getTokenTransferBuilder(): TokenTransferBuilder {\n    return new TokenTransferBuilder(this._coinConfig);\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): void {\n    throw new Error('Method not implemented.');\n  }\n\n  getTonWhalesDepositBuilder(): TonWhalesDepositBuilder {\n    return new TonWhalesDepositBuilder(this._coinConfig);\n  }\n\n  getTonWhalesWithdrawalBuilder(): TonWhalesWithdrawalBuilder {\n    return new TonWhalesWithdrawalBuilder(this._coinConfig);\n  }\n\n  getTonWhalesVestingDepositBuilder(): TonWhalesVestingDepositBuilder {\n    return new TonWhalesVestingDepositBuilder(this._coinConfig);\n  }\n\n  getTonWhalesVestingWithdrawBuilder(): TonWhalesVestingWithdrawBuilder {\n    return new TonWhalesVestingWithdrawBuilder(this._coinConfig);\n  }\n}\n"]}

package/dist/esm/lib/transactionExplanation.d.ts

@@ -0,0 +1,14 @@
+import { ITransactionRecipient } from '@bitgo/sdk-core';
+export interface ITransactionExplanation<TFee = any, TAmount = any> {
+    displayOrder: string[];
+    id: string;
+    outputs: ITransactionRecipient[];
+    outputAmount: TAmount;
+    changeOutputs: ITransactionRecipient[];
+    changeAmount: TAmount;
+    fee: TFee;
+    proxy?: string;
+    producers?: string[];
+    withdrawAmount?: string;
+}
+//# sourceMappingURL=transactionExplanation.d.ts.map

package/dist/{src → esm}/lib/transactionExplanation.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb25FeHBsYW5hdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvdHJhbnNhY3Rpb25FeHBsYW5hdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVRyYW5zYWN0aW9uUmVjaXBpZW50IH0gZnJvbSAnQGJpdGdvL3Nkay1jb3JlJztcblxuZXhwb3J0IGludGVyZmFjZSBJVHJhbnNhY3Rpb25FeHBsYW5hdGlvbjxURmVlID0gYW55LCBUQW1vdW50ID0gYW55PiB7XG4gIGRpc3BsYXlPcmRlcjogc3RyaW5nW107XG4gIGlkOiBzdHJpbmc7XG4gIG91dHB1dHM6IElUcmFuc2FjdGlvblJlY2lwaWVudFtdO1xuICBvdXRwdXRBbW91bnQ6IFRBbW91bnQ7XG4gIGNoYW5nZU91dHB1dHM6IElUcmFuc2FjdGlvblJlY2lwaWVudFtdO1xuICBjaGFuZ2VBbW91bnQ6IFRBbW91bnQ7XG4gIGZlZTogVEZlZTtcbiAgcHJveHk/OiBzdHJpbmc7XG4gIHByb2R1Y2Vycz86IHN0cmluZ1tdO1xuICB3aXRoZHJhd0Ftb3VudD86IHN0cmluZztcbn1cbiJdfQ==

package/dist/esm/lib/transferBuilder.d.ts

@@ -0,0 +1,9 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { Recipient, TransactionType } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class TransferBuilder extends TransactionBuilder {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    send(recipient: Recipient): TransferBuilder;
+}
+//# sourceMappingURL=transferBuilder.d.ts.map

package/dist/esm/lib/transferBuilder.js

@@ -0,0 +1,17 @@
+import { TransactionType } from '@bitgo/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+export class TransferBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new Transaction(_coinConfig);
+    }
+    get transactionType() {
+        return TransactionType.Send;
+    }
+    send(recipient) {
+        this.transaction.recipient = recipient;
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJCdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90cmFuc2ZlckJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFhLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzdELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzFELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFNUMsTUFBTSxPQUFPLGVBQWdCLFNBQVEsa0JBQWtCO0lBQ3JELFlBQVksV0FBaUM7UUFDM0MsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ25CLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxXQUFXLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVELElBQWMsZUFBZTtRQUMzQixPQUFPLGVBQWUsQ0FBQyxJQUFJLENBQUM7SUFDOUIsQ0FBQztJQUVELElBQUksQ0FBQyxTQUFvQjtRQUN2QixJQUFJLENBQUMsV0FBVyxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDdkMsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlQ29pbiBhcyBDb2luQ29uZmlnIH0gZnJvbSAnQGJpdGdvL3N0YXRpY3MnO1xuaW1wb3J0IHsgUmVjaXBpZW50LCBUcmFuc2FjdGlvblR5cGUgfSBmcm9tICdAYml0Z28vc2RrLWNvcmUnO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb25CdWlsZGVyIH0gZnJvbSAnLi90cmFuc2FjdGlvbkJ1aWxkZXInO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb24gfSBmcm9tICcuL3RyYW5zYWN0aW9uJztcblxuZXhwb3J0IGNsYXNzIFRyYW5zZmVyQnVpbGRlciBleHRlbmRzIFRyYW5zYWN0aW9uQnVpbGRlciB7XG4gIGNvbnN0cnVjdG9yKF9jb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKF9jb2luQ29uZmlnKTtcbiAgICB0aGlzLl90cmFuc2FjdGlvbiA9IG5ldyBUcmFuc2FjdGlvbihfY29pbkNvbmZpZyk7XG4gIH1cblxuICBwcm90ZWN0ZWQgZ2V0IHRyYW5zYWN0aW9uVHlwZSgpOiBUcmFuc2FjdGlvblR5cGUge1xuICAgIHJldHVybiBUcmFuc2FjdGlvblR5cGUuU2VuZDtcbiAgfVxuXG4gIHNlbmQocmVjaXBpZW50OiBSZWNpcGllbnQpOiBUcmFuc2ZlckJ1aWxkZXIge1xuICAgIHRoaXMudHJhbnNhY3Rpb24ucmVjaXBpZW50ID0gcmVjaXBpZW50O1xuICAgIHJldHVybiB0aGlzO1xuICB9XG59XG4iXX0=

package/dist/esm/lib/utils.d.ts

@@ -0,0 +1,41 @@
+import { BaseUtils } from '@bitgo/sdk-core';
+import { VestingContractParams } from './iface';
+export declare class Utils implements BaseUtils {
+    /** @inheritdoc */
+    isValidAddress(address: string): boolean;
+    /** @inheritdoc */
+    isValidBlockId(hash: string): boolean;
+    /** @inheritdoc */
+    isValidPrivateKey(key: string): boolean;
+    /** @inheritdoc */
+    isValidPublicKey(key: string): boolean;
+    /** @inheritdoc */
+    isValidSignature(signature: string): boolean;
+    /** @inheritdoc */
+    isValidTransactionId(txId: string): boolean;
+    getAddressFromPublicKey(publicKey: string, bounceable?: boolean, isUserFriendly?: boolean): Promise<string>;
+    getAddress(address: string, bounceable?: boolean): string;
+    getMessageHashFromData(data: string): Promise<string>;
+    getRawWalletAddressFromCell(data: string): string;
+    getVestingContractAddress(params: VestingContractParams): Promise<string>;
+    /**
+     * Converts a TON address into a Base64 encoded BOC (Bag of Cells) string.
+     * This is required when passing an address as a 'slice' argument to `runGetMethod`.
+     * @param address - The TON address (friendly or raw)
+     * @returns Base64 string of the serialized address cell
+     */
+    getAddressBoc(address: string): Promise<string>;
+}
+/**
+ * Function to estimate the fee for a transaction.
+ * This function uses the dummy private key exclusively for fee estimation.
+ * @param wallet - The wallet instance.
+ * @param toAddress - The destination address.
+ * @param amount - The amount to transfer.
+ * @param seqno - The sequence number for the transaction.
+ * @returns The estimated fee for the transaction.
+ */
+export declare function getFeeEstimate(wallet: any, toAddress: string, amount: string, seqno: number): Promise<any>;
+declare const utils: Utils;
+export default utils;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/lib/utils.js

@@ -0,0 +1,151 @@
+import TonWeb from 'tonweb';
+import { BN } from 'bn.js';
+import { isValidEd25519PublicKey } from '@bitgo/sdk-core';
+import { VESTING_CONTRACT_CODE_B64 } from './constants';
+export class Utils {
+    /** @inheritdoc */
+    isValidAddress(address) {
+        try {
+            if (address.length != 48) {
+                return false;
+            }
+            Buffer.from(address, 'base64');
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /** @inheritdoc */
+    isValidBlockId(hash) {
+        try {
+            return Buffer.from(hash, 'base64').length === 32;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /** @inheritdoc */
+    isValidPrivateKey(key) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritdoc */
+    isValidPublicKey(key) {
+        return isValidEd25519PublicKey(key);
+    }
+    /** @inheritdoc */
+    isValidSignature(signature) {
+        throw new Error('Method not implemented.');
+    }
+    /** @inheritdoc */
+    isValidTransactionId(txId) {
+        try {
+            return Buffer.from(txId, 'base64').length === 32;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async getAddressFromPublicKey(publicKey, bounceable = true, isUserFriendly = true) {
+        const tonweb = new TonWeb(new TonWeb.HttpProvider(''));
+        const WalletClass = tonweb.wallet.all['v4R2'];
+        const wallet = new WalletClass(tonweb.provider, {
+            publicKey: TonWeb.utils.hexToBytes(publicKey),
+            wc: 0,
+        });
+        const address = await wallet.getAddress();
+        const legacyAddress = address.toString(isUserFriendly, true, bounceable);
+        return legacyAddress;
+    }
+    getAddress(address, bounceable = true) {
+        if (bounceable) {
+            return new TonWeb.Address(address).isBounceable
+                ? address
+                : new TonWeb.Address(address).toString(true, true, bounceable);
+        }
+        else {
+            return new TonWeb.Address(address).isBounceable
+                ? new TonWeb.Address(address).toString(true, true, bounceable)
+                : address;
+        }
+    }
+    async getMessageHashFromData(data) {
+        const cell = TonWeb.boc.Cell.oneFromBoc(TonWeb.utils.base64ToBytes(data));
+        // this is need to be confirmed by ton team
+        const message = cell.refs[0].refs[0];
+        const hash = TonWeb.utils.bytesToBase64(await message.hash());
+        return hash.toString();
+    }
+    getRawWalletAddressFromCell(data) {
+        const cell = TonWeb.boc.Cell.oneFromBoc(TonWeb.utils.base64ToBytes(data));
+        const slice = cell.beginParse();
+        const address = slice.loadAddress();
+        return address.toString();
+    }
+    async getVestingContractAddress(params) {
+        const cell = new TonWeb.boc.Cell();
+        cell.bits.writeUint(0, 32); //seq no
+        cell.bits.writeUint(params.subWalletId, 32);
+        cell.bits.writeBytes(TonWeb.utils.hexToBytes(params.publicKeyHex));
+        cell.bits.writeUint(0, 1); // empty whitelist
+        const vestingParamsCell = new TonWeb.boc.Cell();
+        vestingParamsCell.bits.writeUint(params.vestingStartTime, 64);
+        vestingParamsCell.bits.writeUint(params.vestingTotalDuration, 32);
+        vestingParamsCell.bits.writeUint(params.unlockPeriod, 32);
+        vestingParamsCell.bits.writeUint(params.cliffDuration, 32);
+        vestingParamsCell.bits.writeCoins(new BN(params.vestingTotalAmount.toString()));
+        const senderAddress = new TonWeb.Address(params.vestingSenderAddress);
+        vestingParamsCell.bits.writeAddress(senderAddress);
+        const ownerAddress = new TonWeb.Address(params.ownerAddress);
+        vestingParamsCell.bits.writeAddress(ownerAddress);
+        cell.refs.push(vestingParamsCell);
+        const contractCodeCell = TonWeb.boc.Cell.oneFromBoc(TonWeb.utils.base64ToBytes(VESTING_CONTRACT_CODE_B64));
+        const stateInit = TonWeb.Contract.createStateInit(contractCodeCell, cell);
+        const stateInitHash = await stateInit.hash();
+        const contractAddress = new TonWeb.Address('0:' + TonWeb.utils.bytesToHex(stateInitHash));
+        return contractAddress.toString(true, true, true);
+    }
+    /**
+     * Converts a TON address into a Base64 encoded BOC (Bag of Cells) string.
+     * This is required when passing an address as a 'slice' argument to `runGetMethod`.
+     * @param address - The TON address (friendly or raw)
+     * @returns Base64 string of the serialized address cell
+     */
+    async getAddressBoc(address) {
+        const cell = new TonWeb.boc.Cell();
+        cell.bits.writeAddress(new TonWeb.Address(address));
+        const boc = await cell.toBoc(false);
+        return TonWeb.utils.bytesToBase64(boc);
+    }
+}
+const DUMMY_PRIVATE_KEY = '43e8594854cb53947c4a1a2fab926af11e123f6251dcd5bd0dfb100604186430'; // This dummy private key is used only for fee estimation
+/**
+ * Function to estimate the fee for a transaction.
+ * This function uses the dummy private key exclusively for fee estimation.
+ * @param wallet - The wallet instance.
+ * @param toAddress - The destination address.
+ * @param amount - The amount to transfer.
+ * @param seqno - The sequence number for the transaction.
+ * @returns The estimated fee for the transaction.
+ */
+export async function getFeeEstimate(wallet, toAddress, amount, seqno) {
+    try {
+        const secretKey = TonWeb.utils.stringToBytes(DUMMY_PRIVATE_KEY);
+        const feeEstimate = await wallet.methods
+            .transfer({
+            secretKey,
+            toAddress,
+            amount,
+            seqno,
+            sendMode: 1,
+        })
+            .estimateFee();
+        return feeEstimate;
+    }
+    catch (error) {
+        throw new Error(`Failed to estimate fee: ${error.message}`);
+    }
+}
+const utils = new Utils();
+export default utils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import TonWeb from 'tonweb';\nimport { BN } from 'bn.js';\nimport { BaseUtils, isValidEd25519PublicKey } from '@bitgo/sdk-core';\nimport { VESTING_CONTRACT_CODE_B64 } from './constants';\nimport { VestingContractParams } from './iface';\nexport class Utils implements BaseUtils {\n  /** @inheritdoc */\n  isValidAddress(address: string): boolean {\n    try {\n      if (address.length != 48) {\n        return false;\n      }\n      Buffer.from(address, 'base64');\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    try {\n      return Buffer.from(hash, 'base64').length === 32;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /** @inheritdoc */\n  isValidPrivateKey(key: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPublicKey(key: string): boolean {\n    return isValidEd25519PublicKey(key);\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    try {\n      return Buffer.from(txId, 'base64').length === 32;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  async getAddressFromPublicKey(publicKey: string, bounceable = true, isUserFriendly = true): Promise<string> {\n    const tonweb = new TonWeb(new TonWeb.HttpProvider(''));\n    const WalletClass = tonweb.wallet.all['v4R2'];\n    const wallet = new WalletClass(tonweb.provider, {\n      publicKey: TonWeb.utils.hexToBytes(publicKey),\n      wc: 0,\n    });\n    const address = await wallet.getAddress();\n    const legacyAddress = address.toString(isUserFriendly, true, bounceable);\n    return legacyAddress;\n  }\n\n  getAddress(address: string, bounceable = true): string {\n    if (bounceable) {\n      return new TonWeb.Address(address).isBounceable\n        ? address\n        : new TonWeb.Address(address).toString(true, true, bounceable);\n    } else {\n      return new TonWeb.Address(address).isBounceable\n        ? new TonWeb.Address(address).toString(true, true, bounceable)\n        : address;\n    }\n  }\n\n  async getMessageHashFromData(data: string): Promise<string> {\n    const cell = TonWeb.boc.Cell.oneFromBoc(TonWeb.utils.base64ToBytes(data));\n    // this is need to be confirmed by ton team\n    const message = cell.refs[0].refs[0];\n    const hash = TonWeb.utils.bytesToBase64(await message.hash());\n    return hash.toString();\n  }\n\n  getRawWalletAddressFromCell(data: string): string {\n    const cell = TonWeb.boc.Cell.oneFromBoc(TonWeb.utils.base64ToBytes(data));\n    const slice = (cell as any).beginParse();\n    const address = slice.loadAddress();\n    return address.toString();\n  }\n\n  async getVestingContractAddress(params: VestingContractParams): Promise<string> {\n    const cell = new TonWeb.boc.Cell();\n    cell.bits.writeUint(0, 32); //seq no\n    cell.bits.writeUint(params.subWalletId, 32);\n    cell.bits.writeBytes(TonWeb.utils.hexToBytes(params.publicKeyHex));\n    cell.bits.writeUint(0, 1); // empty whitelist\n    const vestingParamsCell = new TonWeb.boc.Cell();\n    vestingParamsCell.bits.writeUint(params.vestingStartTime, 64);\n    vestingParamsCell.bits.writeUint(params.vestingTotalDuration, 32);\n    vestingParamsCell.bits.writeUint(params.unlockPeriod, 32);\n    vestingParamsCell.bits.writeUint(params.cliffDuration, 32);\n    vestingParamsCell.bits.writeCoins(new BN(params.vestingTotalAmount.toString()));\n    const senderAddress = new TonWeb.Address(params.vestingSenderAddress);\n    vestingParamsCell.bits.writeAddress(senderAddress);\n    const ownerAddress = new TonWeb.Address(params.ownerAddress);\n    vestingParamsCell.bits.writeAddress(ownerAddress);\n    cell.refs.push(vestingParamsCell);\n    const contractCodeCell = TonWeb.boc.Cell.oneFromBoc(TonWeb.utils.base64ToBytes(VESTING_CONTRACT_CODE_B64));\n    const stateInit = TonWeb.Contract.createStateInit(contractCodeCell, cell);\n    const stateInitHash = await stateInit.hash();\n    const contractAddress = new TonWeb.Address('0:' + TonWeb.utils.bytesToHex(stateInitHash));\n    return contractAddress.toString(true, true, true);\n  }\n\n  /**\n   * Converts a TON address into a Base64 encoded BOC (Bag of Cells) string.\n   * This is required when passing an address as a 'slice' argument to `runGetMethod`.\n   * @param address - The TON address (friendly or raw)\n   * @returns Base64 string of the serialized address cell\n   */\n  async getAddressBoc(address: string): Promise<string> {\n    const cell = new TonWeb.boc.Cell();\n    cell.bits.writeAddress(new TonWeb.Address(address));\n    const boc = await cell.toBoc(false);\n    return TonWeb.utils.bytesToBase64(boc);\n  }\n}\n\nconst DUMMY_PRIVATE_KEY = '43e8594854cb53947c4a1a2fab926af11e123f6251dcd5bd0dfb100604186430'; // This dummy private key is used only for fee estimation\n\n/**\n * Function to estimate the fee for a transaction.\n * This function uses the dummy private key exclusively for fee estimation.\n * @param wallet - The wallet instance.\n * @param toAddress - The destination address.\n * @param amount - The amount to transfer.\n * @param seqno - The sequence number for the transaction.\n * @returns The estimated fee for the transaction.\n */\n\nexport async function getFeeEstimate(wallet: any, toAddress: string, amount: string, seqno: number): Promise<any> {\n  try {\n    const secretKey = TonWeb.utils.stringToBytes(DUMMY_PRIVATE_KEY);\n    const feeEstimate = await wallet.methods\n      .transfer({\n        secretKey,\n        toAddress,\n        amount,\n        seqno,\n        sendMode: 1,\n      })\n      .estimateFee();\n    return feeEstimate;\n  } catch (error) {\n    throw new Error(`Failed to estimate fee: ${error.message}`);\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}

package/dist/esm/register.d.ts

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

package/dist/esm/register.js

@@ -0,0 +1,11 @@
+import { Ton } from './ton';
+import { Tton } from './tton';
+import { JettonToken } from './jettonToken';
+export const register = (sdk) => {
+    sdk.register('ton', Ton.createInstance);
+    sdk.register('tton', Tton.createInstance);
+    JettonToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+        sdk.register(name, coinConstructor);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLE9BQU8sQ0FBQztBQUM1QixPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQzlCLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFNUMsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLENBQUMsR0FBYyxFQUFRLEVBQUU7SUFDL0MsR0FBRyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQ3hDLEdBQUcsQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUMxQyxXQUFXLENBQUMsdUJBQXVCLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFO1FBQzFFLEdBQUcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvL3Nkay1jb3JlJztcbmltcG9ydCB7IFRvbiB9IGZyb20gJy4vdG9uJztcbmltcG9ydCB7IFR0b24gfSBmcm9tICcuL3R0b24nO1xuaW1wb3J0IHsgSmV0dG9uVG9rZW4gfSBmcm9tICcuL2pldHRvblRva2VuJztcblxuZXhwb3J0IGNvbnN0IHJlZ2lzdGVyID0gKHNkazogQml0R29CYXNlKTogdm9pZCA9PiB7XG4gIHNkay5yZWdpc3RlcigndG9uJywgVG9uLmNyZWF0ZUluc3RhbmNlKTtcbiAgc2RrLnJlZ2lzdGVyKCd0dG9uJywgVHRvbi5jcmVhdGVJbnN0YW5jZSk7XG4gIEpldHRvblRva2VuLmNyZWF0ZVRva2VuQ29uc3RydWN0b3JzKCkuZm9yRWFjaCgoeyBuYW1lLCBjb2luQ29uc3RydWN0b3IgfSkgPT4ge1xuICAgIHNkay5yZWdpc3RlcihuYW1lLCBjb2luQ29uc3RydWN0b3IpO1xuICB9KTtcbn07XG4iXX0=