import { Turnkey } from "@turnkey/sdk-server";
import {
AptosClient,
AptosAccount,
TxnBuilderTypes,
BCS,
TransactionBuilder,
HexString,
} from "aptos";
// Custom Turnkey signer for Aptos
class TurnkeyAptosSigner {
private turnkeyClient: Turnkey;
private aptosClient: AptosClient;
private address: string;
private organizationId: string;
constructor(
apiPrivateKey: string,
apiPublicKey: string,
organizationId: string,
address: string,
nodeUrl: string = "https://fullnode.mainnet.aptoslabs.com/v1"
) {
this.turnkeyClient = new Turnkey({
apiBaseUrl: "https://api.turnkey.com",
apiPrivateKey,
apiPublicKey,
defaultOrganizationId: organizationId,
});
this.aptosClient = new AptosClient(nodeUrl);
this.address = address;
this.organizationId = organizationId;
}
// Get the account address
getAddress(): string {
return this.address;
}
// Sign a transaction using Turnkey
async signTransaction(
rawTxn: TxnBuilderTypes.RawTransaction
): Promise<Uint8Array> {
// Serialize the raw transaction to BCS
const serializer = new BCS.Serializer();
rawTxn.serialize(serializer);
const toSign = serializer.getBytes();
// Sign the serialized transaction with Turnkey
const signResult = await this.turnkeyClient.signRawPayload({
organizationId: this.organizationId,
signWith: this.address,
payload: Buffer.from(toSign).toString("hex"),
encoding: "hex",
});
// Return the signed transaction bytes
return Buffer.from(signResult.signature, "hex");
}
// Submit a transaction
async submitTransaction(payload: any): Promise<string> {
try {
// Create a raw transaction from the payload
const rawTxn = await this.createRawTransaction(payload);
// Sign the transaction
const signature = await this.signTransaction(rawTxn);
// Get the authenticator
const authenticator = new TxnBuilderTypes.TransactionAuthenticatorEd25519(
new TxnBuilderTypes.Ed25519PublicKey(
// Note: In a real implementation, you would need to get the actual public key
new Uint8Array(32) // Placeholder - replace with actual public key
),
new TxnBuilderTypes.Ed25519Signature(signature)
);
// Create a signed transaction
const signedTxn = new TxnBuilderTypes.SignedTransaction(
rawTxn,
authenticator
);
// Submit the transaction
const pendingTxn = await this.aptosClient.submitSignedBCSTransaction(
BCS.bcsToBytes(signedTxn)
);
return pendingTxn.hash;
} catch (error) {
console.error("Error submitting transaction:", error);
throw error;
}
}
// Helper method to create a raw transaction
private async createRawTransaction(
payload: any
): Promise<TxnBuilderTypes.RawTransaction> {
const account = await this.aptosClient.getAccount(this.address);
const chainId = await this.aptosClient.getChainId();
// Create a raw transaction
return new TxnBuilderTypes.RawTransaction(
TxnBuilderTypes.AccountAddress.fromHex(this.address),
BigInt(account.sequence_number),
payload,
BigInt(2000), // Max gas amount
BigInt(100), // Gas unit price
BigInt(Math.floor(Date.now() / 1000) + 30), // Expiration timestamp (30 seconds from now)
new TxnBuilderTypes.ChainId(chainId)
);
}
}
// Example usage: Transfer coins
async function transferCoins() {
const signer = new TurnkeyAptosSigner(
process.env.API_PRIVATE_KEY!,
process.env.API_PUBLIC_KEY!,
process.env.ORGANIZATION_ID!,
process.env.APTOS_ADDRESS!, // Your Aptos address in Turnkey
"https://fullnode.testnet.aptoslabs.com/v1" // Testnet URL
);
const recipientAddress = "0x..."; // Recipient address
const amount = 1000000; // Amount in octas (1 APT = 100,000,000 octas)
// Create a transfer transaction payload
const payload = new TxnBuilderTypes.TransactionPayloadEntryFunction(
TxnBuilderTypes.EntryFunction.natural(
"0x1::coin",
"transfer",
[
new TxnBuilderTypes.TypeTagStruct(
TxnBuilderTypes.StructTag.fromString("0x1::aptos_coin::AptosCoin")
),
],
[
BCS.bcsToBytes(
TxnBuilderTypes.AccountAddress.fromHex(recipientAddress)
),
BCS.bcsSerializeUint64(amount),
]
)
);
try {
const txnHash = await signer.submitTransaction(payload);
console.log(`Transaction submitted successfully! Hash: ${txnHash}`);
return txnHash;
} catch (error) {
console.error("Error transferring coins:", error);
throw error;
}
}
