@bitgo/account-lib 2.20.1-rc.2 → 2.21.0-hotfix.0

package/dist/src/coin/sol/tokenEncodeDecode.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @prettier
+ */
+import { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';
+export declare enum TokenInstruction {
+    InitializeMint = 0,
+    InitializeAccount = 1,
+    InitializeMultisig = 2,
+    Transfer = 3,
+    Approve = 4,
+    Revoke = 5,
+    SetAuthority = 6,
+    MintTo = 7,
+    Burn = 8,
+    CloseAccount = 9,
+    FreezeAccount = 10,
+    ThawAccount = 11,
+    TransferChecked = 12,
+    ApproveChecked = 13,
+    MintToChecked = 14,
+    BurnChecked = 15,
+    InitializeAccount2 = 16,
+    SyncNative = 17,
+    InitializeAccount3 = 18,
+    InitializeMultisig2 = 19,
+    InitializeMint2 = 20
+}
+export declare abstract class TokenError extends Error {
+    name: string;
+    constructor(message?: string);
+}
+/** Thrown if an instruction's program is invalid */
+export declare class TokenInvalidInstructionProgramError extends TokenError {
+    name: string;
+}
+/** Thrown if an instruction's keys are invalid */
+export declare class TokenInvalidInstructionKeysError extends TokenError {
+    name: string;
+}
+/** Thrown if an instruction's type is invalid */
+export declare class TokenInvalidInstructionTypeError extends TokenError {
+    name: string;
+}
+/** A decoded, valid TransferChecked instruction */
+export interface DecodedTransferCheckedInstruction {
+    programId: PublicKey;
+    keys: {
+        source: AccountMeta;
+        mint: AccountMeta;
+        destination: AccountMeta;
+        owner: AccountMeta;
+        multiSigners: AccountMeta[];
+    };
+    data: {
+        instruction: TokenInstruction.TransferChecked;
+        amount: number;
+        decimals: number;
+    };
+}
+/**
+ * Decode a TransferChecked instruction and validate it
+ *
+ * @param instruction Transaction instruction to decode
+ * @param programId   SPL Token program account
+ *
+ * @return Decoded, valid instruction
+ */
+export declare function decodeTransferCheckedInstruction(instruction: TransactionInstruction, programId?: PublicKey): DecodedTransferCheckedInstruction;
+/** A decoded, non-validated TransferChecked instruction */
+export interface DecodedTransferCheckedInstructionUnchecked {
+    programId: PublicKey;
+    keys: {
+        source: AccountMeta | undefined;
+        mint: AccountMeta | undefined;
+        destination: AccountMeta | undefined;
+        owner: AccountMeta | undefined;
+        multiSigners: AccountMeta[];
+    };
+    data: {
+        instruction: number;
+        amount: number;
+        decimals: number;
+    };
+}
+//# sourceMappingURL=tokenEncodeDecode.d.ts.map

package/dist/src/coin/sol/tokenEncodeDecode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenEncodeDecode.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/tokenEncodeDecode.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAYjF,oBAAY,gBAAgB;IAC1B,cAAc,IAAI;IAClB,iBAAiB,IAAI;IACrB,kBAAkB,IAAI;IACtB,QAAQ,IAAI;IACZ,OAAO,IAAI;IACX,MAAM,IAAI;IACV,YAAY,IAAI;IAChB,MAAM,IAAI;IACV,IAAI,IAAI;IACR,YAAY,IAAI;IAChB,aAAa,KAAK;IAClB,WAAW,KAAK;IAChB,eAAe,KAAK;IACpB,cAAc,KAAK;IACnB,aAAa,KAAK;IAClB,WAAW,KAAK;IAChB,kBAAkB,KAAK;IACvB,UAAU,KAAK;IACf,kBAAkB,KAAK;IACvB,mBAAmB,KAAK;IACxB,eAAe,KAAK;CACrB;AAED,8BAAsB,UAAW,SAAQ,KAAK;IAC5C,IAAI,EAAE,MAAM,CAAC;gBACD,OAAO,CAAC,EAAE,MAAM;CAG7B;AAED,oDAAoD;AACpD,qBAAa,mCAAoC,SAAQ,UAAU;IACjE,IAAI,SAAyC;CAC9C;AAED,kDAAkD;AAClD,qBAAa,gCAAiC,SAAQ,UAAU;IAC9D,IAAI,SAAsC;CAC3C;AAED,iDAAiD;AACjD,qBAAa,gCAAiC,SAAQ,UAAU;IAC9D,IAAI,SAAsC;CAC3C;AAED,mDAAmD;AACnD,MAAM,WAAW,iCAAiC;IAChD,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE;QACJ,MAAM,EAAE,WAAW,CAAC;QACpB,IAAI,EAAE,WAAW,CAAC;QAClB,WAAW,EAAE,WAAW,CAAC;QACzB,KAAK,EAAE,WAAW,CAAC;QACnB,YAAY,EAAE,WAAW,EAAE,CAAC;KAC7B,CAAC;IACF,IAAI,EAAE;QACJ,WAAW,EAAE,gBAAgB,CAAC,eAAe,CAAC;QAC9C,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,sBAAsB,EACnC,SAAS,YAAmB,GAC3B,iCAAiC,CAqBnC;AAED,2DAA2D;AAC3D,MAAM,WAAW,0CAA0C;IACzD,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE;QACJ,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;QAChC,IAAI,EAAE,WAAW,GAAG,SAAS,CAAC;QAC9B,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;QACrC,KAAK,EAAE,WAAW,GAAG,SAAS,CAAC;QAC/B,YAAY,EAAE,WAAW,EAAE,CAAC;KAC7B,CAAC;IACF,IAAI,EAAE;QACJ,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH"}

package/dist/src/coin/sol/tokenEncodeDecode.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeTransferCheckedInstruction = exports.TokenInvalidInstructionTypeError = exports.TokenInvalidInstructionKeysError = exports.TokenInvalidInstructionProgramError = exports.TokenError = exports.TokenInstruction = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const BigNumber = require('bignumber.js');
+/*
+  IMPORTANT:
+
+  Since token transfer encoding and decoding is in alpha (v 0.2.0-alpha.2), a version that is currently not functional due to typing bugs,
+  this file is the cherry-picked methods that are required to complete the token transfer feature. When the Solana foundation releases a stable
+  version, this file should be deleted and the spl-token methods should be used.
+ */
+var TokenInstruction;
+(function (TokenInstruction) {
+    TokenInstruction[TokenInstruction["InitializeMint"] = 0] = "InitializeMint";
+    TokenInstruction[TokenInstruction["InitializeAccount"] = 1] = "InitializeAccount";
+    TokenInstruction[TokenInstruction["InitializeMultisig"] = 2] = "InitializeMultisig";
+    TokenInstruction[TokenInstruction["Transfer"] = 3] = "Transfer";
+    TokenInstruction[TokenInstruction["Approve"] = 4] = "Approve";
+    TokenInstruction[TokenInstruction["Revoke"] = 5] = "Revoke";
+    TokenInstruction[TokenInstruction["SetAuthority"] = 6] = "SetAuthority";
+    TokenInstruction[TokenInstruction["MintTo"] = 7] = "MintTo";
+    TokenInstruction[TokenInstruction["Burn"] = 8] = "Burn";
+    TokenInstruction[TokenInstruction["CloseAccount"] = 9] = "CloseAccount";
+    TokenInstruction[TokenInstruction["FreezeAccount"] = 10] = "FreezeAccount";
+    TokenInstruction[TokenInstruction["ThawAccount"] = 11] = "ThawAccount";
+    TokenInstruction[TokenInstruction["TransferChecked"] = 12] = "TransferChecked";
+    TokenInstruction[TokenInstruction["ApproveChecked"] = 13] = "ApproveChecked";
+    TokenInstruction[TokenInstruction["MintToChecked"] = 14] = "MintToChecked";
+    TokenInstruction[TokenInstruction["BurnChecked"] = 15] = "BurnChecked";
+    TokenInstruction[TokenInstruction["InitializeAccount2"] = 16] = "InitializeAccount2";
+    TokenInstruction[TokenInstruction["SyncNative"] = 17] = "SyncNative";
+    TokenInstruction[TokenInstruction["InitializeAccount3"] = 18] = "InitializeAccount3";
+    TokenInstruction[TokenInstruction["InitializeMultisig2"] = 19] = "InitializeMultisig2";
+    TokenInstruction[TokenInstruction["InitializeMint2"] = 20] = "InitializeMint2";
+})(TokenInstruction = exports.TokenInstruction || (exports.TokenInstruction = {}));
+class TokenError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.TokenError = TokenError;
+/** Thrown if an instruction's program is invalid */
+class TokenInvalidInstructionProgramError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidInstructionProgramError';
+    }
+}
+exports.TokenInvalidInstructionProgramError = TokenInvalidInstructionProgramError;
+/** Thrown if an instruction's keys are invalid */
+class TokenInvalidInstructionKeysError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidInstructionKeysError';
+    }
+}
+exports.TokenInvalidInstructionKeysError = TokenInvalidInstructionKeysError;
+/** Thrown if an instruction's type is invalid */
+class TokenInvalidInstructionTypeError extends TokenError {
+    constructor() {
+        super(...arguments);
+        this.name = 'TokenInvalidInstructionTypeError';
+    }
+}
+exports.TokenInvalidInstructionTypeError = TokenInvalidInstructionTypeError;
+/**
+ * Decode a TransferChecked instruction and validate it
+ *
+ * @param instruction Transaction instruction to decode
+ * @param programId   SPL Token program account
+ *
+ * @return Decoded, valid instruction
+ */
+function decodeTransferCheckedInstruction(instruction, programId = spl_token_1.TOKEN_PROGRAM_ID) {
+    if (!instruction.programId.equals(programId))
+        throw new TokenInvalidInstructionProgramError();
+    const { keys: { source, mint, destination, owner, multiSigners }, data, } = decodeTransferCheckedInstructionUnchecked(instruction);
+    if (data.instruction !== TokenInstruction.TransferChecked)
+        throw new TokenInvalidInstructionTypeError();
+    if (!source || !mint || !destination || !owner)
+        throw new TokenInvalidInstructionKeysError();
+    return {
+        programId,
+        keys: {
+            source,
+            mint,
+            destination,
+            owner,
+            multiSigners,
+        },
+        data,
+    };
+}
+exports.decodeTransferCheckedInstruction = decodeTransferCheckedInstruction;
+function readBigUInt64LE(buffer, offset = 0) {
+    const first = buffer[offset];
+    const last = buffer[offset + 7];
+    if (first === undefined || last === undefined) {
+        throw new Error('Out of bounds');
+    }
+    const lo = first + buffer[++offset] * 2 ** 8 + buffer[++offset] * 2 ** 16 + buffer[++offset] * 2 ** 24;
+    const hi = buffer[++offset] + buffer[++offset] * 2 ** 8 + buffer[++offset] * 2 ** 16 + last * 2 ** 24;
+    return (BigNumber(lo) + (BigNumber(hi) << BigNumber(32))) / 10;
+}
+/**
+ * Decode a TransferChecked instruction without validating it
+ *
+ * @param instruction Transaction instruction to decode
+ *
+ * @return Decoded, non-validated instruction
+ */
+function decodeTransferCheckedInstructionUnchecked({ programId, keys: [source, mint, destination, owner, ...multiSigners], data, }) {
+    const type = data.slice(0, 1).readUInt8(0);
+    const amount = readBigUInt64LE(data.slice(1, 9), 0);
+    const decimals = data.slice(9).readUInt8(0);
+    return {
+        programId,
+        keys: {
+            source,
+            mint,
+            destination,
+            owner,
+            multiSigners,
+        },
+        data: {
+            instruction: type,
+            amount: amount,
+            decimals: decimals,
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenEncodeDecode.js","sourceRoot":"","sources":["../../../../src/coin/sol/tokenEncodeDecode.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { AccountMeta, PublicKey, TransactionInstruction } from '@solana/web3.js';\nimport { TOKEN_PROGRAM_ID } from '@solana/spl-token';\nconst BigNumber = require('bignumber.js');\n\n/*\n  IMPORTANT:\n\n  Since token transfer encoding and decoding is in alpha (v 0.2.0-alpha.2), a version that is currently not functional due to typing bugs,\n  this file is the cherry-picked methods that are required to complete the token transfer feature. When the Solana foundation releases a stable\n  version, this file should be deleted and the spl-token methods should be used.\n */\n\nexport enum TokenInstruction {\n  InitializeMint = 0,\n  InitializeAccount = 1,\n  InitializeMultisig = 2,\n  Transfer = 3,\n  Approve = 4,\n  Revoke = 5,\n  SetAuthority = 6,\n  MintTo = 7,\n  Burn = 8,\n  CloseAccount = 9,\n  FreezeAccount = 10,\n  ThawAccount = 11,\n  TransferChecked = 12,\n  ApproveChecked = 13,\n  MintToChecked = 14,\n  BurnChecked = 15,\n  InitializeAccount2 = 16,\n  SyncNative = 17,\n  InitializeAccount3 = 18,\n  InitializeMultisig2 = 19,\n  InitializeMint2 = 20,\n}\n\nexport abstract class TokenError extends Error {\n  name: string;\n  constructor(message?: string) {\n    super(message);\n  }\n}\n\n/** Thrown if an instruction's program is invalid */\nexport class TokenInvalidInstructionProgramError extends TokenError {\n  name = 'TokenInvalidInstructionProgramError';\n}\n\n/** Thrown if an instruction's keys are invalid */\nexport class TokenInvalidInstructionKeysError extends TokenError {\n  name = 'TokenInvalidInstructionKeysError';\n}\n\n/** Thrown if an instruction's type is invalid */\nexport class TokenInvalidInstructionTypeError extends TokenError {\n  name = 'TokenInvalidInstructionTypeError';\n}\n\n/** A decoded, valid TransferChecked instruction */\nexport interface DecodedTransferCheckedInstruction {\n  programId: PublicKey;\n  keys: {\n    source: AccountMeta;\n    mint: AccountMeta;\n    destination: AccountMeta;\n    owner: AccountMeta;\n    multiSigners: AccountMeta[];\n  };\n  data: {\n    instruction: TokenInstruction.TransferChecked;\n    amount: number;\n    decimals: number;\n  };\n}\n\n/**\n * Decode a TransferChecked instruction and validate it\n *\n * @param instruction Transaction instruction to decode\n * @param programId   SPL Token program account\n *\n * @return Decoded, valid instruction\n */\nexport function decodeTransferCheckedInstruction(\n  instruction: TransactionInstruction,\n  programId = TOKEN_PROGRAM_ID,\n): DecodedTransferCheckedInstruction {\n  if (!instruction.programId.equals(programId)) throw new TokenInvalidInstructionProgramError();\n\n  const {\n    keys: { source, mint, destination, owner, multiSigners },\n    data,\n  } = decodeTransferCheckedInstructionUnchecked(instruction);\n  if (data.instruction !== TokenInstruction.TransferChecked) throw new TokenInvalidInstructionTypeError();\n  if (!source || !mint || !destination || !owner) throw new TokenInvalidInstructionKeysError();\n\n  return {\n    programId,\n    keys: {\n      source,\n      mint,\n      destination,\n      owner,\n      multiSigners,\n    },\n    data,\n  };\n}\n\n/** A decoded, non-validated TransferChecked instruction */\nexport interface DecodedTransferCheckedInstructionUnchecked {\n  programId: PublicKey;\n  keys: {\n    source: AccountMeta | undefined;\n    mint: AccountMeta | undefined;\n    destination: AccountMeta | undefined;\n    owner: AccountMeta | undefined;\n    multiSigners: AccountMeta[];\n  };\n  data: {\n    instruction: number;\n    amount: number;\n    decimals: number;\n  };\n}\n\nfunction readBigUInt64LE(buffer, offset = 0) {\n  const first = buffer[offset];\n  const last = buffer[offset + 7];\n  if (first === undefined || last === undefined) {\n    throw new Error('Out of bounds');\n  }\n\n  const lo = first + buffer[++offset] * 2 ** 8 + buffer[++offset] * 2 ** 16 + buffer[++offset] * 2 ** 24;\n  const hi = buffer[++offset] + buffer[++offset] * 2 ** 8 + buffer[++offset] * 2 ** 16 + last * 2 ** 24;\n\n  return (BigNumber(lo) + (BigNumber(hi) << BigNumber(32))) / 10;\n}\n\n/**\n * Decode a TransferChecked instruction without validating it\n *\n * @param instruction Transaction instruction to decode\n *\n * @return Decoded, non-validated instruction\n */\nfunction decodeTransferCheckedInstructionUnchecked({\n  programId,\n  keys: [source, mint, destination, owner, ...multiSigners],\n  data,\n}: TransactionInstruction): DecodedTransferCheckedInstructionUnchecked {\n  const type = data.slice(0, 1).readUInt8(0);\n  const amount = readBigUInt64LE(data.slice(1, 9), 0);\n  const decimals = data.slice(9).readUInt8(0);\n  return {\n    programId,\n    keys: {\n      source,\n      mint,\n      destination,\n      owner,\n      multiSigners,\n    },\n    data: {\n      instruction: type,\n      amount: amount,\n      decimals: decimals,\n    },\n  };\n}\n"]}

package/dist/src/coin/sol/tokenTransferBuilder.d.ts

@@ -0,0 +1,27 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransactionType } from '@bitgo/sdk-core';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export interface SendParams {
+    address: string;
+    amount: string;
+    tokenName: string;
+}
+export declare class TokenTransferBuilder extends TransactionBuilder {
+    private _sendParams;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    initBuilder(tx: Transaction): void;
+    /**
+     *  Set a transfer
+     *
+     * @param {string} fromAddress - the sender address
+     * @param {string} amount - the amount sent
+     * @param {string} tokenName - name of token that is intended to send
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send({ address, amount, tokenName }: SendParams): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=tokenTransferBuilder.d.ts.map

package/dist/src/coin/sol/tokenTransferBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenTransferBuilder.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/tokenTransferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAkB,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAyB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,oBAAqB,SAAQ,kBAAkB;IAC1D,OAAO,CAAC,WAAW,CAAoB;gBAE3B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAgBlC;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,UAAU,GAAG,IAAI;IAWtD,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;CAoB5D"}

package/dist/src/coin/sol/tokenTransferBuilder.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTransferBuilder = void 0;
+const statics_1 = require("@bitgo/statics");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const assert_1 = __importDefault(require("assert"));
+const transactionBuilder_1 = require("./transactionBuilder");
+class TokenTransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._sendParams = [];
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === constants_1.InstructionBuilderTypes.TokenTransfer) {
+                const transferInstruction = instruction;
+                this.sender(transferInstruction.params.fromAddress);
+                this.send({
+                    address: transferInstruction.params.toAddress,
+                    amount: transferInstruction.params.amount,
+                    tokenName: transferInstruction.params.tokenName,
+                });
+            }
+        }
+    }
+    /**
+     *  Set a transfer
+     *
+     * @param {string} fromAddress - the sender address
+     * @param {string} amount - the amount sent
+     * @param {string} tokenName - name of token that is intended to send
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    send({ address, amount, tokenName }) {
+        utils_1.validateAddress(address, 'address');
+        if (!amount || !utils_1.isValidAmount(amount)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing amount, got: ' + amount);
+        }
+        this._sendParams.push({ address, amount, tokenName: tokenName });
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert_1.default(this._sender, 'Sender must be set before building the transaction');
+        const coin = statics_1.coins.get(this._sendParams[0].tokenName);
+        assert_1.default(coin instanceof statics_1.SolCoin);
+        const sourceAddress = await utils_1.getAssociatedTokenAccountAddress(coin.tokenAddress, this._sender);
+        this._instructionsData = this._sendParams.map((sendParams) => {
+            return {
+                type: constants_1.InstructionBuilderTypes.TokenTransfer,
+                params: {
+                    fromAddress: this._sender,
+                    toAddress: sendParams.address,
+                    amount: sendParams.amount,
+                    tokenName: sendParams.tokenName,
+                    sourceAddress: sourceAddress,
+                },
+            };
+        });
+        return await super.buildImplementation();
+    }
+}
+exports.TokenTransferBuilder = TokenTransferBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/coin/sol/transaction.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" />
+import BigNumber from 'bignumber.js';
+import { BaseTransaction, TransactionRecipient, TransactionType } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { Transaction as SolTransaction } from '@solana/web3.js';
+import { DurableNonceParams, TransactionExplanation, TxData } from './iface';
+import { KeyPair } from '.';
+export declare class Transaction extends BaseTransaction {
+    protected _solTransaction: SolTransaction;
+    private _lamportsPerSignature;
+    protected _type: TransactionType;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    get solTransaction(): SolTransaction;
+    set solTransaction(tx: SolTransaction);
+    private get numberOfRequiredSignatures();
+    /** @inheritDoc */
+    get signablePayload(): Buffer;
+    /** @inheritDoc **/
+    get id(): string;
+    get lamportsPerSignature(): number | undefined;
+    set lamportsPerSignature(lamportsPerSignature: number | undefined);
+    /** @inheritDoc */
+    get signature(): string[];
+    /**
+     * Set the transaction type.
+     *
+     * @param {TransactionType} transactionType The transaction type to be set.
+     */
+    setTransactionType(transactionType: TransactionType): void;
+    /** @inheritdoc */
+    canSign(): boolean;
+    /**
+     * Signs transaction.
+     *
+     * @param {KeyPair} keyPair Signer keys.
+     */
+    sign(keyPair: KeyPair[] | KeyPair): Promise<void>;
+    /** @inheritdoc */
+    toBroadcastFormat(): string;
+    /**
+     * Sets this transaction payload
+     *
+     * @param rawTransaction
+     */
+    fromRawTransaction(rawTransaction: string): void;
+    /** @inheritdoc */
+    toJson(): TxData;
+    /**
+     * Get the nonce from the Solana Transaction
+     * Throws if not set
+     */
+    private getNonce;
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs(): void;
+    /** @inheritDoc */
+    explainTransaction(): TransactionExplanation;
+    protected getExplainedTransaction(outputAmount: BigNumber, outputs: TransactionRecipient[], memo?: undefined | string, durableNonce?: undefined | DurableNonceParams): TransactionExplanation;
+}
+//# sourceMappingURL=transaction.d.ts.map

package/dist/src/coin/sol/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../../src/coin/sol/transaction.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,EACL,eAAe,EAKf,oBAAoB,EACpB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAmD,WAAW,IAAI,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjH,OAAO,EACL,kBAAkB,EAMlB,sBAAsB,EAEtB,MAAM,EAEP,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC;AAK5B,qBAAa,WAAY,SAAQ,eAAe;IAC9C,SAAS,CAAC,eAAe,EAAE,cAAc,CAAC;IAC1C,OAAO,CAAC,qBAAqB,CAAqB;IAClD,SAAS,CAAC,KAAK,EAAE,eAAe,CAAC;gBAErB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,IAAI,cAAc,IAAI,cAAc,CAEnC;IAED,IAAI,cAAc,CAAC,EAAE,EAAE,cAAc,EAEpC;IAED,OAAO,KAAK,0BAA0B,GAErC;IAED,kBAAkB;IAClB,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,mBAAmB;IACnB,IAAI,EAAE,IAAI,MAAM,CAOf;IAED,IAAI,oBAAoB,IAAI,MAAM,GAAG,SAAS,CAE7C;IAED,IAAI,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,GAAG,SAAS,EAEhE;IAED,kBAAkB;IAClB,IAAI,SAAS,IAAI,MAAM,EAAE,CAUxB;IAED;;;;OAIG;IACH,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAI1D,kBAAkB;IAClB,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBvD,kBAAkB;IAClB,iBAAiB,IAAI,MAAM;IAiB3B;;;;OAIG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAkChD,kBAAkB;IAClB,MAAM,IAAI,MAAM;IA0BhB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAUhB;;OAEG;IACH,oBAAoB,IAAI,IAAI;IA0E5B,kBAAkB;IAClB,kBAAkB,IAAI,sBAAsB;IAoE5C,SAAS,CAAC,uBAAuB,CAC/B,YAAY,EAAE,SAAS,EACvB,OAAO,EAAE,oBAAoB,EAAE,EAC/B,IAAI,GAAE,SAAS,GAAG,MAAkB,EACpC,YAAY,GAAE,SAAS,GAAG,kBAA8B,GACvD,sBAAsB;CAgC1B"}