feat(sdk-coin-sui): sui sponsorship support

TICKET: WIN-6028

Author: abhishekagrawal080

modules/sdk-coin-sui/src/lib/iface.ts

@@ -3,14 +3,20 @@ import {
   TransactionType as BitGoTransactionType,
 } from '@bitgo/sdk-core';
 import BigNumber from 'bignumber.js';
-import {
-  CallArg,
-  GasData,
-  ProgrammableTransaction,
-  SuiAddress,
-  SuiObjectRef,
-  TransactionExpiration,
-} from './mystenlab/types';
+import { CallArg, ProgrammableTransaction, SuiAddress, SuiObjectRef, TransactionExpiration } from './mystenlab/types';
+
+export interface GasData {
+  payment: SuiObjectRef[];
+  owner: SuiAddress;
+  price: number;
+  budget: number;
+  sponsor?: SuiAddress;
+}
+
+export interface GasDataWithSponsor extends GasData {
+  sponsor: SuiAddress;
+}
+
 import { TransactionBlockInput, TransactionType } from './mystenlab/builder';
 
 export enum SuiTransactionType {

modules/sdk-coin-sui/src/lib/mystenlab/builder/TransactionDataBlock.ts

@@ -43,6 +43,7 @@ const GasConfig = object({
   price: optional(StringEncodedBigint),
   payment: optional(array(SuiObjectRef)),
   owner: optional(SuiAddress),
+  sponsor: optional(SuiAddress),
 });
 type GasConfig = Infer<typeof GasConfig>;
 
@@ -213,6 +214,9 @@ export class TransactionBlockDataBuilder {
         owner: prepareSuiAddress(this.gasConfig.owner ?? sender),
         price: BigInt(gasConfig.price),
         budget: BigInt(gasConfig.budget),
+        ...(gasConfig.sponsor && {
+          sponsor: prepareSuiAddress(gasConfig.sponsor),
+        }),
       },
       kind: {
         ProgrammableTransaction: {

modules/sdk-coin-sui/src/lib/transaction.ts

@@ -6,10 +6,10 @@ import {
   Signature,
   TransactionType as BitGoTransactionType,
 } from '@bitgo/sdk-core';
-import { SuiProgrammableTransaction, SuiTransaction, SuiTransactionType, TxData } from './iface';
+import { SuiProgrammableTransaction, SuiTransaction, SuiTransactionType, TxData, GasData } from './iface';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import utils, { AppId, Intent, IntentScope, IntentVersion, isImmOrOwnedObj } from './utils';
-import { GasData, normalizeSuiAddress, normalizeSuiObjectId, SuiObjectRef } from './mystenlab/types';
+import { normalizeSuiAddress, normalizeSuiObjectId, SuiObjectRef } from './mystenlab/types';
 import { SIGNATURE_SCHEME_BYTES } from './constants';
 import { Buffer } from 'buffer';
 import { fromB64, toB64 } from '@mysten/bcs';
@@ -23,7 +23,9 @@ import { hashTypedData } from './mystenlab/cryptography/hash';
 export abstract class Transaction<T> extends BaseTransaction {
   protected _suiTransaction: SuiTransaction<T>;
   protected _signature: Signature;
+  protected _feePayerSignature: Signature;
   private _serializedSig: Uint8Array;
+  private _serializedFeePayerSig: Uint8Array;
 
   protected constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
@@ -48,17 +50,31 @@ export abstract class Transaction<T> extends BaseTransaction {
   addSignature(publicKey: BasePublicKey, signature: Buffer): void {
     this._signatures.push(signature.toString('hex'));
     this._signature = { publicKey, signature };
+    this.setSerializedSig(publicKey, signature);
     this.serialize();
   }
 
+  addFeePayerSignature(publicKey: BasePublicKey, signature: Buffer): void {
+    this._feePayerSignature = { publicKey, signature };
+    this.setSerializedFeePayerSig(publicKey, signature);
+  }
+
   get suiSignature(): Signature {
     return this._signature;
   }
 
+  get feePayerSignature(): Signature {
+    return this._feePayerSignature;
+  }
+
   get serializedSig(): Uint8Array {
     return this._serializedSig;
   }
 
+  get serializedFeePayerSig(): Uint8Array {
+    return this._serializedFeePayerSig;
+  }
+
   setSerializedSig(publicKey: BasePublicKey, signature: Buffer): void {
     const pubKey = Buffer.from(publicKey.pub, 'hex');
     const serialized_sig = new Uint8Array(1 + signature.length + pubKey.length);
@@ -68,6 +84,15 @@ export abstract class Transaction<T> extends BaseTransaction {
     this._serializedSig = serialized_sig;
   }
 
+  setSerializedFeePayerSig(publicKey: BasePublicKey, signature: Buffer): void {
+    const pubKey = Buffer.from(publicKey.pub, 'hex');
+    const serialized_sig = new Uint8Array(1 + signature.length + pubKey.length);
+    serialized_sig.set(SIGNATURE_SCHEME_BYTES);
+    serialized_sig.set(signature, 1);
+    serialized_sig.set(pubKey, 1 + signature.length);
+    this._serializedFeePayerSig = serialized_sig;
+  }
+
   /** @inheritdoc */
   canSign(key: BaseKey): boolean {
     return true;
@@ -78,7 +103,6 @@ export abstract class Transaction<T> extends BaseTransaction {
    *
    * @param {KeyPair} signer key
    */
-
   sign(signer: KeyPair): void {
     if (!this._suiTransaction) {
       throw new InvalidTransactionError('empty transaction to sign');
@@ -87,10 +111,29 @@ export abstract class Transaction<T> extends BaseTransaction {
     const intentMessage = this.signablePayload;
     const signature = signer.signMessageinUint8Array(intentMessage);
 
-    this.setSerializedSig({ pub: signer.getKeys().pub }, Buffer.from(signature));
     this.addSignature({ pub: signer.getKeys().pub }, Buffer.from(signature));
   }
 
+  /**
+   * Sign this transaction as a fee payer
+   *
+   * @param {KeyPair} signer key
+   */
+  signFeePayer(signer: KeyPair): void {
+    if (!this._suiTransaction) {
+      throw new InvalidTransactionError('empty transaction to sign');
+    }
+
+    if (!this._suiTransaction.gasData.sponsor) {
+      throw new InvalidTransactionError('transaction does not have a fee payer');
+    }
+
+    const intentMessage = this.signablePayload;
+    const signature = signer.signMessageinUint8Array(intentMessage);
+
+    this.addFeePayerSignature({ pub: signer.getKeys().pub }, Buffer.from(signature));
+  }
+
   /** @inheritdoc */
   toBroadcastFormat(): string {
     if (!this._suiTransaction) {
@@ -178,6 +221,9 @@ export abstract class Transaction<T> extends BaseTransaction {
         owner: normalizeSuiAddress(transactionBlock.gasConfig.owner!),
         price: Number(transactionBlock.gasConfig.price as string),
         budget: Number(transactionBlock.gasConfig.budget as string),
+        ...(transactionBlock.gasConfig.sponsor && {
+          sponsor: normalizeSuiAddress(transactionBlock.gasConfig.sponsor),
+        }),
       },
     };
   }
@@ -213,12 +259,20 @@ export abstract class Transaction<T> extends BaseTransaction {
   }
 
   static getProperGasData(k: any): GasData {
-    return {
-      payment: [this.normalizeSuiObjectRef(k.gasData.payment)],
+    const gasData: GasData = {
+      payment: Array.isArray(k.gasData.payment)
+        ? k.gasData.payment.map((p: any) => this.normalizeSuiObjectRef(p))
+        : [this.normalizeSuiObjectRef(k.gasData.payment)],
       owner: utils.normalizeHexId(k.gasData.owner),
       price: Number(k.gasData.price),
       budget: Number(k.gasData.budget),
     };
+
+    if (k.gasData.sponsor) {
+      gasData.sponsor = utils.normalizeHexId(k.gasData.sponsor);
+    }
+
+    return gasData;
   }
 
   private static normalizeCoins(coins: any[]): SuiObjectRef[] {
@@ -267,4 +321,15 @@ export abstract class Transaction<T> extends BaseTransaction {
 
     return inputGasPaymentObjects;
   }
+
+  hasFeePayerSig(): boolean {
+    return !!this._feePayerSignature;
+  }
+
+  getFeePayerPubKey(): string | undefined {
+    if (!this._feePayerSignature || !this._feePayerSignature.publicKey) {
+      return undefined;
+    }
+    return this._feePayerSignature.publicKey.pub;
+  }
 }

modules/sdk-coin-sui/src/lib/transactionBuilder.ts

@@ -52,7 +52,11 @@ export abstract class TransactionBuilder<T = SuiProgrammableTransaction> extends
   protected signImplementation(key: BaseKey): Transaction<T> {
     const signer = new KeyPair({ prv: key.key });
     this._signer = signer;
-    this.transaction.sign(signer);
+    const signable = this.transaction.signablePayload;
+    const signature = signer.signMessageinUint8Array(signable);
+    const signatureBuffer = Buffer.from(signature);
+    this.transaction.addSignature({ pub: signer.getKeys().pub }, signatureBuffer);
+    this.transaction.setSerializedSig({ pub: signer.getKeys().pub }, signatureBuffer);
     return this.transaction;
   }
 

modules/sdk-coin-sui/src/lib/utils.ts

@@ -549,6 +549,16 @@ export class Utils implements BaseUtils {
     return result.digest;
   }
 
+  async executeTransactionBlockWithMultipleSigners(
+    url: string,
+    serializedTx: string,
+    senderSignature: string,
+    feePayerSignature?: string
+  ): Promise<string> {
+    const signatures = feePayerSignature ? [senderSignature, feePayerSignature] : [senderSignature];
+    return this.executeTransactionBlock(url, serializedTx, signatures);
+  }
+
   validateNonNegativeNumber(defaultVal: number, errorMsg: string, inputVal?: number): number {
     if (inputVal === undefined) {
       return defaultVal;

modules/sdk-coin-sui/src/sui.ts

@@ -81,6 +81,10 @@ export interface SuiParsedTransaction extends ParsedTransaction {
 
 export type SuiTransactionExplanation = TransactionExplanation;
 
+export interface SuiMPCTx extends MPCTx {
+  feePayerSignature?: string;
+}
+
 export class Sui extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
   protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {
@@ -647,9 +651,18 @@ export class Sui extends BaseCoin {
     const url = this.getPublicNodeUrl();
     let digest = '';
     if (!!transactions) {
-      for (const txn of transactions) {
+      for (const txn of transactions as SuiMPCTx[]) {
         try {
-          digest = await utils.executeTransactionBlock(url, txn.serializedTx, [txn.signature!]);
+          if (txn.feePayerSignature) {
+            digest = await utils.executeTransactionBlockWithMultipleSigners(
+              url,
+              txn.serializedTx,
+              txn.signature!,
+              txn.feePayerSignature
+            );
+          } else {
+            digest = await utils.executeTransactionBlock(url, txn.serializedTx, [txn.signature!]);
+          }
         } catch (e) {
           throw new Error(`Failed to broadcast transaction, error: ${e.message}`);
         }